@footgun/cobalt 0.3.3 → 0.5.0

package/packages/typedarray-pool/pool.js

@@ -0,0 +1,225 @@
+'use strict'
+
+var bits = require('bit-twiddle')
+var dup = require('dup')
+
+//Legacy pool support
+if(!globalThis.__TYPEDARRAY_POOL) {
+  globalThis.__TYPEDARRAY_POOL = {
+      UINT8     : dup([32, 0])
+    , UINT16    : dup([32, 0])
+    , UINT32    : dup([32, 0])
+    , BIGUINT64 : dup([32, 0])
+    , INT8      : dup([32, 0])
+    , INT16     : dup([32, 0])
+    , INT32     : dup([32, 0])
+    , BIGINT64  : dup([32, 0])
+    , FLOAT     : dup([32, 0])
+    , DOUBLE    : dup([32, 0])
+    , DATA      : dup([32, 0])
+    , UINT8C    : dup([32, 0])
+  }
+}
+
+var hasUint8C = (typeof Uint8ClampedArray) !== 'undefined'
+var hasBigUint64 = (typeof BigUint64Array) !== 'undefined'
+var hasBigInt64 = (typeof BigInt64Array) !== 'undefined'
+var POOL = globalThis.__TYPEDARRAY_POOL
+
+//Upgrade pool
+if(!POOL.UINT8C) {
+  POOL.UINT8C = dup([32, 0])
+}
+if(!POOL.BIGUINT64) {
+  POOL.BIGUINT64 = dup([32, 0])
+}
+if(!POOL.BIGINT64) {
+  POOL.BIGINT64 = dup([32, 0])
+}
+
+//New technique: Only allocate from ArrayBufferView
+var DATA    = POOL.DATA
+
+exports.free = function free(array) {
+  
+    if(Object.prototype.toString.call(array) !== '[object ArrayBuffer]') {
+      array = array.buffer
+    }
+    if(!array) {
+      return
+    }
+    var n = array.length || array.byteLength
+    var log_n = bits.log2(n)|0
+    DATA[log_n].push(array)
+}
+
+function freeArrayBuffer(buffer) {
+  if(!buffer) {
+    return
+  }
+  var n = buffer.length || buffer.byteLength
+  var log_n = bits.log2(n)
+  DATA[log_n].push(buffer)
+}
+
+function freeTypedArray(array) {
+  freeArrayBuffer(array.buffer)
+}
+
+exports.freeUint8 =
+exports.freeUint16 =
+exports.freeUint32 =
+exports.freeBigUint64 =
+exports.freeInt8 =
+exports.freeInt16 =
+exports.freeInt32 =
+exports.freeBigInt64 =
+exports.freeFloat32 = 
+exports.freeFloat =
+exports.freeFloat64 = 
+exports.freeDouble = 
+exports.freeUint8Clamped = 
+exports.freeDataView = freeTypedArray
+
+exports.freeArrayBuffer = freeArrayBuffer
+
+exports.malloc = function malloc(n, dtype) {
+  if(dtype === undefined || dtype === 'arraybuffer') {
+    return mallocArrayBuffer(n)
+  } else {
+    switch(dtype) {
+      case 'uint8':
+        return mallocUint8(n)
+      case 'uint16':
+        return mallocUint16(n)
+      case 'uint32':
+        return mallocUint32(n)
+      case 'int8':
+        return mallocInt8(n)
+      case 'int16':
+        return mallocInt16(n)
+      case 'int32':
+        return mallocInt32(n)
+      case 'float':
+      case 'float32':
+        return mallocFloat(n)
+      case 'double':
+      case 'float64':
+        return mallocDouble(n)
+      case 'uint8_clamped':
+        return mallocUint8Clamped(n)
+      case 'bigint64':
+        return mallocBigInt64(n)
+      case 'biguint64':
+        return mallocBigUint64(n)
+      case 'data':
+      case 'dataview':
+        return mallocDataView(n)
+
+      default:
+        return null
+    }
+  }
+  return null
+}
+
+function mallocArrayBuffer(n) {
+  var n = bits.nextPow2(n)
+  var log_n = bits.log2(n)
+  var d = DATA[log_n]
+  if(d.length > 0) {
+    return d.pop()
+  }
+  return new ArrayBuffer(n)
+}
+exports.mallocArrayBuffer = mallocArrayBuffer
+
+function mallocUint8(n) {
+  return new Uint8Array(mallocArrayBuffer(n), 0, n)
+}
+exports.mallocUint8 = mallocUint8
+
+function mallocUint16(n) {
+  return new Uint16Array(mallocArrayBuffer(2*n), 0, n)
+}
+exports.mallocUint16 = mallocUint16
+
+function mallocUint32(n) {
+  return new Uint32Array(mallocArrayBuffer(4*n), 0, n)
+}
+exports.mallocUint32 = mallocUint32
+
+function mallocInt8(n) {
+  return new Int8Array(mallocArrayBuffer(n), 0, n)
+}
+exports.mallocInt8 = mallocInt8
+
+function mallocInt16(n) {
+  return new Int16Array(mallocArrayBuffer(2*n), 0, n)
+}
+exports.mallocInt16 = mallocInt16
+
+function mallocInt32(n) {
+  return new Int32Array(mallocArrayBuffer(4*n), 0, n)
+}
+exports.mallocInt32 = mallocInt32
+
+function mallocFloat(n) {
+  return new Float32Array(mallocArrayBuffer(4*n), 0, n)
+}
+exports.mallocFloat32 = exports.mallocFloat = mallocFloat
+
+function mallocDouble(n) {
+  return new Float64Array(mallocArrayBuffer(8*n), 0, n)
+}
+exports.mallocFloat64 = exports.mallocDouble = mallocDouble
+
+function mallocUint8Clamped(n) {
+  if(hasUint8C) {
+    return new Uint8ClampedArray(mallocArrayBuffer(n), 0, n)
+  } else {
+    return mallocUint8(n)
+  }
+}
+exports.mallocUint8Clamped = mallocUint8Clamped
+
+function mallocBigUint64(n) {
+  if(hasBigUint64) {
+    return new BigUint64Array(mallocArrayBuffer(8*n), 0, n)
+  } else {
+    return null;
+  }
+}
+exports.mallocBigUint64 = mallocBigUint64
+
+function mallocBigInt64(n) {
+  if (hasBigInt64) {
+    return new BigInt64Array(mallocArrayBuffer(8*n), 0, n)
+  } else {
+    return null;
+  }
+}
+exports.mallocBigInt64 = mallocBigInt64
+
+function mallocDataView(n) {
+  return new DataView(mallocArrayBuffer(n), 0, n)
+}
+exports.mallocDataView = mallocDataView
+
+
+exports.clearCache = function clearCache() {
+  for(var i=0; i<32; ++i) {
+    POOL.UINT8[i].length = 0
+    POOL.UINT16[i].length = 0
+    POOL.UINT32[i].length = 0
+    POOL.INT8[i].length = 0
+    POOL.INT16[i].length = 0
+    POOL.INT32[i].length = 0
+    POOL.FLOAT[i].length = 0
+    POOL.DOUBLE[i].length = 0
+    POOL.BIGUINT64[i].length = 0
+    POOL.BIGINT64[i].length = 0
+    POOL.UINT8C[i].length = 0
+    DATA[i].length = 0
+  }
+}

package/src/primitives/primitives.js

@@ -57,7 +57,8 @@ async function init (cobalt, node) {
     // Define vertices and indices for your line represented as two triangles (a rectangle)
     // For example, this could represent a line segment from (10, 10) to (100, 10) with a thickness of 10 units
     // Updated vertices in normalized device coordinates (NDC)
-    const vertices = new Float32Array(300000)
+
+    const vertices = new Float32Array(1024)
 
     const vertexBuffer = device.createBuffer({
         size: vertices.byteLength,
@@ -65,10 +66,10 @@ async function init (cobalt, node) {
         //mappedAtCreation: true,
     })
 
-
     //new Float32Array(vertexBuffer.getMappedRange()).set(vertices);
     //vertexBuffer.unmap()
 
+
     const uniformBuffer = device.createBuffer({
         size: 64 * 2, // 4x4 matrix with 4 bytes per float32, times 2 matrices (view, projection)
         usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
@@ -186,9 +187,18 @@ function draw (cobalt, node, commandEncoder) {
         node.data.dirty = false
         const stride = 6 * Float32Array.BYTES_PER_ELEMENT // 2 floats per vertex position + 4 floats per vertex color
 
+        // if node.data.vertices has been re-sized, re-create the buffer
+        if (node.data.vertices.buffer.byteLength > node.data.vertexBuffer.size) {
+            node.data.vertexBuffer.destroy()
+            node.data.vertexBuffer = device.createBuffer({
+                size: node.data.vertices.byteLength,
+                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            })
+        }
+
         let byteCount = node.data.vertexCount * stride
         if (byteCount > node.data.vertexBuffer.size) {
-            console.warn('too many primitives, bailing')
+            console.error('too many primitives, bailing')
             return
         }
         

package/src/primitives/public-api.js

@@ -47,6 +47,12 @@ export default {
 
         let i = node.data.vertexCount * 6 // 2 floats position + 4 floats color per vertex
 
+
+        const currentElementCount = node.data.vertexCount * 6
+        const floatsToAdd = triangles.length * 3 * 6
+        node.data.vertices = handleArrayResize(Float32Array, node.data.vertices, currentElementCount, floatsToAdd)
+
+
         const pos = vec2.create()
 
         for (const tri of triangles) {
@@ -123,6 +129,11 @@ export default {
         // angle between each segment
         const deltaAngle = 2 * Math.PI / numSegments
 
+        const currentElementCount = node.data.vertexCount * 6
+        const floatsToAdd = numSegments * 3 * 6
+        node.data.vertices = handleArrayResize(Float32Array, node.data.vertices, currentElementCount, floatsToAdd)
+
+
         const m = node.data.transforms.at(-1)
 
         // Generate points for the ellipsoid
@@ -218,6 +229,12 @@ export default {
         const bottomLeft = vec2.transformMat3([ x - halfWidth, y + halfHeight ], m)
         const bottomRight = vec2.transformMat3([ x + halfWidth, y + halfHeight ], m)
 
+
+        const currentElementCount = node.data.vertexCount * 6
+        const floatsToAdd = 6 * 6
+        node.data.vertices = handleArrayResize(Float32Array, node.data.vertices, currentElementCount, floatsToAdd)
+
+
         let i = node.data.vertexCount * 6 // 2 floats position + 4 floats color per vertex
 
 
@@ -314,6 +331,11 @@ function line (cobalt, node, start, end, color, lineWidth=1) {
     
     let i = node.data.vertexCount * 6 // 2 floats position + 4 floats color per vertex
 
+
+    const currentElementCount = node.data.vertexCount * 6
+    const floatsToAdd = 6 * 6
+    node.data.vertices = handleArrayResize(Float32Array, node.data.vertices, currentElementCount, floatsToAdd)
+
     // triangle 1
     // pt 1
     node.data.vertices[i + 0] = start[0] + perp[0] * halfLineWidth
@@ -383,6 +405,28 @@ function line (cobalt, node, start, end, color, lineWidth=1) {
 }
 
 
+// if the new elements won't fit in the existing vertices array, resize it
+// @param ArrayType ArrayType  one of the TypedArray types (Float32Array, Uint8Array, etc.)
+// @param TypedArray arr
+function handleArrayResize (ArrayType, arr, currentElementCount, elementsToAdd) {
+    // if the new vertices fit in the existing vertices array bail
+    if ((currentElementCount + elementsToAdd) <= arr.length)
+        return arr
+
+    // attempt to double the existing array size when we need more capacity
+    const newSize = arr.length * 2
+
+    const MAX_LENGTH = 16 * 1024 * 1024 / arr.BYTES_PER_ELEMENT
+
+    if (newSize > MAX_LENGTH)
+        throw new Error('vertices exceed max array size')
+
+    const newArray = new ArrayType(newSize)
+    newArray.set(arr)
+    return newArray
+}
+
+
 // return component of vector perpendicular to a unit basis vector
 // (IMPORTANT NOTE: assumes "basis" has unit magnitude (length==1))
 function perpendicularComponent (inp) {