Struct MaterialProperties 

pub struct MaterialProperties {

    pub render_method: OpaqueRendererMethod,
    pub alpha_mode: AlphaMode,
    pub mesh_pipeline_key_bits: ErasedMeshPipelineKey,
    pub depth_bias: f32,
    pub reads_view_transmission_texture: bool,
    pub render_phase_type: RenderPhaseType,
    pub material_layout: Option<BindGroupLayoutDescriptor>,
    pub draw_functions: SmallVec<[(Interned<dyn DrawFunctionLabel>, DrawFunctionId); 11]>,
    pub shaders: SmallVec<[(Interned<dyn ShaderLabel>, Handle<Shader>); 6]>,
    pub bindless: bool,
    pub base_specialize: Option<fn(&mut World, ErasedMaterialPipelineKey, &MeshVertexBufferLayoutRef, &Arc<MaterialProperties>) -> Result<CachedRenderPipelineId, SpecializedMeshPipelineError>>,
    pub prepass_specialize: Option<fn(&mut World, &ErasedMaterialPipelineKey, &MeshVertexBufferLayoutRef, &Arc<MaterialProperties>) -> Result<CachedRenderPipelineId, SpecializedMeshPipelineError>>,
    pub user_specialize: Option<fn(&(dyn Any + 'static), &mut RenderPipelineDescriptor, &MeshVertexBufferLayoutRef, ErasedMaterialPipelineKey) -> Result<(), SpecializedMeshPipelineError>>,
    pub material_key: ErasedMaterialKey,
    pub shadows_enabled: bool,
    pub prepass_enabled: bool,
    pub oit_enabled: bool,
}

Available on crate feature bevy_material only.

Common material properties, calculated for a specific material instance.

Fields

render_method: OpaqueRendererMethod

Is this material should be rendered by the deferred renderer when. AlphaMode::Opaque or AlphaMode::Mask

alpha_mode: AlphaMode

The AlphaMode of this material.

mesh_pipeline_key_bits: ErasedMeshPipelineKey

The bits in the ErasedMeshPipelineKey for this material.

These are precalculated so that we can just “or” them together in queue_material_meshes.

depth_bias: f32

Add a bias to the view depth of the mesh which can be used to force a specific render order for meshes with equal depth, to avoid z-fighting. The bias is in depth-texture units so large values may be needed to overcome small depth differences.

reads_view_transmission_texture: bool

Whether the material would like to read from ViewTransmissionTexture.

This allows taking color output from the Opaque3d pass as an input, (for screen-space transmission) but requires rendering to take place in a separate Transmissive3d pass.

render_phase_type: RenderPhaseType

material_layout: Option<BindGroupLayoutDescriptor>

draw_functions: SmallVec<[(Interned<dyn DrawFunctionLabel>, DrawFunctionId); 11]>

Backing array is a size of 11 because the StandardMaterial needs 11 draw functions by default

shaders: SmallVec<[(Interned<dyn ShaderLabel>, Handle<Shader>); 6]>

Backing array is a size of 6 because the StandardMaterial has 6 custom shaders (frag, prepass_frag, deferred_frag, vertex, prepass_vertex, deferred vertex) which is the most common use case

bindless: bool

Whether this material actually uses bindless resources, taking the platform support (or lack thereof) of bindless resources into account.

base_specialize: Option<fn(&mut World, ErasedMaterialPipelineKey, &MeshVertexBufferLayoutRef, &Arc<MaterialProperties>) -> Result<CachedRenderPipelineId, SpecializedMeshPipelineError>>

prepass_specialize: Option<fn(&mut World, &ErasedMaterialPipelineKey, &MeshVertexBufferLayoutRef, &Arc<MaterialProperties>) -> Result<CachedRenderPipelineId, SpecializedMeshPipelineError>>

user_specialize: Option<fn(&(dyn Any + 'static), &mut RenderPipelineDescriptor, &MeshVertexBufferLayoutRef, ErasedMaterialPipelineKey) -> Result<(), SpecializedMeshPipelineError>>

material_key: ErasedMaterialKey

The key for this material, typically a bitfield of flags that are used to modify the pipeline descriptor used for this material.

shadows_enabled: bool

Whether shadows are enabled for this material

prepass_enabled: bool

Whether prepass is enabled for this material

oit_enabled: bool

Whether OIT is enabled for this material

Implementations

impl MaterialProperties

pub fn get_shader(&self, label: impl ShaderLabel) -> Option<Handle<Shader>>

pub fn add_shader(&mut self, label: impl ShaderLabel, shader: Handle<Shader>)

Examples found in repository

examples/shader_advanced/manual_material.rs (line 207)

    fn prepare_asset(
        source_asset: Self::SourceAsset,
        asset_id: AssetId<Self::SourceAsset>,
        (
            opaque_draw_functions,
            material_layout,
            asset_server,
            bind_group_allocators,
            render_material_bindings,
            gpu_images,
            image_material_sampler,
        ): &mut SystemParamItem<Self::Param>,
    ) -> std::result::Result<Self::ErasedAsset, PrepareAssetError<Self::SourceAsset>> {
        let material_layout = material_layout.0.clone();
        let draw_function_id = opaque_draw_functions.read().id::<DrawMaterial>();
        let bind_group_allocator = bind_group_allocators
            .get_mut(&TypeId::of::<ImageMaterial>())
            .unwrap();
        let Some(image) = gpu_images.get(&source_asset.image) else {
            return Err(PrepareAssetError::RetryNextUpdate(source_asset));
        };
        let mut unprepared = BindGroupBuilder {
            binding_resources: UnpreparedBindingResources(vec![
                (
                    0,
                    UnpreparedBindingResource::TextureView(
                        TextureViewDimension::D2,
                        image.texture_view.clone(),
                    ),
                ),
                (
                    1,
                    UnpreparedBindingResource::Sampler(
                        SamplerBindingType::NonFiltering,
                        image_material_sampler.0.clone(),
                    ),
                ),
            ]),
            data_buffer: vec![],
        };
        let binding = match render_material_bindings.entry(asset_id.into()) {
            Entry::Occupied(mut occupied_entry) => {
                bind_group_allocator.free(*occupied_entry.get());
                let new_binding =
                    bind_group_allocator.allocate_unprepared(&mut unprepared, &material_layout);
                *occupied_entry.get_mut() = new_binding;
                new_binding
            }
            Entry::Vacant(vacant_entry) => *vacant_entry.insert(
                bind_group_allocator.allocate_unprepared(&mut unprepared, &material_layout),
            ),
        };

        let mut properties = MaterialProperties {
            material_layout: Some(material_layout),
            mesh_pipeline_key_bits: ErasedMeshPipelineKey::new(MeshPipelineKey::empty()),
            base_specialize: Some(base_specialize),
            ..Default::default()
        };
        properties.add_draw_function(MainPassOpaqueDrawFunction, draw_function_id);
        properties.add_shader(MaterialFragmentShader, asset_server.load(SHADER_ASSET_PATH));

        Ok(PreparedMaterial {
            binding,
            properties: Arc::new(properties),
        })
    }

pub fn get_draw_function( &self, label: impl DrawFunctionLabel, ) -> Option<DrawFunctionId>

pub fn add_draw_function( &mut self, label: impl DrawFunctionLabel, draw_function: DrawFunctionId, )

Examples found in repository

examples/shader_advanced/manual_material.rs (line 206)

    fn prepare_asset(
        source_asset: Self::SourceAsset,
        asset_id: AssetId<Self::SourceAsset>,
        (
            opaque_draw_functions,
            material_layout,
            asset_server,
            bind_group_allocators,
            render_material_bindings,
            gpu_images,
            image_material_sampler,
        ): &mut SystemParamItem<Self::Param>,
    ) -> std::result::Result<Self::ErasedAsset, PrepareAssetError<Self::SourceAsset>> {
        let material_layout = material_layout.0.clone();
        let draw_function_id = opaque_draw_functions.read().id::<DrawMaterial>();
        let bind_group_allocator = bind_group_allocators
            .get_mut(&TypeId::of::<ImageMaterial>())
            .unwrap();
        let Some(image) = gpu_images.get(&source_asset.image) else {
            return Err(PrepareAssetError::RetryNextUpdate(source_asset));
        };
        let mut unprepared = BindGroupBuilder {
            binding_resources: UnpreparedBindingResources(vec![
                (
                    0,
                    UnpreparedBindingResource::TextureView(
                        TextureViewDimension::D2,
                        image.texture_view.clone(),
                    ),
                ),
                (
                    1,
                    UnpreparedBindingResource::Sampler(
                        SamplerBindingType::NonFiltering,
                        image_material_sampler.0.clone(),
                    ),
                ),
            ]),
            data_buffer: vec![],
        };
        let binding = match render_material_bindings.entry(asset_id.into()) {
            Entry::Occupied(mut occupied_entry) => {
                bind_group_allocator.free(*occupied_entry.get());
                let new_binding =
                    bind_group_allocator.allocate_unprepared(&mut unprepared, &material_layout);
                *occupied_entry.get_mut() = new_binding;
                new_binding
            }
            Entry::Vacant(vacant_entry) => *vacant_entry.insert(
                bind_group_allocator.allocate_unprepared(&mut unprepared, &material_layout),
            ),
        };

        let mut properties = MaterialProperties {
            material_layout: Some(material_layout),
            mesh_pipeline_key_bits: ErasedMeshPipelineKey::new(MeshPipelineKey::empty()),
            base_specialize: Some(base_specialize),
            ..Default::default()
        };
        properties.add_draw_function(MainPassOpaqueDrawFunction, draw_function_id);
        properties.add_shader(MaterialFragmentShader, asset_server.load(SHADER_ASSET_PATH));

        Ok(PreparedMaterial {
            binding,
            properties: Arc::new(properties),
        })
    }

Trait Implementations

impl Default for MaterialProperties

fn default() -> MaterialProperties

Returns the “default value” for a type.