@cosmos-js/wgpu-struct 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,112 @@
+export declare enum LENGTH {
+    BIT8 = 1,
+    BIT16 = 2,
+    BIT32 = 4
+}
+export declare const WGPU_DATA_TYPE: {
+    /**Represents a U8 (1 byte) */
+    readonly U8: {
+        readonly type: "uint";
+        readonly length: LENGTH.BIT8;
+    };
+    /**Represents a U16 (2 byte) */
+    readonly U16: {
+        readonly type: "uint";
+        readonly length: LENGTH.BIT16;
+    };
+    /**Represents a U32 (4 byte) */
+    readonly U32: {
+        readonly type: "uint";
+        readonly length: LENGTH.BIT32;
+    };
+    /**Represent a I8 (1 byte) */
+    readonly I8: {
+        readonly type: "int";
+        readonly length: LENGTH.BIT8;
+    };
+    /**Represent a I16 (2 byte) */
+    readonly I16: {
+        readonly type: "int";
+        readonly length: LENGTH.BIT16;
+    };
+    /**Represent a I32 (4 byte) */
+    readonly I32: {
+        readonly type: "int";
+        readonly length: LENGTH.BIT32;
+    };
+    /**Represent a F16 (2 byte) */
+    readonly F16: {
+        readonly type: "float";
+        readonly length: LENGTH.BIT16;
+    };
+    /**Repesent a F32 (4 byte) */
+    readonly F32: {
+        readonly type: "float";
+        readonly length: LENGTH.BIT32;
+    };
+};
+export type WGPU_DATA_TYPE = typeof WGPU_DATA_TYPE[keyof typeof WGPU_DATA_TYPE];
+export interface TYPE_METADATA {
+    /**
+     * Represents the length of the type.
+     *
+     * e.g. **`length: 4`** meaning it's a **`array<yourType, 4>`**
+     */
+    length: number;
+    /**
+     * Represents the webgpu type;
+     *
+     * e.g. **`WGPU_DATA_TYPE.U8`** represents a **Uint8 [0-256]**
+     */
+    type: WGPU_DATA_TYPE;
+}
+export type FIELD = ({
+    /**Name of the field */
+    name: string;
+    required: boolean;
+}) & (({
+    /**
+     * The type of the field;
+     *
+     * If you want to represent a vec3i; use `{length: 3, type: WGPU_DATA_TYPE.I32}`
+     */
+    type: TYPE_METADATA;
+}) | ({
+    /**
+     * Inner struct
+     */
+    innerStruct: WGPU_STRUCT;
+    length: number;
+}));
+export type WGPU_STRUCT = FIELD[];
+export type DIGESTABLE_FIELD = {
+    name: string;
+    length: number;
+    required: boolean;
+} & ({
+    struct: DIGESTABLE_STRUCT_LAYOUT;
+} | {
+    type: WGPU_DATA_TYPE;
+});
+export interface DIGESTABLE_STRUCT_LAYOUT {
+    byteLength: number;
+    items: DIGESTABLE_FIELD[];
+}
+export interface DATA_TYPE {
+    [x: string]: number[] | DATA_TYPE[];
+}
+export declare namespace StructValidation {
+    function validateNames(struct: WGPU_STRUCT): void;
+    function validateBytelength(struct: WGPU_STRUCT): void;
+    function validateData(data: DATA_TYPE, layout: DIGESTABLE_STRUCT_LAYOUT): void;
+}
+export declare namespace StructConverter {
+    function convertToDigestableLayout(struct: WGPU_STRUCT): DIGESTABLE_STRUCT_LAYOUT;
+}
+export declare namespace Packer {
+    /** Packs data to {type: "f32"|"i32"|"u32", value: number}[] */
+    function packToBit32(data: DATA_TYPE, layout: DIGESTABLE_STRUCT_LAYOUT): {
+        type: "f32" | "i32" | "u32";
+        value: number;
+    }[];
+}

package/dist/index.js

@@ -0,0 +1,185 @@
+export var LENGTH;
+(function (LENGTH) {
+    LENGTH[LENGTH["BIT8"] = 1] = "BIT8";
+    LENGTH[LENGTH["BIT16"] = 2] = "BIT16";
+    LENGTH[LENGTH["BIT32"] = 4] = "BIT32";
+})(LENGTH || (LENGTH = {}));
+export const WGPU_DATA_TYPE = {
+    /**Represents a U8 (1 byte) */
+    U8: { type: "uint", length: LENGTH.BIT8 },
+    /**Represents a U16 (2 byte) */
+    U16: { type: "uint", length: LENGTH.BIT16 },
+    /**Represents a U32 (4 byte) */
+    U32: { type: "uint", length: LENGTH.BIT32 },
+    /**Represent a I8 (1 byte) */
+    I8: { type: "int", length: LENGTH.BIT8 },
+    /**Represent a I16 (2 byte) */
+    I16: { type: "int", length: LENGTH.BIT16 },
+    /**Represent a I32 (4 byte) */
+    I32: { type: "int", length: LENGTH.BIT32 },
+    /**Represent a F16 (2 byte) */
+    F16: { type: "float", length: LENGTH.BIT16 },
+    /**Repesent a F32 (4 byte) */
+    F32: { type: "float", length: LENGTH.BIT32 }
+};
+export var StructValidation;
+(function (StructValidation) {
+    function validateNames(struct) {
+        const set = {};
+        for (const field of struct) {
+            if (set[field.name])
+                throw new Error("Duplicate field name " + field.name);
+            else if (field?.innerStruct)
+                validateNames(field.innerStruct);
+            set[field.name] = true;
+        }
+    }
+    StructValidation.validateNames = validateNames;
+    function getByteLength(struct) {
+        let bytes = 0;
+        for (const field of struct) {
+            const assingleTyped = field;
+            if (assingleTyped.type) {
+                bytes += assingleTyped.type.type.length * assingleTyped.type.length;
+            }
+            const asstructTyped = field;
+            if (asstructTyped.innerStruct) {
+                bytes += asstructTyped.length * getByteLength(asstructTyped.innerStruct);
+            }
+        }
+        return bytes;
+    }
+    function validateBytelength(struct) {
+        const byteLength = getByteLength(struct);
+        if (byteLength % 4 !== 0) {
+            throw new Error(`Length of the given struct is not divisible by 4.`);
+        }
+        if (byteLength % 16 !== 0) {
+            throw new Error(`Length of the given struct is not divisble by 16`);
+        }
+    }
+    StructValidation.validateBytelength = validateBytelength;
+    function validateData(data, layout) {
+        for (const field of layout.items) {
+            const fieldData = data[field.name];
+            if (!fieldData && field.required)
+                throw new Error(`Error while validating data: "${field.name}" not given`);
+            if (fieldData.length !== field.length)
+                throw new Error(`[Field "${field.name}"]: Given data is of ${fieldData.length} where as ${field.length} is required.`);
+            const asTyped = field;
+            if (asTyped.type) {
+                if (fieldData.every(a => typeof a !== "number")) {
+                    throw new Error(`[Field "${field.name}"]: Array given is not of number[] type`);
+                }
+            }
+            else {
+                for (const data of fieldData) {
+                    validateData(data, field.struct);
+                }
+            }
+        }
+    }
+    StructValidation.validateData = validateData;
+})(StructValidation || (StructValidation = {}));
+export var StructConverter;
+(function (StructConverter) {
+    function convertToDigestableLayout(struct) {
+        const layout = { byteLength: 0, items: [] };
+        for (const field of struct) {
+            const fieldTyped = field;
+            const fieldStruct = field;
+            if (fieldTyped.type) {
+                const byteLength = fieldTyped.type.type.length * fieldTyped.type.length;
+                layout.byteLength += byteLength;
+                layout.items.push({ "length": fieldTyped.type.length, "name": fieldTyped.name, "type": fieldTyped.type.type, required: fieldTyped.required });
+            }
+            else if (fieldStruct.innerStruct) {
+                const digested = convertToDigestableLayout(fieldStruct.innerStruct);
+                const byteLength = fieldStruct.length * digested.byteLength;
+                layout.byteLength += byteLength;
+                layout.items.push({ length: fieldStruct.length, name: fieldStruct.name, struct: digested, required: fieldStruct.required });
+            }
+        }
+        return layout;
+    }
+    StructConverter.convertToDigestableLayout = convertToDigestableLayout;
+})(StructConverter || (StructConverter = {}));
+export var Packer;
+(function (Packer) {
+    /** Packs data to {type: "f32"|"i32"|"u32", value: number}[] */
+    function packToBit32(data, layout) {
+        const buffer = new ArrayBuffer(layout.byteLength);
+        const view = new DataView(buffer);
+        const chunkTypes = new Array(layout.byteLength / 4).fill("u32");
+        let byteOffset = 0;
+        function writeField(fieldData, field) {
+            const isPrimitive = "type" in field;
+            if (isPrimitive) {
+                const primitiveType = field.type.type;
+                const bitLength = field.type.length;
+                const numericArray = fieldData;
+                for (let i = 0; i < field.length; i++) {
+                    const value = numericArray[i] ?? 0;
+                    const chunkIndex = Math.floor(byteOffset / 4);
+                    if (primitiveType === "float")
+                        chunkTypes[chunkIndex] = "f32";
+                    else if (primitiveType === "int")
+                        chunkTypes[chunkIndex] = "i32";
+                    if (primitiveType === "uint") {
+                        if (bitLength === 1)
+                            view.setUint8(byteOffset, value);
+                        else if (bitLength === 2)
+                            view.setUint16(byteOffset, value, true);
+                        else if (bitLength === 4)
+                            view.setUint32(byteOffset, value, true);
+                    }
+                    else if (primitiveType === "int") {
+                        if (bitLength === 1)
+                            view.setInt8(byteOffset, value);
+                        else if (bitLength === 2)
+                            view.setInt16(byteOffset, value, true);
+                        else if (bitLength === 4)
+                            view.setInt32(byteOffset, value, true);
+                    }
+                    else if (primitiveType === "float") {
+                        if (bitLength === 4)
+                            view.setFloat32(byteOffset, value, true);
+                    }
+                    byteOffset += bitLength;
+                }
+            }
+            else {
+                const structArray = fieldData;
+                const innerLayout = field.struct;
+                for (let i = 0; i < field.length; i++) {
+                    const innerData = structArray[i] ?? {};
+                    for (const innerField of innerLayout.items) {
+                        writeField(innerData[innerField.name], innerField);
+                    }
+                }
+            }
+        }
+        for (const item of layout.items) {
+            writeField(data[item.name], item);
+        }
+        const result = [];
+        const total32BitChunks = layout.byteLength / 4;
+        for (let i = 0; i < total32BitChunks; i++) {
+            const currentByteOffset = i * 4;
+            const targetType = chunkTypes[i];
+            let value;
+            if (targetType === "f32") {
+                value = view.getFloat32(currentByteOffset, true);
+            }
+            else if (targetType === "i32") {
+                value = view.getInt32(currentByteOffset, true);
+            }
+            else {
+                value = view.getUint32(currentByteOffset, true);
+            }
+            result.push({ type: targetType, value });
+        }
+        return result;
+    }
+    Packer.packToBit32 = packToBit32;
+})(Packer || (Packer = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmos-js/wgpu-struct",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Helper for cosmos-js to descriptor wgpu structs in js.",
   "main": "./dist/index.js",
   "author": {

package/src/index.ts

@@ -74,13 +74,12 @@ export interface DATA_TYPE {
 }
 export namespace StructValidation {
     export function validateNames(struct: WGPU_STRUCT) {
-        let set: Record<string, true> = {};
+        const set: Record<string, true> = {};
         for (const field of struct) {
             if (set[field.name]) throw new Error("Duplicate field name " + field.name)
             else if ((field as { name: string } & { innerStruct: WGPU_STRUCT })?.innerStruct) validateNames((field as { name: string } & { innerStruct: WGPU_STRUCT }).innerStruct)
             set[field.name] = true;
         }
-        set = {}
     }
     function getByteLength(struct: WGPU_STRUCT) {
         let bytes = 0;
@@ -205,7 +204,7 @@ export namespace Packer {
         for (let i = 0; i < total32BitChunks; i++) {
             const currentByteOffset = i * 4;
             const targetType = chunkTypes[i];
-            let value = 0;
+            let value;
 
             if (targetType === "f32") {
                 value = view.getFloat32(currentByteOffset, true);