webgpu-computed 0.0.15 → 0.0.17

package/README.md

@@ -1,9 +1,9 @@
 # webgpu-computed
 
 🌐 Other language versions:
-- [简体中文](https://github.com/xiaguochuqiu/webgpu-computed/blob/main/README.zh.md)
+- [中文](https://github.com/xiaguochuqiu/webgpu-computed/blob/main/README.zh.md)
 
-A simplified WebGPU computing library that encapsulates tedious initialization and buffer management, allowing developers to focus on WGSL shader logic.
+A simplified WebGPU compute library that encapsulates tedious initialization and buffer management, allowing developers to focus on WGSL shader logic.
 
 ## Features
 
@@ -14,7 +14,9 @@ A simplified WebGPU computing library that encapsulates tedious initialization a
 - 📚 Built-in common WGSL functions
 - ✅ Support for Node.js environment
 - 🛠️ TypeScript support
-- 📖 Detailed English documentation and examples
+- 📖 Detailed Chinese documentation and examples
+- 🔄 Support for buffer reuse
+- ⚛️ Support for atomic operations (u32)
 
 ## Installation
 
@@ -26,7 +28,7 @@ npm install webgpu-computed
 
 ### 1. Initialize WebGPU
 
-Before using any computing features, you need to initialize the WebGPU environment:
+Before using any compute features, you need to initialize the WebGPU environment:
 
 ```javascript
 import { GpuComputed } from 'webgpu-computed';
@@ -34,13 +36,13 @@ import { GpuComputed } from 'webgpu-computed';
 // Initialize WebGPU
 await GpuComputed.init();
 
-// After using in Node.js environment, please call:
+// In Node.js environment, call after use:
 // GpuComputed.destroy()
 ```
 
 ### 2. Perform Simple Computation
 
-Here is a simple vector addition example:
+Here's a simple vector addition example:
 
 ```javascript
 import { GpuComputed } from 'webgpu-computed';
@@ -52,7 +54,7 @@ const data = {
   output: new Array(4).fill(0) // Output buffer
 };
 
-// WGSL computation code
+// WGSL compute code
 const code = `
   output[index] = inputA[index] + inputB[index];
 `;
@@ -62,7 +64,7 @@ GpuComputed.computed({
   code,
   data,
   synchronize: ["output"], // Fields to return
-  workgroupCount: [1] // Number of workgroups
+  workgroupCount: [1] // Workgroup count
 }).then(results => {
     console.log(results); // [[1.5, 3.5, 5.5, 7.5]]
 })
@@ -91,15 +93,66 @@ GpuComputed.computed({
   code,
   data,
   synchronize: ["output"], // Fields to return
-  workgroupCount: [1] // Number of workgroups
+  workgroupCount: [1] // Workgroup count
 }).then(results => {
     console.log(results); // [[1.100000023841858,2.200000047683716,3.299999952316284,0,0.20000000298023224,0.4000000059604645,0.6000000238418579,0,4.400000095367432,5.5,6.599999904632568,0,0.800000011920929,1,1.2000000476837158,0]]
 })
 ```
 
-### 4. Manually Create GpuComputed Instance
+### 4. Using Different Data Types
 
-If you need more fine-grained control, you can directly create a GpuComputed instance:
+#### Using Unsigned Integers (u32)
+
+```javascript
+import { GpuComputed } from 'webgpu-computed';
+
+const data = {
+  counters: new Uint32Array([0, 1, 2, 3]), // u32 array
+  output: new Uint32Array(4)
+};
+
+const code = `
+  output[index] = counters[index] * 2u;
+`;
+
+const results = await GpuComputed.computed({
+  code,
+  data,
+  synchronize: ["output"],
+  workgroupCount: [1]
+});
+
+console.log(results[0]); // [0, 2, 4, 6]
+```
+
+#### Using Atomic Operations
+
+```javascript
+import { GpuComputed, AtomicUint32Array } from 'webgpu-computed';
+
+const data = {
+  atomicCounter: new AtomicUint32Array([0]), // Atomic counter
+  output: new Uint32Array(4)
+};
+
+const code = `
+  let old = atomicAdd(&atomicCounter[0], 1u);
+  output[index] = old + 1u;
+`;
+
+const results = await GpuComputed.computed({
+  code,
+  data,
+  synchronize: ["output"],
+  workgroupCount: [1]
+});
+
+console.log(results[0]); // [1, 2, 3, 4]
+```
+
+### 5. Manually Creating a GpuComputed Instance
+
+If you need finer control, you can create a GpuComputed instance directly:
 
 ```javascript
 import { GpuComputed } from 'webgpu-computed';
@@ -116,7 +169,7 @@ const gpuComputed = new GpuComputed(template, {
   code: `
     output[index] = inputA[index] + inputB[index];
   `,
-  workgroupSize: [32, 1, 1] // Optional: custom workgroup size
+  workgroupSize: [32, 1, 1] // Optional: Custom workgroup size
 });
 
 // 3. Initialize pipeline
@@ -138,6 +191,27 @@ const results = await gpuComputed.computed(bindGroup, [1], ['output']);
 console.log(results[0]); // [1.5, 3.5, 5.5, 7.5]
 ```
 
+#### Buffer Reuse
+
+```javascript
+// First computation
+const data1 = { input: [1, 2, 3], output: [0, 0, 0] };
+const bindGroup1 = gpuComputed.createBindGroup(data1);
+const results1 = await gpuComputed.computed(bindGroup1, [1], ['output']);
+
+// Reuse the output buffer from the first computation for the second
+// Note: The template must still include output to build the compute code
+// const template = {
+//   input: [] as number[],
+//   output: [] as number[]
+// };
+const data2 = { input: [4, 5, 6]};
+const bindGroup2 = gpuComputed.createBindGroup(data2, bindGroup1); // Reuse output buffer
+const results2 = await gpuComputed.computed(bindGroup2, [1], ['output']);
+
+console.log(results2[0]); // [4, 5, 6] output buffer reused
+```
+
 #### Using Struct Data
 
 ```javascript
@@ -207,40 +281,49 @@ Initializes the WebGPU environment. Must be called before using other features.
 
 **Returns**: `Promise<void>`
 
-**Throws**: If the browser does not support WebGPU or fails to obtain adapter/device
+**Throws**: If the browser does not support WebGPU or fails to get adapter/device
 
 ##### `GpuComputed.computed(options)`
 
-Executes a GPU computation task.
+Executes a GPU compute task.
 
 **Parameters**:
 
-- `code` (string): WGSL computation code
+- `code` (string): WGSL compute code
 - `data` (object): Input/output data object
-- `workgroupCount` (array): Number of workgroups [x, y?, z?]
+- `workgroupCount` (array): Workgroup count [x, y?, z?]
 - `workgroupSize` (array, optional): Workgroup size, default [32, 1, 1]
 - `globalInvocationIdName` (string, optional): Global invocation ID variable name, default "grid"
 - `workgroupIndexName` (string, optional): Workgroup index variable name, default "index"
-- `synchronize` (array, optional): Array of buffer names to synchronize back to CPU
-- `beforeCodes` (array, optional): WGSL code snippets before the computation function
+- `synchronize` (array, optional): Array of buffer names to sync back to CPU
+- `beforeCodes` (array, optional): WGSL code snippets before the compute function
 - `onSuccess` (function, optional): Success callback function
 
-**Returns**: `Promise<Array<Float32Array>>` - Data from synchronized buffers
+**Returns**: `Promise<Array<Float32Array | Uint32Array | Int32Array>>` - Data of synchronized buffers
 
 ### Data Types
 
 Supports the following WGSL types:
 
 - `f32`: Single-precision float
+- `u32`: Unsigned 32-bit integer
 - `vec2`: 2D vector
 - `vec3`: 3D vector
 - `vec4`: 4D vector
 - `mat3x3`: 3x3 matrix
 - `mat4x4`: 4x4 matrix
 
+### Supported JavaScript Types
+
+- `number[]`: Number array (automatically converted to Float32Array)
+- `Float32Array`: 32-bit float array
+- `Uint32Array`: 32-bit unsigned integer array
+- `Int32Array`: 32-bit signed integer array
+- `AtomicUint32Array`: Atomic unsigned integer array
+
 ### Built-in WGSL Functions
 
-The library provides some commonly used WGSL helper functions:
+The library provides some common WGSL helper functions:
 
 #### Quaternion Rotation
 
@@ -279,20 +362,36 @@ await GpuComputed.computed({
 });
 ```
 
+### Buffer Reuse
+
+```javascript
+// Create initial bind group
+const initialData = { buffer: new Float32Array(1000) };
+const bindGroup = gpuComputed.createBindGroup(initialData);
+
+// Reuse buffer for multiple computations
+for (let i = 0; i < 10; i++) {
+  const newData = { buffer: new Float32Array(1000).fill(i) };
+  const reusedBindGroup = gpuComputed.createBindGroup(newData, bindGroup);
+  const results = await gpuComputed.computed(reusedBindGroup, [32], ['buffer']);
+  // Process results...
+}
+```
+
 ### Synchronizing Data Back to CPU
 
 ```javascript
 const results = await GpuComputed.computed({
   code: '...',
   data: {...},
-  synchronize: ['output'], // Specify buffers to synchronize
+  synchronize: ['output'], // Specify buffers to sync
   workgroupCount: [1]
 });
 
 // results contains synchronized data
 ```
 
-### Callback Function
+### Callback Functions
 
 ```javascript
 await GpuComputed.computed({
@@ -300,7 +399,7 @@ await GpuComputed.computed({
   data: {...},
   workgroupCount: [1],
   onSuccess: ({ gpuComputed, group, results }) => {
-    console.log('Computation completed', results);
+    console.log('Computation complete', results);
   }
 });
 ```
@@ -335,9 +434,50 @@ const simpleResults = await GpuComputed.computed({
     synchronize: ['output']
 });
 
-console.log('Simple computation result:', simpleResults[0]); // [1.5, 3.5, 5.5, 7.5]
+console.log('Simple computation results:', simpleResults[0]); // [1.5, 3.5, 5.5, 7.5]
+
+// 3. Using u32 type example
+console.log('\n=== Using u32 Type ===');
+const u32Data = {
+    counters: new Uint32Array([10, 20, 30, 40]),
+    output: new Uint32Array(4)
+};
+
+const u32Code = `
+    output[index] = counters[index] + 5u;
+`;
+
+const u32Results = await GpuComputed.computed({
+    code: u32Code,
+    data: u32Data,
+    workgroupCount: [1],
+    synchronize: ['output']
+});
+
+console.log('u32 computation results:', u32Results[0]); // [15, 25, 35, 45]
+
+// 4. Atomic operations example
+console.log('\n=== Atomic Operations Example ===');
+const atomicData = {
+    counter: new AtomicUint32Array([0]),
+    results: new Uint32Array(4)
+};
+
+const atomicCode = `
+    let oldValue = atomicAdd(&counter[0], 1u);
+    results[index] = oldValue;
+`;
+
+const atomicResults = await GpuComputed.computed({
+    code: atomicCode,
+    data: atomicData,
+    workgroupCount: [1],
+    synchronize: ['results']
+});
+
+console.log('Atomic operation results:', atomicResults[0]); // [0, 1, 2, 3]
 
-// 3. Complex data structure example (struct)
+// 5. Complex data structure example (structs)
 console.log('\n=== Complex Data Structure Computation ===');
 const complexData = {
     particles: [
@@ -363,9 +503,9 @@ const complexResults = await GpuComputed.computed({
     synchronize: ['output']
 });
 
-console.log('Complex computation result:', complexResults[0]);
+console.log('Complex computation results:', complexResults[0]);
 
-// 4. Using built-in WGSL functions example
+// 6. Using built-in WGSL functions example
 console.log('\n=== Using Built-in WGSL Functions ===');
 const wgslFunData = {
     points: [
@@ -406,9 +546,9 @@ const wgslFunResults = await GpuComputed.computed({
     synchronize: ['results']
 });
 
-console.log('OBB detection result:', wgslFunResults[0]); // [1, 1, 1] All points are inside the OBB
+console.log('OBB detection results:', wgslFunResults[0]); // [1, 1, 1] All points inside OBB
 
-// 5. Custom workgroup configuration example
+// 7. Custom workgroup configuration example
 console.log('\n=== Custom Workgroup Configuration ===');
 const largeData = {
     largeArray: new Array(1024).fill(0).map((_, i) => i * 1.0),
@@ -427,10 +567,10 @@ const largeResults = await GpuComputed.computed({
     synchronize: ['output']
 });
 
-console.log('Large array computation result (first 10):', largeResults[0].slice(0, 10));
+console.log('Large array computation results (first 10):', largeResults[0].slice(0, 10));
 
-// 6. Using callback function example
-console.log('\n=== Using Callback Function ===');
+// 8. Using callback functions example
+console.log('\n=== Using Callback Functions ===');
 const callbackData = {
     values: [10.0, 20.0, 30.0],
     squares: new Array(3).fill(0)
@@ -446,12 +586,12 @@ await GpuComputed.computed({
     workgroupCount: [1],
     synchronize: ['squares'],
     onSuccess: ({ gpuComputed, group, results }) => {
-        console.log('Callback triggered, square computation result:', results[0]); // [100, 400, 900]
+        console.log('Callback triggered, square computation results:', results[0]); // [100, 400, 900]
     }
 });
 
-// 7. Multi-dimensional workgroup example
-console.log('\n=== Multi-dimensional Workgroup ===');
+// 9. Multi-dimensional workgroups example
+console.log('\n=== Multi-dimensional Workgroups ===');
 const matrixData = {
     matrixA: new Array(16).fill(0).map((_, i) => i * 1.0),
     matrixB: new Array(16).fill(0).map((_, i) => (i + 1) * 1.0),
@@ -473,7 +613,7 @@ const matrixResults = await GpuComputed.computed({
     synchronize: ['result']
 });
 
-console.log('Matrix computation result:', matrixResults[0]);
+console.log('Matrix computation results:', matrixResults[0]);
 
 console.log('\nAll feature examples completed!');
 ```
@@ -489,7 +629,7 @@ Ensure the browser supports the WebGPU API.
 
 ## Contributing
 
-Welcome to submit Issues and Pull Requests!
+Issues and Pull Requests are welcome!
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webgpu-computed",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "对webgpu的封装，处理了繁琐的前置工作，只关注wgsl本身逻辑",
   "main": "./src/index.js",
   "scripts": {

package/src/index.js

@@ -1,71 +1,71 @@
-async function z(s, e = !0) {
+async function z(f, e = !0) {
   if (typeof global < "u" && typeof require < "u")
-    return require(s);
+    return require(f);
   {
     let r = await import(
       /* @vite-ignore */
-      s
+      f
     );
     return e && (r = r.default), r;
   }
 }
-function q(s) {
-  if (s instanceof Float32Array) return "f32";
-  if (s instanceof Int32Array) return "i32";
-  if (s instanceof Uint32Array) return "u32";
+function q(f) {
+  if (f instanceof Float32Array) return "f32";
+  if (f instanceof Int32Array) return "i32";
+  if (f instanceof Uint32Array) return "u32";
   throw new Error(
-    `Unsupported ArrayBufferView type: ${s.constructor.name}`
+    `Unsupported ArrayBufferView type: ${f.constructor.name}`
   );
 }
-function S(s) {
-  return s && s[0].toUpperCase() + s.slice(1);
+function S(f) {
+  return f && f[0].toUpperCase() + f.slice(1);
 }
-function x(s) {
-  return O.includes(s);
+function x(f) {
+  return G.includes(f);
 }
-function m(s) {
-  return s && Array.isArray(s) && s.length ? s.every((e) => e && typeof e == "object" && "name" in e && "type" in e && x(e.type)) : !1;
+function m(f) {
+  return f && Array.isArray(f) && f.length ? f.every((e) => e && typeof e == "object" && "name" in e && "type" in e && x(e.type)) : !1;
 }
-function $(s) {
-  return s && "layout" in s && m(s.layout);
+function B(f) {
+  return f && "layout" in f && m(f.layout);
 }
-function _(s, e) {
+function _(f, e) {
   const r = E[e];
-  return (r - s % r) % r;
+  return (r - f % r) % r;
 }
-function P(s, e) {
-  return s + (e - s % e) % e;
+function P(f, e) {
+  return f + (e - f % e) % e;
 }
-function U(s) {
-  const e = Object.keys(s), r = e.map((c) => {
-    const l = s[c];
+function U(f) {
+  const e = Object.keys(f), r = e.map((c) => {
+    const l = f[c];
     if (Array.isArray(l)) {
       for (const d of ["vec2", "vec3", "vec4", "mat3x3", "mat4x4"])
-        if (B[d] === l.length) return d;
+        if ($[d] === l.length) return d;
       throw new Error(`${c} 不支持的数组长度 ${l.length}`);
     }
     if (typeof l == "number") return "f32";
     throw new Error(`${c} 不支持的类型`);
   });
   if (e.length !== r.length) throw new Error("keys 与 types 长度不一致");
-  let i = 0;
-  const f = e.map((c, l) => {
+  let s = 0;
+  const u = e.map((c, l) => {
     const d = r[l];
-    i += _(i, d);
-    const u = {
+    s += _(s, d);
+    const a = {
       name: c,
       type: d,
-      offset: i,
-      size: B[d]
+      offset: s,
+      size: $[d]
     };
-    return i += B[d], u;
+    return s += $[d], a;
   }), t = Math.max(...r.map((c) => E[c]));
   return {
-    stride: i + (t - i % t) % t,
-    layout: f
+    stride: s + (t - s % t) % t,
+    layout: u
   };
 }
-const B = {
+const $ = {
   f32: 1,
   u32: 1,
   vec2: 2,
@@ -86,8 +86,8 @@ const B = {
 };
 class D extends Uint32Array {
 }
-const O = ["f32", "u32", "vec2", "vec3", "vec4", "mat3x3", "mat4x4"];
-let w = null, v = null;
+const G = ["f32", "u32", "vec2", "vec3", "vec4", "mat3x3", "mat4x4"];
+let w = null, A = null;
 class T {
   template;
   option;
@@ -105,9 +105,9 @@ class T {
     const r = (t) => {
       let n = 0;
       t.forEach((c) => {
-        n += _(n, c.type), c.offset = n, c.size = B[c.type], n += c.size;
+        n += _(n, c.type), c.offset = n, c.size = $[c.type], n += c.size;
       });
-    }, i = (t) => {
+    }, s = (t) => {
       r(t.layout);
       const n = t.layout[t.layout.length - 1], c = n.offset + n.size;
       let l = 1;
@@ -116,15 +116,15 @@ class T {
     };
     Object.keys(e).forEach((t) => {
       const n = e[t];
-      m(n) ? r(n) : $(n) ? i(n) : Array.isArray(n) && typeof n[0] == "number" && (e[t] = new Float32Array());
+      m(n) ? r(n) : B(n) ? s(n) : Array.isArray(n) && typeof n[0] == "number" && (e[t] = new Float32Array());
     });
   }
   /** 获取Gpu设备
    * @returns 
    */
   async getDevice() {
-    if (!w || !v) throw new Error("webgpu未初始化或不可用");
-    return { adapter: w, device: v };
+    if (!w || !A) throw new Error("webgpu未初始化或不可用");
+    return { adapter: w, device: A };
   }
   /**
    * 初始化计算管线
@@ -132,8 +132,8 @@ class T {
   async initPipeline() {
     if (!this.template) throw new Error("初始化计算管线错误，未找到可用数据模版");
     await T.init();
-    const e = this.template, { device: r } = await this.getDevice(), i = [], f = [], t = [];
-    this.device = r, Object.keys(e).forEach((a, y) => {
+    const e = this.template, { device: r } = await this.getDevice(), s = [], u = [], t = [];
+    this.device = r, Object.keys(e).forEach((i, y) => {
       if (t.push({
         binding: y,
         // 绑定到组里的0号位插槽
@@ -142,15 +142,15 @@ class T {
         buffer: {
           type: "storage"
         }
-      }), m(e[a])) {
-        const g = e[a], h = g.map((b) => `${b.name}:${b.type === "f32" ? "f32" : b.type + "<f32>"}`).join(","), A = `${S(a)}Struct`;
-        i.push(`struct ${S(a)}Struct {${h}};`), f.push(`@group(0) @binding(${y}) var<storage, read_write> ${a}: ${A};`);
-      } else if ($(e[a])) {
-        const g = e[a], h = g.layout.map((b) => `${b.name}:${b.type === "f32" ? "f32" : b.type + "<f32>"}`).join(","), A = `${S(a)}Struct`;
-        i.push(`struct ${A} {${h}};`), f.push(`@group(0) @binding(${y}) var<storage, read_write> ${a}: array<${A}>;`);
-      } else if (ArrayBuffer.isView(e[a]) && !(e[a] instanceof DataView)) {
-        const g = e[a], h = q(g);
-        g instanceof D ? f.push(`@group(0) @binding(${y}) var<storage, read_write> ${a}: array<atomic<${h}>>;`) : f.push(`@group(0) @binding(${y}) var<storage, read_write> ${a}: array<${h}>;`);
+      }), m(e[i])) {
+        const g = e[i], h = g.map((b) => `${b.name}:${b.type === "f32" ? "f32" : b.type + "<f32>"}`).join(","), v = `${S(i)}Struct`;
+        s.push(`struct ${S(i)}Struct {${h}};`), u.push(`@group(0) @binding(${y}) var<storage, read_write> ${i}: ${v};`);
+      } else if (B(e[i])) {
+        const g = e[i], h = g.layout.map((b) => `${b.name}:${b.type === "f32" ? "f32" : b.type + "<f32>"}`).join(","), v = `${S(i)}Struct`;
+        s.push(`struct ${v} {${h}};`), u.push(`@group(0) @binding(${y}) var<storage, read_write> ${i}: array<${v}>;`);
+      } else if (ArrayBuffer.isView(e[i]) && !(e[i] instanceof DataView)) {
+        const g = e[i], h = q(g);
+        g instanceof D ? u.push(`@group(0) @binding(${y}) var<storage, read_write> ${i}: array<atomic<${h}>>;`) : u.push(`@group(0) @binding(${y}) var<storage, read_write> ${i}: array<${h}>;`);
       }
     });
     const {
@@ -158,18 +158,18 @@ class T {
       workgroupSize: c = [32, 1, 1],
       globalInvocationIdName: l = "grid",
       workgroupIndexName: d = "index",
-      code: u = ""
+      code: a = ""
     } = this.option ?? {}, o = (
       /*wgsl*/
       `
-            ${i.join("")}
-${f.join("")}
+            ${s.join("")}
+${u.join("")}
             ${n.join(" ") ?? ""}
 
             @compute @workgroup_size(${c.join(",")})
             fn main(@builtin(global_invocation_id) ${l}: vec3<u32>) {
                 var ${d} = ${l}.x;
-                ${u}
+                ${a}
             }
         `
     );
@@ -196,50 +196,52 @@ ${f.join("")}
   createBindGroup(e, r) {
     if (!this.template) throw new Error("创建buffer组错误，未找到可用数据模版");
     if (!this.device) throw new Error("创建buffer组错误，未找到可用的gpu设备，请确保初始化完计算管线");
-    const i = this.device, f = this.template, t = [], n = r?.buffers?.reduce((u, o) => (u.set(o.name, o.buffer), u), /* @__PURE__ */ new Map());
-    function c(u, o, p = 0, a) {
-      if (!a) {
+    const s = this.device, u = this.template, t = [], n = r?.buffers?.reduce((a, o) => (a.set(o.name, o.buffer), a), /* @__PURE__ */ new Map());
+    function c(a, o, p = 0, i) {
+      if (ArrayBuffer.isView(a) || Array.isArray(a)) return a;
+      if (!i) {
         const y = o[o.length - 1], g = y.offset + y.size;
         let h = 1;
-        for (const A of o) h = Math.max(h, E[A.type]);
-        a = a ?? new Array(P(g, h)).fill(0);
+        for (const v of o) h = Math.max(h, E[v.type]);
+        i = i ?? new Float32Array(P(g, h)).fill(0);
       }
       return o.forEach((y) => {
-        let g = u[y.name];
+        let g = a[y.name];
         Array.isArray(g) || (g = [g]);
         for (let h = 0; h < y.size; h++)
-          a[p + y.offset + h] = Number(g[h] ?? 0);
-      }), a;
+          i[p + y.offset + h] = Number(g[h] ?? 0);
+      }), i;
     }
-    function l(u, o) {
-      const p = new Array(o.stride * u.length).fill(0);
-      return u.forEach((a, y) => {
+    function l(a, o) {
+      if (ArrayBuffer.isView(a) || typeof a[0] == "number") return a;
+      const p = new Float32Array(o.stride * a.length).fill(0);
+      return a.forEach((i, y) => {
         const g = y * o.stride;
-        c(a, o.layout, g, p);
+        c(i, o.layout, g, p);
       }), p;
     }
-    return Object.keys(f).forEach((u) => {
-      if (!(u in e)) {
-        if (n && n.has(u))
-          return t.push({ name: u, buffer: n.get(u) });
-        throw new Error(`传入的数据中，不存在${u}字段`);
+    return Object.keys(u).forEach((a) => {
+      if (!(a in e)) {
+        if (n && n.has(a))
+          return t.push({ name: a, buffer: n.get(a) });
+        throw new Error(`传入的数据中，不存在${a}字段`);
       }
-      const o = f[u], p = e[u];
-      let a = [];
-      m(o) ? a = c(p, o) : $(o) ? a = l(p, o) : (Array.isArray(p) || ArrayBuffer.isView(p)) && (a = p);
+      const o = u[a], p = e[a];
+      let i = [];
+      m(o) ? i = c(p, o) : B(o) ? i = l(p, o) : (Array.isArray(p) || ArrayBuffer.isView(p)) && (i = p);
       let y = null;
-      if (o instanceof Float32Array ? y = new Float32Array(a) : o instanceof Uint32Array ? y = new Uint32Array(a) : o instanceof Int32Array ? y = new Int32Array(a) : y = new Float32Array(a), !y) throw new Error("不支持的数组类型" + o);
-      const g = i.createBuffer({
+      if (o instanceof Float32Array ? y = new Float32Array(i) : o instanceof Uint32Array ? y = new Uint32Array(i) : o instanceof Int32Array ? y = new Int32Array(i) : y = new Float32Array(i), !y) throw new Error("不支持的数组类型" + o);
+      const g = s.createBuffer({
         size: y.byteLength,
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE
       });
-      i.queue.writeBuffer(g, 0, y), t.push({ name: u, buffer: g });
+      s.queue.writeBuffer(g, 0, y), t.push({ name: a, buffer: g });
     }), {
-      group: i.createBindGroup({
+      group: s.createBindGroup({
         layout: this.groupLayout,
-        entries: t.map((u, o) => ({
+        entries: t.map((a, o) => ({
           binding: o,
-          resource: { buffer: u.buffer }
+          resource: { buffer: a.buffer }
         }))
       }),
       buffers: t
@@ -251,23 +253,23 @@ ${f.join("")}
    */
   dataMap(e, r) {
     if (!(r in this.template)) throw new Error("未找到数据字段：" + r);
-    if ($(this.template[r])) {
-      const i = this.template[r], f = e.length / i.stride, t = [];
-      for (let n = 0; n < f; n++) {
-        const c = n * i.stride, l = {};
-        i.layout.forEach((d) => {
-          const u = e.slice(c + d.offset, c + d.offset + d.size);
-          l[d.name] = u.length === 1 ? u[0] : u;
+    if (B(this.template[r])) {
+      const s = this.template[r], u = e.length / s.stride, t = [];
+      for (let n = 0; n < u; n++) {
+        const c = n * s.stride, l = {};
+        s.layout.forEach((d) => {
+          const a = e.slice(c + d.offset, c + d.offset + d.size);
+          l[d.name] = a.length === 1 ? a[0] : a;
         }), t.push(l);
       }
       return t;
     }
     if (m(this.template[r])) {
-      const i = this.template[r], f = {};
-      return i.forEach((t) => {
+      const s = this.template[r], u = {};
+      return s.forEach((t) => {
         const n = e.slice(t.offset, t.offset + t.size);
-        f[t.name] = n.length === 1 ? n[0] : n;
-      }), f;
+        u[t.name] = n.length === 1 ? n[0] : n;
+      }), u;
     }
     return e;
   }
@@ -277,69 +279,69 @@ ${f.join("")}
    * @param synchronize 需要同步的数据字段
    * @returns 
    */
-  async computed(e, r, i = []) {
+  async computed(e, r, s = []) {
     if (!this.pipeline) throw new Error("未找到可用计算管线，请确保计算管线已经创建成功");
-    const f = this.device, t = this.pipeline, n = f.createCommandEncoder(), c = n.beginComputePass();
+    const u = this.device, t = this.pipeline, n = u.createCommandEncoder(), c = n.beginComputePass();
     c.setPipeline(t), c.setBindGroup(0, e.group), c.dispatchWorkgroups(r[0], r[1], r[2]), c.end();
     const l = e.buffers?.map((o) => {
-      if (i?.includes(o.name)) {
-        const p = f.createBuffer({
+      if (s?.includes(o.name)) {
+        const p = u.createBuffer({
           size: o.buffer.size,
           usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
         });
         return n.copyBufferToBuffer(o.buffer, 0, p, 0, p.size), { buffer: p, name: o.name };
       }
     }).filter((o) => !!o);
-    f.queue.submit([n.finish()]), await f.queue.onSubmittedWorkDone();
+    u.queue.submit([n.finish()]), await u.queue.onSubmittedWorkDone();
     const d = /* @__PURE__ */ new Map();
     return await Promise.all(
       l.map(async (o) => {
         await o.buffer.mapAsync(GPUMapMode.READ);
         const p = o.buffer.getMappedRange();
-        let a = null;
-        this.template[o.name] instanceof Float32Array ? a = new Float32Array(p) : this.template[o.name] instanceof Uint32Array ? a = new Uint32Array(p) : this.template[o.name] instanceof Int32Array ? a = new Int32Array(p) : a = new Float32Array(p);
-        const y = [...a];
+        let i = null;
+        this.template[o.name] instanceof Float32Array ? i = new Float32Array(p) : this.template[o.name] instanceof Uint32Array ? i = new Uint32Array(p) : this.template[o.name] instanceof Int32Array ? i = new Int32Array(p) : i = new Float32Array(p);
+        const y = [...i];
         d.set(o.name, y);
       })
-    ), i.map((o) => d.get(o));
+    ), s.map((o) => d.get(o));
   }
   /** 初始化gpu设备
    * @returns 
    */
   static async init() {
-    if (!(w && v)) {
+    if (!(w && A)) {
       if (typeof globalThis < "u" && typeof window > "u") {
         const { create: e, globals: r } = await z("webgpu", !1);
         Object.assign(globalThis, r), globalThis.navigator || (globalThis.navigator = {}), Object.assign(globalThis.navigator, { gpu: e([]) });
       }
       if (!navigator.gpu) throw new Error("该环境不支持webgpu");
       if (w || (w = await navigator.gpu.requestAdapter({})), !w) throw new Error("获取适配器失败");
-      if (v = await w.requestDevice(), !w) throw new Error("获取设备失败");
+      if (A = await w.requestDevice(), !w) throw new Error("获取设备失败");
     }
   }
   /** 注销gpu设备
    */
   static destroy() {
-    v && v.destroy(), v = null;
+    A && A.destroy(), A = null;
   }
   /** 
    * @param data 
    */
   static buildBufferTypeByData(e) {
-    return Object.keys(e).reduce((i, f) => {
-      let t = e[f];
+    return Object.keys(e).reduce((s, u) => {
+      let t = e[u];
       if (Array.isArray(t) && typeof t[0] == "number" && (t = new Float32Array()), Array.isArray(t))
         if (typeof t[0] == "object" || t.length) {
           const n = U(t[0]);
-          i[f] = n;
-        } else console.log(`字段：${f}， 不支持该值对应数据类型或数组为空`);
+          s[u] = n;
+        } else console.log(`字段：${u}， 不支持该值对应数据类型或数组为空`);
       else if (ArrayBuffer.isView(t) && !(t instanceof DataView))
-        i[f] = t;
+        s[u] = t;
       else if (typeof t == "object") {
         const n = U(t);
-        i[f] = n.layout;
-      } else console.log(`字段：${f}， 不支持的数据类型`);
-      return i;
+        s[u] = n.layout;
+      } else console.log(`字段：${u}， 不支持的数据类型`);
+      return s;
     }, {});
   }
   /** 通过数据创建
@@ -347,8 +349,8 @@ ${f.join("")}
    * @returns 
    */
   static async fromByData(e) {
-    let { data: r, ...i } = e;
-    const f = this.buildBufferTypeByData(r), t = new T(f, i);
+    let { data: r, ...s } = e;
+    const u = this.buildBufferTypeByData(r), t = new T(u, s);
     return await t.initPipeline(), t;
   }
   /** 快捷计算方法
@@ -356,12 +358,12 @@ ${f.join("")}
    * @returns 
    */
   static async computed(e) {
-    let { data: r, map: i = !1, workgroupCount: f, synchronize: t, onSuccess: n, ...c } = e;
-    const l = await this.fromByData({ data: r, ...c }), d = l.createBindGroup(r), u = await l.computed(d, f, t);
-    return n && n({ gpuComputed: l, group: d, results: u }), i ? u.map((o, p) => l.dataMap(o, t[p])) : u;
+    let { data: r, map: s = !1, workgroupCount: u, synchronize: t, onSuccess: n, ...c } = e;
+    const l = await this.fromByData({ data: r, ...c }), d = l.createBindGroup(r), a = await l.computed(d, u, t);
+    return n && n({ gpuComputed: l, group: d, results: a }), s ? a.map((o, p) => l.dataMap(o, t[p])) : a;
   }
 }
-const j = (
+const M = (
   /* wgsl */
   `
     fn quat_rotate(q: vec4<f32>, v: vec3<f32>) -> vec3<f32> {
@@ -370,7 +372,7 @@ const j = (
         return v + q.w * t + cross(q.xyz, t);
     }
 `
-), G = (
+), O = (
   /* wgsl */
   `
     fn point_in_obb(
@@ -390,13 +392,13 @@ const j = (
         return all(abs(pLocal) <= halfSize);
     }
 `
-), M = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+), j = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  point_in_obb: G,
-  quat_rotate: j
+  point_in_obb: O,
+  quat_rotate: M
 }, Symbol.toStringTag, { value: "Module" }));
 export {
   D as AtomicUint32Array,
   T as GpuComputed,
-  M as WGSL_Fun
+  j as WGSL_Fun
 };