Struct Mesh3D

pub struct Mesh3D {
    pub transform: Transform3D,
    pub vertices: Vec<Vec3D>,
    pub faces: Vec<Face>,
}

A 3D mesh made up of vertices, faces made of indices into vertices, and a transformation.

Fields

transform: Transform3D

The mesh’s transform matrix in 3D space

vertices: Vec<Vec3D>

A vector of the Mesh3D’s vertices

faces: Vec<Face>

A vector of Faces of indexes into vertices

Implementations

impl Mesh3D

pub fn default_cube() -> Self

The gemini_engine equivalent of Blender’s default cube. Has sides of length 2

Examples found in repository

examples/spinning-cube.rs (line 22)

fn main() {
    let mut view = View::new(100, 50, ColChar::EMPTY);

    let mut viewport = Viewport::new(
        Transform3D::look_at_lh(Vec3D::new(0.0, -1.5, 4.3), Vec3D::ZERO, Vec3D::Y),
        FOV,
        view.center(),
    );
    viewport.objects.push(Mesh3D::default_cube());

    viewport.display_mode = DisplayMode::Illuminated {
        lights: vec![
            Light::new_ambient(0.3),
            Light::new_directional(0.6, Vec3D::new(0.5, 1.0, 1.0)),
        ],
    };

    fps_gameloop!(
        {
            viewport.objects[0].transform = viewport.objects[0]
                .transform
                .mul_mat4(&Transform3D::from_rotation_y(-0.05));
        },
        {
            view.clear();
            view.draw(&viewport);
            let _ = view.display_render();
        },
        FPS,
        |elapsed: Duration, frame_skip| {
            println!(
                "Elapsed: {:.2?}µs | Frame skip: {}",
                elapsed.as_micros(),
                frame_skip
            );
        }
    );
}

pub fn torus( outer_radius: f64, inner_radius: f64, outer_segments: usize, inner_segments: usize, ) -> Self

Create a torus (donut shape)

Examples found in repository

examples/donut.rs (line 28)

fn main() {
    let mut view = View::new(100, 45, ColChar::EMPTY);
    let mut viewport = Viewport::new(
        Transform3D::look_at_lh(Vec3D::new(0.0, -3.0, 6.0), Vec3D::ZERO, Vec3D::Y),
        FOV,
        view.center(),
    );

    viewport.display_mode = DisplayMode::Illuminated {
        lights: vec![
            Light::new_ambient(0.3),
            Light::new_directional(0.7, Vec3D::new(1.0, 1.0, 1.0)),
        ],
    };

    viewport.objects.push(Mesh3D::torus(1.8, 1.0, 32, 16));

    fps_gameloop!(
        {
            let donut_tr = &mut viewport.objects[0].transform;
            *donut_tr = donut_tr.mul_mat4(&Transform3D::from_rotation_y(-0.03));
            *donut_tr = donut_tr.mul_mat4(&Transform3D::from_rotation_x(0.03));
        },
        {
            view.clear();
            view.draw(&viewport);
            let _ = view.display_render();
        },
        FPS
    );
}

pub fn gimbal() -> Self

A gimbal to help you orient in gemini_engine’s 3D space. The orientation is as follows (from the default Viewport)

• X (red) increases as you move to the right
• Y (green) increases as you move up
• Z (blue) increases as you move away from the viewport

Think of it like Blender’s axes but with Y and Z swapped. Since this Mesh does not have a real triangle mesh, it is only visible in DisplayMode::Wireframe

impl Mesh3D

pub const fn new(vertices: Vec<Vec3D>, faces: Vec<Face>) -> Self

Create a Mesh3D with an identity Transform3D

pub const fn with_transform(self, transform: Transform3D) -> Self

Return the Mesh3D with an updated transform property. Consumes the original Mesh3D

Trait Implementations

impl Clone for Mesh3D

fn clone(&self) -> Mesh3D

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Mesh3D

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

Formats the value using the given formatter.