Struct rin::gl::pbr_material::PbrMaterial

pub struct PbrMaterial<Program = Program, Texture = Texture> { /* fields omitted */ }

A physically based rendering material

Based on several PBR references and papers including the GLTF reference implementation + Filament

With support for:

Standard material

• metallic / roughness pipeline
• normal map
• occlusion map
• emissive map
• base color texture
• base color
• reflectance
• reflectance tint
• double sided

Anistropic material

supports all the features from the standard material and:

• anisotropy
• anisotropy rotation

Clearcoat

supports all the features from the standard material and:

• clearcoat amount
• clearcoat roughness

Subsurface

supports all the features from the standard material and:

• thickness
• subsurface power
• subsurface color

Cloth

• normal map
• occlusion map
• emissive map
• base color texture
• base color
• reflectance
• reflectance tint
• double sided
• sheen
• subsurface color

The filament material guide is a really good reference to understand most of the parameters of this material

Methods

impl PbrMaterial

pub fn new() -> PbrMaterial<Program>

New default PBR material with no maps and gray 0.8 color, 0.2 roughness and 0. metallic

pub fn new_with_texture(tex: Texture) -> PbrMaterial<Program>

New default PBR material with a base color texture and gray 0.8 color, 0.2 roughness and 0. metallic

impl<P: Borrow<Program>, T: Borrow<Texture>> PbrMaterial<P, T>

pub fn ty(&self) -> Type

Type of the material (standard, anisotropic, clearcoat or cloth)

pub fn set_type(&mut self, ty: Type)

pub fn texture(&self) -> Option<&T>

Base color texture

pub fn normal_map(&self) -> Option<&T>

Normal map

pub fn set_texture<TT: Into<Option<T>>>(&mut self, texture: TT) -> Option<T>

pub fn set_normal_map<TT: Into<Option<T>>>(&mut self, texture: TT) -> Option<T>

pub fn set_emissive_map<TT: Into<Option<T>>>(     &mut self,     texture: TT ) -> Option<T>

pub fn set_anisotropy_map<TT: Into<Option<T>>>(     &mut self,     texture: TT ) -> Option<T>

pub fn set_program(&mut self, program: P)

pub fn set_color<C: ToRgba>(&mut self, color: &C)

pub fn color(&self) -> &Rgba<f32>

Base color

pub fn emissive_color(&self) -> &Rgba<f32>

Emissive color

Plain color that the material emits, not affected by light or shadows

pub fn set_emissive_color<C: ToRgba>(&mut self, emissive: &C)

pub fn set_subsurface_color<C: ToRgba>(&mut self, color: &C)

pub fn subsurface_color(&self) -> &Rgba<f32>

Subsurface color, only for subsurface and cloth materials

Non physically based color of the subsurface scattering in cloths and subsurface materials

pub fn set_sheen_color<C: ToRgba>(&mut self, color: &C)

pub fn sheen_color(&self) -> &Rgba<f32>

Modify specular reflectance in cloth materials

pub fn metallic(&self) -> f32

Level of metallic of this material

Pure metallic materials don't have diffuse reflection, only specular non metallic have white specular and a diffuse reflection of the base color

This values should usually be 0 or 1, intermediate values are usually used when using a metallic map to transition from metallic to non metallic areas

pub fn roughness(&self) -> f32

Controls the roughness of the material or how blurry their specular reflection is.

A non metallic material with roughness 1 will appear almost completely diffuse while rouchness 0 will produce a sharp specular reflection

pub fn anisotropy(&self) -> f32

Defines the amount of anistropic in anisotropic materials

pub fn set_anisotropy(&mut self, anisotropy: f32)

pub fn anisotropic_rotation(&self) -> Rad<f32>

Defines the direction of the anisotropy

pub fn set_anisotropic_rotation(&mut self, anisotropic_rotation: Rad<f32>)

pub fn clearcoat(&self) -> f32

Clearcoat materials (like car paint) have a second translucent layer on top of the main material

This value controls if a material has clearcoat or not and should usually be set as 0 or 1

pub fn set_clearcoat(&mut self, clearcoat: f32)

pub fn clearcoat_roughness(&self) -> f32

The roughness of the clearcoat translucent layer

pub fn set_clearcoat_roughness(&mut self, r: f32)

pub fn double_sided(&self) -> bool

When a material is set as double sided it's back face will be seen as well even when culling is enabled

pub fn set_metallic(&mut self, metallic: f32)

pub fn reflectance(&self) -> f32

Controls the specular reflectance for non metallics which usually is 0.04

This value should be between 0..1

pub fn set_reflectance(&mut self, reflectance: f32)

pub fn set_shininess(&mut self, shininess: f32)

Actually sets the roughness based on legacy shininess model

Useful when porting from phong materials

pub fn set_roughness(&mut self, roughness: f32)

pub fn subsurface_power(&self) -> f32

pub fn set_subsurface_power(&mut self, power: f32)

pub fn thickness(&self) -> f32

Only for subsurface materials

Defines how thick is the material

pub fn set_thickness(&mut self, thickness: f32)

pub fn reflectance_tint(&self) -> f32

Tint of the diffuse, base color to the specular reflectance

pub fn set_reflectance_tint(&mut self, t: f32)

pub fn texture_matrix(&self) -> Option<&Mat4>

pub fn set_texture_matrix<M: Into<Option<Mat4>>>(&mut self, mat: M)

pub fn set_normal_map_matrix<M: Into<Option<Mat4>>>(&mut self, mat: M)

pub fn set_emissive_map_matrix<M: Into<Option<Mat4>>>(&mut self, mat: M)

pub fn set_anisotropy_map_matrix<M: Into<Option<Mat4>>>(&mut self, mat: M)

pub fn set_double_sided(&mut self, double_sided: bool)

pub fn has_clip_plane(&self) -> bool

To use when we are going to set a clip plane to cut the render at a certain plane

Useful for mirrors, water...

pub fn set_has_clip_plane(&mut self, c: bool)

pub fn with_double_sided(     &self,     double_sided: bool ) -> PbrMaterial<&Program, &Texture>

A reference to this material but double sided

pub fn set_occlusion_map<TT: Into<Option<T>>>(     &mut self,     texture: TT ) -> Option<T>

pub fn set_occlusion_map_matrix<M: Into<Option<Mat4>>>(&mut self, mat: M)

pub fn set_metallic_roughness_matrix<M: Into<Option<Mat4>>>(&mut self, mat: M)

pub fn set_metallic_roughness_map<TT: Into<Option<T>>>(     &mut self,     texture: TT ) -> Option<T>

pub fn occlusion_map(&self) -> Option<&T>

Occlusion map

pub fn metallic_roughness_map(&self) -> Option<&T>

pub fn normal_scale(&self) -> f32

Scales normals

usually used to make the normal map effect more or less pronounced

pub fn set_normal_scale(&mut self, scale: f32)

pub fn set_alpha_type(&mut self, alpha_type: AlphaType)

pub fn alpha_type(&self) -> AlphaType

Alpha type used for this material

See AlphaType

pub fn has_tangents(&self) -> bool

If the model has precalculated tangents otherwise calculated in shader which could be slower

pub fn set_has_tangents(&mut self, has_tangents: bool)

pub fn has_separate_alpha(&self) -> bool

If the alpha will be set on a separate uniform

Useful for materials that change translucency to not reset the whole ubo

pub fn set_has_separate_alpha(&mut self, has_separate_alpha: bool)

pub fn with_lights<'a, 'l, L, I>(     &'a self,     lights: I ) -> PbrMaterialRef<'a, P, T> where     L: Borrow<&'l dyn Light>,     I: IntoIterator<Item = L>,

Reference to this material with lights and potentially shadows

The resulting material will apply the lights and shadows to any model drawn with it

A pbr material will look completely black unless drawn with lights so calling this method with at least one light is always necesary

pub fn with_lighting_ubo<'l, B, L, I>(     &self,     lights: I,     ubo: B ) -> PbrMaterialRef<P, T> where     B: BufferRange<u8> + Clone,     L: Borrow<&'l dyn Light>,     I: IntoIterator<Item = L>,

Pass a ubo with the properties of the lights to set the lighting faster

The ubo can be created from the light data but the material also needs the original lights the ubo was created from in order to completely setup the shader

pub fn material_ubo<R: RenderSurface>(     &self,     gl: &Renderer<R> ) -> PbrMaterialRef<P, T>

Reference to this material using a ubo to setup properties

pub fn with_camera_ubo<'a>(&'a self) -> PbrMaterialRef<'a, P, T>

Reference to this material but using the camera uniforms from an ubo

Trait Implementations

impl<P: Borrow<Program>, T: Borrow<Texture>> Material for PbrMaterial<P, T>

fn program<R: RenderSurface>(&self, renderer: &Renderer<R>) -> &Program

returns the material glsl program

Important traits for &'a mut [u8]

impl<'a> Write for &'a mut [u8]impl<'a> Read for &'a [u8]

fn uniforms<R: RenderSurface>(&self, gl: &Renderer<R>) -> &[Uniform]

returns the uniforms to set when using the material glsl program

Important traits for &'a mut [u8]

impl<'a> Write for &'a mut [u8]impl<'a> Read for &'a [u8]

fn properties(&self) -> &[Property]

returns the gl properties to use when using this material

impl<Program: Debug, Texture: Debug> Debug for PbrMaterial<Program, Texture>

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

Formats the value using the given formatter.