430 lines
16 KiB
Rust
430 lines
16 KiB
Rust
//! Rendering logic using Macroquad and Lyon tessellation
|
|
|
|
use crate::circle_geometry::{CircleDirection, CircleGeometry};
|
|
use crate::state::{DrawCommand, TurtleParams, TurtleWorld};
|
|
use crate::tessellation;
|
|
use macroquad::prelude::*;
|
|
|
|
// Import the easing function from the tween crate
|
|
// To change the easing, change both this import and the usage in the draw_tween_arc function below
|
|
// Available options: Linear, SineInOut, QuadInOut, CubicInOut, QuartInOut, QuintInOut,
|
|
// ExpoInOut, CircInOut, BackInOut, ElasticInOut, BounceInOut, etc.
|
|
// See https://easings.net/ for visual demonstrations
|
|
use tween::CubicInOut;
|
|
|
|
/// Render the entire turtle world
|
|
pub fn render_world(world: &TurtleWorld) {
|
|
// Update camera zoom based on current screen size to prevent stretching
|
|
let camera = Camera2D {
|
|
zoom: vec2(1.0 / screen_width() * 2.0, 1.0 / screen_height() * 2.0),
|
|
target: world.camera.target,
|
|
..Default::default()
|
|
};
|
|
|
|
// Set camera
|
|
set_camera(&camera);
|
|
|
|
// Draw all accumulated commands from all turtles
|
|
for turtle in &world.turtles {
|
|
for cmd in &turtle.commands {
|
|
match cmd {
|
|
DrawCommand::Mesh { data, source: _ } => {
|
|
// Rendering wie bisher
|
|
draw_mesh(&data.to_mesh());
|
|
// Hier könnte man das source für Debug/Export loggen
|
|
}
|
|
DrawCommand::Text {
|
|
text,
|
|
position,
|
|
heading,
|
|
font_size,
|
|
color,
|
|
source: _,
|
|
} => {
|
|
draw_text_command(text, *position, *heading, *font_size, *color);
|
|
// Hier könnte man das source für Debug/Export loggen
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw all visible turtles
|
|
for turtle in &world.turtles {
|
|
if turtle.params.visible {
|
|
draw_turtle(&turtle.params);
|
|
}
|
|
}
|
|
|
|
// Reset to default camera
|
|
set_default_camera();
|
|
}
|
|
|
|
/// Render the turtle world with active tween visualization
|
|
#[allow(clippy::too_many_lines)]
|
|
pub fn render_world_with_tweens(world: &TurtleWorld, zoom_level: f32) {
|
|
// Update camera zoom based on current screen size to prevent stretching
|
|
// Apply user zoom level by dividing by it (smaller zoom value = more zoomed in)
|
|
let camera = Camera2D {
|
|
zoom: vec2(
|
|
1.0 / screen_width() * 2.0 / zoom_level,
|
|
1.0 / screen_height() * 2.0 / zoom_level,
|
|
),
|
|
target: world.camera.target,
|
|
..Default::default()
|
|
};
|
|
|
|
// Set camera
|
|
set_camera(&camera);
|
|
|
|
// Draw all accumulated commands from all turtles
|
|
for turtle in &world.turtles {
|
|
for cmd in &turtle.commands {
|
|
match cmd {
|
|
DrawCommand::Mesh { data, source: _ } => {
|
|
draw_mesh(&data.to_mesh());
|
|
}
|
|
DrawCommand::Text {
|
|
text,
|
|
position,
|
|
heading,
|
|
font_size,
|
|
color,
|
|
source: _,
|
|
} => {
|
|
draw_text_command(text, *position, *heading, *font_size, *color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw in-progress tween lines for all active tweens
|
|
for turtle in &world.turtles {
|
|
if let Some(tween) = turtle.tween_controller.current_tween() {
|
|
// Only draw if pen is down
|
|
if tween.start_params.pen_down {
|
|
match &tween.command {
|
|
crate::commands::TurtleCommand::Circle {
|
|
radius,
|
|
angle,
|
|
steps,
|
|
direction,
|
|
} => {
|
|
// Draw arc segments from start to current position
|
|
draw_tween_arc(tween, *radius, *angle, *steps, *direction);
|
|
}
|
|
_ if should_draw_tween_line(&tween.command) => {
|
|
// Draw straight line for other movement commands (use tween's current position)
|
|
draw_line(
|
|
tween.start_params.position.x,
|
|
tween.start_params.position.y,
|
|
tween.current_position.x,
|
|
tween.current_position.y,
|
|
tween.start_params.pen_width,
|
|
tween.start_params.color,
|
|
);
|
|
// Add circle at current position for smooth line joins
|
|
draw_circle(
|
|
tween.current_position.x,
|
|
tween.current_position.y,
|
|
tween.start_params.pen_width / 2.0,
|
|
tween.start_params.color,
|
|
);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw live fill preview for all turtles that are currently filling
|
|
for turtle in &world.turtles {
|
|
if let Some(ref fill_state) = turtle.filling {
|
|
// Build all contours: completed contours + current contour with animation
|
|
let mut all_contours: Vec<Vec<Vec2>> = Vec::new();
|
|
|
|
// Add all completed contours
|
|
for completed_contour in &fill_state.contours {
|
|
let contour_vec2: Vec<Vec2> = completed_contour
|
|
.iter()
|
|
.map(|c| Vec2::new(c.x, c.y))
|
|
.collect();
|
|
all_contours.push(contour_vec2);
|
|
}
|
|
|
|
// Build current contour with animation
|
|
// Find the tween for this specific turtle
|
|
let turtle_tween = turtle.tween_controller.current_tween();
|
|
|
|
let mut current_preview: Vec<Vec2>;
|
|
|
|
// If we have an active tween for this turtle, build the preview from tween state
|
|
if let Some(tween) = turtle_tween {
|
|
// Start with the existing contour vertices (vertices before the current tween)
|
|
current_preview = fill_state
|
|
.current_contour
|
|
.iter()
|
|
.map(|c| Vec2::new(c.x, c.y))
|
|
.collect();
|
|
|
|
// If we're animating a circle command with pen down, add progressive arc vertices
|
|
if tween.start_params.pen_down {
|
|
if let crate::commands::TurtleCommand::Circle {
|
|
radius,
|
|
angle,
|
|
steps,
|
|
direction,
|
|
} = &tween.command
|
|
{
|
|
// Calculate partial arc vertices based on current progress
|
|
use crate::circle_geometry::CircleGeometry;
|
|
let geom = CircleGeometry::new(
|
|
tween.start_params.position,
|
|
tween.start_params.heading,
|
|
*radius,
|
|
*direction,
|
|
); // Calculate progress
|
|
let elapsed = get_time() - tween.start_time;
|
|
let progress = (elapsed / tween.duration).min(1.0);
|
|
let eased_progress = CubicInOut.tween(1.0, progress as f32);
|
|
|
|
// Generate arc vertices for the partial arc
|
|
let num_samples = *steps.max(&1);
|
|
let samples_to_draw =
|
|
((num_samples as f32 * eased_progress) as usize).max(1);
|
|
|
|
for i in 1..=samples_to_draw {
|
|
let sample_progress = i as f32 / num_samples as f32;
|
|
let current_angle = match direction {
|
|
crate::circle_geometry::CircleDirection::Left => {
|
|
geom.start_angle_from_center
|
|
- angle.to_radians() * sample_progress
|
|
}
|
|
crate::circle_geometry::CircleDirection::Right => {
|
|
geom.start_angle_from_center
|
|
+ angle.to_radians() * sample_progress
|
|
}
|
|
};
|
|
|
|
let vertex = Vec2::new(
|
|
geom.center.x + radius * current_angle.cos(),
|
|
geom.center.y + radius * current_angle.sin(),
|
|
);
|
|
current_preview.push(vertex);
|
|
}
|
|
} else if matches!(
|
|
&tween.command,
|
|
crate::commands::TurtleCommand::Move(_)
|
|
| crate::commands::TurtleCommand::Goto(_)
|
|
) {
|
|
// For Move/Goto commands, just add the current position from tween
|
|
current_preview.push(Vec2::new(
|
|
tween.current_position.x,
|
|
tween.current_position.y,
|
|
));
|
|
}
|
|
} else if matches!(
|
|
&tween.command,
|
|
crate::commands::TurtleCommand::Move(_)
|
|
| crate::commands::TurtleCommand::Goto(_)
|
|
) {
|
|
// For Move/Goto with pen up during filling, still add current position for preview
|
|
current_preview.push(Vec2::new(
|
|
tween.current_position.x,
|
|
tween.current_position.y,
|
|
));
|
|
}
|
|
|
|
// Add current turtle position if not already included
|
|
if let Some(last) = current_preview.last() {
|
|
let current_pos = tween.current_position;
|
|
// Use a larger threshold to reduce flickering from tiny movements
|
|
if (last.x - current_pos.x).abs() > 0.1 || (last.y - current_pos.y).abs() > 0.1
|
|
{
|
|
current_preview.push(Vec2::new(current_pos.x, current_pos.y));
|
|
}
|
|
} else if !current_preview.is_empty() {
|
|
current_preview.push(Vec2::new(
|
|
tween.current_position.x,
|
|
tween.current_position.y,
|
|
));
|
|
}
|
|
} else {
|
|
// No active tween - use the actual current contour from fill state
|
|
current_preview = fill_state
|
|
.current_contour
|
|
.iter()
|
|
.map(|c| Vec2::new(c.x, c.y))
|
|
.collect();
|
|
|
|
// No active tween - just show current state
|
|
if !current_preview.is_empty() {
|
|
if let Some(last) = current_preview.last() {
|
|
let current_pos = turtle.params.position;
|
|
if (last.x - current_pos.x).abs() > 0.1
|
|
|| (last.y - current_pos.y).abs() > 0.1
|
|
{
|
|
current_preview.push(Vec2::new(current_pos.x, current_pos.y));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add current contour to all contours if it has enough vertices
|
|
if current_preview.len() >= 3 {
|
|
all_contours.push(current_preview);
|
|
}
|
|
|
|
// Tessellate and draw all contours together using multi-contour tessellation
|
|
if !all_contours.is_empty() {
|
|
match crate::tessellation::tessellate_multi_contour(
|
|
&all_contours,
|
|
fill_state.fill_color,
|
|
) {
|
|
Ok(mesh_data) => {
|
|
draw_mesh(&mesh_data.to_mesh());
|
|
}
|
|
Err(e) => {
|
|
tracing::error!("Failed to tessellate fill preview: {:?}", e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw all visible turtles
|
|
for turtle in &world.turtles {
|
|
if turtle.params.visible {
|
|
draw_turtle(&turtle.params);
|
|
}
|
|
}
|
|
|
|
// Reset to default camera
|
|
set_default_camera();
|
|
}
|
|
|
|
fn should_draw_tween_line(command: &crate::commands::TurtleCommand) -> bool {
|
|
use crate::commands::TurtleCommand;
|
|
matches!(command, TurtleCommand::Move(..) | TurtleCommand::Goto(..))
|
|
}
|
|
|
|
/// Draw a text command with rotation based on turtle heading
|
|
fn draw_text_command(
|
|
text: &str,
|
|
position: Vec2,
|
|
heading_radians: f32,
|
|
font_size: crate::general::FontSize,
|
|
color: Color,
|
|
) {
|
|
// Heading in turtle coordinates: 0 rad = right, positive = counter-clockwise
|
|
// Macroquad rotation: same convention (0 = right, positive = counter-clockwise)
|
|
// So we use the heading directly
|
|
let rotation_rad = heading_radians;
|
|
|
|
// Calculate perpendicular offset (90° clockwise from heading)
|
|
// This places text slightly to the right of the movement direction
|
|
let font_size_val = font_size.value();
|
|
let offset_distance = f32::from(font_size_val) / 3.0;
|
|
|
|
// Perpendicular direction: heading - π/2 (rotated 90° clockwise)
|
|
let perpendicular_angle = heading_radians - std::f32::consts::PI / 2.0;
|
|
let offset_x = offset_distance * perpendicular_angle.cos();
|
|
let offset_y = offset_distance * perpendicular_angle.sin();
|
|
|
|
draw_text_ex(
|
|
text,
|
|
position.x + offset_x,
|
|
position.y + offset_y,
|
|
TextParams {
|
|
font_size: font_size_val,
|
|
rotation: rotation_rad,
|
|
color,
|
|
..Default::default()
|
|
},
|
|
);
|
|
}
|
|
|
|
/// Draw arc segments for circle tween animation
|
|
fn draw_tween_arc(
|
|
tween: &crate::tweening::CommandTween,
|
|
radius: f32,
|
|
total_angle: f32,
|
|
steps: usize,
|
|
direction: CircleDirection,
|
|
) {
|
|
let geom = CircleGeometry::new(
|
|
tween.start_params.position,
|
|
tween.start_params.heading,
|
|
radius,
|
|
direction,
|
|
);
|
|
|
|
// Debug: draw center using Lyon tessellation
|
|
if let Ok(mesh_data) = crate::tessellation::tessellate_circle(geom.center, 5.0, GRAY, true, 1.0)
|
|
{
|
|
draw_mesh(&mesh_data.to_mesh());
|
|
}
|
|
|
|
// Calculate how much of the arc we've traveled based on tween progress
|
|
// Use the same eased progress as the turtle position for synchronized animation
|
|
let elapsed = get_time() - tween.start_time;
|
|
let t = (elapsed / tween.duration).min(1.0);
|
|
let progress = CubicInOut.tween(1.0, t as f32); // tween from 0 to 1
|
|
|
|
// Use Lyon to tessellate and draw the partial arc
|
|
if let Ok(mesh_data) = crate::tessellation::tessellate_arc(
|
|
geom.center,
|
|
radius,
|
|
geom.start_angle_from_center.to_degrees(),
|
|
total_angle * progress,
|
|
tween.start_params.color,
|
|
tween.start_params.pen_width,
|
|
((steps as f32 * progress).ceil() as usize).max(1),
|
|
direction,
|
|
) {
|
|
draw_mesh(&mesh_data.to_mesh());
|
|
}
|
|
}
|
|
|
|
/// Draw the turtle shape
|
|
pub fn draw_turtle(turtle_params: &TurtleParams) {
|
|
let rotated_vertices = turtle_params.shape.rotated_vertices(turtle_params.heading);
|
|
|
|
if turtle_params.shape.filled {
|
|
// Draw filled polygon using Lyon tessellation
|
|
if rotated_vertices.len() >= 3 {
|
|
let absolute_vertices: Vec<Vec2> = rotated_vertices
|
|
.iter()
|
|
.map(|v| turtle_params.position + *v)
|
|
.collect();
|
|
|
|
// Use Lyon for turtle shape too
|
|
if let Ok(mesh_data) =
|
|
tessellation::tessellate_polygon(&absolute_vertices, Color::new(0.0, 0.5, 1.0, 1.0))
|
|
{
|
|
draw_mesh(&mesh_data.to_mesh());
|
|
} else {
|
|
// Fallback to simple triangle fan if Lyon fails
|
|
let first = absolute_vertices[0];
|
|
for i in 1..absolute_vertices.len() - 1 {
|
|
draw_triangle(
|
|
first,
|
|
absolute_vertices[i],
|
|
absolute_vertices[i + 1],
|
|
Color::new(0.0, 0.5, 1.0, 1.0),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Draw outline
|
|
if !rotated_vertices.is_empty() {
|
|
for i in 0..rotated_vertices.len() {
|
|
let next_i = (i + 1) % rotated_vertices.len();
|
|
let p1 = turtle_params.position + rotated_vertices[i];
|
|
let p2 = turtle_params.position + rotated_vertices[next_i];
|
|
draw_line(p1.x, p1.y, p2.x, p2.y, 2.0, Color::new(0.0, 0.5, 1.0, 1.0));
|
|
}
|
|
}
|
|
}
|
|
}
|