@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/dist/core/src/assets/loader-texture.js

@@ -0,0 +1,264 @@
+import { assertCount, MAX_MIP_LEVELS, MAX_TEXTURE_DIM } from "../safety/bounds.js";
+import { loadDDSTexture } from "./loader-dds.js";
+import { loadHDRFile } from "./loader-hdr.js";
+export function detectTextureFormat(uri) {
+    const lower = uri.toLowerCase();
+    if (lower.endsWith(".png"))
+        return "png";
+    if (lower.endsWith(".webp"))
+        return "webp";
+    if (lower.endsWith(".ktx2"))
+        return "ktx2";
+    if (lower.endsWith(".dds"))
+        return "dds";
+    if (lower.endsWith(".hdr"))
+        return "hdr";
+    if (lower.endsWith(".exr"))
+        return "exr";
+    return "unknown";
+}
+export async function loadImageBitmap(uri) {
+    const response = await fetch(uri);
+    const blob = await response.blob();
+    return await createImageBitmap(blob);
+}
+export async function loadTextureFromImage(uri, format = "rgba8unorm", generateMips = false) {
+    const bitmap = await loadImageBitmap(uri);
+    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(bitmap, 0, 0);
+    const imageData = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+    let data = new Uint8Array(imageData.data.buffer);
+    let mipLevels = 1;
+    if (generateMips) {
+        mipLevels = Math.floor(Math.log2(Math.max(bitmap.width, bitmap.height))) + 1;
+        const mipChain = generateMipChain(data, bitmap.width, bitmap.height, mipLevels);
+        data = mipChain;
+    }
+    return {
+        width: bitmap.width,
+        height: bitmap.height,
+        data,
+        format,
+        mipLevels,
+        isHDR: false,
+    };
+}
+function generateMipChain(baseData, baseWidth, baseHeight, mipLevels) {
+    const levels = [baseData];
+    let prevWidth = baseWidth;
+    let prevHeight = baseHeight;
+    for (let level = 1; level < mipLevels; level++) {
+        const w = Math.max(1, Math.floor(prevWidth / 2));
+        const h = Math.max(1, Math.floor(prevHeight / 2));
+        const prevCanvas = new OffscreenCanvas(prevWidth, prevHeight);
+        const prevCtx = prevCanvas.getContext("2d");
+        const prevImageData = prevCtx.createImageData(prevWidth, prevHeight);
+        prevImageData.data.set(levels[level - 1]);
+        prevCtx.putImageData(prevImageData, 0, 0);
+        const mipCanvas = new OffscreenCanvas(w, h);
+        const mipCtx = mipCanvas.getContext("2d");
+        mipCtx.drawImage(prevCanvas, 0, 0, w, h);
+        const mipImageData = mipCtx.getImageData(0, 0, w, h);
+        levels.push(new Uint8Array(mipImageData.data.buffer));
+        prevWidth = w;
+        prevHeight = h;
+    }
+    const totalSize = levels.reduce((sum, l) => sum + l.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    levels.forEach((level) => {
+        result.set(level, offset);
+        offset += level.length;
+    });
+    return result;
+}
+function readKTX2Header(data) {
+    const KTX2_MAGIC = [0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
+    for (let i = 0; i < 12; i++) {
+        if (data[i] !== KTX2_MAGIC[i])
+            return null;
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const pixelWidth = view.getUint32(20, true);
+    const pixelHeight = view.getUint32(24, true);
+    const levelCount = view.getUint32(40, true);
+    // Validate texture dimensions and mip level count
+    assertCount("ktx2-dim", Math.max(pixelWidth, pixelHeight), MAX_TEXTURE_DIM);
+    assertCount("ktx2-levels", levelCount, MAX_MIP_LEVELS);
+    return {
+        vkFormat: view.getUint32(12, true),
+        typeSize: view.getUint32(16, true),
+        pixelWidth,
+        pixelHeight,
+        pixelDepth: view.getUint32(28, true),
+        layerCount: view.getUint32(32, true),
+        faceCount: view.getUint32(36, true),
+        levelCount,
+    };
+}
+const VK_FORMAT_MAP = {
+    // Unpacked formats (VK_FORMAT_* enum values)
+    37: "rgba8unorm",
+    43: "rgba8unorm-srgb",
+    45: "bgra8unorm",
+    50: "bgra8unorm-srgb",
+    76: "r16float",
+    100: "r32float",
+    103: "rg32float",
+    109: "rgba32float",
+    // BC compressed (VK_FORMAT_BC*_*_BLOCK enum values)
+    130: "bc1-rgba-unorm-srgb",
+    131: "bc1-rgba-unorm",
+    132: "bc2-rgba-unorm-srgb",
+    133: "bc2-rgba-unorm",
+    134: "bc3-rgba-unorm-srgb",
+    135: "bc3-rgba-unorm",
+    138: "bc4-r-unorm-srgb",
+    139: "bc4-r-unorm",
+    140: "bc5-rg-unorm-srgb",
+    141: "bc5-rg-unorm",
+    91: "bc7-unorm",
+    92: "bc7-unorm-srgb",
+    97: "bc6h-ufloat",
+    98: "bc6h-sfloat",
+    // ETC2/EAC compressed (VK_FORMAT_ETC2/EAC_*_BLOCK enum values)
+    146: "etc2-rgb8unorm-srgb",
+    147: "etc2-rgb8unorm",
+    150: "etc2-rgba8unorm-srgb",
+    151: "etc2-rgba8unorm",
+    152: "eac-r11unorm",
+    154: "eac-rg11unorm",
+    // ASTC compressed (VK_FORMAT_ASTC_*_BLOCK enum values = 168-195)
+    168: "astc-4x4-unorm",
+    169: "astc-4x4-unorm-srgb",
+    170: "astc-5x4-unorm",
+    171: "astc-5x4-unorm-srgb",
+    172: "astc-5x5-unorm",
+    173: "astc-5x5-unorm-srgb",
+    174: "astc-6x5-unorm",
+    175: "astc-6x5-unorm-srgb",
+    176: "astc-6x6-unorm",
+    177: "astc-6x6-unorm-srgb",
+    178: "astc-8x5-unorm",
+    179: "astc-8x5-unorm-srgb",
+    180: "astc-8x6-unorm",
+    181: "astc-8x6-unorm-srgb",
+    182: "astc-8x8-unorm",
+    183: "astc-8x8-unorm-srgb",
+    184: "astc-10x5-unorm",
+    185: "astc-10x5-unorm-srgb",
+    186: "astc-10x6-unorm",
+    187: "astc-10x6-unorm-srgb",
+    188: "astc-10x8-unorm",
+    189: "astc-10x8-unorm-srgb",
+    190: "astc-10x10-unorm",
+    191: "astc-10x10-unorm-srgb",
+    192: "astc-12x10-unorm",
+    193: "astc-12x10-unorm-srgb",
+    194: "astc-12x12-unorm",
+    195: "astc-12x12-unorm-srgb",
+};
+export async function loadKTX2Texture(uri) {
+    const response = await fetch(uri);
+    const buffer = await response.arrayBuffer();
+    return parseKTX2FromBuffer(buffer);
+}
+export function parseKTX2FromBuffer(buffer) {
+    const data = new Uint8Array(buffer);
+    const header = readKTX2Header(data);
+    if (!header)
+        return null;
+    const format = VK_FORMAT_MAP[header.vkFormat] ?? "rgba8unorm";
+    const isCompressed = isCompressedFormat(format);
+    return {
+        width: header.pixelWidth,
+        height: header.pixelHeight,
+        data: data.subarray(80),
+        format,
+        mipLevels: header.levelCount,
+        isHDR: header.vkFormat === 97 || header.vkFormat === 98,
+    };
+}
+export async function loadTexture(uri, options = {}) {
+    const fmt = detectTextureFormat(uri);
+    if (fmt === "ktx2") {
+        const result = await loadKTX2Texture(uri);
+        if (result)
+            return result;
+    }
+    if (fmt === "dds") {
+        const result = await loadDDSTexture(uri);
+        if (result)
+            return result;
+    }
+    if (fmt === "hdr" || fmt === "exr") {
+        const result = await loadHDRFile(uri);
+        if (result)
+            return result;
+    }
+    return loadTextureFromImage(uri, options.format, options.generateMips);
+}
+export function createGPUTextureFromData(device, texture, usage = GPUTextureUsage.TEXTURE_BINDING |
+    GPUTextureUsage.COPY_DST |
+    GPUTextureUsage.RENDER_ATTACHMENT) {
+    const isCompressed = isCompressedFormat(texture.format);
+    const gpuTexture = device.createTexture({
+        size: [texture.width, texture.height],
+        format: texture.format,
+        usage: isCompressed ? usage | GPUTextureUsage.COPY_DST : usage,
+        mipLevelCount: texture.mipLevels,
+    });
+    if (texture.data instanceof Float32Array) {
+        // HDR float data
+        const bytesPerRow = texture.width * 4 * (texture.format === "rgba32float" ? 4 : 2);
+        device.queue.writeTexture({ texture: gpuTexture }, texture.data, { bytesPerRow }, { width: texture.width, height: texture.height });
+    }
+    else if (texture.data instanceof Uint8Array && !isCompressed) {
+        if (texture.mipLevels > 1) {
+            let offset = 0;
+            let w = texture.width;
+            let h = texture.height;
+            for (let level = 0; level < texture.mipLevels; level++) {
+                const levelSize = w * h * 4;
+                device.queue.writeTexture({ texture: gpuTexture, mipLevel: level }, texture.data.subarray(offset, offset + levelSize), { bytesPerRow: w * 4 }, { width: w, height: h });
+                offset += levelSize;
+                w = Math.max(1, Math.floor(w / 2));
+                h = Math.max(1, Math.floor(h / 2));
+            }
+        }
+        else {
+            device.queue.writeTexture({ texture: gpuTexture }, texture.data, { bytesPerRow: texture.width * 4 }, { width: texture.width, height: texture.height });
+        }
+    }
+    else if (texture.data instanceof Uint8Array && isCompressed) {
+        let offset = 0;
+        let w = texture.width;
+        let h = texture.height;
+        for (let level = 0; level < texture.mipLevels; level++) {
+            const blockSize = texture.format.startsWith("bc") ? 16 : 8;
+            const blocksX = Math.max(1, Math.ceil(w / 4));
+            const blocksY = Math.max(1, Math.ceil(h / 4));
+            const levelSize = blocksX * blocksY * blockSize;
+            if (offset + levelSize <= texture.data.length) {
+                device.queue.writeTexture({ texture: gpuTexture, mipLevel: level }, texture.data.subarray(offset, offset + levelSize), { bytesPerRow: blocksX * blockSize }, { width: w, height: h });
+            }
+            offset += levelSize;
+            w = Math.max(1, Math.floor(w / 2));
+            h = Math.max(1, Math.floor(h / 2));
+        }
+    }
+    return gpuTexture;
+}
+function isCompressedFormat(format) {
+    return format.startsWith("bc") || format.startsWith("astc") || format.startsWith("etc") || format.startsWith("eac");
+}
+export function createSampler(device, options = {}) {
+    return device.createSampler({
+        magFilter: options.magFilter ?? "linear",
+        minFilter: options.minFilter ?? "linear",
+        mipmapFilter: options.mipmapFilter ?? "linear",
+        addressModeU: options.addressModeU ?? "repeat",
+        addressModeV: options.addressModeV ?? "repeat",
+    });
+}

package/dist/core/src/assets/lod.js

@@ -0,0 +1,150 @@
+function addQuadric(q1, q2) {
+    return { a: q1.a + q2.a, b: q1.b + q2.b, c: q1.c + q2.c, d: q1.d + q2.d };
+}
+function quadricError(q, x, y, z) {
+    return q.a * x * x + q.b * y * y + q.c * z * z + 2 * (q.a * y * z + q.b * x * z + q.c * x * y) + q.d * x + q.d * y + q.d * z;
+}
+function quadricFromPlane(a, b, c, d) {
+    return { a: a * a, b: b * b, c: c * c, d: d };
+}
+function quadricFromTriangle(p0, p1, p2) {
+    const ex = p1[0] - p0[0], ey = p1[1] - p0[1], ez = p1[2] - p0[2];
+    const fx = p2[0] - p0[0], fy = p2[1] - p0[1], fz = p2[2] - p0[2];
+    const nx = ey * fz - ez * fy;
+    const ny = ez * fx - ex * fz;
+    const nz = ex * fy - ey * fx;
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    const a = nx / len, b = ny / len, c = nz / len;
+    const d = -(a * p0[0] + b * p0[1] + c * p0[2]);
+    return quadricFromPlane(a, b, c, d);
+}
+export class LODGenerator {
+    generateLOD(mesh, targetReduction) {
+        if (targetReduction <= 0 || targetReduction >= 1)
+            return mesh;
+        const indices = mesh.indices;
+        const vertices = mesh.vertices;
+        const indexCount = indices.length;
+        const targetIndexCount = Math.floor(indexCount * (1 - targetReduction));
+        if (targetIndexCount >= indexCount)
+            return mesh;
+        const stride = mesh.layout.stride / 4;
+        const edgeCollapses = this.computeQEMEdgeCollapses(vertices, indices, targetIndexCount, stride);
+        const { newVertices, newIndices } = this.applyEdgeCollapses(vertices, indices, edgeCollapses, stride);
+        return {
+            vertices: newVertices,
+            indices: newIndices,
+            layout: mesh.layout,
+            vertexCount: newVertices.length / stride,
+            indexCount: newIndices.length,
+        };
+    }
+    generateLODLevels(mesh, levels) {
+        const result = [];
+        const baseReduction = 0.5;
+        result.push({
+            mesh,
+            screenSpaceError: 0,
+            distance: 0,
+        });
+        for (let i = 1; i < levels; i++) {
+            const reduction = Math.min(baseReduction * i, 0.9);
+            const lodMesh = this.generateLOD(mesh, reduction);
+            result.push({
+                mesh: lodMesh,
+                screenSpaceError: i * 2,
+                distance: i * 20,
+            });
+        }
+        return result;
+    }
+    selectLOD(levels, distance, screenSize) {
+        let selected = levels[0];
+        levels.forEach((level) => {
+            if (distance >= level.distance) {
+                const projectedSize = screenSize / Math.max(distance, 0.1);
+                if (projectedSize > level.screenSpaceError || level === levels[levels.length - 1]) {
+                    selected = level;
+                }
+            }
+        });
+        return selected;
+    }
+    computeQEMEdgeCollapses(vertices, indices, targetIndexCount, stride) {
+        const vertexCount = vertices.length / stride;
+        const quadrics = new Array(vertexCount);
+        for (let i = 0; i < vertexCount; i++)
+            quadrics[i] = { a: 0, b: 0, c: 0, d: 0 };
+        for (let i = 0; i < indices.length; i += 3) {
+            const a = indices[i], b = indices[i + 1], c = indices[i + 2];
+            const p0 = [vertices[a * stride], vertices[a * stride + 1], vertices[a * stride + 2]];
+            const p1 = [vertices[b * stride], vertices[b * stride + 1], vertices[b * stride + 2]];
+            const p2 = [vertices[c * stride], vertices[c * stride + 1], vertices[c * stride + 2]];
+            const q = quadricFromTriangle(p0, p1, p2);
+            quadrics[a] = addQuadric(quadrics[a], q);
+            quadrics[b] = addQuadric(quadrics[b], q);
+            quadrics[c] = addQuadric(quadrics[c], q);
+        }
+        const edgeMap = new Map();
+        for (let i = 0; i < indices.length; i += 3) {
+            for (let j = 0; j < 3; j++) {
+                const a = indices[i + j];
+                const b = indices[i + (j + 1) % 3];
+                if (a > b)
+                    continue;
+                const key = `${a}:${b}`;
+                if (!edgeMap.has(key)) {
+                    const combined = addQuadric(quadrics[a], quadrics[b]);
+                    const mx = (vertices[a * stride] + vertices[b * stride]) / 2;
+                    const my = (vertices[a * stride + 1] + vertices[b * stride + 1]) / 2;
+                    const mz = (vertices[a * stride + 2] + vertices[b * stride + 2]) / 2;
+                    const cost = quadricError(combined, mx, my, mz);
+                    edgeMap.set(key, { from: a, to: b, cost });
+                }
+            }
+        }
+        const edges = [...edgeMap.values()].sort((a, b) => a.cost - b.cost);
+        const collapseCount = Math.floor((indices.length - targetIndexCount) / 3);
+        return edges.slice(0, collapseCount);
+    }
+    applyEdgeCollapses(vertices, indices, collapses, stride) {
+        const remap = new Map();
+        collapses.forEach((c) => {
+            remap.set(c.from, c.to);
+        });
+        const newIndices = [];
+        for (let i = 0; i < indices.length; i += 3) {
+            let a = indices[i];
+            let b = indices[i + 1];
+            let c = indices[i + 2];
+            while (remap.has(a))
+                a = remap.get(a);
+            while (remap.has(b))
+                b = remap.get(b);
+            while (remap.has(c))
+                c = remap.get(c);
+            if (a !== b && b !== c && a !== c) {
+                newIndices.push(a, b, c);
+            }
+        }
+        const usedVertices = new Set();
+        newIndices.forEach((idx) => { usedVertices.add(idx); ; });
+        const compactedVertices = [];
+        const vertexRemap = new Map();
+        let compactIdx = 0;
+        for (let i = 0; i < vertices.length / stride; i++) {
+            if (usedVertices.has(i)) {
+                for (let j = 0; j < stride; j++) {
+                    compactedVertices.push(vertices[i * stride + j]);
+                }
+                vertexRemap.set(i, compactIdx);
+                compactIdx++;
+            }
+        }
+        const compactedIndices = newIndices.map(idx => vertexRemap.get(idx));
+        return {
+            newVertices: new Float32Array(compactedVertices),
+            newIndices: new Uint32Array(compactedIndices),
+        };
+    }
+}