@zephyr3d/device 0.2.2 → 0.2.3

package/dist/base_types.js

@@ -21,11 +21,12 @@ const COMPRESSED_FORMAT_SHIFT = 24;
 const COMPRESSION_FORMAT_BC1 = 1 << COMPRESSED_FORMAT_SHIFT;
 const COMPRESSION_FORMAT_BC2 = 2 << COMPRESSED_FORMAT_SHIFT;
 const COMPRESSION_FORMAT_BC3 = 3 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC4 = 4 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC5 = 5 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC6H = 6 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC7 = 7 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC = 8 << COMPRESSED_FORMAT_SHIFT;
 /*
-const COMPRESSION_FORMAT_BC4 = 4 << COMPRESSED_FORMAT_SHIFT;
-const COMPRESSION_FORMAT_BC5 = 5 << COMPRESSED_FORMAT_SHIFT;
-const COMPRESSION_FORMAT_BC6 = 6 << COMPRESSED_FORMAT_SHIFT;
-const COMPRESSION_FORMAT_BC7 = 7 << COMPRESSED_FORMAT_SHIFT;
 const COMPRESSION_FORMAT_ETC2_RGB8 = 8 << COMPRESSED_FORMAT_SHIFT;
 const COMPRESSION_FORMAT_ETC2_RGB8_A1 = 9 << COMPRESSED_FORMAT_SHIFT;
 const COMPRESSION_FORMAT_ETC2_RGBA8 = 10 << COMPRESSED_FORMAT_SHIFT;
@@ -114,7 +115,43 @@ const textureFormatMap = {
     dxt3: makeTextureFormat(COMPRESSION_FORMAT_BC2, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
     'dxt3-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC2, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16),
     dxt5: makeTextureFormat(COMPRESSION_FORMAT_BC3, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
-    'dxt5-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC3, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16)
+    'dxt5-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC3, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16),
+    bc4: makeTextureFormat(COMPRESSION_FORMAT_BC4, true, false, false, false, false, false, false, false, false, false, false, 4, 4, 8),
+    'bc4-signed': makeTextureFormat(COMPRESSION_FORMAT_BC4, true, false, false, false, false, false, false, false, true, false, false, 4, 4, 8),
+    bc5: makeTextureFormat(COMPRESSION_FORMAT_BC5, true, true, false, false, false, false, false, false, false, false, false, 4, 4, 16),
+    'bc5-signed': makeTextureFormat(COMPRESSION_FORMAT_BC5, true, true, false, false, false, false, false, false, true, false, false, 4, 4, 16),
+    bc6h: makeTextureFormat(COMPRESSION_FORMAT_BC6H, true, true, true, false, false, false, true, false, false, false, false, 4, 4, 16),
+    'bc6h-signed': makeTextureFormat(COMPRESSION_FORMAT_BC6H, true, true, true, false, false, false, true, false, true, false, false, 4, 4, 16),
+    bc7: makeTextureFormat(COMPRESSION_FORMAT_BC7, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
+    'bc7-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC7, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16),
+    'astc-4x4': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
+    'astc-4x4-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16),
+    'astc-5x4': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 5, 4, 16),
+    'astc-5x4-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 5, 4, 16),
+    'astc-5x5': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 5, 5, 16),
+    'astc-5x5-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 5, 5, 16),
+    'astc-6x5': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 6, 5, 16),
+    'astc-6x5-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 6, 5, 16),
+    'astc-6x6': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 6, 6, 16),
+    'astc-6x6-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 6, 6, 16),
+    'astc-8x5': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 8, 5, 16),
+    'astc-8x5-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 8, 5, 16),
+    'astc-8x6': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 8, 6, 16),
+    'astc-8x6-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 8, 6, 16),
+    'astc-8x8': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 8, 8, 16),
+    'astc-8x8-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 8, 8, 16),
+    'astc-10x5': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 10, 5, 16),
+    'astc-10x5-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 10, 5, 16),
+    'astc-10x6': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 10, 6, 16),
+    'astc-10x6-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 10, 6, 16),
+    'astc-10x8': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 10, 8, 16),
+    'astc-10x8-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 10, 8, 16),
+    'astc-10x10': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 10, 10, 16),
+    'astc-10x10-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 10, 10, 16),
+    'astc-12x10': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 12, 10, 16),
+    'astc-12x10-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 12, 10, 16),
+    'astc-12x12': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, false, false, 12, 12, 16),
+    'astc-12x12-srgb': makeTextureFormat(COMPRESSION_FORMAT_ASTC, true, true, true, true, false, false, false, false, false, true, false, 12, 12, 16)
 };
 /**
  * Converts a non-sRGB texture format to the corresponding sRGB texture format
@@ -133,6 +170,36 @@ const textureFormatMap = {
             return 'dxt3-srgb';
         case 'dxt5':
             return 'dxt5-srgb';
+        case 'bc7':
+            return 'bc7-srgb';
+        case 'astc-4x4':
+            return 'astc-4x4-srgb';
+        case 'astc-5x4':
+            return 'astc-5x4-srgb';
+        case 'astc-5x5':
+            return 'astc-5x5-srgb';
+        case 'astc-6x5':
+            return 'astc-6x5-srgb';
+        case 'astc-6x6':
+            return 'astc-6x6-srgb';
+        case 'astc-8x5':
+            return 'astc-8x5-srgb';
+        case 'astc-8x6':
+            return 'astc-8x6-srgb';
+        case 'astc-8x8':
+            return 'astc-8x8-srgb';
+        case 'astc-10x5':
+            return 'astc-10x5-srgb';
+        case 'astc-10x6':
+            return 'astc-10x6-srgb';
+        case 'astc-10x8':
+            return 'astc-10x8-srgb';
+        case 'astc-10x10':
+            return 'astc-10x10-srgb';
+        case 'astc-12x10':
+            return 'astc-12x10-srgb';
+        case 'astc-12x12':
+            return 'astc-12x12-srgb';
         default:
             return format;
     }

package/dist/base_types.js.map

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

package/dist/device.js

@@ -6,6 +6,7 @@ import { ProgramBuilder } from './builder/programbuilder.js';
 import { DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceResizeEvent } from './base_types.js';
 import '@zephyr3d/base';
 import { DrawText } from './helpers/drawtext.js';
+import { Pool } from './pool.js';
 
 /**
  * Base class for rendering device
@@ -28,6 +29,9 @@ import { DrawText } from './helpers/drawtext.js';
     _backend;
     _beginFrameCounter;
     _programBuilder;
+    _pool;
+    _temporalFramebuffer;
+    _vSync;
     _stateStack;
     constructor(cvs, backend){
         this._backend = backend;
@@ -72,6 +76,9 @@ import { DrawText } from './helpers/drawtext.js';
         };
         this._stateStack = [];
         this._beginFrameCounter = 0;
+        this._pool = new Pool(this);
+        this._temporalFramebuffer = false;
+        this._vSync = true;
         this._registerEventHandlers();
     }
     get backend() {
@@ -92,6 +99,15 @@ import { DrawText } from './helpers/drawtext.js';
     get type() {
         return this._backend.typeName();
     }
+    get vSync() {
+        return this._vSync;
+    }
+    set vSync(val) {
+        this._vSync = !!val;
+    }
+    get pool() {
+        return this._pool;
+    }
     get runLoopFunction() {
         return this._runLoopFunc;
     }
@@ -104,6 +120,31 @@ import { DrawText } from './helpers/drawtext.js';
     drawText(text, x, y, color) {
         DrawText.drawText(this, text, color, x, y);
     }
+    setFramebuffer(colorOrRT, depth, sampleCount) {
+        let newRT = null;
+        let temporal = false;
+        if (!Array.isArray(colorOrRT)) {
+            newRT = colorOrRT ?? null;
+        } else {
+            const colorAttachments = colorOrRT.map((val)=>val.texture ?? val);
+            newRT = this._pool.createTemporalFramebuffer(false, colorAttachments, depth, sampleCount, true);
+            for(let i = 0; i < colorOrRT.length; i++){
+                const rt = colorOrRT[i];
+                newRT.setColorAttachmentMipLevel(i, rt.texture ? rt.miplevel ?? 0 : 0);
+                newRT.setColorAttachmentLayer(i, rt.texture ? rt.face ?? 0 : 0);
+                newRT.setColorAttachmentCubeFace(i, rt.texture ? rt.layer ?? 0 : 0);
+            }
+            temporal = true;
+        }
+        const currentRT = this.getFramebuffer();
+        if (currentRT !== newRT) {
+            if (this._temporalFramebuffer) {
+                this._pool.releaseFrameBuffer(currentRT);
+            }
+            this._temporalFramebuffer = temporal;
+            this._setFramebuffer(newRT);
+        }
+    }
     disposeObject(obj, remove = true) {
         if (obj) {
             if (remove) {
@@ -145,6 +186,7 @@ import { DrawText } from './helpers/drawtext.js';
         this._beginFrameCounter++;
         this._beginFrameTime = this._cpuTimer.now();
         this.updateFrameInfo();
+        this._pool.autoRelease();
         return this.onBeginFrame();
     }
     endFrame() {
@@ -224,8 +266,12 @@ import { DrawText } from './helpers/drawtext.js';
         }
     }
     exitLoop() {
-        if (this._runningLoop) {
-            cancelAnimationFrame(this._runningLoop);
+        if (this._runningLoop !== null) {
+            if (this._runningLoop !== 0) {
+                cancelAnimationFrame(this._runningLoop);
+            } else {
+                this.cancelNextFrame(this._runningLoop);
+            }
             this._runningLoop = null;
         }
     }
@@ -241,7 +287,15 @@ import { DrawText } from './helpers/drawtext.js';
         const that = this;
         that._runLoopFunc = func;
         (function entry() {
-            that._runningLoop = requestAnimationFrame(entry);
+            if (that._vSync) {
+                that._runningLoop = requestAnimationFrame(entry);
+            } else {
+                that._runningLoop = that.nextFrame(()=>{
+                    if (that._runningLoop !== null) {
+                        entry();
+                    }
+                });
+            }
             if (that.beginFrame()) {
                 that._runLoopFunc(that);
                 that.endFrame();

package/dist/device.js.map

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

package/dist/gpuobject.js

@@ -1754,6 +1754,48 @@ const vertexAttribFormatMap = {
         'u32',
         4
     ],
+    blendweights_f16x1: [
+        VERTEX_ATTRIB_BLEND_WEIGHT,
+        PBPrimitiveType.F16,
+        2,
+        'f16',
+        1
+    ],
+    blendweights_f32x1: [
+        VERTEX_ATTRIB_BLEND_WEIGHT,
+        PBPrimitiveType.F32,
+        4,
+        'f32',
+        1
+    ],
+    blendweights_f16x2: [
+        VERTEX_ATTRIB_BLEND_WEIGHT,
+        PBPrimitiveType.F16VEC2,
+        4,
+        'f16',
+        2
+    ],
+    blendweights_f32x2: [
+        VERTEX_ATTRIB_BLEND_WEIGHT,
+        PBPrimitiveType.F32VEC2,
+        8,
+        'f32',
+        2
+    ],
+    blendweights_f16x3: [
+        VERTEX_ATTRIB_BLEND_WEIGHT,
+        PBPrimitiveType.F16VEC3,
+        6,
+        'f16',
+        3
+    ],
+    blendweights_f32x3: [
+        VERTEX_ATTRIB_BLEND_WEIGHT,
+        PBPrimitiveType.F32VEC3,
+        12,
+        'f32',
+        3
+    ],
     blendweights_f16x4: [
         VERTEX_ATTRIB_BLEND_WEIGHT,
         PBPrimitiveType.F16VEC4,
@@ -1768,6 +1810,90 @@ const vertexAttribFormatMap = {
         'f32',
         4
     ],
+    blendindices_u16x1: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.U16,
+        2,
+        'u16',
+        1
+    ],
+    blendindices_f16x1: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.F16,
+        2,
+        'f16',
+        1
+    ],
+    blendindices_f32x1: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.F32,
+        4,
+        'f32',
+        1
+    ],
+    blendindices_u32x1: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.U32,
+        4,
+        'u32',
+        1
+    ],
+    blendindices_u16x2: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.U16VEC2,
+        4,
+        'u16',
+        2
+    ],
+    blendindices_f16x2: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.F16VEC2,
+        4,
+        'f16',
+        2
+    ],
+    blendindices_f32x2: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.F32VEC2,
+        8,
+        'f32',
+        2
+    ],
+    blendindices_u32x2: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.U32VEC2,
+        8,
+        'u32',
+        2
+    ],
+    blendindices_u16x3: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.U16VEC3,
+        6,
+        'u16',
+        3
+    ],
+    blendindices_f16x3: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.F16VEC3,
+        6,
+        'f16',
+        3
+    ],
+    blendindices_f32x3: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.F32VEC3,
+        12,
+        'f32',
+        3
+    ],
+    blendindices_u32x3: [
+        VERTEX_ATTRIB_BLEND_INDICES,
+        PBPrimitiveType.U32VEC3,
+        12,
+        'u32',
+        3
+    ],
     blendindices_u16x4: [
         VERTEX_ATTRIB_BLEND_INDICES,
         PBPrimitiveType.U16VEC4,
@@ -1846,22 +1972,28 @@ var GPUResourceUsageFlags;
 })(GPUResourceUsageFlags || (GPUResourceUsageFlags = {}));
 /**
  * Get vertex attribute index by semantic
- * @internal
+ * @public
  */ function getVertexAttribByName(name) {
     return vertexAttribNameMap[name];
 }
 /**
  * Get vertex semantic by attribute index
- * @internal
+ * @public
  */ function getVertexAttribName(attrib) {
     return vertexAttribNameRevMap[attrib];
 }
 /**
  * Get byte size of specified vertex format
- * @internal
+ * @public
  */ function getVertexFormatSize(fmt) {
     return vertexAttribFormatMap[fmt][2];
 }
+/**
+ * Get number of components of specified vertex format
+ * @public
+ */ function getVertexFormatComponentCount(fmt) {
+    return vertexAttribFormatMap[fmt][4];
+}
 /**
  * Get vertex format by semantic and component type and component count
  * @param semantic - The vertex semantic
@@ -2043,5 +2175,5 @@ var GPUResourceUsageFlags;
     }
 }
 
-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 };
+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 };
 //# sourceMappingURL=gpuobject.js.map

package/dist/gpuobject.js.map

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

package/dist/index.d.ts

@@ -599,7 +599,7 @@ type TextureImageElement = ImageBitmap | HTMLCanvasElement;
  * The vertex format types
  * @public
  */
-type VertexAttribFormat = 'position_u8normx2' | 'position_u8normx4' | 'position_i8normx2' | 'position_i8normx4' | 'position_u16x2' | 'position_u16x4' | 'position_i16x2' | 'position_i16x4' | 'position_u16normx2' | 'position_u16normx4' | 'position_i16normx2' | 'position_i16normx4' | 'position_f16x2' | 'position_f16x4' | 'position_f32' | 'position_f32x2' | 'position_f32x3' | 'position_f32x4' | 'position_i32' | 'position_i32x2' | 'position_i32x3' | 'position_i32x4' | 'position_u32' | 'position_u32x2' | 'position_u32x3' | 'position_u32x4' | 'normal_f16x4' | 'normal_f32x3' | 'normal_f32x4' | 'diffuse_u8normx4' | 'diffuse_u16x4' | 'diffuse_u16normx4' | 'diffuse_f16x4' | 'diffuse_f32x3' | 'diffuse_f32x4' | 'diffuse_u32x3' | 'diffuse_u32x4' | 'tangent_f16x4' | 'tangent_f32x3' | 'tangent_f32x4' | 'tex0_u8normx2' | 'tex0_u8normx4' | 'tex0_i8normx2' | 'tex0_i8normx4' | 'tex0_u16x2' | 'tex0_u16x4' | 'tex0_i16x2' | 'tex0_i16x4' | 'tex0_u16normx2' | 'tex0_u16normx4' | 'tex0_i16normx2' | 'tex0_i16normx4' | 'tex0_f16x2' | 'tex0_f16x4' | 'tex0_f32' | 'tex0_f32x2' | 'tex0_f32x3' | 'tex0_f32x4' | 'tex0_i32' | 'tex0_i32x2' | 'tex0_i32x3' | 'tex0_i32x4' | 'tex0_u32' | 'tex0_u32x2' | 'tex0_u32x3' | 'tex0_u32x4' | 'tex1_u8normx2' | 'tex1_u8normx4' | 'tex1_i8normx2' | 'tex1_i8normx4' | 'tex1_u16x2' | 'tex1_u16x4' | 'tex1_i16x2' | 'tex1_i16x4' | 'tex1_u16normx2' | 'tex1_u16normx4' | 'tex1_i16normx2' | 'tex1_i16normx4' | 'tex1_f16x2' | 'tex1_f16x4' | 'tex1_f32' | 'tex1_f32x2' | 'tex1_f32x3' | 'tex1_f32x4' | 'tex1_i32' | 'tex1_i32x2' | 'tex1_i32x3' | 'tex1_i32x4' | 'tex1_u32' | 'tex1_u32x2' | 'tex1_u32x3' | 'tex1_u32x4' | 'tex2_u8normx2' | 'tex2_u8normx4' | 'tex2_i8normx2' | 'tex2_i8normx4' | 'tex2_u16x2' | 'tex2_u16x4' | 'tex2_i16x2' | 'tex2_i16x4' | 'tex2_u16normx2' | 'tex2_u16normx4' | 'tex2_i16normx2' | 'tex2_i16normx4' | 'tex2_f16x2' | 'tex2_f16x4' | 'tex2_f32' | 'tex2_f32x2' | 'tex2_f32x3' | 'tex2_f32x4' | 'tex2_i32' | 'tex2_i32x2' | 'tex2_i32x3' | 'tex2_i32x4' | 'tex2_u32' | 'tex2_u32x2' | 'tex2_u32x3' | 'tex2_u32x4' | 'tex3_u8normx2' | 'tex3_u8normx4' | 'tex3_i8normx2' | 'tex3_i8normx4' | 'tex3_u16x2' | 'tex3_u16x4' | 'tex3_i16x2' | 'tex3_i16x4' | 'tex3_u16normx2' | 'tex3_u16normx4' | 'tex3_i16normx2' | 'tex3_i16normx4' | 'tex3_f16x2' | 'tex3_f16x4' | 'tex3_f32' | 'tex3_f32x2' | 'tex3_f32x3' | 'tex3_f32x4' | 'tex3_i32' | 'tex3_i32x2' | 'tex3_i32x3' | 'tex3_i32x4' | 'tex3_u32' | 'tex3_u32x2' | 'tex3_u32x3' | 'tex3_u32x4' | 'tex4_u8normx2' | 'tex4_u8normx4' | 'tex4_i8normx2' | 'tex4_i8normx4' | 'tex4_u16x2' | 'tex4_u16x4' | 'tex4_i16x2' | 'tex4_i16x4' | 'tex4_u16normx2' | 'tex4_u16normx4' | 'tex4_i16normx2' | 'tex4_i16normx4' | 'tex4_f16x2' | 'tex4_f16x4' | 'tex4_f32' | 'tex4_f32x2' | 'tex4_f32x3' | 'tex4_f32x4' | 'tex4_i32' | 'tex4_i32x2' | 'tex4_i32x3' | 'tex4_i32x4' | 'tex4_u32' | 'tex4_u32x2' | 'tex4_u32x3' | 'tex4_u32x4' | 'tex5_u8normx2' | 'tex5_u8normx4' | 'tex5_i8normx2' | 'tex5_i8normx4' | 'tex5_u16x2' | 'tex5_u16x4' | 'tex5_i16x2' | 'tex5_i16x4' | 'tex5_u16normx2' | 'tex5_u16normx4' | 'tex5_i16normx2' | 'tex5_i16normx4' | 'tex5_f16x2' | 'tex5_f16x4' | 'tex5_f32' | 'tex5_f32x2' | 'tex5_f32x3' | 'tex5_f32x4' | 'tex5_i32' | 'tex5_i32x2' | 'tex5_i32x3' | 'tex5_i32x4' | 'tex5_u32' | 'tex5_u32x2' | 'tex5_u32x3' | 'tex5_u32x4' | 'tex6_u8normx2' | 'tex6_u8normx4' | 'tex6_i8normx2' | 'tex6_i8normx4' | 'tex6_u16x2' | 'tex6_u16x4' | 'tex6_i16x2' | 'tex6_i16x4' | 'tex6_u16normx2' | 'tex6_u16normx4' | 'tex6_i16normx2' | 'tex6_i16normx4' | 'tex6_f16x2' | 'tex6_f16x4' | 'tex6_f32' | 'tex6_f32x2' | 'tex6_f32x3' | 'tex6_f32x4' | 'tex6_i32' | 'tex6_i32x2' | 'tex6_i32x3' | 'tex6_i32x4' | 'tex6_u32' | 'tex6_u32x2' | 'tex6_u32x3' | 'tex6_u32x4' | 'tex7_u8normx2' | 'tex7_u8normx4' | 'tex7_i8normx2' | 'tex7_i8normx4' | 'tex7_u16x2' | 'tex7_u16x4' | 'tex7_i16x2' | 'tex7_i16x4' | 'tex7_u16normx2' | 'tex7_u16normx4' | 'tex7_i16normx2' | 'tex7_i16normx4' | 'tex7_f16x2' | 'tex7_f16x4' | 'tex7_f32' | 'tex7_f32x2' | 'tex7_f32x3' | 'tex7_f32x4' | 'tex7_i32' | 'tex7_i32x2' | 'tex7_i32x3' | 'tex7_i32x4' | 'tex7_u32' | 'tex7_u32x2' | 'tex7_u32x3' | 'tex7_u32x4' | 'blendweights_f16x4' | 'blendweights_f32x4' | 'blendindices_u16x4' | 'blendindices_f16x4' | 'blendindices_f32x4' | 'blendindices_u32x4';
+type VertexAttribFormat = 'position_u8normx2' | 'position_u8normx4' | 'position_i8normx2' | 'position_i8normx4' | 'position_u16x2' | 'position_u16x4' | 'position_i16x2' | 'position_i16x4' | 'position_u16normx2' | 'position_u16normx4' | 'position_i16normx2' | 'position_i16normx4' | 'position_f16x2' | 'position_f16x4' | 'position_f32' | 'position_f32x2' | 'position_f32x3' | 'position_f32x4' | 'position_i32' | 'position_i32x2' | 'position_i32x3' | 'position_i32x4' | 'position_u32' | 'position_u32x2' | 'position_u32x3' | 'position_u32x4' | 'normal_f16x4' | 'normal_f32x3' | 'normal_f32x4' | 'diffuse_u8normx4' | 'diffuse_u16x4' | 'diffuse_u16normx4' | 'diffuse_f16x4' | 'diffuse_f32x3' | 'diffuse_f32x4' | 'diffuse_u32x3' | 'diffuse_u32x4' | 'tangent_f16x4' | 'tangent_f32x3' | 'tangent_f32x4' | 'tex0_u8normx2' | 'tex0_u8normx4' | 'tex0_i8normx2' | 'tex0_i8normx4' | 'tex0_u16x2' | 'tex0_u16x4' | 'tex0_i16x2' | 'tex0_i16x4' | 'tex0_u16normx2' | 'tex0_u16normx4' | 'tex0_i16normx2' | 'tex0_i16normx4' | 'tex0_f16x2' | 'tex0_f16x4' | 'tex0_f32' | 'tex0_f32x2' | 'tex0_f32x3' | 'tex0_f32x4' | 'tex0_i32' | 'tex0_i32x2' | 'tex0_i32x3' | 'tex0_i32x4' | 'tex0_u32' | 'tex0_u32x2' | 'tex0_u32x3' | 'tex0_u32x4' | 'tex1_u8normx2' | 'tex1_u8normx4' | 'tex1_i8normx2' | 'tex1_i8normx4' | 'tex1_u16x2' | 'tex1_u16x4' | 'tex1_i16x2' | 'tex1_i16x4' | 'tex1_u16normx2' | 'tex1_u16normx4' | 'tex1_i16normx2' | 'tex1_i16normx4' | 'tex1_f16x2' | 'tex1_f16x4' | 'tex1_f32' | 'tex1_f32x2' | 'tex1_f32x3' | 'tex1_f32x4' | 'tex1_i32' | 'tex1_i32x2' | 'tex1_i32x3' | 'tex1_i32x4' | 'tex1_u32' | 'tex1_u32x2' | 'tex1_u32x3' | 'tex1_u32x4' | 'tex2_u8normx2' | 'tex2_u8normx4' | 'tex2_i8normx2' | 'tex2_i8normx4' | 'tex2_u16x2' | 'tex2_u16x4' | 'tex2_i16x2' | 'tex2_i16x4' | 'tex2_u16normx2' | 'tex2_u16normx4' | 'tex2_i16normx2' | 'tex2_i16normx4' | 'tex2_f16x2' | 'tex2_f16x4' | 'tex2_f32' | 'tex2_f32x2' | 'tex2_f32x3' | 'tex2_f32x4' | 'tex2_i32' | 'tex2_i32x2' | 'tex2_i32x3' | 'tex2_i32x4' | 'tex2_u32' | 'tex2_u32x2' | 'tex2_u32x3' | 'tex2_u32x4' | 'tex3_u8normx2' | 'tex3_u8normx4' | 'tex3_i8normx2' | 'tex3_i8normx4' | 'tex3_u16x2' | 'tex3_u16x4' | 'tex3_i16x2' | 'tex3_i16x4' | 'tex3_u16normx2' | 'tex3_u16normx4' | 'tex3_i16normx2' | 'tex3_i16normx4' | 'tex3_f16x2' | 'tex3_f16x4' | 'tex3_f32' | 'tex3_f32x2' | 'tex3_f32x3' | 'tex3_f32x4' | 'tex3_i32' | 'tex3_i32x2' | 'tex3_i32x3' | 'tex3_i32x4' | 'tex3_u32' | 'tex3_u32x2' | 'tex3_u32x3' | 'tex3_u32x4' | 'tex4_u8normx2' | 'tex4_u8normx4' | 'tex4_i8normx2' | 'tex4_i8normx4' | 'tex4_u16x2' | 'tex4_u16x4' | 'tex4_i16x2' | 'tex4_i16x4' | 'tex4_u16normx2' | 'tex4_u16normx4' | 'tex4_i16normx2' | 'tex4_i16normx4' | 'tex4_f16x2' | 'tex4_f16x4' | 'tex4_f32' | 'tex4_f32x2' | 'tex4_f32x3' | 'tex4_f32x4' | 'tex4_i32' | 'tex4_i32x2' | 'tex4_i32x3' | 'tex4_i32x4' | 'tex4_u32' | 'tex4_u32x2' | 'tex4_u32x3' | 'tex4_u32x4' | 'tex5_u8normx2' | 'tex5_u8normx4' | 'tex5_i8normx2' | 'tex5_i8normx4' | 'tex5_u16x2' | 'tex5_u16x4' | 'tex5_i16x2' | 'tex5_i16x4' | 'tex5_u16normx2' | 'tex5_u16normx4' | 'tex5_i16normx2' | 'tex5_i16normx4' | 'tex5_f16x2' | 'tex5_f16x4' | 'tex5_f32' | 'tex5_f32x2' | 'tex5_f32x3' | 'tex5_f32x4' | 'tex5_i32' | 'tex5_i32x2' | 'tex5_i32x3' | 'tex5_i32x4' | 'tex5_u32' | 'tex5_u32x2' | 'tex5_u32x3' | 'tex5_u32x4' | 'tex6_u8normx2' | 'tex6_u8normx4' | 'tex6_i8normx2' | 'tex6_i8normx4' | 'tex6_u16x2' | 'tex6_u16x4' | 'tex6_i16x2' | 'tex6_i16x4' | 'tex6_u16normx2' | 'tex6_u16normx4' | 'tex6_i16normx2' | 'tex6_i16normx4' | 'tex6_f16x2' | 'tex6_f16x4' | 'tex6_f32' | 'tex6_f32x2' | 'tex6_f32x3' | 'tex6_f32x4' | 'tex6_i32' | 'tex6_i32x2' | 'tex6_i32x3' | 'tex6_i32x4' | 'tex6_u32' | 'tex6_u32x2' | 'tex6_u32x3' | 'tex6_u32x4' | 'tex7_u8normx2' | 'tex7_u8normx4' | 'tex7_i8normx2' | 'tex7_i8normx4' | 'tex7_u16x2' | 'tex7_u16x4' | 'tex7_i16x2' | 'tex7_i16x4' | 'tex7_u16normx2' | 'tex7_u16normx4' | 'tex7_i16normx2' | 'tex7_i16normx4' | 'tex7_f16x2' | 'tex7_f16x4' | 'tex7_f32' | 'tex7_f32x2' | 'tex7_f32x3' | 'tex7_f32x4' | 'tex7_i32' | 'tex7_i32x2' | 'tex7_i32x3' | 'tex7_i32x4' | 'tex7_u32' | 'tex7_u32x2' | 'tex7_u32x3' | 'tex7_u32x4' | 'blendweights_f16x1' | 'blendweights_f32x1' | 'blendweights_f16x2' | 'blendweights_f32x2' | 'blendweights_f16x3' | 'blendweights_f32x3' | 'blendweights_f16x4' | 'blendweights_f32x4' | 'blendindices_f16x1' | 'blendindices_u16x1' | 'blendindices_f32x1' | 'blendindices_u32x1' | 'blendindices_f16x2' | 'blendindices_u16x2' | 'blendindices_f32x2' | 'blendindices_u32x2' | 'blendindices_f16x3' | 'blendindices_u16x3' | 'blendindices_f32x3' | 'blendindices_u32x3' | 'blendindices_f16x4' | 'blendindices_u16x4' | 'blendindices_f32x4' | 'blendindices_u32x4';
 /**
  * The semantic type of vertex
  * @public
@@ -688,6 +688,26 @@ declare enum GPUResourceUsageFlags {
     DYNAMIC = 2048,
     MANAGED = 4096
 }
+/**
+ * Get vertex attribute index by semantic
+ * @public
+ */
+declare function getVertexAttribByName(name: VertexSemantic): number;
+/**
+ * Get vertex semantic by attribute index
+ * @public
+ */
+declare function getVertexAttribName(attrib: number): VertexSemantic;
+/**
+ * Get byte size of specified vertex format
+ * @public
+ */
+declare function getVertexFormatSize(fmt: VertexAttribFormat): number;
+/**
+ * Get number of components of specified vertex format
+ * @public
+ */
+declare function getVertexFormatComponentCount(fmt: VertexAttribFormat): number;
 /**
  * Get vertex format by semantic and component type and component count
  * @param semantic - The vertex semantic
@@ -1021,6 +1041,7 @@ interface BaseTexture<T = unknown> extends GPUObject<T> {
     readonly depth: number;
     readonly format: TextureFormat;
     readonly mipLevelCount: number;
+    readonly memCost: number;
     samplerOptions: SamplerOptions;
     init(): void;
     generateMipmaps(): void;
@@ -2688,6 +2709,133 @@ interface RenderStateSet {
     apply(force?: boolean): void;
 }
 
+/**
+ * ObjectPool class is responsible for managing and reusing textures and framebuffers.
+ * @public
+ */
+declare class Pool {
+    /**
+     * Creates an instance of Pool class
+     * @param device - Rendering device
+     */
+    constructor(device: AbstractDevice, memCostThreshold?: number);
+    autoRelease(): void;
+    /**
+     * 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: boolean, format: TextureFormat, width: number, height: number, mipmapping: boolean): Texture2D;
+    /**
+     * 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: boolean, format: TextureFormat, width: number, height: number, numLayers: number, mipmapping: boolean): Texture2DArray;
+    /**
+     * 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: boolean, format: TextureFormat, size: number, mipmapping: boolean): TextureCube;
+    /**
+     * Fetch a temporal framebuffer from the object pool.
+     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
+     * @param colorFormat - Texture format for color attachment.
+     * @param depthFormat - Texture format for depth attachment.
+     * @param sampleCount - The sample count for the framebuffer.
+     * @param ignoreDepthStencil - Whether to ignore depth stencil.
+     * @returns The fetched FrameBuffer object.
+     */
+    fetchTemporalFramebuffer(autoRelease: boolean, width: number, height: number, colorFormat: TextureFormat, depthFormat?: TextureFormat, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
+    /**
+     * Fetch a temporal framebuffer from the object pool.
+     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
+     * @param colorFormat - Texture format for color attachment.
+     * @param depthTex - depth attachment.
+     * @param sampleCount - The sample count for the framebuffer.
+     * @param ignoreDepthStencil - Whether to ignore depth stencil.
+     * @returns The fetched FrameBuffer object.
+     */
+    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorFormat: TextureFormat, depthTex?: T, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
+    /**
+     * Fetch a temporal framebuffer from the object pool.
+     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
+     * @param colorTex - color attachment.
+     * @param depthFormat - Texture format for depth attachment.
+     * @param sampleCount - The sample count for the framebuffer.
+     * @param ignoreDepthStencil - Whether to ignore depth stencil.
+     * @returns The fetched FrameBuffer object.
+     */
+    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorTex: T, depthFormat?: TextureFormat, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
+    /**
+     * Fetch a temporal framebuffer from the object pool.
+     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
+     * @param colorTex - color attachment.
+     * @param depthTex - depth attachment.
+     * @param sampleCount - The sample count for the framebuffer.
+     * @param ignoreDepthStencil - Whether to ignore depth stencil.
+     * @returns The fetched FrameBuffer object.
+     */
+    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorTex: T, depthTex?: T, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
+    /**
+     * Fetch a temporal framebuffer from the object pool.
+     * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
+     * @param colorTexOrFormat - color attachment or texture format.
+     * @param depthTexOrFormat - depth attachment or texture format.
+     * @param sampleCount - The sample count for the framebuffer.
+     * @param ignoreDepthStencil - Whether to ignore depth stencil.
+     * @returns The fetched FrameBuffer object.
+     */
+    fetchTemporalFramebuffer<T extends BaseTexture<unknown>>(autoRelease: boolean, width: number, height: number, colorTexOrFormat: TextureFormat | T, depthTexOrFormat?: TextureFormat | T, mipmapping?: boolean, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer;
+    /**
+     * 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: boolean, colorAttachments: BaseTexture[], depthAttachment?: BaseTexture, sampleCount?: number, ignoreDepthStencil?: boolean): FrameBuffer<unknown>;
+    /**
+     * Dispose a texture that is allocated from the object pool.
+     * @param texture - The texture to dispose.
+     */
+    disposeTexture(texture: BaseTexture): void;
+    /**
+     * Release a texture back to the object pool.
+     * @param texture - The texture to release.
+     */
+    releaseTexture(texture: BaseTexture): void;
+    /**
+     * Dispose a framebuffer that is allocated from the object pool.
+     * @param fb - The framebuffer to dispose.
+     */
+    disposeFrameBuffer(fb: FrameBuffer): void;
+    /**
+     * Release a framebuffer back to the object pool.
+     * @param fb - The framebuffer to release.
+     */
+    releaseFrameBuffer(fb: FrameBuffer): void;
+    /**
+     * Purge the object pool by disposing all free framebuffers and textures.
+     */
+    purge(): void;
+}
+
 /**
  * The webgl context type
  * @public
@@ -2722,7 +2870,7 @@ type DataType = 'u8' | 'u8norm' | 'i8' | 'i8norm' | 'u16' | 'u16norm' | 'i16' |
  * Texture format type
  * @public
  */
-type TextureFormat = 'unknown' | 'r8unorm' | 'r8snorm' | 'r16f' | 'r32f' | 'r8ui' | 'r8i' | 'r16ui' | 'r16i' | 'r32ui' | 'r32i' | 'rg8unorm' | 'rg8snorm' | 'rg16f' | 'rg32f' | 'rg8ui' | 'rg8i' | 'rg16ui' | 'rg16i' | 'rg32ui' | 'rg32i' | 'rgba8unorm' | 'rgba8unorm-srgb' | 'rgba8snorm' | 'bgra8unorm' | 'bgra8unorm-srgb' | 'rgba16f' | 'rgba32f' | 'rgba8ui' | 'rgba8i' | 'rgba16ui' | 'rgba16i' | 'rgba32ui' | 'rgba32i' | 'rg11b10uf' | 'd16' | 'd24' | 'd32f' | 'd24s8' | 'd32fs8' | 'dxt1' | 'dxt1-srgb' | 'dxt3' | 'dxt3-srgb' | 'dxt5' | 'dxt5-srgb';
+type TextureFormat = 'unknown' | 'r8unorm' | 'r8snorm' | 'r16f' | 'r32f' | 'r8ui' | 'r8i' | 'r16ui' | 'r16i' | 'r32ui' | 'r32i' | 'rg8unorm' | 'rg8snorm' | 'rg16f' | 'rg32f' | 'rg8ui' | 'rg8i' | 'rg16ui' | 'rg16i' | 'rg32ui' | 'rg32i' | 'rgba8unorm' | 'rgba8unorm-srgb' | 'rgba8snorm' | 'bgra8unorm' | 'bgra8unorm-srgb' | 'rgba16f' | 'rgba32f' | 'rgba8ui' | 'rgba8i' | 'rgba16ui' | 'rgba16i' | 'rgba32ui' | 'rgba32i' | 'rg11b10uf' | 'd16' | 'd24' | 'd32f' | 'd24s8' | 'd32fs8' | 'dxt1' | 'dxt1-srgb' | 'dxt3' | 'dxt3-srgb' | 'dxt5' | 'dxt5-srgb' | 'bc4' | 'bc4-signed' | 'bc5' | 'bc5-signed' | 'bc7' | 'bc7-srgb' | 'bc6h' | 'bc6h-signed' | 'astc-4x4' | 'astc-4x4-srgb' | 'astc-5x4' | 'astc-5x4-srgb' | 'astc-5x5' | 'astc-5x5-srgb' | 'astc-6x5' | 'astc-6x5-srgb' | 'astc-6x6' | 'astc-6x6-srgb' | 'astc-8x5' | 'astc-8x5-srgb' | 'astc-8x6' | 'astc-8x6-srgb' | 'astc-8x8' | 'astc-8x8-srgb' | 'astc-10x5' | 'astc-10x5-srgb' | 'astc-10x6' | 'astc-10x6-srgb' | 'astc-10x8' | 'astc-10x8-srgb' | 'astc-10x10' | 'astc-10x10-srgb' | 'astc-12x10' | 'astc-12x10-srgb' | 'astc-12x12' | 'astc-12x12-srgb';
 /**
  * Converts a non-sRGB texture format to the corresponding sRGB texture format
  * @param format - The texture format to be converted
@@ -2990,6 +3138,12 @@ interface TextureCaps {
     npo2Repeating: boolean;
     /** True if device supports dxt1, dxt3, dxt5 texture format */
     supportS3TC: boolean;
+    /** True if device supports bptc texture format */
+    supportBPTC: boolean;
+    /** True if device supports rgtc texture format */
+    supportRGTC: boolean;
+    /** True if device supports astc texture format */
+    supportASTC: boolean;
     /** True if device supports dxt1_srgb, dxt3-srgb, dxt5-srgb texture format */
     supportS3TCSRGB: boolean;
     /** True if device supports depth texture */
@@ -3168,6 +3322,12 @@ type DeviceViewport = {
  * @public
  */
 interface AbstractDevice extends IEventTarget<DeviceEventMap> {
+    /** Get pool object */
+    pool: Pool;
+    /** vSync */
+    vSync: boolean;
+    /** Get adapter information */
+    getAdapterInfo(): any;
     /** Get sample count of current frame buffer */
     getFrameBufferSampleCount(): number;
     /** Returns true if device context is lost. */
@@ -3184,6 +3344,10 @@ interface AbstractDevice extends IEventTarget<DeviceEventMap> {
     getBackBufferHeight(): number;
     /** Get the device capabilities */
     getDeviceCaps(): DeviceCaps;
+    /** Schedule next frame */
+    nextFrame(callback: () => void): number;
+    /** Cancel schedule next frame */
+    cancelNextFrame(handle: number): any;
     /** Set font for drawText function */
     setFont(fontName: string): any;
     /**
@@ -3389,11 +3553,29 @@ interface AbstractDevice extends IEventTarget<DeviceEventMap> {
     /** Get current render states */
     getRenderStates(): RenderStateSet;
     /**
-     * Set current frame buffer
+     * Sets the current framebuffer to the specified FrameBuffer object.
      *
-     * @param rt - The frame buffer
+     * @param rt - The FrameBuffer object to set as the current framebuffer.
      */
-    setFramebuffer(rt: FrameBuffer): void;
+    setFramebuffer(rt: FrameBuffer): any;
+    /**
+     * Sets the current framebuffer specifying complex color attachments, an optional depth attachment, MIP level, face, and sample count.
+     *
+     * @param color - An array of BaseTextures or objects containing a BaseTexture and optional properties. Each BaseTexture or object will serve as a color attachment.
+     *                - If an object is provided, it can specify:
+     *                  - `texture`: The BaseTexture to use.
+     *                  - `miplevel`: Optional MIP level for this specific texture. default is 0.
+     *                  - `face`: Optional face index for cube map textures, specifying the cube face this texture is attached to. default is 0.
+     *                  - `layer`: Optional layer index, useful for texture arrays. default is 0.
+     * @param depth - Optional BaseTexture to serve as the depth attachment.
+     * @param sampleCount - Optional sample count defining the number of samples for multisampling.
+     */
+    setFramebuffer(color: (BaseTexture | {
+        texture: BaseTexture;
+        miplevel?: number;
+        face?: number;
+        layer?: number;
+    })[], depth?: BaseTexture, miplevel?: number, face?: number, sampleCount?: number): any;
     /** Get current frame buffer */
     getFramebuffer(): FrameBuffer;
     /**
@@ -3638,8 +3820,12 @@ declare abstract class BaseDevice {
     protected _backend: DeviceBackend;
     protected _beginFrameCounter: number;
     protected _programBuilder: ProgramBuilder;
+    protected _pool: Pool;
+    protected _temporalFramebuffer: boolean;
+    protected _vSync: boolean;
     private _stateStack;
     constructor(cvs: HTMLCanvasElement, backend: DeviceBackend);
+    abstract getAdapterInfo(): any;
     abstract getFrameBufferSampleCount(): number;
     abstract isContextLost(): boolean;
     abstract getScale(): number;
@@ -3684,11 +3870,12 @@ declare abstract class BaseDevice {
     abstract getVertexLayout(): VertexLayout;
     abstract setRenderStates(renderStates: RenderStateSet): void;
     abstract getRenderStates(): RenderStateSet;
-    abstract setFramebuffer(rt: FrameBuffer): void;
     abstract getFramebuffer(): FrameBuffer;
     abstract setBindGroup(index: number, bindGroup: BindGroup, dynamicOffsets?: Iterable<number>): any;
     abstract getBindGroup(index: number): [BindGroup, Iterable<number>];
     abstract flush(): void;
+    abstract nextFrame(callback: () => void): number;
+    abstract cancelNextFrame(handle: number): any;
     abstract readPixels(index: number, x: number, y: number, w: number, h: number, buffer: TypedArray): Promise<void>;
     abstract readPixelsToBuffer(index: number, x: number, y: number, w: number, h: number, buffer: GPUDataBuffer): void;
     abstract beginCapture(): void;
@@ -3705,10 +3892,20 @@ declare abstract class BaseDevice {
     get isRendering(): boolean;
     get canvas(): HTMLCanvasElement;
     get type(): string;
+    get vSync(): boolean;
+    set vSync(val: boolean);
+    get pool(): Pool;
     get runLoopFunction(): (device: AbstractDevice) => void;
     get programBuilder(): ProgramBuilder;
     setFont(fontName: string): void;
     drawText(text: string, x: number, y: number, color: string): void;
+    setFramebuffer(rt: FrameBuffer): any;
+    setFramebuffer(color: (BaseTexture | {
+        texture: BaseTexture;
+        miplevel?: number;
+        face?: number;
+        layer?: number;
+    })[], depth?: BaseTexture, sampleCount?: number): any;
     disposeObject(obj: GPUObject, remove?: boolean): void;
     restoreObject(obj: GPUObject): Promise<void>;
     enableGPUTimeRecording(enable: boolean): void;
@@ -3736,6 +3933,7 @@ declare abstract class BaseDevice {
     updateVideoMemoryCost(delta: number): void;
     protected abstract onBeginFrame(): boolean;
     protected abstract onEndFrame(): void;
+    protected abstract _setFramebuffer(fb: FrameBuffer): any;
     private _onresize;
     private _registerEventHandlers;
     private updateFrameInfo;
@@ -3963,4 +4161,4 @@ declare class StructuredBufferData {
     set(name: string, value: StructuredValue): void;
 }
 
-export { AbstractDevice, ArrayTypeDetail, AtlasInfo, AtomicTypeInfoDetail, BaseCreationOptions, BaseDevice, BaseTexture, BindGroup, BindGroupLayout, BindGroupLayoutEntry, BindPointInfo, BlendEquation, BlendFunc, BlendingState, BufferBindingLayout, BufferCreationOptions, BufferUsage, CPUTimer, ColorState, CompareFunc, ComputeProgramConstructParams, DataType, DepthState, DeviceBackend, DeviceCaps, DeviceEventMap, DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceGPUObjectRenameEvent, DeviceLostEvent, DeviceOptions, DeviceResizeEvent, DeviceRestoreEvent, DeviceViewport, DrawText, ExpValueNonArrayType, ExpValueType, ExternalTextureBindingLayout, FaceMode, FaceWinding, Font, FrameBuffer, FrameBufferOptions, FrameBufferTextureAttachment, FrameInfo, FramebufferCaps, FunctionTypeDetail, GPUDataBuffer, GPUObject, GPUObjectList, GPUProgram, GPUProgramConstructParams, GPUResourceUsageFlags, GlyphManager, ITimer, IndexBuffer, MiscCaps, PBAddressSpace, PBAnyTypeInfo, PBArrayTypeInfo, PBAtomicI32TypeInfo, PBAtomicU32TypeInfo, PBBuiltinScope, PBComputeOptions, PBDoWhileScope, PBForScope, PBFunctionScope, PBFunctionTypeInfo, PBGlobalScope, PBIfScope, PBInputScope, PBInsideFunctionScope, PBLocalScope, PBNakedScope, PBOutputScope, PBPointerTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, PBReflection, PBReflectionTagGetter, PBRenderOptions, PBSamplerAccessMode, PBSamplerTypeInfo, PBScope, PBShaderExp, PBStructLayout, PBStructTypeInfo, PBTextureType, PBTextureTypeInfo, PBTypeInfo, PBVoidTypeInfo, PBWhileScope, PointerTypeDetail, PrimitiveType, PrimitiveTypeDetail, ProgramBuilder, Proxiable, RasterizerState, RenderBundle, RenderProgramConstructParams, RenderStateSet, SamplerBindingLayout, SamplerOptions, SamplerTypeDetail, ShaderCaps, ShaderExpTagRecord, ShaderExpTagValue, ShaderKind, ShaderType, ShaderTypeFunc, StencilOp, StencilState, StorageTextureBindingLayout, StructTypeDetail, StructuredBuffer, StructuredBufferData, StructuredValue, Texture2D, Texture2DArray, Texture3D, TextureAddressMode, TextureAtlasManager, TextureBindingLayout, TextureCaps, TextureColorSpace, TextureCreationOptions, TextureCube, TextureFilterMode, TextureFormat, TextureFormatInfo, TextureImageElement, TextureMipmapData, TextureMipmapLevelData, TextureSampler, TextureType, TextureTypeDetail, TextureVideo, TypeDetailInfo, UniformBufferLayout, UniformLayout, VertexAttribFormat, VertexBufferInfo, VertexData, VertexLayout, VertexLayoutOptions, VertexSemantic, VertexStepMode, WebGLContext, genDefaultName, getTextureFormatBlockHeight, getTextureFormatBlockSize, getTextureFormatBlockWidth, getVertexAttribFormat, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, hasAlphaChannel, hasBlueChannel, hasDepthChannel, hasGreenChannel, hasRedChannel, hasStencilChannel, isCompressedTextureFormat, isFloatTextureFormat, isIntegerTextureFormat, isSRGBTextureFormat, isSignedTextureFormat, linearTextureFormatToSRGB, makeVertexBufferType, semanticList };
+export { AbstractDevice, ArrayTypeDetail, AtlasInfo, AtomicTypeInfoDetail, BaseCreationOptions, BaseDevice, BaseTexture, BindGroup, BindGroupLayout, BindGroupLayoutEntry, BindPointInfo, BlendEquation, BlendFunc, BlendingState, BufferBindingLayout, BufferCreationOptions, BufferUsage, CPUTimer, ColorState, CompareFunc, ComputeProgramConstructParams, DataType, DepthState, DeviceBackend, DeviceCaps, DeviceEventMap, DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceGPUObjectRenameEvent, DeviceLostEvent, DeviceOptions, DeviceResizeEvent, DeviceRestoreEvent, DeviceViewport, DrawText, ExpValueNonArrayType, ExpValueType, ExternalTextureBindingLayout, FaceMode, FaceWinding, Font, FrameBuffer, FrameBufferOptions, FrameBufferTextureAttachment, FrameInfo, FramebufferCaps, FunctionTypeDetail, GPUDataBuffer, GPUObject, GPUObjectList, GPUProgram, GPUProgramConstructParams, GPUResourceUsageFlags, GlyphManager, ITimer, IndexBuffer, MiscCaps, PBAddressSpace, PBAnyTypeInfo, PBArrayTypeInfo, PBAtomicI32TypeInfo, PBAtomicU32TypeInfo, PBBuiltinScope, PBComputeOptions, PBDoWhileScope, PBForScope, PBFunctionScope, PBFunctionTypeInfo, PBGlobalScope, PBIfScope, PBInputScope, PBInsideFunctionScope, PBLocalScope, PBNakedScope, PBOutputScope, PBPointerTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, PBReflection, PBReflectionTagGetter, PBRenderOptions, PBSamplerAccessMode, PBSamplerTypeInfo, PBScope, PBShaderExp, PBStructLayout, PBStructTypeInfo, PBTextureType, PBTextureTypeInfo, PBTypeInfo, PBVoidTypeInfo, PBWhileScope, PointerTypeDetail, PrimitiveType, PrimitiveTypeDetail, ProgramBuilder, Proxiable, RasterizerState, RenderBundle, RenderProgramConstructParams, RenderStateSet, SamplerBindingLayout, SamplerOptions, SamplerTypeDetail, ShaderCaps, ShaderExpTagRecord, ShaderExpTagValue, ShaderKind, ShaderType, ShaderTypeFunc, StencilOp, StencilState, StorageTextureBindingLayout, StructTypeDetail, StructuredBuffer, StructuredBufferData, StructuredValue, Texture2D, Texture2DArray, Texture3D, TextureAddressMode, TextureAtlasManager, TextureBindingLayout, TextureCaps, TextureColorSpace, TextureCreationOptions, TextureCube, TextureFilterMode, TextureFormat, TextureFormatInfo, TextureImageElement, TextureMipmapData, TextureMipmapLevelData, TextureSampler, TextureType, TextureTypeDetail, TextureVideo, TypeDetailInfo, UniformBufferLayout, UniformLayout, VertexAttribFormat, VertexBufferInfo, VertexData, VertexLayout, VertexLayoutOptions, VertexSemantic, VertexStepMode, WebGLContext, genDefaultName, getTextureFormatBlockHeight, getTextureFormatBlockSize, getTextureFormatBlockWidth, getVertexAttribByName, getVertexAttribFormat, getVertexAttribName, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, getVertexFormatComponentCount, getVertexFormatSize, hasAlphaChannel, hasBlueChannel, hasDepthChannel, hasGreenChannel, hasRedChannel, hasStencilChannel, isCompressedTextureFormat, isFloatTextureFormat, isIntegerTextureFormat, isSRGBTextureFormat, isSignedTextureFormat, linearTextureFormatToSRGB, makeVertexBufferType, semanticList };

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.2",
+	"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,7 +55,7 @@
 		"typescript": "^5.1.3"
 	},
 	"peerDependencies": {
-		"@zephyr3d/base": "^0.1.3"
+		"@zephyr3d/base": "^0.1.4"
 	},
 	"dependencies": {
 		"@types/node": "^18.13.0",