@haiyue/extensions 0.1.0

package/dist/chunks/RenderSystem2DBase-DDT61dAu.js

@@ -0,0 +1,227 @@
+import { estimateTextureBytes, isEntityDisabledInHierarchyCached, getExtensionGPUResourceTracker, requireEngineDevice } from '@haiyue/engine/extension-authoring';
+import { Transform3D, Camera2D } from '@haiyue/engine/components';
+import { System } from '@haiyue/engine/ecs';
+import '@haiyue/engine';
+import { mat4 } from 'wgpu-matrix';
+
+function createCamera2DScratch() {
+    return {
+        viewMatrix: mat4.identity(),
+        viewProjMatrix: mat4.identity(),
+    };
+}
+function compute2DViewProjection(engine, cameraEntity, camera, scratch = createCamera2DScratch()) {
+    camera.resize(engine.displayWidth, engine.displayHeight);
+    const transform = cameraEntity.getComponent(Transform3D);
+    if (!transform)
+        return camera.projectionMatrix;
+    transform.updateWorldMatrix();
+    const viewMatrix = mat4.inverse(transform.worldMatrix, scratch.viewMatrix);
+    return mat4.multiply(camera.projectionMatrix, viewMatrix, scratch.viewProjMatrix);
+}
+function write2DCameraBuffer(queue, buffer, viewProj) {
+    queue.writeBuffer(buffer, 0, viewProj.buffer, viewProj.byteOffset, viewProj.byteLength);
+}
+mat4.identity();
+
+function createCamera2DLayout(device) {
+    return device.createBindGroupLayout({
+        entries: [{ binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } }],
+    });
+}
+function createCamera2DGpu(device, tracker, layout = createCamera2DLayout(device)) {
+    const buffer = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+    tracker?.trackBuffer(buffer, 'render2d.cameraBuffer', 64);
+    const bindGroup = device.createBindGroup({
+        layout,
+        entries: [{ binding: 0, resource: { buffer } }],
+    });
+    return { layout, buffer, bindGroup, ...(tracker === undefined ? {} : { tracker }) };
+}
+function createObject2DLayout(device) {
+    return device.createBindGroupLayout({
+        entries: [{ binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } }],
+    });
+}
+function createObject2DGpu(device, layout, tracker) {
+    const buffer = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+    tracker?.trackBuffer(buffer, 'render2d.objectBuffer', 64);
+    return {
+        buffer,
+        bindGroup: device.createBindGroup({
+            layout,
+            entries: [{ binding: 0, resource: { buffer } }],
+        }),
+        snapshot: createMatrixSnapshot(),
+        ...(tracker === undefined ? {} : { tracker }),
+    };
+}
+function createTexture2DGpu(device, fallbackAlpha = 255, tracker) {
+    const layout = device.createBindGroupLayout({
+        entries: [
+            { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
+            { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
+        ],
+    });
+    const sampler = device.createSampler({ magFilter: 'linear', minFilter: 'linear' });
+    const fallbackTexture = device.createTexture({
+        size: [1, 1],
+        format: 'rgba8unorm',
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+    });
+    tracker?.trackTexture(fallbackTexture, 'render2d.fallbackTexture', estimateTextureBytes([1, 1, 1], 'rgba8unorm'));
+    device.queue.writeTexture({ texture: fallbackTexture }, new Uint8Array([255, 255, 255, fallbackAlpha]), { bytesPerRow: 4 }, [1, 1]);
+    const fallbackBindGroup = device.createBindGroup({
+        layout,
+        entries: [
+            { binding: 0, resource: fallbackTexture.createView() },
+            { binding: 1, resource: sampler },
+        ],
+    });
+    return { layout, sampler, fallbackTexture, fallbackBindGroup, ...(tracker === undefined ? {} : { tracker }) };
+}
+function writeFloatBuffer(queue, buffer, data) {
+    queue.writeBuffer(buffer, 0, data.buffer, data.byteOffset, data.byteLength);
+}
+function matrixEquals(a, b) {
+    for (let i = 0; i < 16; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function createMatrixSnapshot() {
+    const snapshot = new Float32Array(16);
+    snapshot.fill(Number.NaN);
+    return snapshot;
+}
+function writeObjectMatrixIfChanged(queue, gpu, matrix) {
+    if (matrixEquals(gpu.snapshot, matrix))
+        return false;
+    writeFloatBuffer(queue, gpu.buffer, matrix);
+    gpu.snapshot.set(matrix);
+    return true;
+}
+function destroyCamera2DGpu(gpu) {
+    gpu.tracker?.untrackBuffer(gpu.buffer);
+    gpu.buffer.destroy();
+}
+function destroyObject2DGpu(gpu) {
+    gpu.tracker?.untrackBuffer(gpu.buffer);
+    gpu.buffer.destroy();
+}
+function destroyTexture2DGpu(gpu) {
+    gpu.tracker?.untrackTexture(gpu.fallbackTexture);
+    gpu.fallbackTexture.destroy();
+}
+
+class RenderSystem2DBase extends System {
+    engine;
+    cameraEntity;
+    disabledHierarchyCache = new Map();
+    liveEntityIds = new Set();
+    loadOp;
+    recoveryLabel;
+    recoverySource;
+    unregisterRecovery;
+    constructor(rule, engine, cameraEntity, options = {}, name) {
+        super(rule);
+        this.engine = engine;
+        this.cameraEntity = cameraEntity;
+        this.loadOp = options.loadOp ?? 'load';
+        if (name)
+            this.name = name;
+        if (options.priority !== undefined)
+            this.priority = options.priority;
+        this.recoveryLabel = `${name ?? this.constructor.name}:${this.id}`;
+        this.recoverySource = { kind: 'component-render-system', system: name ?? this.constructor.name };
+        this.unregisterRecovery = engine.registerDeviceRecoveryParticipant?.(this) ?? null;
+    }
+    setCameraEntity(cameraEntity) {
+        this.cameraEntity = cameraEntity;
+        return this;
+    }
+    getCamera2D(context) {
+        return this.getCameraEntity(context).getComponent(Camera2D);
+    }
+    getFrameData(context) {
+        const cameraEntity = this.getCameraEntity(context);
+        const frameData = context.frameData ?? cameraEntity.world?.frameData;
+        if (!frameData)
+            throw new Error(`${this.name} requires frame data from its render context or camera usage.`);
+        return frameData;
+    }
+    computeCameraViewProjection(camera, context) {
+        if (context) {
+            return this.getFrameData(context).getCamera2D(this.getCameraEntity(context), camera, context.view?.displayWidth ?? this.engine.displayWidth, context.view?.displayHeight ?? this.engine.displayHeight).viewProjectionMatrix;
+        }
+        return compute2DViewProjection(this.engine, this.cameraEntity, camera);
+    }
+    writeCameraBuffer(queue, buffer, context) {
+        const camera = this.getCamera2D(context);
+        if (!camera)
+            return false;
+        write2DCameraBuffer(queue, buffer, this.computeCameraViewProjection(camera, context));
+        return true;
+    }
+    getWorldMatrix2D(entity, context) {
+        return this.getFrameData(context).getWorldMatrix2D(entity);
+    }
+    getCameraEntity(context) {
+        return context?.view?.camera.getComponent(Camera2D) ? context.view.camera : this.cameraEntity;
+    }
+    isEntityRenderable(entity) {
+        return !isEntityDisabledInHierarchyCached(entity, this.disabledHierarchyCache);
+    }
+    beginLiveEntityTracking() {
+        this.liveEntityIds.clear();
+        this.disabledHierarchyCache.clear();
+        return this.liveEntityIds;
+    }
+    markEntityLive(entity) {
+        this.liveEntityIds.add(typeof entity === 'number' ? entity : entity.id);
+    }
+    createObjectGpu(layout) {
+        return createObject2DGpu(requireEngineDevice(this.engine), layout, getExtensionGPUResourceTracker(this.engine));
+    }
+    destroyObjectGpu(objectGpu) {
+        destroyObject2DGpu(objectGpu);
+    }
+    getOrCreateEntityGpu(cache, entity, create) {
+        let gpu = cache.get(entity.id);
+        if (!gpu) {
+            gpu = create();
+            cache.set(entity.id, gpu);
+        }
+        return gpu;
+    }
+    releaseEntityGpuEntriesNotIn(cache, destroy, liveEntities = this.liveEntityIds) {
+        for (const [entityId, gpu] of cache) {
+            if (!liveEntities.has(entityId)) {
+                destroy(gpu);
+                cache.delete(entityId);
+            }
+        }
+    }
+    destroyEntityGpuEntries(cache, destroy) {
+        for (const gpu of cache.values())
+            destroy(gpu);
+        cache.clear();
+    }
+    suspendForDeviceLoss() {
+        this.releaseGpuResourcesForRecovery();
+    }
+    recoverGpuResource(_device, signal) {
+        if (signal.aborted)
+            throw signal.reason;
+        this.restoreGpuResourcesAfterRecovery();
+    }
+    destroy() {
+        this.unregisterRecovery?.();
+        return super.destroy();
+    }
+    restoreGpuResourcesAfterRecovery() { }
+}
+
+export { RenderSystem2DBase as R, destroyTexture2DGpu as a, createObject2DLayout as b, createCamera2DGpu as c, destroyCamera2DGpu as d, createTexture2DGpu as e, writeFloatBuffer as f, createObject2DGpu as g, destroyObject2DGpu as h, createCamera2DLayout as i, writeObjectMatrixIfChanged as w };
+//# sourceMappingURL=RenderSystem2DBase-DDT61dAu.js.map