Struct Decal3D 

#[repr(C)]
pub struct Decal3D {

    pub size: Vec3,
    pub image: u32,
    pub normal_image: u32,
    pub uv_min: Vec2,
    pub uv_max: Vec2,
    pub color: Color,
    pub opacity: f32,
    pub normal_strength: f32,
    pub roughness: f32,
    pub metallic: f32,
    pub angle_fade_start: f32,
    pub angle_fade_end: f32,
    pub depth_fade: f32,
    pub max_distance: f32,
    pub order: i32,
    pub layers: u32,
}

A box that paints an image onto the opaque surfaces inside it. The entity’s Transform3D places the box (its scale multiplies size). The image is projected along the box’s -Z (looking from +Z), its top along +Y, as with MeshData::decal; only surfaces turned towards +Z get it.

Unlike a mesh decal, nothing is built: the decal is drawn onto whatever is inside the box each frame, so it follows moving and skinned models, costs the same however much geometry is under it, and is lit with the surface it lands on. Put hundreds on screen (MAX_DECALS at most). Parent a decal to a model (see Attached) to carry it along.

Images come from the texture array set with Ctx::set_decal_textures; without one a decal is a flat color rectangle. Surfaces whose model has no matching ReceivesDecals layer are skipped, as are transparent materials.

use ponko::*;
// A 2 x 2 m mark, 1 m deep, from the first image of the decal textures.
let mark = Decal3D { size: vec3(2.0, 2.0, 1.0), image: 0, ..Default::default() };
let mut world = World::new();
// Looking down: the box's +Z turned to point up.
let down = Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2);
world.spawn((Transform3D::at(vec3(0.0, 0.5, 0.0)).rotated(down), mark));

Fields

size: Vec3

Width (x), height (y) and depth (z) of the box, in world units. Default (1, 1, 1).

image: u32

The layer of the decal textures holding the color image, or Decal3D::NO_IMAGE for a flat color. Colors are sRGB, as images are painted. Default 0.

normal_image: u32

The layer holding a tangent-space normal map, or Decal3D::NO_IMAGE for none (the surface’s own normals). Default none.

uv_min: Vec2

The top left of the image in its layer, as a fraction of it: use a part of a layer as an atlas. Default (0, 0).

uv_max: Vec2

The bottom right of the image in its layer. Default (1, 1).

color: Color

Multiplies the image (sRGB); its alpha multiplies opacity. Default white.

opacity: f32

How much of the decal shows, 0 to 1, times the image’s alpha. Default 1.

normal_strength: f32

How strongly the normal map tilts the surface. Default 1.

roughness: f32

The surface’s roughness where the decal is fully opaque, or a negative number to leave it as it is (the default). Wet blood is low, dust high.

metallic: f32

The surface’s metallic value under the decal, or a negative number to leave it (the default). Dirt on metal is 0.

angle_fade_start: f32

Angle from the projection axis, in radians, up to which the decal is fully visible; beyond it, it fades out so it doesn’t stretch over steep surfaces. Default 1.0 (about 57 degrees).

angle_fade_end: f32

Angle where it has faded out completely. Default 1.45 (about 83 degrees); surfaces at 90 degrees or more get none.

depth_fade: f32

How much of the box’s depth, from each end, the decal fades over (0 to 1): 0 is a hard edge, 1 fades from the middle. Default 0.25.

max_distance: f32

Distance from the camera past which the decal is not drawn; it fades out over the last quarter. 0 is unlimited (the default).

order: i32

Decals with a higher order are drawn over those with a lower one. Equal orders keep the entities’ order in the world, which is not stable across despawns. Default 0.

layers: u32

Which models get it: it shows on a model whose ReceivesDecals has any of these bits. Only the low 16 bits count. Default all.

Implementations

impl Decal3D

pub const NO_IMAGE: u32 = u32::MAX

image and normal_image value that selects no image.

Trait Implementations

impl Clone for Decal3D

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Decal3D

impl Debug for Decal3D

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

Formats the value using the given formatter.

impl Default for Decal3D

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Decal3D

where Decal3D: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Decal3D

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Decal3D

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Decal3D