/**
 * Layout of a single point in the {@link points} buffer. 12 floats per point,
 * interleaved so an InstancedBufferAttribute can stride over the whole thing
 * once and the geometry builder can split it into per-instance attributes
 * with offsets.
 *
 * Order chosen so a single 16-byte fetch (vec4) covers the most-used pair
 * (albedo.rgb + occlusion) and another covers normal.xyz + roughness.
 *
 * | offset | size | content                                  |
 * |--------|------|------------------------------------------|
 * |   0    |   3  | position.xyz (object space)              |
 * |   3    |   3  | normal.xyz   (object space, unit length) |
 * |   6    |   3  | albedo.rgb   (linear, no alpha)          |
 * |   9    |   3  | orm (occlusion, roughness, metalness)    |
 *
 * @type {number}
 */
export const VOXEL_POINT_STRIDE: number;
export const VOXEL_POINT_OFFSET_POSITION: 0;
export const VOXEL_POINT_OFFSET_NORMAL: 3;
export const VOXEL_POINT_OFFSET_ALBEDO: 6;
export const VOXEL_POINT_OFFSET_ORM: 9;
/**
 * Output of {@link VoxelImpostorBaker.bake} — describes a baked voxel
 * impostor entirely on the CPU, in a form that's cheap to re-upload to a
 * GPU instanced-quad geometry (see make_voxel_impostor_geometry).
 *
 * Conceptually: a sparse cloud of equally-sized points, each carrying the
 * same G-buffer attributes the octahedral impostor packs into its texture
 * atlas — position, normal, albedo, and ORM (occlusion / roughness /
 * metalness). No alpha. Each point represents one occupied voxel cell of
 * the source mesh's surface, captured at the bake-time resolution.
 *
 * Same impostor mental model as the octahedral system: pre-baked, no
 * animation, only what's visible from outside the bounding sphere gets
 * captured.
 */
export class VoxelImpostorDescription {
    /**
     * How the impostor was sampled. Drives which directions the baker
     * placed cameras at during the GPU sampling pass.
     * @type {number}
     */
    capture_type: number;
    /**
     * Radius of the bounding sphere captured during the bake, in
     * object-space units.
     * @type {number}
     */
    sphere_radius: number;
    /**
     * Centre of the bounding sphere in object space — points in
     * {@link points} are stored in this same frame.
     * @type {number[]}
     */
    offset: number[];
    /**
     * Voxel grid cell size used during baking, in **bake (object)
     * space**. Reference / diagnostic value — the renderer reads
     * {@link point_diameter} instead of computing from this.
     * @type {number}
     */
    voxel_size: number;
    /**
     * Auto-tuned splat diameter in **bake (object) space** — what
     * the renderer should set `uPointDiameter` to. Set by the baker
     * to `voxel_size * sqrt(2)` so that camera-facing quads cover
     * the worst-case oblique projection of a voxel cell (45° to the
     * view direction, where the cell's projected width grows by
     * sqrt(2)). At less oblique angles the splat overlaps with its
     * neighbours, which the depth test resolves cleanly.
     *
     * The shaders apply the silhouette-tightening inward-shift at
     * draw time, using this diameter: each splat's CENTRE sits at
     * `iPosition - iNormal * (point_diameter * 0.5)`, so its outer
     * edge falls on the source mesh surface — silhouette stays tight
     * regardless of how much overlap was needed for fill.
     *
     * @type {number}
     */
    point_diameter: number;
    /**
     * Number of valid points in {@link points}. Always {@link points}.length / {@link VOXEL_POINT_STRIDE}.
     * @type {number}
     */
    point_count: number;
    /**
     * Interleaved per-point attributes. See {@link VOXEL_POINT_STRIDE} for layout.
     * @type {Float32Array|null}
     */
    points: Float32Array | null;
    /**
     * Voxel grid resolution used during baking — the longest side of the
     * grid covering the bounding box. Useful for diagnostics and for
     * choosing a similar grid when re-baking the same model.
     * @type {number}
     */
    grid_resolution: number;
    /**
     * Atlas resolution and frame count used to sample the surface. Kept
     * for diagnostics; the atlas itself is discarded once voxels are
     * extracted.
     * @type {number}
     */
    source_atlas_resolution: number;
    /**
     * @type {number}
     */
    source_atlas_frames: number;
    /**
     * @type {number}
     */
    source_geometry_polygon_count: number;
    /**
     * @type {number}
     */
    source_geometry_vertex_count: number;
    /**
     * @type {number}
     */
    source_material_count: number;
    /**
     * @type {number}
     */
    source_instance_count: number;
}
//# sourceMappingURL=VoxelImpostorDescription.d.ts.map