Struct ParallaxMaterial 

pub struct ParallaxMaterial {

    pub base_color: Color,
    pub base_color_texture: Option<Handle<Image>>,
    pub emissive: Color,
    pub emissive_texture: Option<Handle<Image>>,
    pub perceptual_roughness: f32,
    pub metallic: f32,
    pub metallic_roughness_texture: Option<Handle<Image>>,
    pub reflectance: f32,
    pub normal_map_texture: Handle<Image>,
    pub flip_normal_map_y: bool,
    pub occlusion_texture: Option<Handle<Image>>,
    pub double_sided: bool,
    pub cull_mode: Option<Face>,
    pub unlit: bool,
    pub alpha_mode: AlphaMode,
    pub depth_bias: f32,
    pub height_map: Handle<Image>,
    pub height_depth: f32,
    pub algorithm: ParallaxAlgo,
    pub max_height_layers: f32,
    pub fog_enabled: bool,
}

A shameless clone of bevy’s default PBR material with an additional field: height_map.

height_map is a greyscale image representing the height of the object at a given pixel. Works like the original StandardMaterial otherwise.

WARNING: this material assumes the mesh has tangents set. If your mesh doesn’t have tangents, bad unspecified things will happen.

Fields

base_color: Color

Doubles as diffuse albedo for non-metallic, specular for metallic and a mix for everything in between. If used together with a base_color_texture, this is factored into the final base color as base_color * base_color_texture_value

base_color_texture: Option<Handle<Image>>

The “albedo” of the material, when Some, this will be the texture applied to the mesh.

emissive: Color

Color the material “emits” to the camera.

This is typically used for monitor screens or LED lights. Anything that can be visible even in darkness.

The emissive color is added to what would otherwise be the material’s visible color. This means that for a light emissive value, in darkness, you will mostly see the emissive component.

The default emissive color is black, which doesn’t add anything to the material color.

Note that an emissive material won’t light up surrounding areas like a light source, it just adds a value to the color seen on screen.

emissive_texture: Option<Handle<Image>>

Same as emissive, but based off a texture

perceptual_roughness: f32

Linear perceptual roughness, clamped to [0.089, 1.0] in the shader Defaults to minimum of 0.089 If used together with a roughness/metallic texture, this is factored into the final base color as roughness * roughness_texture_value

metallic: f32

From [0.0, 1.0], dielectric to pure metallic If used together with a roughness/metallic texture, this is factored into the final base color as metallic * metallic_texture_value

metallic_roughness_texture: Option<Handle<Image>>

A texture representing both metallic and preceptual_roughness.

The blue channel is the metallic and green is roughness (we don’t talk about the red channel)

reflectance: f32

Specular intensity for non-metals on a linear scale of [0.0, 1.0] defaults to 0.5 which is mapped to 4% reflectance in the shader

normal_map_texture: Handle<Image>

Used to fake the lighting of bumps and dents on a material.

A typical usage would be faking cobblestones on a flat plane mesh in 3D.

Notes

Normal mapping with StandardMaterial and the core bevy PBR shaders requires:

• A normal map texture
• Vertex UVs
• Vertex tangents
• Vertex normals

Tangents do not have to be stored in your model, they can be generated using the Mesh::generate_tangents method. If your material has a normal map, but still renders as a flat surface, make sure your meshes have their tangents set.

flip_normal_map_y: bool

Normal map textures authored for DirectX have their y-component flipped. Set this to flip it to right-handed conventions.

occlusion_texture: Option<Handle<Image>>

Specifies the level of exposure to ambient light.

This is usually generated and stored automatically (“baked”) by 3D-modelling software.

Typically, steep concave parts of a model (such as the armpit of a shirt) are darker, because they have little exposed to light. An occlusion map specifies those parts of the model that light doesn’t reach well.

The material will be less lit in places where this texture is dark. This is similar to ambient occlusion, but built into the model.

double_sided: bool

Support two-sided lighting by automatically flipping the normals for “back” faces within the PBR lighting shader. Defaults to false. This does not automatically configure backface culling, which can be done via cull_mode.

cull_mode: Option<Face>

Whether to cull the “front”, “back” or neither side of a mesh defaults to Face::Back

unlit: bool

Whether to shade this material.

Normals, occlusion textures, roughness, metallic, reflectance and emissive are ignored if this is set to true.

alpha_mode: AlphaMode

How to interpret the alpha channel of the base_color_texture.

By default, it’s Opaque, therefore completely ignored. Note that currently bevy handles poorly semi-transparent textures. You are likely to encounter the following bugs:

• When two AlphaMode::Blend material occupy the same pixel, only one material’s color will show.
• If a different mesh is both “in front” and “behind” a non-opaque material, bevy won’t know which material to display in front, which might result in flickering.

depth_bias: f32

Re-arange depth of material, useful to avoid z-fighting.

height_map: Handle<Image>

The height map used for parallax mapping.

Black is the tallest, white deepest.

To improve performance, set your height_map’s Image::sampler_descriptor filter mode to FilterMode::Nearest, as this paper indicates, it improves perfs a bit.

height_depth: f32

How deep the offset introduced by the height map should be.

Default is 0.1, anything over that value may look very awkward. Lower value look less “deep.”

algorithm: ParallaxAlgo

Whether to use a more accurate and more expensive algorithm.

We recommend that all objects use the same ParallaxAlgo, to avoid duplicating and running two shaders.

max_height_layers: f32

In how many layers to split the height maps for Steep Parallax Mapping.

If your height_depth is >0.1 and you are seeing jaggy edges, increase this value. However, this incures a performance cost.

Default is 16.0.

This must never be less than 2.0.

fog_enabled: bool

Whether to enable fog for this material

Trait Implementations

impl AsBindGroup for ParallaxMaterial

type Data = ParallaxMaterialKey

Data that will be stored alongside the “prepared” bind group.

fn as_bind_group( &self, layout: &BindGroupLayout, render_device: &RenderDevice, images: &RenderAssets<Image>, fallback_image: &FallbackImage, ) -> Result<PreparedBindGroup<Self::Data>, AsBindGroupError>

Creates a bind group for self matching the layout defined in AsBindGroup::bind_group_layout.

fn bind_group_layout(render_device: &RenderDevice) -> BindGroupLayout

Creates the bind group layout matching all bind groups returned by AsBindGroup::as_bind_group

impl AsBindGroupShaderType<ParallaxMaterialUniform> for ParallaxMaterial

fn as_bind_group_shader_type( &self, images: &RenderAssets<Image>, ) -> ParallaxMaterialUniform

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.

impl Clone for ParallaxMaterial

fn clone(&self) -> ParallaxMaterial

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParallaxMaterial

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

Formats the value using the given formatter.

impl Default for ParallaxMaterial

fn default() -> Self

Returns the “default value” for a type.

impl From<&ParallaxMaterial> for ParallaxMaterialKey

fn from(material: &ParallaxMaterial) -> Self

Converts to this type from the input type.

impl From<&ParallaxMaterial> for StandardMaterial

fn from(mat: &ParallaxMaterial) -> Self

Converts to this type from the input type.

impl FromReflect for ParallaxMaterial

where Color: FromReflect, Option<Handle<Image>>: FromReflect, f32: FromReflect, Handle<Image>: FromReflect, bool: FromReflect, AlphaMode: FromReflect, ParallaxAlgo: FromReflect, Option<Face>:,

fn from_reflect(reflect: &dyn Reflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect>, ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for ParallaxMaterial

where Color: Reflect, Option<Handle<Image>>: Reflect, f32: Reflect, Handle<Image>: Reflect, bool: Reflect, AlphaMode: Reflect, ParallaxAlgo: Reflect, Option<Face>: Any + Send + Sync,

fn get_type_registration() -> TypeRegistration

impl Material for ParallaxMaterial

fn specialize( _pipeline: &MaterialPipeline<Self>, descriptor: &mut RenderPipelineDescriptor, _layout: &MeshVertexBufferLayout, key: MaterialPipelineKey<Self>, ) -> Result<(), SpecializedMeshPipelineError>

Customizes the default RenderPipelineDescriptor for a specific entity using the entity’s MaterialPipelineKey and MeshVertexBufferLayout as input.

fn fragment_shader() -> ShaderRef

Returns this material’s fragment shader. If ShaderRef::Default is returned, the default mesh fragment shader will be used.

fn alpha_mode(&self) -> AlphaMode

Returns this material’s AlphaMode. Defaults to AlphaMode::Opaque.

fn depth_bias(&self) -> f32

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

fn vertex_shader() -> ShaderRef

Returns this material’s vertex shader. If ShaderRef::Default is returned, the default mesh vertex shader will be used.

fn prepass_vertex_shader() -> ShaderRef

Returns this material’s prepass vertex shader. If ShaderRef::Default is returned, the default prepass vertex shader will be used.

fn prepass_fragment_shader() -> ShaderRef

Returns this material’s prepass fragment shader. If ShaderRef::Default is returned, the default prepass fragment shader will be used.

impl Reflect for ParallaxMaterial

where Color: Reflect, Option<Handle<Image>>: Reflect, f32: Reflect, Handle<Image>: Reflect, bool: Reflect, AlphaMode: Reflect, ParallaxAlgo: Reflect, Option<Face>: Any + Send + Sync,

fn type_name(&self) -> &str

Returns the type name of the underlying type.

fn get_type_info(&self) -> &'static TypeInfo

Returns the TypeInfo of the underlying type.

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

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

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, value: &dyn Reflect)

Applies a reflected value to this value.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

impl Struct for ParallaxMaterial

where Color: Reflect, Option<Handle<Image>>: Reflect, f32: Reflect, Handle<Image>: Reflect, bool: Reflect, AlphaMode: Reflect, ParallaxAlgo: Reflect, Option<Face>: Any + Send + Sync,

fn field(&self, name: &str) -> Option<&dyn Reflect>

Returns a reference to the value of the field named name as a &dyn Reflect.

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

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

fn field_at(&self, index: usize) -> Option<&dyn Reflect>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypeUuid for ParallaxMaterial

const TYPE_UUID: Uuid

impl Typed for ParallaxMaterial

where Color: Reflect, Option<Handle<Image>>: Reflect, f32: Reflect, Handle<Image>: Reflect, bool: Reflect, AlphaMode: Reflect, ParallaxAlgo: Reflect, Option<Face>: Any + Send + Sync,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.