Struct ChunkGpu 

#[repr(C)]
pub struct ChunkGpu {
    pub frame_a: [f32; 4],
    pub frame_b: [f32; 4],
    pub frame_c: [f32; 4],
    pub bary0: [f32; 2],
    pub bary1: [f32; 2],
    pub bary2: [f32; 2],
    pub slot: u32,
    pub level: u32,
    pub res: u32,
    pub _pad: [u32; 3],
}

One chunk’s GPU descriptor (std430, 96 bytes).

Field order is the shader’s layout contract — do not reorder without updating ChunkRealize.slang. Every array member is [f32;4] or smaller, and the struct is padded to a 16-byte multiple so that an array of ChunkGpu has the correct std430 stride (the shader indexes chunks[i] directly).

Fields

frame_a: [f32; 4]

Face frame corner A (xyz) and sphere radius (w); radius=0 → flat terrain.

frame_b: [f32; 4]

Face frame corner B (xyz), w=0 (unused).

frame_c: [f32; 4]

Face frame corner C (xyz), w=0 (unused).

bary0: [f32; 2]

Barycentric coords of chunk corner 0: (wb, wc); wa = 1 − wb − wc.

bary1: [f32; 2]

Barycentric coords of chunk corner 1.

bary2: [f32; 2]

Barycentric coords of chunk corner 2.

slot: u32

Vertex-pool slot: this chunk owns verts_per_chunk(res) contiguous vertices starting at slot * verts_per_chunk(res) in the pool texture.

level: u32

LOD level (== quadtree depth from the icosphere face root).

res: u32

Edge resolution: each chunk edge has res segments; vertex count = verts_per_chunk(res).

_pad: [u32; 3]

Explicit std430 padding: rounds the struct from 84 → 96 bytes so that size_of::<ChunkGpu>() % 16 == 0 (required by the std430 array-stride rule).

Implementations

impl ChunkGpu

pub fn from_chunk(frame: &FaceFrame, c: &Chunk, slot: u32, res: u32) -> Self

Pack one chunk into its GPU descriptor.

frame is the icosphere face that owns this chunk; slot is the chunk’s assigned vertex-pool slot.

Trait Implementations

impl Clone for ChunkGpu

fn clone(&self) -> ChunkGpu

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChunkGpu

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

Formats the value using the given formatter.

impl PartialEq for ChunkGpu

fn eq(&self, other: &ChunkGpu) -> 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 Zeroable for ChunkGpu

fn zeroed() -> Self

Calls zeroed.

impl Copy for ChunkGpu

impl Pod for ChunkGpu

impl StructuralPartialEq for ChunkGpu