Struct SurfaceData

pub struct SurfaceData {
    pub vertex_buffer: VertexBuffer,
    pub geometry_buffer: TriangleBuffer,
    pub blend_shapes_container: Option<BlendShapesContainer>,
    /* private fields */
}

Data source of a surface. Each surface can share same data source, this is used in instancing technique to render multiple instances of same model at different places.

Fields

vertex_buffer: VertexBuffer

Current vertex buffer.

geometry_buffer: TriangleBuffer

Current geometry buffer.

blend_shapes_container: Option<BlendShapesContainer>

A container for blend shapes.

Implementations

impl SurfaceData

pub const VERTEX_BUFFER: &'static str = "vertex_buffer"

pub const GEOMETRY_BUFFER: &'static str = "geometry_buffer"

pub const BLEND_SHAPES_CONTAINER: &'static str = "blend_shapes_container"

impl SurfaceData

pub fn new(vertex_buffer: VertexBuffer, triangles: TriangleBuffer) -> Self

Creates new data source using given vertices and indices.

pub fn transform_geometry( &mut self, transform: &Matrix4<f32>, ) -> Result<(), VertexFetchError>

Applies given transform for every spatial part of the data (vertex position, normal, tangent).

pub fn from_raw_mesh<T>(raw: RawMesh<T>) -> Self

where T: VertexTrait,

Converts raw mesh into “renderable” mesh. It is useful to build procedural meshes. See RawMesh docs for more info.

pub fn calculate_tangents(&mut self) -> Result<(), VertexFetchError>

Calculates tangents of surface. Tangents are needed for correct lighting, you will get incorrect lighting if tangents of your surface are invalid! When engine loads a mesh from “untrusted” source, it automatically calculates tangents for you, so there is no need to call this manually in this case. However if you making your mesh procedurally, you have to use this method! This method uses “classic” method which is described in: “Computing Tangent Space Basis Vectors for an Arbitrary Mesh” article by Eric Lengyel.

pub fn make_unit_xy_quad() -> Self

Creates a quad oriented on oXY plane with unit width and height.

pub fn make_collapsed_xy_quad() -> Self

Creates a degenerated quad which collapsed in a point. This is very special method for sprite renderer - shader will automatically “push” corners in correct sides so sprite will always face camera.

pub fn make_quad(transform: &Matrix4<f32>) -> Self

Creates new quad at oXY plane with given transform.

pub fn calculate_normals(&mut self) -> Result<(), VertexFetchError>

Calculates per-face normals. This method is fast, but have very poor quality, and surface will look facet.

pub fn make_sphere( slices: usize, stacks: usize, r: f32, transform: &Matrix4<f32>, ) -> Self

Creates sphere of specified radius with given slices and stacks. The larger the slices and stacks, the smoother the sphere will be. Typical values are [16..32]. The sphere is then transformed by the given transformation matrix, which could be Matrix4::identity to not modify the sphere at all.

pub fn make_cone(sides: usize, r: f32, h: f32, transform: &Matrix4<f32>) -> Self

Creates vertical cone with the given amount of sides, radius, height. The larger the amount of sides, the smoother the cone will be, typical values are [16..32]. The cone is then transformed using the given transformation matrix, which could be Matrix4::identity to not modify the cone at all.

pub fn make_torus( inner_radius: f32, outer_radius: f32, num_rings: usize, num_segments: usize, transform: &Matrix4<f32>, ) -> Self

Creates a torus in oXY plane with the given inner and outer radii. num_rings defines the amount of “slices” around the Z axis of the torus shape, num_segments defines the amount of segments in every slice. The larger the num_rings and num_segments are, the more smooth the torus will be, typical values are 16..32. Torus will be transformed using the given transformation matrix, which could be Matrix4::identity to not modify the torus at all.

pub fn make_cylinder( sides: usize, r: f32, h: f32, caps: bool, transform: &Matrix4<f32>, ) -> Self

Creates vertical cylinder with the given amount of sides, radius, height and optional caps. The larger the sides, the smoother the cylinder will be, typical values are [16..32]. caps defines whether the cylinder will have caps or not. The cylinder is transformed using the given transformation matrix, which could be Matrix4::identity to not modify the cylinder at all.

pub fn make_cube(transform: Matrix4<f32>) -> Self

Creates unit cube with the given transform, which could be Matrix4::identity to not modify the cube at all and leave it unit.

pub fn content_hash(&self) -> u64

Calculates hash based on the contents of the surface shared data. This could be time-consuming if there’s a lot of vertices or indices.

pub fn clear(&mut self)

Clears both vertex and index buffers.

Trait Implementations

impl Clone for SurfaceData

fn clone(&self) -> SurfaceData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SurfaceData

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

Formats the value using the given formatter.

impl Default for SurfaceData

fn default() -> SurfaceData

Returns the “default value” for a type.

impl Reflect for SurfaceData

where Self: 'static, VertexBuffer: Reflect, TriangleBuffer: Reflect, Option<BlendShapesContainer>: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&dyn Any))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn Any))

fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect))

fn fields(&self, func: &mut dyn FnMut(&[&dyn Reflect]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [&mut dyn Reflect]))

fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>))

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl ResourceData for SurfaceData

fn type_uuid(&self) -> Uuid

Returns unique data type id.

fn save(&mut self, _path: &Path) -> Result<(), Box<dyn Error>>

Saves the resource data a file at the specified path. This method is free to decide how the resource data is saved. This is needed, because there are multiple formats that defines various kinds of resources. For example, a rectangular texture could be saved into a bunch of formats, such as png, bmp, tga, jpg etc., but in the engine it is single Texture resource. In any case, produced file should be compatible with a respective resource loader.

fn can_be_saved(&self) -> bool

Returns true if the resource data can be saved to a file, false - otherwise. Not every resource type supports saving, for example there might be temporary resource type that is used only at runtime which does not need saving at all.

impl TypeUuidProvider for SurfaceData

fn type_uuid() -> Uuid

Return type UUID.

impl Visit for SurfaceData

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult

Read or write this value, depending on whether Visitor::is_reading() is true or false.