Struct Kv6 

pub struct Kv6 {
    pub xsiz: u32,
    pub ysiz: u32,
    pub zsiz: u32,
    pub xpiv: f32,
    pub ypiv: f32,
    pub zpiv: f32,
    pub voxels: Vec<Voxel>,
    pub xlen: Vec<u32>,
    pub ylen: Vec<Vec<u16>>,
    pub palette: Option<[Rgb6; 256]>,
}

Parsed .kv6 model. Round-trips byte-equally via parse + serialize.

Fields

xsiz: u32

ysiz: u32

zsiz: u32

xpiv: f32

ypiv: f32

zpiv: f32

voxels: Vec<Voxel>

Voxel records in file order (numvoxs == voxels.len() as u32).

xlen: Vec<u32>

xlen[x] is the number of voxels in the x-th slice. xlen.len() == xsiz. xlen.iter().sum() == numvoxs.

ylen: Vec<Vec<u16>>

ylen[x][y] is the number of voxels in column (x, y). Outer length xsiz, inner ysiz.

palette: Option<[Rgb6; 256]>

Optional trailing 256-entry palette ("SPal" section).

Implementations

impl Kv6

pub fn from_fn<F>(xsiz: u32, ysiz: u32, zsiz: u32, fill: F) -> Kv6

where F: Fn(u32, u32, u32) -> Option<u32>,

Build a Kv6 procedurally from a dense occupancy + colour closure: fill(x, y, z) returns Some(col) for a solid voxel, None for air. col is voxlap-packed 0x80RRGGBB — the high byte is brightness, not alpha, so 0x00… renders black; use 0x80… for a flat-lit mid value.

Only surface voxels are emitted (a voxel with at least one of its six neighbours air or out of bounds), matching how a .kv6 stores a hull and how crate::sprite::Sprite expects to be drawn; fully-enclosed interior voxels are skipped. Emitted voxels get vis = 63 (all faces) and dir = 0, mirroring roxlap_core::meltsphere’s flat output — adequate for procedural models that don’t need per-face normals. The pivot is the geometric centre.

Voxels are emitted in the canonical x-major, then y, then ascending-z order the format requires, with matching xlen / ylen run tables.

pub fn from_fn_shaded<F>(xsiz: u32, ysiz: u32, zsiz: u32, fill: F) -> Kv6

where F: Fn(u32, u32, u32) -> Option<u32>,

Like Kv6::from_fn, but fills real per-voxel surface normals (Voxel::dir) and face visibility (Voxel::vis) instead of the flat dir = 0, vis = 63. The CPU sprite rasteriser shades each voxel by dir (kv6colmul[dir]), so a from_fn-built model shades flat while a from_fn_shaded one gets proper directional gradient shading — the difference an authored .kv6 shows.

dir is the nearest voxlap direction (crate::equivec::nearest_dir) to the voxel’s outward surface normal, estimated as the occupancy gradient over the 3³ neighbourhood (pointing toward empty space). vis is the bitmask of the six exposed faces.

pub fn recompute_surface(&mut self, occupied: impl Fn(i32, i32, i32) -> bool)

Recompute every stored voxel’s Voxel::vis + Voxel::dir from occupied (a predicate over the full solid in this kv6’s local coordinates; out-of-range / air ⇒ false). Use this after editing a model’s voxels to refresh its shading + face visibility — the editor counterpart to building with Kv6::from_fn_shaded. Geometry (positions, run tables) is left untouched; only vis/dir change.

pub fn carve_sphere_with_colfunc<S, C>( &mut self, centre: [i32; 3], radius: u32, solid: S, colfunc: C, )

where S: Fn(i32, i32, i32) -> bool, C: Fn(i32, i32, i32) -> u32,

Carve a sphere out of this model and control the colour of the interior the cut exposes — the sprite counterpart of roxlap_scene::Grid::set_sphere_with_colfunc / crate::edit::set_sphere_with_colfunc.

Why a solid predicate is required. A .kv6 stores only its surface hull — fully-enclosed interior voxels are not recorded (see Kv6::from_fn). A carve must therefore know the model’s full occupancy to expose meaningful interior walls, which the data alone can’t provide. The caller supplies it via solid(x, y, z) -> bool in kv6-local voxel coords (e.g. the same predicate used to build the model with Kv6::from_fn_shaded). solid must report true for at least every stored surface voxel.

Behaviour:

• Voxels inside the sphere (dx²+dy²+dz² <= r², matching crate::edit::set_sphere) become air.
• Voxels the cut newly exposes get their colour from colfunc(x, y, z) (kv6-local coords, voxlap-packed 0x80RRGGBB). Pass |_, _, _| col for a flat crater colour.
• Voxels that were already on the surface keep their stored colour.

centre / radius are in kv6-local voxel units. Dimensions, pivot, and palette are preserved; the model is re-extracted with real per-voxel normals + face visibility (as Kv6::from_fn_shaded).

pub fn solid_box(xsiz: u32, ysiz: u32, zsiz: u32, col: u32) -> Kv6

A solid axis-aligned box of a single colour (voxlap-packed 0x80RRGGBB). Convenience over Kv6::from_fn.

pub fn solid_cube(n: u32, col: u32) -> Kv6

A solid n³ cube of a single colour.

Trait Implementations

impl Clone for Kv6

fn clone(&self) -> Kv6

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Kv6

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

Formats the value using the given formatter.