Hello,
je refais en rust le programme présenté ici
et mon programme est hyper lent, l’animation est saccadée et je saisis pas vraiment pourquoi, je me dis que c’est les nombreux sin et cos qui pourraient causer ceci. Mais j’ai vu que faire une table de lookup ne va pas forcément améliorer mes perfs.
Je comprends pas comment afficher 5 cercles et 5 lignes peut être si gourmand.
Et la j’ai pas commencé à implémenter le graph. Je compte le faire de cette manière : je retiens la position y de l’epicycle le plus petit et je graph tout les y a dt d’interval en x.
Mais bon ça saccade beaucoup trop déjà maintenant avant d’avoir un graph qui fonctionne. Je m’y prend peut-être mal.
Actuellement je pose un cercle centré en , trace une ligne de et je pose un autre cercle + ligne au bout de la ligne du cercle précédent.
j’update tout mes cercles avec la position du cercles précédent et avec le dt pour qu’il calcule le nouvelle angle Je sais pas s’il y a une meilleur méthode ou si c’est juste que mon code est hyper mal conçu.
Si vous avez des idée pour améliorer tout ça :
use piston_window::*;
use std::time::Instant;
#[derive(Debug)]
struct Epi {
radius: f64,
color: [f32; 4],
x: f64,
y: f64,
angular_speed: f64,
angle: f64,
}
impl Epi {
fn new() -> Epi {
Epi {
radius: 100.0,
color: color::BLACK,
x: 300.0,
y: 512.0 / 2.0,
angular_speed: 1.0,
angle: 0.0,
}
}
fn draw(&mut self, e: &Event, window: &mut PistonWindow) {
window.draw_2d(e, |c, g, _| {
let border = Ellipse::new_border(self.color, 1.0);
border.draw(
rectangle::centered_square(self.x, self.y, self.radius),
&c.draw_state,
c.transform,
g,
);
line(
color::BLACK,
1.0,
[self.x, self.y, self.x + self.cos(), self.y + self.sin()],
c.transform,
g,
); //draw a line
});
}
fn update(&mut self, dt: u128, pos: (f64, f64)) {
self.angle += (self.angular_speed * 2.0 * std::f64::consts::PI * dt as f64) / (1000.0);
self.angle %= 2.0 * std::f64::consts::PI;
self.x = pos.0;
self.y = pos.1;
}
fn cos(&self) -> f64 {
self.radius as f64 * self.angle.cos()
}
fn sin(&self) -> f64 {
self.radius as f64 * self.angle.sin()
}
fn get_absolute_pos(&self) -> (f64, f64) {
(self.get_absolute_x(), self.get_absolute_y())
}
fn get_absolute_x(&self) -> f64 {
self.x + self.cos()
}
fn get_absolute_y(&self) -> f64 {
self.y + self.sin()
}
}
fn main() {
let opengl = OpenGL::V4_5;
let mut window: PistonWindow = WindowSettings::new("Square fourrier", [1024, 512])
.exit_on_esc(true)
.graphics_api(opengl)
.build()
.unwrap();
let mut epis = vec![Epi::new()];
let mut now = Instant::now();
//https://fr.wikipedia.org/wiki/Signal_carr%C3%A9
//4/pi [sin( (2k+1) 2*pi*dt)/(2k + 1)]
let n_epicycle = 5;
for k in 1..n_epicycle {
epis.push(Epi {
radius: 4.0 / (std::f64::consts::PI * (2 * k + 1) as f64) * 100.0,
color: [0.0, 0.0, 0.0, 0.5],
x: epis[k - 1].get_absolute_x(),
y: epis[k - 1].get_absolute_y(),
angular_speed: (2 * k + 1) as f64,
angle: 0.0,
});
}
while let Some(e) = window.next() {
window.draw_2d(&e, |_c, g, _| {
clear([1.0; 4], g); //clear screen
});
let dt = now.elapsed().as_millis();
epis[0].draw(&e, &mut window);
epis[0].update(dt, (250.0, 512.0 / 2.0));
for i in 1..epis.len() {
epis[i].draw(&e, &mut window);
let pos_of_previous_epi = epis[i - 1].get_absolute_pos();
epis[i].update(dt, pos_of_previous_epi);
}
now = Instant::now(); //init timer for next frame
}
}
