@zephyr3d/device 0.1.0

package/dist/builder/builtinfunc.js.map

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

package/dist/builder/constructors.js

@@ -0,0 +1,173 @@
+import { makeConstructor, PBShaderExp } from './base.js';
+import { PBTextureType, typeAtomicI32, typeAtomicU32, typeU32, PBPrimitiveType, typeF32, typeI32, typeBool, typeF32Vec2, typeI32Vec2, typeU32Vec2, typeBVec2, typeF32Vec3, typeI32Vec3, typeU32Vec3, typeBVec3, typeF32Vec4, typeI32Vec4, typeU32Vec4, typeBVec4, typeMat2, typeMat2x3, typeMat2x4, typeMat3x2, typeMat3, typeMat3x4, typeMat4x2, typeMat4x3, typeMat4, typeTex1D, typeTex2D, typeTex3D, typeTexCube, typeTexDepth2D, typeTexDepthCube, typeTex2DArray, typeTexDepth2DArray, typeTexExternal, typeITex1D, typeITex2D, typeITex3D, typeITexCube, typeITex2DArray, typeUTex1D, typeUTex2D, typeUTex3D, typeUTexCube, typeUTex2DArray, typeSampler, typeSamplerComparison, PBTextureTypeInfo } from './types.js';
+import { ASTShaderExpConstructor, ASTScalar } from './ast.js';
+import { PBParamLengthError, PBParamTypeError, PBDeviceNotSupport } from './errors.js';
+
+const StorageTextureFormatMap = {
+    rgba8unorm: 'rgba8unorm',
+    rgba8snorm: 'rgba8snorm',
+    rgba8uint: 'rgba8ui',
+    rgba8sint: 'rgba8i',
+    rgba16uint: 'rgba16ui',
+    rgba16sint: 'rgba16i',
+    rgba16float: 'rgba16f',
+    r32float: 'r32f',
+    r32uint: 'r32ui',
+    r32sint: 'r32i',
+    rg32float: 'rg32f',
+    rg32uint: 'rg32ui',
+    rg32sint: 'rg32i',
+    rgba32float: 'rgba32f',
+    rgba32uint: 'rgba32ui',
+    rgba32sint: 'rgba32i'
+};
+function vec_n(vecType, ...args) {
+    if (this.getDevice().type === 'webgl') {
+        if (vecType.scalarType === PBPrimitiveType.U32) {
+            throw new PBDeviceNotSupport('unsigned integer type');
+        }
+        if (vecType.isMatrixType() && vecType.cols !== vecType.rows) {
+            throw new PBDeviceNotSupport('non-square matrix type');
+        }
+    }
+    if (args.length === 1 && typeof args[0] === 'string') {
+        return new PBShaderExp(args[0], vecType);
+    } else {
+        const exp = new PBShaderExp('', vecType);
+        if (vecType.isScalarType() && args.length === 1 && (typeof args[0] === 'number' || typeof args[0] === 'boolean')) {
+            exp.$ast = new ASTScalar(args[0], vecType);
+        } else {
+            exp.$ast = new ASTShaderExpConstructor(exp.$typeinfo, args.map((arg)=>{
+                if (typeof arg === 'string') {
+                    throw new PBParamTypeError('vec_n');
+                }
+                return arg instanceof PBShaderExp ? arg.$ast : arg;
+            }));
+        }
+        return exp;
+    }
+}
+const primitiveCtors = {
+    float: typeF32,
+    int: typeI32,
+    uint: typeU32,
+    bool: typeBool,
+    vec2: typeF32Vec2,
+    ivec2: typeI32Vec2,
+    uvec2: typeU32Vec2,
+    bvec2: typeBVec2,
+    vec3: typeF32Vec3,
+    ivec3: typeI32Vec3,
+    uvec3: typeU32Vec3,
+    bvec3: typeBVec3,
+    vec4: typeF32Vec4,
+    ivec4: typeI32Vec4,
+    uvec4: typeU32Vec4,
+    bvec4: typeBVec4,
+    mat2: typeMat2,
+    mat2x3: typeMat2x3,
+    mat2x4: typeMat2x4,
+    mat3x2: typeMat3x2,
+    mat3: typeMat3,
+    mat3x4: typeMat3x4,
+    mat4x2: typeMat4x2,
+    mat4x3: typeMat4x3,
+    mat4: typeMat4
+};
+const simpleCtors = {
+    tex1D: typeTex1D,
+    tex2D: typeTex2D,
+    tex3D: typeTex3D,
+    texCube: typeTexCube,
+    tex2DShadow: typeTexDepth2D,
+    texCubeShadow: typeTexDepthCube,
+    tex2DArray: typeTex2DArray,
+    tex2DArrayShadow: typeTexDepth2DArray,
+    texExternal: typeTexExternal,
+    itex1D: typeITex1D,
+    itex2D: typeITex2D,
+    itex3D: typeITex3D,
+    itexCube: typeITexCube,
+    itex2DArray: typeITex2DArray,
+    utex1D: typeUTex1D,
+    utex2D: typeUTex2D,
+    utex3D: typeUTex3D,
+    utexCube: typeUTexCube,
+    utex2DArray: typeUTex2DArray,
+    sampler: typeSampler,
+    samplerComparison: typeSamplerComparison
+};
+function makeStorageTextureCtor(type) {
+    const ctor = {};
+    for (const k of Object.keys(StorageTextureFormatMap)){
+        ctor[k] = function(rhs) {
+            return new PBShaderExp(rhs, new PBTextureTypeInfo(type, StorageTextureFormatMap[k]));
+        };
+    }
+    return ctor;
+}
+const texStorageCtors = {
+    texStorage1D: PBTextureType.TEX_STORAGE_1D,
+    texStorage2D: PBTextureType.TEX_STORAGE_2D,
+    texStorage2DArray: PBTextureType.TEX_STORAGE_2D_ARRAY,
+    texStorage3D: PBTextureType.TEX_STORAGE_3D
+};
+/** @internal */ function setConstructors(cls) {
+    Object.keys(primitiveCtors).forEach((k)=>{
+        cls.prototype[k] = makeConstructor(function(...args) {
+            return vec_n.call(this, primitiveCtors[k], ...args);
+        }, primitiveCtors[k]);
+    });
+    Object.keys(simpleCtors).forEach((k)=>{
+        cls.prototype[k] = function(rhs) {
+            return new PBShaderExp(rhs, simpleCtors[k]);
+        };
+    });
+    Object.keys(texStorageCtors).forEach((k)=>{
+        cls.prototype[k] = makeStorageTextureCtor(texStorageCtors[k]);
+    });
+    cls.prototype['atomic_int'] = function(...args) {
+        if (args.length > 1) {
+            throw new PBParamLengthError('atomic_int');
+        }
+        if (args.length === 1) {
+            if (typeof args[0] !== 'string') {
+                throw new PBParamTypeError('atomic_int', 'name');
+            }
+            return new PBShaderExp(args[0], typeAtomicI32);
+        } else {
+            const exp = new PBShaderExp('', typeAtomicI32);
+            exp.$ast = new ASTShaderExpConstructor(exp.$typeinfo, []);
+            return exp;
+        }
+    };
+    cls.prototype['atomic_uint'] = function(...args) {
+        if (args.length > 1) {
+            throw new PBParamLengthError('atomic_uint');
+        }
+        if (args.length === 1 && typeof args[0] === 'string') {
+            return new PBShaderExp(args[0], typeAtomicU32);
+        } else if (args.length === 0) {
+            const exp = new PBShaderExp('', typeAtomicU32);
+            exp.$ast = new ASTShaderExpConstructor(exp.$typeinfo, []);
+            return exp;
+        }
+        const arg = args[0];
+        if (typeof arg === 'number' && Number.isInteger(arg) || arg instanceof PBShaderExp && arg.$ast.getType().typeId === typeU32.typeId) {
+            const exp = new PBShaderExp('', typeAtomicU32);
+            exp.$ast = new ASTShaderExpConstructor(exp.$typeinfo, [
+                arg instanceof PBShaderExp ? arg.$ast : arg
+            ]);
+            return exp;
+        }
+        return null;
+    };
+} /*
+ProgramBuilder.prototype.texStorage1D = makeStorageTextureCtor(typeinfo.PBTextureType.TEX_STORAGE_1D);
+ProgramBuilder.prototype.texStorage2D = makeStorageTextureCtor(typeinfo.PBTextureType.TEX_STORAGE_2D);
+ProgramBuilder.prototype.texStorage2DArray = makeStorageTextureCtor(typeinfo.PBTextureType.TEX_STORAGE_2D_ARRAY);
+ProgramBuilder.prototype.texStorage3D = makeStorageTextureCtor(typeinfo.PBTextureType.TEX_STORAGE_3D);
+*/
+
+export { setConstructors };
+//# sourceMappingURL=constructors.js.map

package/dist/builder/constructors.js.map

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

package/dist/builder/errors.js

@@ -0,0 +1,148 @@
+/** @internal */ function expValueToString(deviceType, value) {
+    if (typeof value === 'number' || typeof value === 'boolean' || Array.isArray(value)) {
+        return `${value}`;
+    } else {
+        return value.$ast?.toString(deviceType);
+    }
+}
+/** @internal */ function expValueTypeToString(deviceType, type) {
+    return type?.toTypeName(deviceType);
+}
+/** @internal */ class PBError extends Error {
+}
+/** @internal */ class PBValueOutOfRange extends PBError {
+    value;
+    constructor(value){
+        super();
+        this.value = value;
+    }
+    getMessage(deviceType) {
+        return `value out of range: ${this.value}`;
+    }
+}
+/** @internal */ class PBTypeCastError extends PBError {
+    value;
+    valueType;
+    expectedType;
+    constructor(value, valueType, expectedType){
+        super();
+        this.value = value;
+        this.valueType = valueType;
+        this.expectedType = expectedType;
+    }
+    getMessage(deviceType) {
+        const valueStr = typeof this.value === 'string' ? this.value : expValueToString(deviceType, this.value);
+        const valueTypeStr = typeof this.valueType === 'string' ? this.valueType : expValueTypeToString(deviceType, this.valueType);
+        const expectedTypeStr = typeof this.expectedType === 'string' ? this.expectedType : expValueTypeToString(deviceType, this.expectedType);
+        return `cannot convert '${valueStr}' of type '${valueTypeStr}' to type ${expectedTypeStr}`;
+    }
+}
+/** @internal */ class PBParamLengthError extends PBError {
+    func;
+    constructor(func){
+        super();
+        this.func = func;
+    }
+    getMessage(deviceType) {
+        return `wrong argument count for function '${this.func}'`;
+    }
+}
+/** @internal */ class PBParamTypeError extends PBError {
+    func;
+    param;
+    constructor(func, param){
+        super();
+        this.func = func;
+        this.param = param || null;
+    }
+    getMessage(deviceType) {
+        return `parameter type error for function '${this.func}': ${this.param}`;
+    }
+}
+/** @internal */ class PBParamValueError extends PBError {
+    func;
+    param;
+    reason;
+    constructor(func, param, reason){
+        super();
+        this.func = func;
+        this.param = param || null;
+        this.reason = reason || null;
+    }
+    getMessage(deviceType) {
+        return `invalid parameter value for function '${this.func}'${this.param ? ': ' + this.param : ''}${this.reason ? ': ' + this.reason : ''}}`;
+    }
+}
+/** @internal */ class PBOverloadingMatchError extends PBError {
+    func;
+    constructor(func){
+        super();
+        this.func = func;
+    }
+    getMessage(deviceType) {
+        return `No matched overloading found for function '${this.func}'`;
+    }
+}
+/** @internal */ class PBReferenceValueRequired extends PBError {
+    value;
+    constructor(value){
+        super();
+        this.value = value;
+    }
+    getMessage(deviceType) {
+        return `'${expValueToString(deviceType, this.value)}' is not a reference type`;
+    }
+}
+/** @internal */ class PBPointerValueRequired extends PBError {
+    value;
+    constructor(value){
+        super();
+        this.value = value;
+    }
+    getMessage(deviceType) {
+        return `'${expValueToString(deviceType, this.value)}' is not a pointer type`;
+    }
+}
+/** @internal */ class PBDeviceNotSupport extends PBError {
+    feature;
+    constructor(feature){
+        super();
+        this.feature = feature;
+    }
+    getMessage(deviceType) {
+        return `feature not support for ${deviceType} device: ${this.feature}`;
+    }
+}
+/** @internal */ class PBNonScopedFunctionCall extends PBError {
+    funcName;
+    constructor(funcName){
+        super();
+        this.funcName = funcName;
+    }
+    getMessage(deviceType) {
+        return `function call must be made inside a function scope: ${this.funcName}()`;
+    }
+}
+/** @internal */ class PBASTError extends PBError {
+    ast;
+    text;
+    constructor(ast, text){
+        super();
+        this.ast = ast;
+        this.text = text;
+    }
+    getMessage(deviceType) {
+        return `${this.text}: ${this.ast.toString(deviceType)}`;
+    }
+}
+/** @internal */ class PBInternalError extends PBError {
+    constructor(desc){
+        super(desc);
+    }
+    getMessage(deviceType) {
+        return `Internal error: ${this.message}`;
+    }
+}
+
+export { PBASTError, PBDeviceNotSupport, PBError, PBInternalError, PBNonScopedFunctionCall, PBOverloadingMatchError, PBParamLengthError, PBParamTypeError, PBParamValueError, PBPointerValueRequired, PBReferenceValueRequired, PBTypeCastError, PBValueOutOfRange, expValueToString, expValueTypeToString };
+//# sourceMappingURL=errors.js.map

package/dist/builder/errors.js.map

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