@woosh/meep-engine 3.30.0 → 3.31.0

package/src/engine/graphics3/terrain/TERRAIN_MATERIAL_TEMPLATE.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @typedef {import("../../../shade/renderer/material/GPUMaterialContext.js").GPUMaterialContext} GPUMaterialContext
+ * @typedef {import("../../../shade/renderer/material/template/GPUMaterialServices.js").GPUMaterialServices} GPUMaterialServices
+ * @typedef {import("../../../shade/renderer/texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
+ * @typedef {import("./TerrainShadeMaterial.js").TerrainShadeMaterial} TerrainShadeMaterial
+ */
+/**
+ * The terrain material's uniform — what changes only when the terrain is resized, regridded or
+ * given a different number of layers.
+ */
+export const TERRAIN_SURFACE_STRUCT: WebGPUStruct;
+/**
+ * Group 0 of the terrain template.
+ *
+ * Everything sampled is declared **filterable** ("float"), because every one of these is read
+ * through a linear sampler — the pipeline is rejected outright if the declaration says
+ * `unfilterable-float` while a `filtering` sampler is bound (the defect U7g caught on a device).
+ * The overlay map alone is read by `textureLoad` and keeps the default.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const TERRAIN_MATERIAL_RESOURCE_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * What one terrain material owns on the GPU, beyond its uniform.
+ */
+export class TerrainMaterialState {
+    weights: TextureResidency;
+    layers: TextureResidency;
+    overlay: TextureResidency;
+    sprite: TextureResidency;
+    /**
+     * Two floats per layer, the legacy `materialScalesMap`.
+     *
+     * @type {GPUBuffer|null}
+     */
+    scales: GPUBuffer | null;
+    /**
+     * @type {number} in bytes
+     */
+    scales_capacity: number;
+    /**
+     * @type {number}
+     */
+    scales_version: number;
+}
+/**
+ * @type {ShadeMaterialTemplate}
+ */
+export const TERRAIN_MATERIAL_TEMPLATE: ShadeMaterialTemplate;
+export type GPUMaterialContext = import("../../../shade/renderer/material/GPUMaterialContext.js").GPUMaterialContext;
+export type GPUMaterialServices = import("../../../shade/renderer/material/template/GPUMaterialServices.js").GPUMaterialServices;
+export type GPUTextureContext = import("../../../shade/renderer/texture/GPUTextureContext.js").GPUTextureContext;
+export type TerrainShadeMaterial = import("./TerrainShadeMaterial.js").TerrainShadeMaterial;
+import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
+import { ShaderResourceGroupDescriptor } from "../../../shade/renderer/shader/resource/ShaderResourceGroupDescriptor.js";
+/**
+ * One CPU image as the GPU holds it — the array the texture was last written from and its version
+ * together say whether the texture still agrees with the source.
+ */
+declare class TextureResidency {
+    /**
+     * @type {GPUTextureContext|null}
+     */
+    texture: GPUTextureContext | null;
+    /**
+     * @type {number}
+     */
+    version: number;
+    /**
+     * @type {*}
+     */
+    source: any;
+    destroy(): void;
+}
+import { ShadeMaterialTemplate } from "../../../shade/renderer/material/template/ShadeMaterialTemplate.js";
+export {};
+//# sourceMappingURL=TERRAIN_MATERIAL_TEMPLATE.d.ts.map

package/src/engine/graphics3/terrain/TERRAIN_MATERIAL_TEMPLATE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TERRAIN_MATERIAL_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/TERRAIN_MATERIAL_TEMPLATE.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AAEH;;;GAGG;AACH,kDAkBqB;AAErB;;;;;;;;;GASG;AACH,8CAFU,6BAA6B,CAE4C;AA2FnF;;GAEG;AACH;IACI,0BAAiC;IACjC,yBAAgC;IAChC,0BAAiC;IACjC,yBAAgC;IAEhC;;;;OAIG;IACH,QAFU,YAAU,IAAI,CAEV;IAEd;;OAEG;IACH,iBAFU,MAAM,CAEI;IAEpB;;OAEG;IACH,gBAFU,MAAM,CAEI;CACvB;AA6SD;;GAEG;AACH,wCAFU,qBAAqB,CAQ5B;iCAldU,OAAO,wDAAwD,EAAE,kBAAkB;kCACnF,OAAO,kEAAkE,EAAE,mBAAmB;gCAC9F,OAAO,sDAAsD,EAAE,iBAAiB;mCAChF,OAAO,2BAA2B,EAAE,oBAAoB;6BARxC,qDAAqD;8CAH3E,0EAA0E;AA4GjF;;;GAGG;AACH;IACI;;OAEG;IACH,SAFU,iBAAiB,GAAC,IAAI,CAEjB;IAEf;;OAEG;IACH,SAFU,MAAM,CAEH;IAEb;;OAEG;IACH,YAAc;IAEd,gBAQC;CACJ;sCA5IqC,oEAAoE"}

package/src/engine/graphics3/terrain/TERRAIN_MATERIAL_TEMPLATE.js

@@ -0,0 +1,485 @@
+import { assert } from "../../../core/assert.js";
+import { round_up } from "../../../core/math/round_up.js";
+import { GPUShaderStage } from "../../../shade/descriptor/GPUShaderStage.js";
+import { SamplerDescriptor } from "../../../shade/descriptor/texture/SamplerDescriptor.js";
+import { TextureDescriptor } from "../../../shade/descriptor/texture/TextureDescriptor.js";
+import { TextureViewDescriptor } from "../../../shade/descriptor/texture/TextureViewDescriptor.js";
+import { G_BUFFER_ALBEDO_FORMAT } from "../../../shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js";
+import { ShadeMaterialTemplate } from "../../../shade/renderer/material/template/ShadeMaterialTemplate.js";
+import {
+    ShaderResourceGroupDescriptor
+} from "../../../shade/renderer/shader/resource/ShaderResourceGroupDescriptor.js";
+import { u32, vec2f, vec4f } from "../../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shade/renderer/shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
+import { TextureFilterType } from "../../../shade/renderer/texture/TextureFilterType.js";
+import { chunk_terrain_material_surface } from "./chunk_terrain_material_surface.js";
+
+/**
+ * @typedef {import("../../../shade/renderer/material/GPUMaterialContext.js").GPUMaterialContext} GPUMaterialContext
+ * @typedef {import("../../../shade/renderer/material/template/GPUMaterialServices.js").GPUMaterialServices} GPUMaterialServices
+ * @typedef {import("../../../shade/renderer/texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
+ * @typedef {import("./TerrainShadeMaterial.js").TerrainShadeMaterial} TerrainShadeMaterial
+ */
+
+/**
+ * The terrain material's uniform — what changes only when the terrain is resized, regridded or
+ * given a different number of layers.
+ */
+export const TERRAIN_SURFACE_STRUCT = WebGPUStruct.from({
+    /**
+     * The grid transform as the terrain authors it: scale in xy, offset in zw. Grid position
+     * `(local.xz - offset) / scale` puts cell centres on integers.
+     */
+    grid_transform: vec4f,
+
+    /**
+     * `1 / (size × gridScale)` per axis.
+     */
+    inv_world_size: vec2f,
+
+    /**
+     * The terrain's size in cells.
+     */
+    grid_resolution: vec2f,
+
+    layer_count: u32,
+}, "TerrainSurface");
+
+/**
+ * Group 0 of the terrain template.
+ *
+ * Everything sampled is declared **filterable** ("float"), because every one of these is read
+ * through a linear sampler — the pipeline is rejected outright if the declaration says
+ * `unfilterable-float` while a `filtering` sampler is bound (the defect U7g caught on a device).
+ * The overlay map alone is read by `textureLoad` and keeps the default.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const TERRAIN_MATERIAL_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
+
+TERRAIN_MATERIAL_RESOURCE_GROUP.label = "Material Terrain";
+
+TERRAIN_MATERIAL_RESOURCE_GROUP
+    .addUniform("terrain", TERRAIN_SURFACE_STRUCT)
+    .addStorageBuffer("layer_scales", WebGPUArray.f32)
+    .addTexture("splat_weights", "float", "2d-array")
+    .addSampler("splat_sampler")
+    .addTexture("layer_diffuse", "float", "2d-array")
+    .addSampler("layer_sampler")
+    .addTexture("overlay_map")
+    .addTexture("overlay_sprite", "float")
+    .addSampler("sprite_sampler");
+
+TERRAIN_MATERIAL_RESOURCE_GROUP.addVisibility(GPUShaderStage.FRAGMENT);
+
+/**
+ * Buffers grow with headroom and never shrink.
+ *
+ * @type {number}
+ */
+const GROWTH_FACTOR = 1.5;
+
+/**
+ * What the legacy weight texture declared: linear magnification, no mip chain, edges clamped.
+ */
+const SAMPLER_SPLAT_WEIGHTS = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    minFilter: "nearest",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+}));
+
+/**
+ * What the legacy layer array declared: trilinear over a full mip chain, repeat wrap — the layers
+ * tile — and the same anisotropy.
+ */
+const SAMPLER_TERRAIN_LAYERS = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "linear",
+    addressModeU: "repeat",
+    addressModeV: "repeat",
+    maxAnisotropy: 8
+}));
+
+const SAMPLER_OVERLAY_SPRITE = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+}));
+
+/**
+ * The whole-array view, said explicitly: a one-layer terrain would otherwise get the "2d" default
+ * view of its depth-1 texture, which does not bind against a `texture_2d_array` declaration.
+ */
+const VIEW_2D_ARRAY = TextureViewDescriptor.from({ dimension: "2d-array" });
+
+/**
+ * One CPU image as the GPU holds it — the array the texture was last written from and its version
+ * together say whether the texture still agrees with the source.
+ */
+class TextureResidency {
+    /**
+     * @type {GPUTextureContext|null}
+     */
+    texture = null;
+
+    /**
+     * @type {number}
+     */
+    version = -1;
+
+    /**
+     * @type {*}
+     */
+    source = null;
+
+    destroy() {
+        if (this.texture !== null) {
+            this.texture.destroy();
+        }
+
+        this.texture = null;
+        this.version = -1;
+        this.source = null;
+    }
+}
+
+/**
+ * What one terrain material owns on the GPU, beyond its uniform.
+ */
+export class TerrainMaterialState {
+    weights = new TextureResidency();
+    layers = new TextureResidency();
+    overlay = new TextureResidency();
+    sprite = new TextureResidency();
+
+    /**
+     * Two floats per layer, the legacy `materialScalesMap`.
+     *
+     * @type {GPUBuffer|null}
+     */
+    scales = null;
+
+    /**
+     * @type {number} in bytes
+     */
+    scales_capacity = 0;
+
+    /**
+     * @type {number}
+     */
+    scales_version = -1;
+}
+
+/**
+ * Put one image on the GPU, rewriting in place when its source moved and reallocating when its
+ * shape did.
+ *
+ * @param {GPUMaterialServices} services
+ * @param {TextureResidency} residency
+ * @param {{data: Uint8Array, width: number, height: number, version: number}} image
+ * @param {number} depth layers
+ * @param {GPUTextureFormat} format
+ * @param {number} bytes_per_pixel
+ * @param {boolean} mips
+ * @param {string} label
+ * @returns {boolean} whether the texture was replaced, which the bind group has to follow
+ */
+function upload_texture(services, residency, image, depth, format, bytes_per_pixel, mips, label) {
+    const existing = residency.texture;
+
+    // a texture has at least one layer; a terrain without layers leaves the one it has unwritten
+    const layers = Math.max(1, depth);
+
+    let replaced = false;
+
+    if (
+        existing === null
+        || existing.descriptor.size[0] !== image.width
+        || existing.descriptor.size[1] !== image.height
+        || existing.descriptor.size[2] !== layers
+    ) {
+        // the old one goes back before the new one is taken — nothing in the frame graph owns
+        // these, so nothing else reclaims them
+        if (existing !== null) {
+            existing.destroy();
+        }
+
+        const mip_levels = mips ? 1 + Math.floor(Math.log2(Math.max(image.width, image.height))) : 1;
+
+        residency.texture = services.textures.contextFromDescriptor(TextureDescriptor.from({
+            label,
+            size: [image.width, image.height, layers],
+            format,
+            mipLevelCount: mip_levels,
+            /*
+             `RENDER_ATTACHMENT` is the mip generator's: with it, each level is rendered straight
+             into the texture through the texture's own views — sRGB for the layers, which decode on
+             the read and encode on the write — rather than into a scratch texture that is then
+             copied home. Nothing is copied out of it, so there is no `COPY_SRC`: that was for a
+             copy into a linear twin that was meant to decode the layers and, a texture copy being
+             byte-exact, never did. The decal atlas carries the same flags for the same reason.
+            */
+            usage: mips
+                ? GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+                : GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+        }));
+
+        residency.version = -1;
+        residency.source = null;
+
+        replaced = true;
+    }
+
+    if (residency.source === image.data && residency.version === image.version) {
+        return replaced;
+    }
+
+    if (depth > 0) {
+        services.device.queue.writeTexture(
+            { texture: residency.texture.gpu_texture },
+            image.data,
+            { bytesPerRow: image.width * bytes_per_pixel, rowsPerImage: image.height },
+            [image.width, image.height, depth]
+        );
+
+        if (mips) {
+            services.textures.mipmaps.generateMipmap(
+                residency.texture.gpu_texture,
+                residency.texture.descriptor,
+                TextureFilterType.Linear
+            );
+        }
+    }
+
+    residency.source = image.data;
+    residency.version = image.version;
+
+    return replaced;
+}
+
+/**
+ * @param {GPUMaterialServices} services
+ * @param {TerrainMaterialState} state
+ * @param {TerrainShadeMaterial} material
+ * @returns {boolean} whether the buffer was replaced
+ */
+function upload_scales(services, state, material) {
+    const element_count = material.layer_count * 2;
+
+    // a zero-length storage buffer is not a legal binding; the floor keeps it legal, not meaningful
+    const bytes = Math.max(4, element_count * Float32Array.BYTES_PER_ELEMENT);
+
+    let replaced = false;
+
+    if (state.scales_capacity < bytes) {
+        if (state.scales !== null) {
+            state.scales.destroy();
+        }
+
+        const size = round_up(Math.ceil(bytes * GROWTH_FACTOR), 4);
+
+        state.scales = services.device.createBuffer({
+            size,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            label: "terrain/layer_scales"
+        });
+
+        state.scales_capacity = size;
+        state.scales_version = -1;
+
+        replaced = true;
+    }
+
+    if (state.scales_version !== material.layer_scales_version) {
+        if (element_count > 0) {
+            services.device.queue.writeBuffer(state.scales, 0, material.layer_scales, 0, element_count);
+        }
+
+        state.scales_version = material.layer_scales_version;
+    }
+
+    return replaced;
+}
+
+/**
+ * The terrain as a material template: the splat mix and the grid overlay as a surface function,
+ * over tiles that are ordinary meshlet geometry.
+ *
+ * **Dynamic.** The weight map is painted, the overlay is gameplay state and the sprite loads late,
+ * none of which moves the material's version — so every frame, before any pass, each terrain
+ * material's textures are compared against their sources and rewritten only when one moved, and a
+ * texture that changed shape is reallocated and its material's bind group rebuilt. The first upload
+ * happens when the context is created, so the first bind group binds real textures.
+ *
+ * **Opaque only.** It has no opacity function, and the transparent passes cannot draw it.
+ */
+class TerrainMaterialTemplate extends ShadeMaterialTemplate {
+
+    /**
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUMaterialServices} services
+     */
+    build(ctx, services) {
+        assert.defined(services.samplers, 'the terrain template binds shared samplers, and the material manager was given no sampler manager');
+
+        ctx.state = new TerrainMaterialState();
+
+        this.#upload(ctx, services);
+    }
+
+    /**
+     * @param {TerrainShadeMaterial} material
+     * @returns {Object}
+     */
+    uniform_value(material) {
+        return {
+            grid_transform: material.grid_transform,
+            inv_world_size: material.inv_world_size,
+            grid_resolution: material.grid_resolution,
+            layer_count: material.layer_count,
+        };
+    }
+
+    /**
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUBindGroupLayout} layout
+     * @param {GPUMaterialServices} services
+     * @returns {GPUBindGroup}
+     */
+    create_bind_group(ctx, layout, services) {
+        /**
+         * @type {TerrainMaterialState}
+         */
+        const state = ctx.state;
+
+        const samplers = services.samplers;
+
+        return services.device.createBindGroup({
+            label: "terrain material",
+            layout,
+            entries: TERRAIN_MATERIAL_RESOURCE_GROUP.generateGPUBindGroupEntryArray({
+                terrain: { buffer: ctx.uniform_buffer },
+                layer_scales: { buffer: state.scales },
+                splat_weights: state.weights.texture.obtainView(VIEW_2D_ARRAY),
+                splat_sampler: samplers.obtain(SAMPLER_SPLAT_WEIGHTS),
+                layer_diffuse: state.layers.texture.obtainView(VIEW_2D_ARRAY),
+                layer_sampler: samplers.obtain(SAMPLER_TERRAIN_LAYERS),
+                overlay_map: state.overlay.texture.obtainView(),
+                overlay_sprite: state.sprite.texture.obtainView(),
+                sprite_sampler: samplers.obtain(SAMPLER_OVERLAY_SPRITE),
+            })
+        });
+    }
+
+    /**
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUMaterialServices} services
+     * @returns {boolean}
+     */
+    update(ctx, services) {
+        return this.#upload(ctx, services);
+    }
+
+    /**
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUMaterialServices} services
+     */
+    destroy(ctx, services) {
+        /**
+         * @type {TerrainMaterialState|null}
+         */
+        const state = ctx.state;
+
+        if (state === null) {
+            return;
+        }
+
+        state.weights.destroy();
+        state.layers.destroy();
+        state.overlay.destroy();
+        state.sprite.destroy();
+
+        if (state.scales !== null) {
+            state.scales.destroy();
+            state.scales = null;
+        }
+
+        state.scales_capacity = 0;
+        state.scales_version = -1;
+
+        ctx.state = null;
+    }
+
+    /**
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUMaterialServices} services
+     * @returns {boolean} whether anything the bind group names was replaced
+     */
+    #upload(ctx, services) {
+        /**
+         * @type {TerrainShadeMaterial}
+         */
+        const material = ctx.source;
+
+        /**
+         * @type {TerrainMaterialState}
+         */
+        const state = ctx.state;
+
+        let replaced = upload_scales(services, state, material);
+
+        const weights = material.weights;
+
+        /*
+         The weight array has no mip chain — the legacy texture never generated one — and one byte
+         per texel per layer keeps the upload the size of the authored data.
+        */
+        replaced = upload_texture(
+            services, state.weights, weights, weights.depth,
+            "r8unorm", 1, false, "terrain/splat_weights"
+        ) || replaced;
+
+        const layers = material.layers;
+
+        /*
+         The layers are authored sRGB, and uploading them as such is what makes the shader's mix
+         linear without a decode of its own — the sampler decodes each texel before filtering. The
+         mip chain is generated exactly as the decal atlas generates its own, per array layer.
+        */
+        replaced = upload_texture(
+            services, state.layers, layers, layers.depth,
+            `${G_BUFFER_ALBEDO_FORMAT}-srgb`, 4, true, "terrain/layers"
+        ) || replaced;
+
+        /*
+         Both overlay textures are sRGB for the same reason the layers are: the sprite is an
+         authored image and the cell map holds authored colours.
+        */
+        replaced = upload_texture(
+            services, state.overlay, material.overlay, 1,
+            `${G_BUFFER_ALBEDO_FORMAT}-srgb`, 4, false, "terrain/overlay_map"
+        ) || replaced;
+
+        replaced = upload_texture(
+            services, state.sprite, material.sprite, 1,
+            `${G_BUFFER_ALBEDO_FORMAT}-srgb`, 4, false, "terrain/overlay_sprite"
+        ) || replaced;
+
+        return replaced;
+    }
+}
+
+/**
+ * @type {ShadeMaterialTemplate}
+ */
+export const TERRAIN_MATERIAL_TEMPLATE = new TerrainMaterialTemplate({
+    name: "Terrain",
+    resources: TERRAIN_MATERIAL_RESOURCE_GROUP,
+    uniform_type: TERRAIN_SURFACE_STRUCT,
+    surface: chunk_terrain_material_surface,
+    dynamic: true,
+});

package/src/engine/graphics3/terrain/TerrainShadeMaterial.d.ts

@@ -0,0 +1,103 @@
+/**
+ * A terrain's surface as a material: what {@link TERRAIN_MATERIAL_TEMPLATE} needs to draw one
+ * terrain's tiles. {@link TerrainSystem} keeps it current.
+ *
+ * **Two kinds of field, two ways of reaching the GPU.** The images and the per-layer scales carry
+ * versions of their own and are uploaded when those move, every frame the template compares them;
+ * they change while the game runs — the weight map is painted, the overlay is gameplay state — and
+ * moving the material's version for them would restage its metadata row and rebuild the resident
+ * material mirror each time. The uniform fields — {@link inv_world_size}, {@link grid_resolution},
+ * {@link grid_transform}, {@link layer_count} — change when the terrain is resized, regridded or
+ * given layers, and reach the GPU the way every material's fields do: set `needsUpdate`.
+ *
+ * **Identity is the material.** Two terrains with equal settings are still two terrains with their
+ * own textures, so this compares and hashes by identity — the value-keyed caches (the resident
+ * mirror, import dedupe) must not merge them.
+ *
+ * Transient: built from the terrain on load, never serialized or cloned.
+ */
+export class TerrainShadeMaterial extends ShadeMaterial {
+    /**
+     * The splat weight array, one r8 layer per terrain layer.
+     *
+     * @type {TerrainImage}
+     */
+    weights: TerrainImage;
+    /**
+     * The layers' diffuse, rgba8 sRGB, one array layer per terrain layer.
+     *
+     * @type {TerrainImage}
+     */
+    layers: TerrainImage;
+    /**
+     * The per-cell rgba map the game paints.
+     *
+     * @type {TerrainImage2D}
+     */
+    overlay: TerrainImage2D;
+    /**
+     * The sprite repeated in every cell the overlay colours, rgba.
+     *
+     * @type {TerrainImage2D}
+     */
+    sprite: TerrainImage2D;
+    /**
+     * Two floats per layer: how many times the layer tiles across the terrain on each axis.
+     *
+     * @type {Float32Array}
+     */
+    layer_scales: Float32Array;
+    /**
+     * Moves when {@link layer_scales} changes.
+     *
+     * @type {number}
+     */
+    layer_scales_version: number;
+    /**
+     * @type {number}
+     */
+    layer_count: number;
+    /**
+     * `1 / (size × gridScale)` per axis.
+     *
+     * @type {Float32Array}
+     */
+    inv_world_size: Float32Array;
+    /**
+     * The terrain's size in cells.
+     *
+     * @type {Float32Array}
+     */
+    grid_resolution: Float32Array;
+    /**
+     * Scale in xy, offset in zw.
+     *
+     * @type {Float32Array}
+     */
+    grid_transform: Float32Array;
+    /**
+     * @readonly
+     * @type {ShadeMaterialTemplate}
+     */
+    readonly template: ShadeMaterialTemplate;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isTerrainShadeMaterial: boolean;
+}
+export type TerrainImage = {
+    data: Uint8Array;
+    width: number;
+    height: number;
+    depth: number;
+    version: number;
+};
+export type TerrainImage2D = {
+    data: Uint8Array;
+    width: number;
+    height: number;
+    version: number;
+};
+import { ShadeMaterial } from "../../../shade/renderer/material/ShadeMaterial.js";
+//# sourceMappingURL=TerrainShadeMaterial.d.ts.map

package/src/engine/graphics3/terrain/TerrainShadeMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainShadeMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/TerrainShadeMaterial.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;;;OAIG;IACH,SAFU,YAAY,CAEE;IAExB;;;;OAIG;IACH,QAFU,YAAY,CAEC;IAEvB;;;;OAIG;IACH,SAFU,cAAc,CAEA;IAExB;;;;OAIG;IACH,QAFU,cAAc,CAED;IAEvB;;;;OAIG;IACH,cAFU,YAAY,CAEa;IAEnC;;;;OAIG;IACH,sBAFU,MAAM,CAES;IAEzB;;OAEG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,gBAFU,YAAY,CAEe;IAErC;;;;OAIG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;;OAIG;IACH,gBAFU,YAAY,CAEe;IAkBzC;;;OAGG;IACH,yCAAuC;IAEvC;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CAZpD;2BAjHY;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC;6BACjF;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC;8BALjD,mDAAmD"}