Function vec3 

pub const fn vec3(x: f32, y: f32, z: f32) -> Vec3

Shorthand Vec3 constructor.

Examples found in repository

examples/chat/welcome.rs (line 553)

fn axis_hit(origin: Vec3, direction: Vec3) -> (f32, bool, Vec3) {
	let quadratic = direction.x * direction.x + direction.z * direction.z;
	let linear = 2.0 * (origin.x * direction.x + origin.z * direction.z);
	let constant = origin.x * origin.x + origin.z * origin.z - AXIS_RADIUS * AXIS_RADIUS;
	let discriminant = linear * linear - 4.0 * quadratic * constant;
	let root = (-linear - discriminant.max(0.0).sqrt()) / (2.0 * quadratic).max(1e-8);
	let hit_y = origin.y + direction.y * root;
	let cylinder = if discriminant >= 0.0 && root > 0.0 && (AXIS_BOTTOM..=AXIS_TOP).contains(&hit_y)
	{
		root
	} else {
		f32::INFINITY
	};
	let cap_center = vec3(0.0, AXIS_TOP, 0.0);
	let cap = sphere_depth(origin, direction, cap_center, AXIS_RADIUS * 1.75);
	let depth = cylinder.min(cap);
	if !depth.is_finite() {
		return (f32::INFINITY, false, vec3(0.0, 1.0, 0.0));
	}
	let point = origin + direction * depth;
	let normal = if cap < cylinder {
		(point - cap_center).normalize()
	} else {
		vec3(point.x, 0.0, point.z).normalize()
	};
	(depth, true, normal)
}

/// Terminal display lift in linear light so braille remains legible on the
/// dark card.
fn tone(color: Vec3) -> Vec3 {
	color * 1.28 + Vec3::rgb(4, 4, 4)
}

/// Per-frame scene state shared by every ray: sun direction, disk spin,
/// glass transition, and the pointer camera offsets.
struct Platter {
	sun:        Vec3,
	angle:      f32,
	transition: f32,
	/// Smoothed pointer camera from [`Welcome`]: (lift, yaw).
	pointer:    (f32, f32),
}

impl Platter {
	fn new(pointer: (f32, f32)) -> Self {
		Self { sun: vec3(-0.55, 1.0, 0.38).normalize(), angle: 0.0, transition: 0.0, pointer }
	}

	/// Floor glow: light shafts, the disk's shadow, tinted transmission
	/// through the glass, and a soft rim reflection.
	fn ground(&self, origin: Vec3, direction: Vec3) -> (Vec3, f32) {
		if direction.y >= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let depth = (FLOOR_Y - origin.y) / direction.y;
		if depth <= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let floor = origin + direction * depth;
		let stage =
			(-0.42 * ((floor.x.abs() / 2.30).powi(4) + ((floor.z + 0.15).abs() / 1.70).powi(4))).exp();

		let sun_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / self.sun.y;
		let sunlit = floor + self.sun * sun_depth;
		let shadow_radius = sunlit.x.hypot(sunlit.z);
		let occlusion = smooth(((DISK_RADIUS + 0.08 - shadow_radius) / 0.16).clamp(0.0, 1.0));
		let rays = sun_rays(floor.x, floor.z);

		let neutral_alpha = stage * rays * (1.0 - occlusion) * 0.36;
		let neutral = (BACKGROUND + vec3(0.36, 0.33, 0.27) * (stage * rays)).clamp01();
		let mut color = neutral * neutral_alpha + BACKGROUND * (1.0 - neutral_alpha);
		let mut alpha = neutral_alpha;

		let transmission_alpha =
			stage * sun_rays(sunlit.x, sunlit.z) * occlusion * self.transition * 0.64;
		let transmission =
			(BACKGROUND + gradient(sunlit.z.atan2(sunlit.x) - self.angle) * 0.86).clamp01();
		color = transmission * transmission_alpha + color * (1.0 - transmission_alpha);
		alpha = transmission_alpha + alpha * (1.0 - transmission_alpha);

		let mirrored = vec3(direction.x, -direction.y, direction.z);
		let reflected_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / mirrored.y.max(1e-6);
		let reflected = floor + mirrored * reflected_depth;
		let reflected_radius = reflected.x.hypot(reflected.z);
		if reflected_radius <= DISK_RADIUS {
			let edge = smooth(((DISK_RADIUS - reflected_radius) / 0.13).clamp(0.0, 1.0));
			let grazing = (1.0 + direction.y).clamp(0.0, 1.0);
			let reflection_alpha = self.transition * edge * (0.22 + 0.28 * grazing);
			let reflection = gradient(reflected.z.atan2(reflected.x) - self.angle);
			color = reflection * reflection_alpha + color * (1.0 - reflection_alpha);
			alpha = reflection_alpha + alpha * (1.0 - reflection_alpha);
		}
		(color, alpha)
	}
}

impl Trace for Platter {
	fn advance(&mut self, now: Duration) -> Camera {
		let elapsed = now.as_secs_f32();
		self.angle = disk_rotation(elapsed);
		self.transition = color_mix(elapsed);
		Camera {
			target:   vec3(0.0, 0.08, 0.0),
			yaw:      self.pointer.1 + reveal_orbit(elapsed) + (elapsed * 0.31).sin() * 0.018,
			pitch:    CAMERA_PITCH,
			distance: CAMERA_DISTANCE,
			lift:     self.pointer.0.clamp(-0.42, 0.42) + (elapsed * 0.55).sin() * 0.014,
			focal:    CAMERA_FOCAL,
		}
	}