@zephyr3d/device 0.2.2 → 0.2.4

package/dist/pool.js

@@ -0,0 +1,352 @@
+/**
+ * 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 = false) {
+        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) {
+                this._freeTextures[hash] = undefined;
+            }
+        }
+        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 = false) {
+        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) {
+                this._freeTextures[hash] = undefined;
+            }
+        }
+        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 = false) {
+        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) {
+                this._freeTextures[hash] = undefined;
+            }
+        }
+        this._allocatedTextures.set(texture, {
+            hash,
+            refcount: 1,
+            dispose: false
+        });
+        if (autoRelease) {
+            this._autoReleaseTextures.add(texture);
+        }
+        return texture;
+    }
+    /**
+   * Creates a temporal framebuffer from the object pool.
+   * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
+   * @param width - Width of the framebuffer
+   * @param height - Height of the framebuffer
+   * @param colorAttachments - Array of color attachments or texture format of the framebuffer.
+   * @param depthAttachment - Depth attachment or texture format of the framebuffer.
+   * @param mipmapping - Whether mipmapping should be enabled when creating color attachment textures, default is false.
+   * @param sampleCount - The sample count for the framebuffer, default is 1.
+   * @param ignoreDepthStencil - Whether to ignore depth stencil when resolving msaa framebuffer, default is true.
+   * @param attachmentMipLevel - The mipmap level to which the color attachment will render, default is 0
+   * @param attachmentCubeface - The cubemap face to which the color attachment will render, default is 0
+   * @param attachmentLayer - The texture layer to which the color attachment will render, default is 0
+   * @returns The fetched FrameBuffer object.
+   */ fetchTemporalFramebuffer(autoRelease, width, height, colorTexOrFormat, depthTexOrFormat = null, mipmapping = false, sampleCount = 1, ignoreDepthStencil = true, attachmentMipLevel = 0, attachmentCubeface = 0, attachmentLayer = 0) {
+        const colors = Array.isArray(colorTexOrFormat) ? colorTexOrFormat : colorTexOrFormat ? [
+            colorTexOrFormat
+        ] : [];
+        const colorAttachments = colors.map((val)=>{
+            return typeof val === 'string' ? this.fetchTemporalTexture2D(false, val, width, height, mipmapping) : val;
+        });
+        const depthAttachment = typeof depthTexOrFormat === 'string' ? this.fetchTemporalTexture2D(false, depthTexOrFormat, width, height, false) : depthTexOrFormat;
+        const fb = this.createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment, sampleCount, ignoreDepthStencil, attachmentMipLevel, attachmentCubeface, attachmentLayer);
+        for(let i = 0; i < colors.length; i++){
+            if (typeof colors[i] === 'string') {
+                this.releaseTexture(colorAttachments[i]);
+            }
+        }
+        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, default is 1.
+   * @param ignoreDepthStencil - Whether to ignore depth stencil when resolving msaa framebuffer, default is true.
+   * @param attachmentMipLevel - The mipmap level to which the color attachment will render, default is 0.
+   * @param attachmentCubeface - The cubemap face to which the color attachment will render, default is 0.
+   * @param attachmentLayer - The texture layer to which the color attachment will render, default is 0.
+   * @returns The fetched FrameBuffer object.
+   */ createTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment = null, sampleCount = 1, ignoreDepthStencil = true, attachmentMipLevel = 0, attachmentCubeface = 0, attachmentLayer = 0) {
+        colorAttachments = colorAttachments ?? [];
+        let hash = `${depthAttachment?.uid ?? 0}:${sampleCount ?? 1}:${ignoreDepthStencil ? 1 : 0}`;
+        if (colorAttachments.length > 0) {
+            hash += `:${attachmentMipLevel}:${attachmentCubeface}:${attachmentLayer}`;
+            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
+            });
+            for(let i = 0; i < fb.getColorAttachments().length; i++){
+                fb.setColorAttachmentMipLevel(i, attachmentMipLevel);
+                fb.setColorAttachmentCubeFace(i, attachmentCubeface);
+                fb.setColorAttachmentLayer(i, attachmentLayer);
+            }
+        } else {
+            fb = list.pop();
+            if (list.length === 0) {
+                this._freeFramebuffers[hash] = undefined;
+            }
+        }
+        // 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.2",
+	"version": "0.2.4",
 	"description": "Device API for zephyr3d",
 	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
 	"type": "module",
@@ -44,7 +44,6 @@
 		"@rollup/plugin-terser": "^0.4.0",
 		"@rollup/pluginutils": "^5.0.2",
 		"@swc/core": "^1.3.62",
-		"@zephyr3d/base": "^0.1.3",
 		"cross-env": "^7.0.3",
 		"rollup": "^3.15.0",
 		"rollup-plugin-copy": "^3.4.0",
@@ -54,12 +53,10 @@
 		"shx": "^0.3.4",
 		"typescript": "^5.1.3"
 	},
-	"peerDependencies": {
-		"@zephyr3d/base": "^0.1.3"
-	},
 	"dependencies": {
-		"@types/node": "^18.13.0",
-		"@webgpu/types": "^0.1.40"
+		"@zephyr3d/base": "^0.1.5",
+		"@webgpu/types": "^0.1.40",
+		"@types/node": "^18.13.0"
 	},
 	"scripts": {
 		"clean": "shx rm -rf ./dist .tsbuildinfo",