Struct Vertex 

#[repr(C)]
pub struct Vertex {
    pub position: [f32; 3],
    pub tex_coords: [f32; 2],
    pub normal: [f32; 3],
}

A rust representation of what a Vertex that is passed to mesh and onto WGPU and its shaders.

Fields

position: [f32; 3]

tex_coords: [f32; 2]

normal: [f32; 3]

Implementations

impl Vertex

pub fn desc() -> VertexBufferLayout<'static>

Examples found in repository

examples/test_components.rs (line 61)

    fn create(engine: &mut RenderEngine) -> Self { 
        // generate camera
        let mut camera = Camera::new(
            &engine, 
            engine.config.width as f32 / engine.config.height as f32,
            45.0, 0.1, 100.0
        );
        camera.position = (0.0, 0.0, 5.0).into();
        camera.update(engine);

        // create instances
        let instances = vec![Transform {
            position: cgmath::Vector3 { x: 0.0, y: 0.0, z: 0.0 },
            rotation: cgmath::Quaternion::euler_deg_z(0.0),
            scale: (1.0, 1.0, 1.0).into()
        }];

        engine.verify_pipeline_exists("forte.test", |engine| {
            Pipeline::new(
                "std", &engine, include_str!("rotating_cube.wgsl"),
                &[Vertex::desc(), TransformRaw::desc()],
                &[
                    &engine.device.create_bind_group_layout(&Camera::BIND_LAYOUT),
                    &engine.device.create_bind_group_layout(&Texture::BIND_LAYOUT),
                ],
                true
            )
        });

        Self {
            instance_buffer: TransformRaw::buffer_from_generic(engine, &instances),
            mesh: engine.create_mesh("test", VERTICES, INDICES),
            texture: engine.create_texture("test", include_bytes!("rotating_cube.png")),
            camera, instances,
            test: "".to_string()
        }
    }

examples/rotating_cube.rs (line 50)

    fn create(mut engine: RenderEngine) -> Self {
        // create render pipeline
        let pipeline = Pipeline::new(
            "std", &engine, include_str!("rotating_cube.wgsl"),
            &[Vertex::desc(), TransformRaw::desc()],
            &[
                &engine.device.create_bind_group_layout(&Camera::BIND_LAYOUT),
                &engine.device.create_bind_group_layout(&Texture::BIND_LAYOUT),
            ],
            true
        );

        // generate camera
        let mut camera = Camera::new(
            &engine, 
            engine.config.width as f32 / engine.config.height as f32,
            45.0, 0.1, 100.0
        );
        camera.position = (0.0, 0.0, 5.0).into();
        camera.update(&mut engine);
        let camera_controller = CameraController::new(0.02);

        // create instances
        let instances = vec![Transform {
            position: cgmath::Vector3 { x: 0.0, y: 0.0, z: 0.0 },
            rotation: cgmath::Quaternion::from_axis_angle(cgmath::Vector3::unit_z(), cgmath::Deg(0.0)),
            scale: (1.0, 1.0, 1.0).into()
        }];

        // create instance buffer
        let instance_data = instances.iter().map(TransformRaw::from_generic).collect::<Vec<_>>();
        let instance_buffer = engine.device.create_buffer_init(
            &wgpu::util::BufferInitDescriptor {
                label: Some("Instance Buffer"),
                contents: bytemuck::cast_slice(&instance_data),
                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST
            }
        );

        let mesh = engine.create_mesh("test", VERTICES, INDICES);
        let texture = engine.create_texture("test", include_bytes!("rotating_cube.png"));

        // create instance of self
        Self {
            render_engine: engine,
            mesh, texture,
            camera, pipeline,
            controller: camera_controller,
            instances, instance_buffer
        }
    }

Trait Implementations

impl Clone for Vertex

fn clone(&self) -> Vertex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Vertex

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

Formats the value using the given formatter.

impl Zeroable for Vertex

fn zeroed() -> Self

Calls zeroed.

impl Copy for Vertex

impl Pod for Vertex