Struct Material 

pub struct Material {

    pub asset_id: AssetId,
    pub albedo: Option<TextureHandle>,
    pub normal_map: Option<TextureHandle>,
    pub emissive_map: Option<TextureHandle>,
    pub orm_map: Option<TextureHandle>,
    pub roughness: f32,
    pub metallic: f32,
    pub tint: [f32; 3],
    pub emissive_factor: [f32; 3],
    pub alpha_cutoff: f32,
    pub opacity: f32,
    pub transparent: bool,
    pub see_through: bool,
    pub shader: Option<ShaderHandle>,
}

A Material bundles the surface parameters that control how a Prop is lit and shaded.

Reference it from a Prop’s material field. The material field takes precedence over the older texture field.

Material {
    roughness: 0.85,
    metallic: 0.0,
    ..Default::default()
};

Fields

asset_id: AssetId

Asset identity; injected via inject_name. Not part of args.

albedo: Option<TextureHandle>

The Texture asset used as the base colour (albedo) map.

normal_map: Option<TextureHandle>

The Texture asset used as a tangent-space normal map.

emissive_map: Option<TextureHandle>

The Texture asset used as an emissive map. Multiplied by emissive_factor to drive the glow; when omitted, only the scalar emissive_factor is used. Pair a textured emissive with an emissive_factor above 1 to make the bright parts bloom.

orm_map: Option<TextureHandle>

The Texture asset used as a packed surface map: green = roughness, blue = metalness. When present it overrides the scalar roughness and metallic per-texel; when omitted those scalars are used. The red channel is reserved and not read as ambient occlusion: packed maps in the wild (glTF metallic-roughness, FBX specular maps) leave red empty, so treating it as occlusion would darken indirect light to black. Ambient occlusion comes from the screen-space pass.

roughness: f32

Perceptual roughness in [0, 1]. 0 = mirror, 1 = fully diffuse. Controls the width of the specular highlight.

metallic: f32

Metallic factor in [0, 1]. 0 = dielectric (plastic/stone), 1 = metal. Metallic surfaces tint their reflections with the albedo colour and show almost no diffuse; dielectrics keep a neutral, dim reflection.

tint: [f32; 3]

Linear-space RGB multiplier applied to the albedo sample. Useful for tinting a shared texture without a separate asset (e.g. coloured brick).

emissive_factor: [f32; 3]

Additive emission colour in linear space. Non-zero values make the surface appear to glow independently of the scene lighting.

alpha_cutoff: f32

Alpha-cutout threshold in [0, 1]. When non-zero, a texel whose albedo alpha falls below it is discarded outright, punching a hole in the surface: this is how foliage, chain-link, and decal cards are drawn as one opaque quad. 0 (the default) disables the test and keeps every texel. Cutout is not glass: the surface still renders in the opaque pass, so leave transparent and see_through off.

opacity: f32

Surface opacity in [0, 1]. 1 = fully opaque (the default). Only meaningful when transparent is set: it drives how much of the scene behind the surface shows through the glass.

transparent: bool

When true, the surface is a translucent dielectric (glass): it renders in the engine’s transparent pass instead of the opaque pass, refracting and reflecting the scene rather than writing solid colour + depth. The importer sets this for materials it detects as glass; authored materials can opt in directly. Defaults to false (opaque).

see_through: bool

When true, the glass is rendered as genuinely see-through: the scene behind it shows through with a sharp per-pixel reflection (requires a ray-tracing-capable GPU). When false (the default), a transparent surface still renders as low-roughness reflective glass that hides whatever is behind it. See-through only looks right when the space behind the glass is actually modelled, so it is opt-in per material. Setting it implies transparent.

shader: Option<ShaderHandle>

The Shader asset that shades surfaces using this material. When omitted, the world’s default shader is used. Referencing a shader from a material ties that shader’s lifetime to the material’s: a shader referenced only by scene-exclusive materials loads and unloads with the scene.

Trait Implementations

impl Clone for Material

fn clone(&self) -> Material

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Material

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

Formats the value using the given formatter.

impl Default for Material

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Material

where Material: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ResourceAsset for Material

impl Serialize for Material

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.