Struct despero::render::pbr::model::Mesh

pub struct Mesh {
    pub vertexdata: Vec<Vertex>,
    pub indexdata: Vec<u32>,
    /* private fields */
}

Model mesh struct

Fields

vertexdata: Vec<Vertex>

indexdata: Vec<u32>

Implementations

impl Mesh

pub fn plane() -> Self

Create a textured plane mesh

Examples found in repository

examples/pbr.rs (line 44)

fn create_scene(
    mut cmd: Write<CommandBuffer>,
    mut asset_manager: Write<AssetManager>,
){    
    let diffuse = asset_manager.create_texture("assets/pbr_test/diffuse.jpg", Filter::Linear);
    
    cmd.spawn(
        ModelBundle::builder()
            .mesh(Mesh::plane())
            .material(asset_manager.create_material(
                DefaultMat::builder()
                    .albedo(diffuse)
                    .metallic(0.0)
                    .roughness(0.5)
                    .build()
            ))
            .transform(Transform::from_rotation(UnitQuaternion::from_axis_angle(&Vector3::x_axis(), to_radian(-45.0))))
            .build()
    );
    
    cmd.spawn((
        Camera::builder()
            .is_active(true)
            .camera_type(CameraType::FirstPerson)
            .build(),
        Transform::from_translation(Vector3::new(0.0, 0.0, 3.0)),
        CameraConfiguration {
            limit: (-85.0, 85.0),
            ..Default::default()
        },
    ));
    
    cmd.spawn((
        DirectionalLight {
            direction: Vector3::new(-1., -1., 0.),
            illuminance: [0.5, 0.5, 0.5],
        },
    ));
    
    let sky_tex = asset_manager.create_texture("assets/StandardCubeMap.png", Filter::Linear);
    
    cmd.spawn(
        ModelBundle::builder()
            .mesh(Mesh::load_obj("assets/skybox.obj").swap_remove(0))
            .material(
                asset_manager.create_material(
                    DefaultMat::builder()
                        .albedo(sky_tex)
                        .build()
                )
            )
            .transform(Transform::default())
            .build()
    );
}

pub fn cube() -> Self

Create untextured cube mesh

pub fn icosahedron() -> Self

Create ico sphere mesh

pub fn sphere(refinements: u32) -> Self

Create untextured sphere mesh with given resolution

pub fn load_obj<P>(path: P) -> Vec<Self>where P: AsRef<Path> + Debug,

Load model from .obj file

Examples found in repository

examples/serde.rs (line 38)

fn setup(
    mut asset_manager: Write<AssetManager>,
    mut cmd: Write<CommandBuffer>,
){
    let texture_id = asset_manager.create_texture("assets/uv.jpg", Filter::Nearest);    
    let mesh = Mesh::load_obj("assets/model.obj").swap_remove(0);
    
    cmd.spawn(ModelBundle {
        mesh,
        material: asset_manager.create_material(
            DefaultMat::builder()
                .albedo(texture_id)
                .metallic(0.0)
                .roughness(1.0)
                .build(),
        ),
        transform: Transform::default(),
    });
    
    cmd.spawn(CameraBundle{
        camera: 
            Camera::builder()
                .is_active(true)
                .build(),
        transform: Transform::from_translation(Vector3::new(0.0, 0.0, 5.0)),
    });
}

examples/pbr.rs (line 79)

fn create_scene(
    mut cmd: Write<CommandBuffer>,
    mut asset_manager: Write<AssetManager>,
){    
    let diffuse = asset_manager.create_texture("assets/pbr_test/diffuse.jpg", Filter::Linear);
    
    cmd.spawn(
        ModelBundle::builder()
            .mesh(Mesh::plane())
            .material(asset_manager.create_material(
                DefaultMat::builder()
                    .albedo(diffuse)
                    .metallic(0.0)
                    .roughness(0.5)
                    .build()
            ))
            .transform(Transform::from_rotation(UnitQuaternion::from_axis_angle(&Vector3::x_axis(), to_radian(-45.0))))
            .build()
    );
    
    cmd.spawn((
        Camera::builder()
            .is_active(true)
            .camera_type(CameraType::FirstPerson)
            .build(),
        Transform::from_translation(Vector3::new(0.0, 0.0, 3.0)),
        CameraConfiguration {
            limit: (-85.0, 85.0),
            ..Default::default()
        },
    ));
    
    cmd.spawn((
        DirectionalLight {
            direction: Vector3::new(-1., -1., 0.),
            illuminance: [0.5, 0.5, 0.5],
        },
    ));
    
    let sky_tex = asset_manager.create_texture("assets/StandardCubeMap.png", Filter::Linear);
    
    cmd.spawn(
        ModelBundle::builder()
            .mesh(Mesh::load_obj("assets/skybox.obj").swap_remove(0))
            .material(
                asset_manager.create_material(
                    DefaultMat::builder()
                        .albedo(sky_tex)
                        .build()
                )
            )
            .transform(Transform::default())
            .build()
    );
}

pub fn refine(&mut self)

Subdivide mesh triangles

Trait Implementations

impl Clone for Mesh

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Mesh

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Mesh

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl SerializableComponent for Mesh

fn add_into(&self, entity_builder: &mut EntityBuilder)

impl Serialize for Mesh

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.