Struct ImageSprite 

pub struct ImageSprite {
    pub image: ImageId,
    pub origin: [f32; 3],
    pub facing: ImageFacing,
    pub size: [f32; 2],
    pub tint: u32,
    pub alpha_cutoff: f32,
    pub depth_test: bool,
    pub double_sided: bool,
}

One placed 2D image sprite for the current frame: a flat textured quad in world space, composited over the rendered scene with the frame’s depth buffer (so the voxel model can occlude it). Built per frame and passed to SceneRenderer::draw_images, mirroring Line3 / SceneRenderer::draw_lines. The texture is uploaded once via SceneRenderer::upload_image and referenced by image.

Fields

image: ImageId

The uploaded texture to draw (from SceneRenderer::upload_image).

origin: [f32; 3]

World position of the quad’s top-left corner — the image’s (column 0, row 0) texel. The quad extends size[0] along the facing’s u and size[1] along its v.

facing: ImageFacing

World orientation of the quad — fixed in world or camera-facing.

size: [f32; 2]

World size of the quad along u and v. For pixel-art traced at 1 texel = 1 voxel, pass [width as f32, height as f32].

tint: u32

Multiplied into every sampled texel (tint + opacity), 0xAARRGGBB. 0xFFFFFFFF draws the texture unchanged; the high byte scales the texel alpha (e.g. 0x80FFFFFF = 50 % opacity).

alpha_cutoff: f32

Alpha cutoff in 0.0..=1.0. Texels whose own alpha is below this are discarded outright (not blended) — crisp pixel-art edges instead of a semi-transparent haze, and the same threshold decides what SceneRenderer::pick_image treats as solid. 0.0 keeps the plain straight-alpha over-blend (every non-zero texel draws).

depth_test: bool

true: occluded by nearer rendered geometry (depth-tested against the frame’s depth buffer, with a bias so a quad resting on a coincident voxel face doesn’t z-fight). false: always on top.

double_sided: bool

true: draw regardless of which way the quad faces (no backface cull) — what reference images usually want. false: cull when the quad faces away from the camera. Ignored for ImageFacing::Billboard (it always faces the camera).

Trait Implementations

impl Clone for ImageSprite

fn clone(&self) -> ImageSprite

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ImageSprite

impl Debug for ImageSprite

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

Formats the value using the given formatter.

impl PartialEq for ImageSprite

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ImageSprite