Enum Fixed 

pub enum Fixed<N>
where
    N: Copy + RealField,
{
    Hor(N),
    Ver(N),
    Upp(N),
}

Fixed quantity wrt field of view.

• Implements Default and can be created with Fixed::default() returning Fixed::Ver(N::frac_pi_4()).
• Implements From<N> and can be created with N::into() returning Fixed::Ver().

Variants

Hor(N)

Fixed horizontal field of view aka Vert- scaling.

Ver(N)

Fixed vertical field of view aka Hor+ scaling.

Upp(N)

Fixed unit per pixel on focus plane at distance from eye of one aka Pixel-based scaling.

Implementations

impl<N> Fixed<N>

where N: Copy + RealField,

pub fn to_hor(self, max: &OPoint<N, Const<2>>) -> Fixed<N>

Converts to fixed horizontal field of view wrt maximum position in screen space.

Examples found in repository

examples/scaling_modes.rs (line 81)

fn setup(
	mut windows: Query<&mut Window>,
	mut commands: Commands,
	mut meshes: ResMut<Assets<Mesh>>,
	mut materials: ResMut<Assets<StandardMaterial>>,
) {
	// circular base
	commands.spawn((
		Mesh3d(meshes.add(Circle::new(4.0))),
		MeshMaterial3d(materials.add(Color::WHITE)),
		Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
	));
	// cube
	commands.spawn((
		Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
		MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
		Transform::from_xyz(0.0, 0.5, 0.0),
	));
	// light
	commands.spawn((
		PointLight {
			shadow_maps_enabled: true,
			..default()
		},
		Transform::from_xyz(4.0, 8.0, 4.0),
	));

	// Windows
	let mut window1 = windows.single_mut().unwrap();
	"Fixed Vertical Field of View (Perspective vs Orthographic)".clone_into(&mut window1.title);
	let res = &window1.resolution;
	let max = Vec2::new(res.width() * 0.5, res.height()).into();
	// Left and right camera orientation.
	let [target, eye, up] = [Vec3::Y * 0.5, Vec3::new(-2.5, 4.5, 9.0) * 1.2, Vec3::Y];
	// Spawn a 2nd window.
	let window2 = commands
		.spawn(Window {
			title: "Fixed Horizontal Field of View (Perspective vs Orthographic)".to_owned(),
			..default()
		})
		.id();
	// Spawn a 3rd window.
	let window3 = commands
		.spawn(Window {
			title: "Fixed Unit Per Pixels (Perspective vs Orthographic)".to_owned(),
			..default()
		})
		.id();

	// Cameras
	let fov = Fixed::default();
	for (fov, window) in [
		(fov, WindowRef::Primary),
		(fov.to_hor(&max), WindowRef::Entity(window2)),
		(fov.to_upp(&max), WindowRef::Entity(window3)),
	] {
		let mut scope = Scope::default();
		scope.set_fov(fov);
		// Left trackball controller and camera 3D bundle.
		let left = commands
			.spawn((
				TrackballController::default(),
				Camera {
					order: 0,
					..default()
				},
				RenderTarget::Window(window),
				Camera3d::default(),
				LeftCamera,
			))
			.id();
		// Right trackball controller and camera 3D bundle.
		let right = commands
			.spawn((
				TrackballController::default(),
				Camera {
					order: 1,
					..default()
				},
				RenderTarget::Window(window),
				Camera3d::default(),
				RightCamera,
			))
			.id();
		// Insert left trackball camera and make it sensitive to right trackball controller as well.
		commands.entity(left).insert(
			TrackballCamera::look_at(target, eye, up)
				.with_scope(scope)
				.add_controller(right, true),
		);
		// Set orthographic projection mode for right camera.
		scope.set_ortho(true);
		// Insert right trackball camera and make it sensitive to left trackball controller as well.
		commands.entity(right).insert(
			TrackballCamera::look_at(target, eye, up)
				.with_scope(scope)
				.add_controller(left, true),
		);
	}
}

pub fn to_ver(self, max: &OPoint<N, Const<2>>) -> Fixed<N>

Converts to fixed vertical field of view wrt maximum position in screen space.

pub fn to_upp(self, max: &OPoint<N, Const<2>>) -> Fixed<N>

Converts to fixed unit per pixel on focus plane at distance from eye of one wrt maximum position in screen space.

Examples found in repository

examples/scaling_modes.rs (line 82)

fn setup(
	mut windows: Query<&mut Window>,
	mut commands: Commands,
	mut meshes: ResMut<Assets<Mesh>>,
	mut materials: ResMut<Assets<StandardMaterial>>,
) {
	// circular base
	commands.spawn((
		Mesh3d(meshes.add(Circle::new(4.0))),
		MeshMaterial3d(materials.add(Color::WHITE)),
		Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
	));
	// cube
	commands.spawn((
		Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
		MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
		Transform::from_xyz(0.0, 0.5, 0.0),
	));
	// light
	commands.spawn((
		PointLight {
			shadow_maps_enabled: true,
			..default()
		},
		Transform::from_xyz(4.0, 8.0, 4.0),
	));

	// Windows
	let mut window1 = windows.single_mut().unwrap();
	"Fixed Vertical Field of View (Perspective vs Orthographic)".clone_into(&mut window1.title);
	let res = &window1.resolution;
	let max = Vec2::new(res.width() * 0.5, res.height()).into();
	// Left and right camera orientation.
	let [target, eye, up] = [Vec3::Y * 0.5, Vec3::new(-2.5, 4.5, 9.0) * 1.2, Vec3::Y];
	// Spawn a 2nd window.
	let window2 = commands
		.spawn(Window {
			title: "Fixed Horizontal Field of View (Perspective vs Orthographic)".to_owned(),
			..default()
		})
		.id();
	// Spawn a 3rd window.
	let window3 = commands
		.spawn(Window {
			title: "Fixed Unit Per Pixels (Perspective vs Orthographic)".to_owned(),
			..default()
		})
		.id();

	// Cameras
	let fov = Fixed::default();
	for (fov, window) in [
		(fov, WindowRef::Primary),
		(fov.to_hor(&max), WindowRef::Entity(window2)),
		(fov.to_upp(&max), WindowRef::Entity(window3)),
	] {
		let mut scope = Scope::default();
		scope.set_fov(fov);
		// Left trackball controller and camera 3D bundle.
		let left = commands
			.spawn((
				TrackballController::default(),
				Camera {
					order: 0,
					..default()
				},
				RenderTarget::Window(window),
				Camera3d::default(),
				LeftCamera,
			))
			.id();
		// Right trackball controller and camera 3D bundle.
		let right = commands
			.spawn((
				TrackballController::default(),
				Camera {
					order: 1,
					..default()
				},
				RenderTarget::Window(window),
				Camera3d::default(),
				RightCamera,
			))
			.id();
		// Insert left trackball camera and make it sensitive to right trackball controller as well.
		commands.entity(left).insert(
			TrackballCamera::look_at(target, eye, up)
				.with_scope(scope)
				.add_controller(right, true),
		);
		// Set orthographic projection mode for right camera.
		scope.set_ortho(true);
		// Insert right trackball camera and make it sensitive to left trackball controller as well.
		commands.entity(right).insert(
			TrackballCamera::look_at(target, eye, up)
				.with_scope(scope)
				.add_controller(left, true),
		);
	}
}

pub fn max_and_upp( &self, zat: N, max: &OPoint<N, Const<2>>, ) -> (OPoint<N, Const<2>>, N)

Maximum position in camera space and unit per pixel on focus plane wrt distance between eye and target and maximum position in screen space.

pub const fn into_inner(self) -> N

Underlying quantity.

pub fn cast<M>(self) -> Fixed<M>

where M: Copy + RealField, N: SubsetOf<M>,

Casts components to another type, e.g., between f32 and f64.

Trait Implementations

impl<N> Clone for Fixed<N>

where N: Clone + Copy + RealField,

fn clone(&self) -> Fixed<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N> Copy for Fixed<N>

where N: Copy + RealField,

impl<N> Debug for Fixed<N>

where N: Debug + Copy + RealField,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<N> Default for Fixed<N>

where N: Copy + RealField,

fn default() -> Fixed<N>

Returns the “default value” for a type.

impl<N> Eq for Fixed<N>

where N: Eq + Copy + RealField,

impl<N> From<N> for Fixed<N>

where N: Copy + RealField,

fn from(fov: N) -> Fixed<N>

Converts to this type from the input type.

impl<N> PartialEq for Fixed<N>

where N: PartialEq + Copy + RealField,

fn eq(&self, other: &Fixed<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N> StructuralPartialEq for Fixed<N>

where N: PartialEq + Copy + RealField,