Struct bevy::pbr::StandardMaterial
pub struct StandardMaterial {Show 29 fields
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 diffuse_transmission: f32,
pub specular_transmission: f32,
pub thickness: f32,
pub ior: f32,
pub attenuation_distance: f32,
pub attenuation_color: Color,
pub normal_map_texture: Option<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 fog_enabled: bool,
pub alpha_mode: AlphaMode,
pub depth_bias: f32,
pub depth_map: Option<Handle<Image>>,
pub parallax_depth_scale: f32,
pub parallax_mapping_method: ParallaxMappingMethod,
pub max_parallax_layer_count: f32,
pub opaque_render_method: OpaqueRendererMethod,
pub deferred_lighting_pass_id: u8,
}
Expand description
A material with “standard” properties used in PBR lighting Standard property values with pictures here https://google.github.io/filament/Material%20Properties.pdf.
Fields§
§base_color: Color
The color of the surface of the material before lighting.
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
Defaults to Color::WHITE
.
base_color_texture: Option<Handle<Image>>
The texture component of the material’s color before lighting.
The actual pre-lighting color is base_color * this_texture
.
See base_color
for details.
You should set base_color
to Color::WHITE
(the default)
if you want the texture to show as-is.
Setting base_color
to something else than white will tint
the texture. For example, setting base_color
to pure red will
tint the texture red.
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>>
The emissive map, multiplies pixels with emissive
to get the final “emitting” color of a surface.
This color is multiplied by emissive
to get the final emitted color.
Meaning that you should set emissive
to Color::WHITE
if you want to use the full range of color of the emissive texture.
perceptual_roughness: f32
Linear perceptual roughness, clamped to [0.089, 1.0]
in the shader.
Defaults to 0.5
.
Low values result in a “glossy” material with specular highlights,
while values close to 1
result in rough materials.
If used together with a roughness/metallic texture, this is factored into the final base
color as roughness * roughness_texture_value
.
0.089 is the minimum floating point value that won’t be rounded down to 0 in the calculations used.
metallic: f32
How “metallic” the material appears, within [0.0, 1.0]
.
This should be set to 0.0 for dielectric materials or 1.0 for metallic materials. For a hybrid surface such as corroded metal, you may need to use in-between values.
Defaults to 0.00
, for dielectric.
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>>
Metallic and roughness maps, stored as a single texture.
The blue channel contains metallic values, and the green channel contains the roughness values. Other channels are unused.
Those values are multiplied by the scalar ones of the material,
see metallic
and perceptual_roughness
for details.
Note that with the default values of metallic
and perceptual_roughness
,
setting this texture has no effect. If you want to exclusively use the
metallic_roughness_texture
values for your material, make sure to set metallic
and perceptual_roughness
to 1.0
.
reflectance: f32
Specular intensity for non-metals on a linear scale of [0.0, 1.0]
.
Use the value as a way to control the intensity of the specular highlight of the material, i.e. how reflective is the material, rather than the physical property “reflectance.”
Set to 0.0
, no specular highlight is visible, the highlight is strongest
when reflectance
is set to 1.0
.
Defaults to 0.5
which is mapped to 4% reflectance in the shader.
diffuse_transmission: f32
The amount of light transmitted diffusely through the material (i.e. “translucency”)
Implemented as a second, flipped Lambertian diffuse lobe, which provides an inexpensive but plausible approximation of translucency for thin dieletric objects (e.g. paper, leaves, some fabrics) or thicker volumetric materials with short scattering distances (e.g. porcelain, wax).
For specular transmission usecases with refraction (e.g. glass) use the StandardMaterial::specular_transmission
and
StandardMaterial::ior
properties instead.
- When set to
0.0
(the default) no diffuse light is transmitted; - When set to
1.0
all diffuse light is transmitted through the material; - Values higher than
0.5
will cause more diffuse light to be transmitted than reflected, resulting in a “darker” appearance on the side facing the light than the opposite side. (e.g. plant leaves)
Notes
- The material’s
StandardMaterial::base_color
also modulates the transmitted light; - To receive transmitted shadows on the diffuse transmission lobe (i.e. the “backside”) of the material,
use the
TransmittedShadowReceiver
component.
specular_transmission: f32
The amount of light transmitted specularly through the material (i.e. via refraction)
- When set to
0.0
(the default) no light is transmitted. - When set to
1.0
all light is transmitted through the material.
The material’s StandardMaterial::base_color
also modulates the transmitted light.
Note: Typically used in conjunction with StandardMaterial::thickness
, StandardMaterial::ior
and StandardMaterial::perceptual_roughness
.
Performance
Specular transmission is implemented as a relatively expensive screen-space effect that allows ocluded objects to be seen through the material, with distortion and blur effects.
Camera3d::screen_space_specular_transmission_steps
can be used to enable transmissive objects to be seen through other transmissive objects, at the cost of additional draw calls and texture copies; (Use with caution!)- If a simplified approximation of specular transmission using only environment map lighting is sufficient, consider setting
Camera3d::screen_space_specular_transmission_steps
to0
.
- If a simplified approximation of specular transmission using only environment map lighting is sufficient, consider setting
- If purely diffuse light transmission is needed, (i.e. “translucency”) consider using
StandardMaterial::diffuse_transmission
instead, for a much less expensive effect. - Specular transmission is rendered before alpha blending, so any material with
AlphaMode::Blend
,AlphaMode::Premultiplied
,AlphaMode::Add
orAlphaMode::Multiply
won’t be visible through specular transmissive materials.
thickness: f32
Thickness of the volume beneath the material surface.
When set to 0.0
(the default) the material appears as an infinitely-thin film,
transmitting light without distorting it.
When set to any other value, the material distorts light like a thick lens.
Note: Typically used in conjunction with StandardMaterial::specular_transmission
and StandardMaterial::ior
, or with
StandardMaterial::diffuse_transmission
.
ior: f32
The index of refraction of the material.
Defaults to 1.5.
Material | Index of Refraction |
---|---|
Vacuum | 1 |
Air | 1.00 |
Ice | 1.31 |
Water | 1.33 |
Eyes | 1.38 |
Quartz | 1.46 |
Olive Oil | 1.47 |
Honey | 1.49 |
Acrylic | 1.49 |
Window Glass | 1.52 |
Polycarbonate | 1.58 |
Flint Glass | 1.69 |
Ruby | 1.71 |
Glycerine | 1.74 |
Saphire | 1.77 |
Cubic Zirconia | 2.15 |
Diamond | 2.42 |
Moissanite | 2.65 |
Note: Typically used in conjunction with StandardMaterial::specular_transmission
and StandardMaterial::thickness
.
attenuation_distance: f32
How far, on average, light travels through the volume beneath the material’s surface before being absorbed.
Defaults to f32::INFINITY
, i.e. light is never absorbed.
Note: To have any effect, must be used in conjunction with:
attenuation_color: Color
The resulting (non-absorbed) color after white light travels through the attenuation distance.
Defaults to Color::WHITE
, i.e. no change.
Note: To have any effect, must be used in conjunction with:
normal_map_texture: Option<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
or
Mesh::with_generated_tangents
methods.
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 exposure 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.
If set to None
, the two sides of the mesh are visible.
Defaults to Some(Face::Back)
.
In bevy, the order of declaration of a triangle’s vertices
in Mesh
defines the triangle’s front face.
When a triangle is in a viewport, if its vertices appear counter-clockwise from the viewport’s perspective, then the viewport is seeing the triangle’s front face. Conversely, if the vertices appear clockwise, you are seeing the back face.
In short, in bevy, front faces winds counter-clockwise.
Your 3D editing software should manage all of that.
unlit: bool
Whether to apply only the base color to this material.
Normals, occlusion textures, roughness, metallic, reflectance, emissive,
shadows, alpha mode and ambient light are ignored if this is set to true
.
fog_enabled: bool
Whether to enable fog for this material.
alpha_mode: AlphaMode
How to apply the alpha channel of the base_color_texture
.
See AlphaMode
for details. Defaults to AlphaMode::Opaque
.
depth_bias: f32
Adjust rendered depth.
A material with a positive depth bias will render closer to the camera while negative values cause the material to render behind other objects. This is independent of the viewport.
depth_bias
affects render ordering and depth write operations
using the wgpu::DepthBiasState::Constant
field.
depth_map: Option<Handle<Image>>
The depth map used for parallax mapping.
It is a greyscale image where white represents bottom and black the top. If this field is set, bevy will apply parallax mapping. Parallax mapping, unlike simple normal maps, will move the texture coordinate according to the current perspective, giving actual depth to the texture.
The visual result is similar to a displacement map, but does not require additional geometry.
Use the parallax_depth_scale
field to control the depth of the parallax.
Limitations
- It will look weird on bent/non-planar surfaces.
- The depth of the pixel does not reflect its visual position, resulting in artifacts for depth-dependent features such as fog or SSAO.
- For the same reason, the geometry silhouette will always be the one of the actual geometry, not the parallaxed version, resulting in awkward looks on intersecting parallaxed surfaces.
Performance
Parallax mapping requires multiple texture lookups, proportional to
max_parallax_layer_count
, which might be costly.
Use the parallax_mapping_method
and max_parallax_layer_count
fields
to tweak the shader, trading graphical quality for performance.
To improve performance, set your depth_map
’s Image::sampler
filter mode to FilterMode::Nearest
, as this paper indicates, it improves
performance a bit.
To reduce artifacts, avoid steep changes in depth, blurring the depth map helps with this.
Larger depth maps haves a disproportionate performance impact.
parallax_depth_scale: f32
How deep the offset introduced by the depth map should be.
Default is 0.1
, anything over that value may look distorted.
Lower values lessen the effect.
The depth is relative to texture size. This means that if your texture
occupies a surface of 1
world unit, and parallax_depth_scale
is 0.1
, then
the in-world depth will be of 0.1
world units.
If the texture stretches for 10
world units, then the final depth
will be of 1
world unit.
parallax_mapping_method: ParallaxMappingMethod
Which parallax mapping method to use.
We recommend that all objects use the same ParallaxMappingMethod
, to avoid
duplicating and running two shaders.
max_parallax_layer_count: f32
In how many layers to split the depth maps for parallax mapping.
If you are seeing jaggy edges, increase this value. However, this incurs a performance cost.
Dependent on the situation, switching to ParallaxMappingMethod::Relief
and keeping this value low might have better performance than increasing the
layer count while using ParallaxMappingMethod::Occlusion
.
Default is 16.0
.
opaque_render_method: OpaqueRendererMethod
Render method used for opaque materials. (Where alpha_mode
is AlphaMode::Opaque
or AlphaMode::Mask
)
deferred_lighting_pass_id: u8
Used for selecting the deferred lighting pass for deferred materials.
Default is DEFAULT_PBR_DEFERRED_LIGHTING_PASS_ID
for default
PBR deferred lighting pass. Ignored in the case of forward materials.
Trait Implementations§
§impl AsBindGroup for StandardMaterial
impl AsBindGroup for StandardMaterial
§type Data = StandardMaterialKey
type Data = StandardMaterialKey
§fn unprepared_bind_group(
&self,
layout: &BindGroupLayout,
render_device: &RenderDevice,
images: &RenderAssets<Image>,
fallback_image: &FallbackImage
) -> Result<UnpreparedBindGroup<<StandardMaterial as AsBindGroup>::Data>, AsBindGroupError>
fn unprepared_bind_group( &self, layout: &BindGroupLayout, render_device: &RenderDevice, images: &RenderAssets<Image>, fallback_image: &FallbackImage ) -> Result<UnpreparedBindGroup<<StandardMaterial as AsBindGroup>::Data>, AsBindGroupError>
OwnedBindingResource
).
In cases where OwnedBindingResource
is not available (as for bindless texture arrays currently),
an implementor may define as_bind_group
directly. This may prevent certain features
from working correctly.§fn bind_group_layout_entries(
render_device: &RenderDevice
) -> Vec<BindGroupLayoutEntry>
fn bind_group_layout_entries( render_device: &RenderDevice ) -> Vec<BindGroupLayoutEntry>
§fn as_bind_group(
&self,
layout: &BindGroupLayout,
render_device: &RenderDevice,
images: &RenderAssets<Image>,
fallback_image: &FallbackImage
) -> Result<PreparedBindGroup<Self::Data>, AsBindGroupError>
fn as_bind_group( &self, layout: &BindGroupLayout, render_device: &RenderDevice, images: &RenderAssets<Image>, fallback_image: &FallbackImage ) -> Result<PreparedBindGroup<Self::Data>, AsBindGroupError>
self
matching the layout defined in AsBindGroup::bind_group_layout
.§fn bind_group_layout(render_device: &RenderDevice) -> BindGroupLayoutwhere
Self: Sized,
fn bind_group_layout(render_device: &RenderDevice) -> BindGroupLayoutwhere Self: Sized,
AsBindGroup::as_bind_group
§impl AsBindGroupShaderType<StandardMaterialUniform> for StandardMaterial
impl AsBindGroupShaderType<StandardMaterialUniform> for StandardMaterial
§fn as_bind_group_shader_type(
&self,
images: &RenderAssets<Image>
) -> StandardMaterialUniform
fn as_bind_group_shader_type( &self, images: &RenderAssets<Image> ) -> StandardMaterialUniform
T
ShaderType
for self
. When used in AsBindGroup
derives, it is safe to assume that all images in self
exist.§impl Clone for StandardMaterial
impl Clone for StandardMaterial
§fn clone(&self) -> StandardMaterial
fn clone(&self) -> StandardMaterial
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more§impl Debug for StandardMaterial
impl Debug for StandardMaterial
§impl Default for StandardMaterial
impl Default for StandardMaterial
§fn default() -> StandardMaterial
fn default() -> StandardMaterial
§impl From<&StandardMaterial> for StandardMaterialKey
impl From<&StandardMaterial> for StandardMaterialKey
§fn from(material: &StandardMaterial) -> StandardMaterialKey
fn from(material: &StandardMaterial) -> StandardMaterialKey
§impl From<Color> for StandardMaterial
impl From<Color> for StandardMaterial
§fn from(color: Color) -> StandardMaterial
fn from(color: Color) -> StandardMaterial
§impl From<Handle<Image>> for StandardMaterial
impl From<Handle<Image>> for StandardMaterial
§fn from(texture: Handle<Image>) -> StandardMaterial
fn from(texture: Handle<Image>) -> StandardMaterial
§impl FromReflect for StandardMaterialwhere
Color: FromReflect,
Option<Handle<Image>>: FromReflect,
f32: FromReflect,
bool: FromReflect,
AlphaMode: FromReflect,
ParallaxMappingMethod: FromReflect,
OpaqueRendererMethod: FromReflect,
u8: FromReflect,
Option<Face>: Any + Send + Sync,
impl FromReflect for StandardMaterialwhere Color: FromReflect, Option<Handle<Image>>: FromReflect, f32: FromReflect, bool: FromReflect, AlphaMode: FromReflect, ParallaxMappingMethod: FromReflect, OpaqueRendererMethod: FromReflect, u8: FromReflect, Option<Face>: Any + Send + Sync,
§fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<StandardMaterial>
fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<StandardMaterial>
Self
from a reflected value.§fn take_from_reflect(
reflect: Box<dyn Reflect>
) -> Result<Self, Box<dyn Reflect>>
fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>
Self
using,
constructing the value using from_reflect
if that fails. Read more§impl GetTypeRegistration for StandardMaterialwhere
Color: FromReflect,
Option<Handle<Image>>: FromReflect,
f32: FromReflect,
bool: FromReflect,
AlphaMode: FromReflect,
ParallaxMappingMethod: FromReflect,
OpaqueRendererMethod: FromReflect,
u8: FromReflect,
Option<Face>: Any + Send + Sync,
impl GetTypeRegistration for StandardMaterialwhere Color: FromReflect, Option<Handle<Image>>: FromReflect, f32: FromReflect, bool: FromReflect, AlphaMode: FromReflect, ParallaxMappingMethod: FromReflect, OpaqueRendererMethod: FromReflect, u8: FromReflect, Option<Face>: Any + Send + Sync,
§impl Material for StandardMaterial
impl Material for StandardMaterial
§fn specialize(
_pipeline: &MaterialPipeline<StandardMaterial>,
descriptor: &mut RenderPipelineDescriptor,
_layout: &Hashed<InnerMeshVertexBufferLayout>,
key: MaterialPipelineKey<StandardMaterial>
) -> Result<(), SpecializedMeshPipelineError>
fn specialize( _pipeline: &MaterialPipeline<StandardMaterial>, descriptor: &mut RenderPipelineDescriptor, _layout: &Hashed<InnerMeshVertexBufferLayout>, key: MaterialPipelineKey<StandardMaterial> ) -> Result<(), SpecializedMeshPipelineError>
RenderPipelineDescriptor
for a specific entity using the entity’s
MaterialPipelineKey
and MeshVertexBufferLayout
as input.§fn prepass_fragment_shader() -> ShaderRef
fn prepass_fragment_shader() -> ShaderRef
ShaderRef::Default
is returned, the default prepass fragment shader
will be used. Read more§fn deferred_fragment_shader() -> ShaderRef
fn deferred_fragment_shader() -> ShaderRef
ShaderRef::Default
is returned, the default deferred fragment shader
will be used.§fn fragment_shader() -> ShaderRef
fn fragment_shader() -> ShaderRef
ShaderRef::Default
is returned, the default mesh fragment shader
will be used.§fn alpha_mode(&self) -> AlphaMode
fn alpha_mode(&self) -> AlphaMode
AlphaMode
. Defaults to AlphaMode::Opaque
.§fn depth_bias(&self) -> f32
fn depth_bias(&self) -> f32
§fn reads_view_transmission_texture(&self) -> bool
fn reads_view_transmission_texture(&self) -> bool
ViewTransmissionTexture
. Read more§fn opaque_render_method(&self) -> OpaqueRendererMethod
fn opaque_render_method(&self) -> OpaqueRendererMethod
AlphaMode::Opaque
or AlphaMode::Mask
materials.
If OpaqueRendererMethod::Auto
, it will default to what is selected in the DefaultOpaqueRendererMethod
resource.§fn vertex_shader() -> ShaderRef
fn vertex_shader() -> ShaderRef
ShaderRef::Default
is returned, the default mesh vertex shader
will be used.§fn prepass_vertex_shader() -> ShaderRef
fn prepass_vertex_shader() -> ShaderRef
ShaderRef::Default
is returned, the default prepass vertex shader
will be used. Read more§fn deferred_vertex_shader() -> ShaderRef
fn deferred_vertex_shader() -> ShaderRef
ShaderRef::Default
is returned, the default deferred vertex shader
will be used.§impl Reflect for StandardMaterialwhere
Color: FromReflect,
Option<Handle<Image>>: FromReflect,
f32: FromReflect,
bool: FromReflect,
AlphaMode: FromReflect,
ParallaxMappingMethod: FromReflect,
OpaqueRendererMethod: FromReflect,
u8: FromReflect,
Option<Face>: Any + Send + Sync,
impl Reflect for StandardMaterialwhere Color: FromReflect, Option<Handle<Image>>: FromReflect, f32: FromReflect, bool: FromReflect, AlphaMode: FromReflect, ParallaxMappingMethod: FromReflect, OpaqueRendererMethod: FromReflect, u8: FromReflect, Option<Face>: Any + Send + Sync,
§fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
§fn into_any(self: Box<StandardMaterial>) -> Box<dyn Any>
fn into_any(self: Box<StandardMaterial>) -> Box<dyn Any>
Box<dyn Any>
.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut dyn Any
.§fn into_reflect(self: Box<StandardMaterial>) -> Box<dyn Reflect>
fn into_reflect(self: Box<StandardMaterial>) -> Box<dyn Reflect>
§fn as_reflect(&self) -> &(dyn Reflect + 'static)
fn as_reflect(&self) -> &(dyn Reflect + 'static)
§fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
§fn clone_value(&self) -> Box<dyn Reflect>
fn clone_value(&self) -> Box<dyn Reflect>
Reflect
trait object. Read more§fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
§fn apply(&mut self, value: &(dyn Reflect + 'static))
fn apply(&mut self, value: &(dyn Reflect + 'static))
§fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
§fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
§fn reflect_owned(self: Box<StandardMaterial>) -> ReflectOwned
fn reflect_owned(self: Box<StandardMaterial>) -> ReflectOwned
§fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>
fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>
§fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
§fn type_name(&self) -> &str
fn type_name(&self) -> &str
§fn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
§fn serializable(&self) -> Option<Serializable<'_>>
fn serializable(&self) -> Option<Serializable<'_>>
§fn is_dynamic(&self) -> bool
fn is_dynamic(&self) -> bool
§impl Struct for StandardMaterialwhere
Color: FromReflect,
Option<Handle<Image>>: FromReflect,
f32: FromReflect,
bool: FromReflect,
AlphaMode: FromReflect,
ParallaxMappingMethod: FromReflect,
OpaqueRendererMethod: FromReflect,
u8: FromReflect,
Option<Face>: Any + Send + Sync,
impl Struct for StandardMaterialwhere Color: FromReflect, Option<Handle<Image>>: FromReflect, f32: FromReflect, bool: FromReflect, AlphaMode: FromReflect, ParallaxMappingMethod: FromReflect, OpaqueRendererMethod: FromReflect, u8: FromReflect, Option<Face>: Any + Send + Sync,
§fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>
fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>
name
as a &dyn Reflect
.§fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>
fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>
name
as a
&mut dyn Reflect
.§fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
index
as a
&dyn Reflect
.§fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>
fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>
index
as a &mut dyn Reflect
.§fn iter_fields(&self) -> FieldIter<'_> ⓘ
fn iter_fields(&self) -> FieldIter<'_> ⓘ
§fn clone_dynamic(&self) -> DynamicStruct
fn clone_dynamic(&self) -> DynamicStruct
DynamicStruct
.§impl TypePath for StandardMaterialwhere
Color: FromReflect,
Option<Handle<Image>>: FromReflect,
f32: FromReflect,
bool: FromReflect,
AlphaMode: FromReflect,
ParallaxMappingMethod: FromReflect,
OpaqueRendererMethod: FromReflect,
u8: FromReflect,
Option<Face>: Any + Send + Sync,
impl TypePath for StandardMaterialwhere Color: FromReflect, Option<Handle<Image>>: FromReflect, f32: FromReflect, bool: FromReflect, AlphaMode: FromReflect, ParallaxMappingMethod: FromReflect, OpaqueRendererMethod: FromReflect, u8: FromReflect, Option<Face>: Any + Send + Sync,
§fn short_type_path() -> &'static str
fn short_type_path() -> &'static str
§fn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
§fn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
§impl Typed for StandardMaterialwhere
Color: FromReflect,
Option<Handle<Image>>: FromReflect,
f32: FromReflect,
bool: FromReflect,
AlphaMode: FromReflect,
ParallaxMappingMethod: FromReflect,
OpaqueRendererMethod: FromReflect,
u8: FromReflect,
Option<Face>: Any + Send + Sync,
impl Typed for StandardMaterialwhere Color: FromReflect, Option<Handle<Image>>: FromReflect, f32: FromReflect, bool: FromReflect, AlphaMode: FromReflect, ParallaxMappingMethod: FromReflect, OpaqueRendererMethod: FromReflect, u8: FromReflect, Option<Face>: Any + Send + Sync,
§impl VisitAssetDependencies for StandardMaterial
impl VisitAssetDependencies for StandardMaterial
fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId))
impl Asset for StandardMaterial
Auto Trait Implementations§
impl !RefUnwindSafe for StandardMaterial
impl Send for StandardMaterial
impl Sync for StandardMaterial
impl Unpin for StandardMaterial
impl !UnwindSafe for StandardMaterial
Blanket Implementations§
§impl<T, U> AsBindGroupShaderType<U> for Twhere
U: ShaderType,
&'a T: for<'a> Into<U>,
impl<T, U> AsBindGroupShaderType<U> for Twhere U: ShaderType, &'a T: for<'a> Into<U>,
§fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U
fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U
T
ShaderType
for self
. When used in AsBindGroup
derives, it is safe to assume that all images in self
exist.§impl<A> AssetContainer for Awhere
A: Asset,
impl<A> AssetContainer for Awhere A: Asset,
fn insert(self: Box<A>, id: UntypedAssetId, world: &mut World)
fn asset_type_name(&self) -> &'static str
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.§impl<T> DynamicTypePath for Twhere
T: TypePath,
impl<T> DynamicTypePath for Twhere T: TypePath,
§fn reflect_type_path(&self) -> &str
fn reflect_type_path(&self) -> &str
TypePath::type_path
.§fn reflect_short_type_path(&self) -> &str
fn reflect_short_type_path(&self) -> &str
§fn reflect_type_ident(&self) -> Option<&str>
fn reflect_type_ident(&self) -> Option<&str>
TypePath::type_ident
.§fn reflect_crate_name(&self) -> Option<&str>
fn reflect_crate_name(&self) -> Option<&str>
TypePath::crate_name
.§fn reflect_module_path(&self) -> Option<&str>
fn reflect_module_path(&self) -> Option<&str>
§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere T: Default,
§fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Self
using data from the given World
.§impl<T> GetPath for Twhere
T: Reflect + ?Sized,
impl<T> GetPath for Twhere T: Reflect + ?Sized,
§fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>
) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path<'p>( &self, path: impl ReflectPath<'p> ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read more§fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p> ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read more§fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
fn path<'p, T>( &self, path: impl ReflectPath<'p> ) -> Result<&T, ReflectPathError<'p>>where T: Reflect,
path
. Read more§fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p> ) -> Result<&mut T, ReflectPathError<'p>>where T: Reflect,
path
. Read more