Struct three_d::renderer::material::DeferredPhysicalMaterial

pub struct DeferredPhysicalMaterial {

    pub name: String,
    pub albedo: Srgba,
    pub albedo_texture: Option<Texture2DRef>,
    pub metallic: f32,
    pub roughness: f32,
    pub metallic_roughness_texture: Option<Texture2DRef>,
    pub occlusion_strength: f32,
    pub occlusion_texture: Option<Texture2DRef>,
    pub normal_scale: f32,
    pub normal_texture: Option<Texture2DRef>,
    pub render_states: RenderStates,
    pub emissive: Srgba,
    pub emissive_texture: Option<Texture2DRef>,
    pub alpha_cutout: Option<f32>,
}

Similar to PhysicalMaterial except that rendering happens in two stages which produces the same result, but is more efficient for complex scenes. This material does not support transparency but does support alpha cutout.

The first stage renders geometry information to a RenderTarget and the second stage uses this render target to apply lighting based on the geometry information which means the expensive lighting calculations are only done once per pixel. The RenderTarget::render, ColorTarget::render or DepthTarget::render methods all support the two stages required by this material, so just pass the Object with this material applied into one of these methods. However, it is not possible to use the Object::render method to render a Geometry with this material directly to the screen. Instead render the object into a RenderTarget consisting of a Texture2DArray with three RGBA u8 layers as color target and a DepthTexture2D as depth target. Then call the DeferredPhysicalMaterial::lighting_pass method with these textures to render to the screen.

Fields

name: String

Name.

albedo: Srgba

Albedo base color, also called diffuse color.

albedo_texture: Option<Texture2DRef>

Texture with albedo base colors, also called diffuse color. The colors are assumed to be in linear sRGB (RgbU8), linear sRGB with an alpha channel (RgbaU8) or HDR color space.

metallic: f32

A value in the range [0..1] specifying how metallic the material is.

roughness: f32

A value in the range [0..1] specifying how rough the material surface is.

metallic_roughness_texture: Option<Texture2DRef>

Texture containing the metallic and roughness parameters which are multiplied with the Self::metallic and Self::roughness values in the shader. The metallic values are sampled from the blue channel and the roughness from the green channel.

occlusion_strength: f32

A scalar multiplier controlling the amount of occlusion applied from the Self::occlusion_texture. A value of 0.0 means no occlusion. A value of 1.0 means full occlusion.

occlusion_texture: Option<Texture2DRef>

An occlusion map. Higher values indicate areas that should receive full indirect lighting and lower values indicate no indirect lighting. The occlusion values are sampled from the red channel.

normal_scale: f32

A scalar multiplier applied to each normal vector of the Self::normal_texture.

normal_texture: Option<Texture2DRef>

A tangent space normal map, also known as bump map.

render_states: RenderStates

Render states

emissive: Srgba

Color of light shining from an object.

emissive_texture: Option<Texture2DRef>

Texture with color of light shining from an object. The colors are assumed to be in linear sRGB (RgbU8), linear sRGB with an alpha channel (RgbaU8) or HDR color space.

alpha_cutout: Option<f32>

A threshold on the alpha value of the color as a workaround for transparency. If the alpha value of a pixel touched by an object with this material is less than the threshold, then that object is not contributing to the color of that pixel. On the other hand, if the alpha value is more than the threshold, then it is contributing fully to that pixel and thereby blocks out everything behind.

Implementations

impl DeferredPhysicalMaterial

pub fn new(context: &Context, cpu_material: &CpuMaterial) -> Self

Constructs a new deferred physical material from a CpuMaterial. If the input contains an CpuMaterial::occlusion_metallic_roughness_texture, this texture is used for both DeferredPhysicalMaterial::metallic_roughness_texture and DeferredPhysicalMaterial::occlusion_texture while any CpuMaterial::metallic_roughness_texture or CpuMaterial::occlusion_texture are ignored.

pub fn from_physical_material(physical_material: &PhysicalMaterial) -> Self

Constructs a deferred physical material from a physical material.

pub fn lighting_pass( context: &Context, camera: &Camera, geometry_pass_color_texture: ColorTexture<'_>, geometry_pass_depth_texture: DepthTexture<'_>, lights: &[&dyn Light] )

The second stage of a deferred render call. Use the Object::render method to render the objects with this material into a RenderTarget and then call this method with these textures to render to the screen. See DeferredPhysicalMaterial for more information.

Trait Implementations

impl Clone for DeferredPhysicalMaterial

fn clone(&self) -> DeferredPhysicalMaterial

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for DeferredPhysicalMaterial

fn default() -> Self

Returns the “default value” for a type.

impl FromCpuMaterial for DeferredPhysicalMaterial

fn from_cpu_material(context: &Context, cpu_material: &CpuMaterial) -> Self

Creates a new material that can be used for rendering from a CpuMaterial.

impl Material for DeferredPhysicalMaterial

fn id(&self) -> u16

Returns a unique ID for each variation of the shader source returned from Material::fragment_shader_source.

fn fragment_shader_source(&self, _lights: &[&dyn Light]) -> String

Returns the fragment shader source for this material.

fn fragment_attributes(&self) -> FragmentAttributes

Returns a FragmentAttributes struct that describes which fragment attributes, ie. the input from the vertex shader, are required for rendering with this material.

fn use_uniforms( &self, program: &Program, _camera: &Camera, _lights: &[&dyn Light] )

Sends the uniform data needed for this material to the fragment shader.

fn render_states(&self) -> RenderStates

Returns the render states needed to render with this material.

fn material_type(&self) -> MaterialType

Returns the type of material.