@zephyr3d/device 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,6 +1,6 @@
 export { DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceGPUObjectRenameEvent, DeviceLostEvent, DeviceResizeEvent, DeviceRestoreEvent, ShaderType, encodePixel, encodePixelToArray, getTextureFormatBlockHeight, getTextureFormatBlockSize, getTextureFormatBlockWidth, hasAlphaChannel, hasBlueChannel, hasDepthChannel, hasGreenChannel, hasRedChannel, hasStencilChannel, isCompressedTextureFormat, isFloatTextureFormat, isIntegerTextureFormat, isSRGBTextureFormat, isSignedTextureFormat, linearTextureFormatToSRGB } from './base_types.js';
 export { VertexData } from './vertexdata.js';
-export { GPUResourceUsageFlags, MAX_BINDING_GROUPS, MAX_TEXCOORD_INDEX_COUNT, MAX_VERTEX_ATTRIBUTES, VERTEX_ATTRIB_BLEND_INDICES, VERTEX_ATTRIB_BLEND_WEIGHT, VERTEX_ATTRIB_DIFFUSE, VERTEX_ATTRIB_NORMAL, VERTEX_ATTRIB_POSITION, VERTEX_ATTRIB_TANGENT, VERTEX_ATTRIB_TEXCOORD0, VERTEX_ATTRIB_TEXCOORD1, VERTEX_ATTRIB_TEXCOORD2, VERTEX_ATTRIB_TEXCOORD3, VERTEX_ATTRIB_TEXCOORD4, VERTEX_ATTRIB_TEXCOORD5, VERTEX_ATTRIB_TEXCOORD6, VERTEX_ATTRIB_TEXCOORD7, genDefaultName, getVertexAttribByName, getVertexAttribFormat, getVertexAttribName, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, getVertexFormatSize, makeVertexBufferType, semanticList, semanticToAttrib } from './gpuobject.js';
+export { GPUResourceUsageFlags, MAX_BINDING_GROUPS, MAX_TEXCOORD_INDEX_COUNT, MAX_VERTEX_ATTRIBUTES, VERTEX_ATTRIB_BLEND_INDICES, VERTEX_ATTRIB_BLEND_WEIGHT, VERTEX_ATTRIB_DIFFUSE, VERTEX_ATTRIB_NORMAL, VERTEX_ATTRIB_POSITION, VERTEX_ATTRIB_TANGENT, VERTEX_ATTRIB_TEXCOORD0, VERTEX_ATTRIB_TEXCOORD1, VERTEX_ATTRIB_TEXCOORD2, VERTEX_ATTRIB_TEXCOORD3, VERTEX_ATTRIB_TEXCOORD4, VERTEX_ATTRIB_TEXCOORD5, VERTEX_ATTRIB_TEXCOORD6, VERTEX_ATTRIB_TEXCOORD7, genDefaultName, getVertexAttribByName, getVertexAttribFormat, getVertexAttribName, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, getVertexFormatComponentCount, getVertexFormatSize, makeVertexBufferType, semanticList, semanticToAttrib } from './gpuobject.js';
 export { BaseDevice } from './device.js';
 export { PBShaderExp, Proxiable, getCurrentProgramBuilder, makeConstructor, setCurrentProgramBuilder } from './builder/base.js';
 export { ASTAddressOf, ASTArrayIndex, ASTAssignment, ASTBinaryFunc, ASTBreak, ASTCallFunction, ASTCast, ASTContinue, ASTDeclareVar, ASTDiscard, ASTDoWhile, ASTExpression, ASTFunction, ASTFunctionParameter, ASTGlobalScope, ASTHash, ASTIf, ASTLValue, ASTLValueArray, ASTLValueDeclare, ASTLValueHash, ASTLValueScalar, ASTNakedScope, ASTPrimitive, ASTRange, ASTReferenceOf, ASTReturn, ASTScalar, ASTScope, ASTSelect, ASTShaderExpConstructor, ASTStructDefine, ASTTouch, ASTUnaryFunc, ASTWhile, DeclareType, ShaderAST, ShaderPrecisionType, builtinVariables, genSamplerName, getBuiltinInputStructInstanceName, getBuiltinInputStructName, getBuiltinOutputStructInstanceName, getBuiltinOutputStructName, getBuiltinParamName, getTextureSampleType } from './builder/ast.js';

package/dist/pool.js

@@ -0,0 +1,324 @@
+/**
+ * ObjectPool class is responsible for managing and reusing textures and framebuffers.
+ * @public
+ */ class Pool {
+    /** @internal */ _memCost;
+    /** @internal */ _memCostThreshold;
+    /** @internal */ _device;
+    /** @internal */ _freeTextures = {};
+    /** @internal */ _allocatedTextures = new WeakMap();
+    /** @internal */ _autoReleaseTextures = new Set();
+    /** @internal */ _freeFramebuffers = {};
+    /** @internal */ _allocatedFramebuffers = new WeakMap();
+    /** @internal */ _autoReleaseFramebuffers = new Set();
+    /**
+   * Creates an instance of Pool class
+   * @param device - Rendering device
+   */ constructor(device, memCostThreshold = 1024 * 1024 * 1024){
+        this._device = device;
+        this._memCost = 0;
+        this._memCostThreshold = memCostThreshold;
+        this._freeTextures = {};
+        this._allocatedTextures = new WeakMap();
+        this._autoReleaseTextures = new Set();
+        this._freeFramebuffers = {};
+        this._allocatedFramebuffers = new WeakMap();
+        this._autoReleaseFramebuffers = new Set();
+        this._memCost = 0;
+    }
+    autoRelease() {
+        // auto release objects
+        for (const tex of this._autoReleaseTextures){
+            this.releaseTexture(tex);
+        }
+        this._autoReleaseTextures.clear();
+        for (const fb of this._autoReleaseFramebuffers){
+            this.releaseFrameBuffer(fb);
+        }
+        this._autoReleaseFramebuffers.clear();
+        // Free up video memory if memory usage is greater than specific value
+        if (this._memCost >= this._memCostThreshold) {
+            this.purge();
+        }
+    }
+    /**
+   * Fetch a temporal 2D texture from the object pool.
+   * @param autoRelease - Whether the texture should be automatically released at the next frame.
+   * @param format - The format of the texture.
+   * @param width - The width of the texture.
+   * @param height - The height of the texture.
+   * @param mipmapping - Whether this texture support mipmapping
+   * @returns The fetched Texture2D object.
+   */ fetchTemporalTexture2D(autoRelease, format, width, height, mipmapping) {
+        const hash = `2d:${format}:${width}:${height}:${mipmapping ? 1 : 0}`;
+        let texture = null;
+        const list = this._freeTextures[hash];
+        if (!list) {
+            texture = this._device.createTexture2D(format, width, height, mipmapping ? {} : {
+                samplerOptions: {
+                    mipFilter: 'none'
+                }
+            });
+            this._memCost += texture.memCost;
+        } else {
+            texture = list.pop();
+            if (list.length === 0) {
+                delete this._freeTextures[hash];
+            }
+        }
+        this._allocatedTextures.set(texture, {
+            hash,
+            refcount: 1,
+            dispose: false
+        });
+        if (autoRelease) {
+            this._autoReleaseTextures.add(texture);
+        }
+        return texture;
+    }
+    /**
+   * Fetch a temporal 2D array texture from the object pool.
+   * @param autoRelease - Whether the texture should be automatically released at the next frame.
+   * @param format - Format of the texture.
+   * @param width - Width of the texture.
+   * @param height - Height of the texture.
+   * @param numLayers - Layer count of the texture
+   * @param mipmapping - Whether this texture support mipmapping
+   * @returns The fetched Texture2DArray object.
+   */ fetchTemporalTexture2DArray(autoRelease, format, width, height, numLayers, mipmapping) {
+        const hash = `2darray:${format}:${width}:${height}:${numLayers}:${mipmapping ? 1 : 0}`;
+        let texture = null;
+        const list = this._freeTextures[hash];
+        if (!list) {
+            texture = this._device.createTexture2DArray(format, width, height, numLayers, mipmapping ? {} : {
+                samplerOptions: {
+                    mipFilter: 'none'
+                }
+            });
+            this._memCost += texture.memCost;
+        } else {
+            texture = list.pop();
+            if (list.length === 0) {
+                delete this._freeTextures[hash];
+            }
+        }
+        this._allocatedTextures.set(texture, {
+            hash,
+            refcount: 1,
+            dispose: false
+        });
+        if (autoRelease) {
+            this._autoReleaseTextures.add(texture);
+        }
+        return texture;
+    }
+    /**
+   * Fetch a temporal Cube texture from the object pool.
+   * @param autoRelease - Whether the texture should be automatically released at the next frame.
+   * @param format - Format of the texture.
+   * @param size - size of the texture.
+   * @param mipmapping - Whether this texture support mipmapping
+   * @returns The fetched TextureCube object.
+   */ fetchTemporalTextureCube(autoRelease, format, size, mipmapping) {
+        const hash = `cube:${format}:${size}:${mipmapping ? 1 : 0}`;
+        let texture = null;
+        const list = this._freeTextures[hash];
+        if (!list) {
+            texture = this._device.createCubeTexture(format, size, mipmapping ? {} : {
+                samplerOptions: {
+                    mipFilter: 'none'
+                }
+            });
+            this._memCost += texture.memCost;
+        } else {
+            texture = list.pop();
+            if (list.length === 0) {
+                delete this._freeTextures[hash];
+            }
+        }
+        this._allocatedTextures.set(texture, {
+            hash,
+            refcount: 1,
+            dispose: false
+        });
+        if (autoRelease) {
+            this._autoReleaseTextures.add(texture);
+        }
+        return texture;
+    }
+    fetchTemporalFramebuffer(autoRelease, width, height, colorTexOrFormat, depthTexOrFormat, mipmapping, sampleCount, ignoreDepthStencil) {
+        const colorAttachments = typeof colorTexOrFormat === 'string' ? [
+            this.fetchTemporalTexture2D(false, colorTexOrFormat, width, height, mipmapping)
+        ] : colorTexOrFormat ? [
+            colorTexOrFormat
+        ] : null;
+        const depthAttachment = typeof depthTexOrFormat === 'string' ? this.fetchTemporalTexture2D(false, depthTexOrFormat, width, height, false) : depthTexOrFormat;
+        const fb = this.createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment, sampleCount, ignoreDepthStencil);
+        if (typeof colorTexOrFormat === 'string') {
+            this.releaseTexture(colorAttachments[0]);
+        }
+        if (typeof depthTexOrFormat === 'string') {
+            this.releaseTexture(depthAttachment);
+        }
+        return fb;
+    }
+    /**
+   * Creates a temporal framebuffer from the object pool.
+   * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
+   * @param colorAttachments - Array of color attachments for the framebuffer.
+   * @param depthAttachment - Depth attachment for the framebuffer.
+   * @param sampleCount - The sample count for the framebuffer.
+   * @param ignoreDepthStencil - Whether to ignore depth stencil.
+   * @returns The fetched FrameBuffer object.
+   */ createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment, sampleCount, ignoreDepthStencil) {
+        colorAttachments = colorAttachments ?? [];
+        let hash = `${depthAttachment?.uid ?? 0}:${sampleCount ?? 1}:${ignoreDepthStencil ? 1 : 0}`;
+        for (const tex of colorAttachments){
+            hash += `:${tex.uid}`;
+        }
+        let fb = null;
+        const list = this._freeFramebuffers[hash];
+        if (!list) {
+            fb = this._device.createFrameBuffer(colorAttachments, depthAttachment, {
+                ignoreDepthStencil,
+                sampleCount
+            });
+        } else {
+            fb = list.pop();
+            if (list.length === 0) {
+                delete this._freeFramebuffers[hash];
+            }
+        }
+        // Mark referenced textures
+        const info = this._allocatedTextures.get(depthAttachment);
+        if (info) {
+            info.refcount++;
+        }
+        for (const tex of colorAttachments){
+            const info = this._allocatedTextures.get(tex);
+            if (info) {
+                info.refcount++;
+            }
+        }
+        this._allocatedFramebuffers.set(fb, hash);
+        if (autoRelease) {
+            this._autoReleaseFramebuffers.add(fb);
+        }
+        return fb;
+    }
+    /**
+   * Dispose a texture that is allocated from the object pool.
+   * @param texture - The texture to dispose.
+   */ disposeTexture(texture) {
+        this.safeReleaseTexture(texture, true);
+    }
+    /**
+   * Release a texture back to the object pool.
+   * @param texture - The texture to release.
+   */ releaseTexture(texture) {
+        const info = this._allocatedTextures.get(texture);
+        if (!info) {
+            console.error(`ObjectPool.releaseTexture(): texture is not allocated from pool`);
+        } else {
+            this.safeReleaseTexture(texture);
+        }
+    }
+    /**
+   * Dispose a framebuffer that is allocated from the object pool.
+   * @param fb - The framebuffer to dispose.
+   */ disposeFrameBuffer(fb) {
+        const hash = this._allocatedFramebuffers.get(fb);
+        if (!hash) {
+            console.error(`ObjectPool.disposeFrameBuffer(): framebuffer is not allocated from pool`);
+        } else {
+            this.internalDisposeFrameBuffer(fb);
+            fb.dispose();
+        }
+    }
+    /**
+   * Release a framebuffer back to the object pool.
+   * @param fb - The framebuffer to release.
+   */ releaseFrameBuffer(fb) {
+        const hash = this._allocatedFramebuffers.get(fb);
+        if (!hash) {
+            console.error(`ObjectPool.releaseFrameBuffer(): framebuffer is not allocated from pool`);
+        } else {
+            this.internalDisposeFrameBuffer(fb);
+            const list = this._freeFramebuffers[hash];
+            if (list) {
+                list.push(fb);
+            } else {
+                this._freeFramebuffers[hash] = [
+                    fb
+                ];
+            }
+        }
+    }
+    /**
+   * Purge the object pool by disposing all free framebuffers and textures.
+   */ purge() {
+        for(const k in this._freeFramebuffers){
+            const list = this._freeFramebuffers[k];
+            if (list) {
+                for (const fb of this._freeFramebuffers[k]){
+                    this.internalDisposeFrameBuffer(fb);
+                    fb.dispose();
+                }
+            }
+        }
+        this._freeFramebuffers = {};
+        for(const k in this._freeTextures){
+            const list = this._freeTextures[k];
+            for (const tex of list){
+                this._memCost -= tex.memCost;
+                tex.dispose();
+            }
+        }
+        this._freeTextures = {};
+    }
+    /** @internal */ internalDisposeFrameBuffer(fb) {
+        if (fb) {
+            // Release attachment textures
+            const colorAttachments = fb.getColorAttachments();
+            if (colorAttachments) {
+                for (const tex of colorAttachments){
+                    this.safeReleaseTexture(tex);
+                }
+            }
+            const depthAttachment = fb.getDepthAttachment();
+            if (depthAttachment) {
+                this.safeReleaseTexture(depthAttachment);
+            }
+            this._allocatedFramebuffers.delete(fb);
+            this._autoReleaseFramebuffers.delete(fb);
+        }
+    }
+    /** @internal */ safeReleaseTexture(texture, purge = false) {
+        const info = this._allocatedTextures.get(texture);
+        if (info) {
+            info.refcount--;
+            if (info.refcount === 0) {
+                this._allocatedTextures.delete(texture);
+                this._autoReleaseTextures.delete(texture);
+                if (purge || info.dispose) {
+                    this._memCost -= texture.memCost;
+                    texture.dispose();
+                } else {
+                    const list = this._freeTextures[info.hash];
+                    if (list) {
+                        list.push(texture);
+                    } else {
+                        this._freeTextures[info.hash] = [
+                            texture
+                        ];
+                    }
+                }
+            } else if (purge) {
+                info.dispose = true;
+            }
+        }
+    }
+}
+
+export { Pool };
+//# sourceMappingURL=pool.js.map

package/dist/pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zephyr3d/device",
-	"version": "0.2.1",
+	"version": "0.2.3",
 	"description": "Device API for zephyr3d",
 	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
 	"type": "module",
@@ -44,7 +44,7 @@
 		"@rollup/plugin-terser": "^0.4.0",
 		"@rollup/pluginutils": "^5.0.2",
 		"@swc/core": "^1.3.62",
-		"@zephyr3d/base": "^0.1.3",
+		"@zephyr3d/base": "^0.1.4",
 		"cross-env": "^7.0.3",
 		"rollup": "^3.15.0",
 		"rollup-plugin-copy": "^3.4.0",
@@ -55,11 +55,11 @@
 		"typescript": "^5.1.3"
 	},
 	"peerDependencies": {
-		"@zephyr3d/base": "^0.1.3"
+		"@zephyr3d/base": "^0.1.4"
 	},
 	"dependencies": {
 		"@types/node": "^18.13.0",
-		"@webgpu/types": "^0.1.31"
+		"@webgpu/types": "^0.1.40"
 	},
 	"scripts": {
 		"clean": "shx rm -rf ./dist .tsbuildinfo",