Struct RenderDataBundleStorage

pub struct RenderDataBundleStorage {
    pub observer_info: ObserverInfo,
    pub bundles: Vec<RenderDataBundle>,
    pub light_sources: Vec<LightSource>,
    /* private fields */
}

Bundle storage handles bundle generation for a scene before rendering. It is used to optimize rendering by reducing amount of state changes of OpenGL context.

Fields

observer_info: ObserverInfo

bundles: Vec<RenderDataBundle>

A sorted list of bundles.

light_sources: Vec<LightSource>

Implementations

impl RenderDataBundleStorage

pub fn new_empty(observer_info: ObserverInfo) -> Self

pub fn from_graph( graph: &Graph, elapsed_time: f32, observer_info: ObserverInfo, render_pass_name: ImmutableString, options: RenderDataBundleStorageOptions, ) -> Self

Creates a new render bundle storage from the given graph and observer info. It “asks” every node in the graph one-by-one to give render data which is then put in the storage, sorted and ready for rendering. Frustum culling is done on scene node side (crate::scene::node::NodeTrait::collect_render_data).

pub fn sort(&mut self)

Sorts the bundles by their respective sort index.

pub fn write_global_uniform_blocks( &self, render_context: &mut BundleRenderContext<'_>, ) -> GlobalUniformData

pub fn render_to_frame_buffer<BundleFilter, InstanceFilter>( &self, server: &dyn GraphicsServer, geometry_cache: &mut GeometryCache, shader_cache: &mut ShaderCache, bundle_filter: BundleFilter, instance_filter: InstanceFilter, render_context: BundleRenderContext<'_>, ) -> Result<RenderPassStatistics, FrameworkError>

where BundleFilter: FnMut(&RenderDataBundle) -> bool, InstanceFilter: FnMut(&SurfaceInstanceData) -> bool,

Draws the entire bundle set to the specified frame buffer with the specified rendering environment.

Trait Implementations

impl RenderDataBundleStorageTrait for RenderDataBundleStorage

fn push_triangles( &mut self, layout: &[VertexAttributeDescriptor], material: &MaterialResource, render_path: RenderPath, sort_index: u64, node_handle: Handle<Node>, func: &mut dyn FnMut(VertexBufferRefMut<'_>, TriangleBufferRefMut<'_>), )

Adds a new mesh to the bundle storage using the given set of vertices and triangles. This method automatically creates a render bundle according to a hash of the following parameters:

• Material
• Vertex Type
• Render Path

If one of these parameters is different, then a new bundle will be created and used to store the given vertices and indices. If an appropriate bundle exists, the method will store the given vertices and the triangles in it.

When to use

This method is used to reduce amount of draw calls of underlying GAPI, by merging small portions of data into one big block that shares drawing parameters and can be rendered in a single draw call. The vertices in this case should be pre-processed by applying world transform to them.

Do not use this method if you have a mesh with lots of vertices and triangles, because pre-processing them on CPU could take more time than rendering them directly on GPU one-by-one.

fn push( &mut self, data: &SurfaceResource, material: &MaterialResource, render_path: RenderPath, sort_index: u64, instance_data: SurfaceInstanceData, )

Adds a new surface instance to the storage. The method will automatically put the instance in the appropriate bundle. Bundle selection is done using the material, surface data, render path. If only one of these parameters is different, then the surface instance will be put in a separate bundle.