@zephyr3d/scene 0.1.0 → 0.1.2

package/dist/shadow/shadowmapper.js

@@ -26,9 +26,9 @@ import '../render/watermesh.js';
 const tmpMatrix = new Matrix4x4();
 const tmpFrustum = new Frustum(Matrix4x4.identity());
 // const zeroPosition = Vector3.zero();
-/**
- * The shadow map generator
- * @public
+/**
+ * The shadow map generator
+ * @public
  */ class ShadowMapper {
     /** @internal */ static _snapMatrix = new Matrix4x4();
     /** @internal */ static _target = new Vector3();
@@ -54,9 +54,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** @internal */ _esmBlurKernelSize;
     /** @internal */ _esmBlurRadius;
     /** @internal */ _esmDepthScale;
-    /**
-   * Creates an instance of ShadowMapper
-   * @param light - The light that is used to generate shadow map
+    /**
+   * Creates an instance of ShadowMapper
+   * @param light - The light that is used to generate shadow map
    */ constructor(light){
         this._light = light;
         this._config = {
@@ -159,14 +159,14 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             this.applyMode(this._shadowMode);
         }
     }
-    /** Generated shadow map */ /*
-  get shadowMap(): ShadowMapType {
-    return (this._impl.getShadowMap(this) ?? this._framebuffer?.getColorAttachments()[0] ?? null) as ShadowMapType;
-  }
-  */ /** Sampler of the shadow map */ /*
-  get shadowMapSampler(): TextureSampler {
-    return this._impl.getShadowMapSampler(this);
-  }
+    /** Generated shadow map */ /*
+  get shadowMap(): ShadowMapType {
+    return (this._impl.getShadowMap(this) ?? this._framebuffer?.getColorAttachments()[0] ?? null) as ShadowMapType;
+  }
+  */ /** Sampler of the shadow map */ /*
+  get shadowMapSampler(): TextureSampler {
+    return this._impl.getShadowMapSampler(this);
+  }
   */ /** @internal */ getShaderHash(shadowMapParams) {
         return `${shadowMapParams.impl.constructor.name}_${shadowMapParams.impl.getShaderHash()}_${shadowMapParams.lightType}_${shadowMapParams.shadowMap.target}_${Number(shadowMapParams.numShadowCascades > 1)}_${Number(Application.instance.device.getDeviceCaps().textureCaps.getTextureFormatInfo(shadowMapParams.shadowMap.format).filterable)}`;
     }
@@ -411,68 +411,68 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             center.setXYZ((rx - tx) * 2 / this.shadowMapSize, (ry - ty) * 2 / this.shadowMapSize, 0);
             cropMatrix.translation(center);
         }
-    /*
-    const minx = frustumMin.x;
-    const maxx = frustumMax.x;
-    const miny = frustumMin.y;
-    const maxy = frustumMax.y;
-    const minz = frustumMin.z;
-    const maxz = frustumMax.z;
-    const texelSizeW = (maxx - minx) / this.shadowMapSize;
-    const texelSizeH = (maxy - miny) / this.shadowMapSize;
-    const cx = Math.floor((minx + maxx) / 2 / texelSizeW) * texelSizeW;
-    const cy = Math.floor((miny + maxy) / 2 / texelSizeH) * texelSizeH;
-    const cz = (minz + maxz) / 2;
-    const hx = Math.floor(((maxx - minx) * (expand + 0.5)) / texelSizeW) * texelSizeW;
-    const hy = Math.floor(((maxy - miny) * (expand + 0.5)) / texelSizeH) * texelSizeH;
-    lightCamera.position.setXYZ(cx, cy, cz);
-    lightCamera.setOrtho(
-      -hx,
-      hx,
-      -hy,
-      hy,
-      sceneMax.z - maxz,
-      sceneMax.z - minz + 1
-    );
-    if (cropMatrix) {
-      // compute crop matrix
-      let clipMaxX = 0,
-        clipMaxY = 0;
-      let clipMinX = Number.MAX_VALUE,
-        clipMinY = Number.MAX_VALUE;
-      frustum.corners.forEach((p) => {
-        const clipPos = lightCamera.viewProjectionMatrix.transformPoint(p);
-        clipPos.x = Math.min(1, Math.max(-1, clipPos.x / clipPos.w));
-        clipPos.y = Math.min(1, Math.max(-1, clipPos.y / clipPos.w));
-        if (clipPos.x > clipMaxX) {
-          clipMaxX = clipPos.x;
-        }
-        if (clipPos.x < clipMinX) {
-          clipMinX = clipPos.x;
-        }
-        if (clipPos.y > clipMaxY) {
-          clipMaxY = clipPos.y;
-        }
-        if (clipPos.y < clipMinY) {
-          clipMinY = clipPos.y;
-        }
-      });
-      const clipW = clipMaxX - clipMinX;
-      const clipH = clipMaxY - clipMinY;
-      clipMinX -= expand * clipW;
-      clipMinY -= expand * clipH;
-      clipMaxX += expand * clipW;
-      clipMaxY += expand * clipH;
-      const scaleX = 2 / (clipMaxX - clipMinX);
-      const scaleY = 2 / (clipMaxY - clipMinY);
-      const offsetX = -0.5 * (clipMaxX + clipMinX) * scaleX;
-      const offsetY = -0.5 * (clipMaxY + clipMinY) * scaleY;
-      cropMatrix.identity();
-      cropMatrix.m00 = scaleX;
-      cropMatrix.m11 = scaleY;
-      cropMatrix.m03 = offsetX;
-      cropMatrix.m13 = offsetY;
-    }
+    /*
+    const minx = frustumMin.x;
+    const maxx = frustumMax.x;
+    const miny = frustumMin.y;
+    const maxy = frustumMax.y;
+    const minz = frustumMin.z;
+    const maxz = frustumMax.z;
+    const texelSizeW = (maxx - minx) / this.shadowMapSize;
+    const texelSizeH = (maxy - miny) / this.shadowMapSize;
+    const cx = Math.floor((minx + maxx) / 2 / texelSizeW) * texelSizeW;
+    const cy = Math.floor((miny + maxy) / 2 / texelSizeH) * texelSizeH;
+    const cz = (minz + maxz) / 2;
+    const hx = Math.floor(((maxx - minx) * (expand + 0.5)) / texelSizeW) * texelSizeW;
+    const hy = Math.floor(((maxy - miny) * (expand + 0.5)) / texelSizeH) * texelSizeH;
+    lightCamera.position.setXYZ(cx, cy, cz);
+    lightCamera.setOrtho(
+      -hx,
+      hx,
+      -hy,
+      hy,
+      sceneMax.z - maxz,
+      sceneMax.z - minz + 1
+    );
+    if (cropMatrix) {
+      // compute crop matrix
+      let clipMaxX = 0,
+        clipMaxY = 0;
+      let clipMinX = Number.MAX_VALUE,
+        clipMinY = Number.MAX_VALUE;
+      frustum.corners.forEach((p) => {
+        const clipPos = lightCamera.viewProjectionMatrix.transformPoint(p);
+        clipPos.x = Math.min(1, Math.max(-1, clipPos.x / clipPos.w));
+        clipPos.y = Math.min(1, Math.max(-1, clipPos.y / clipPos.w));
+        if (clipPos.x > clipMaxX) {
+          clipMaxX = clipPos.x;
+        }
+        if (clipPos.x < clipMinX) {
+          clipMinX = clipPos.x;
+        }
+        if (clipPos.y > clipMaxY) {
+          clipMaxY = clipPos.y;
+        }
+        if (clipPos.y < clipMinY) {
+          clipMinY = clipPos.y;
+        }
+      });
+      const clipW = clipMaxX - clipMinX;
+      const clipH = clipMaxY - clipMinY;
+      clipMinX -= expand * clipW;
+      clipMinY -= expand * clipH;
+      clipMaxX += expand * clipW;
+      clipMaxY += expand * clipH;
+      const scaleX = 2 / (clipMaxX - clipMinX);
+      const scaleY = 2 / (clipMaxY - clipMinY);
+      const offsetX = -0.5 * (clipMaxX + clipMinX) * scaleX;
+      const offsetY = -0.5 * (clipMaxY + clipMinY) * scaleY;
+      cropMatrix.identity();
+      cropMatrix.m00 = scaleX;
+      cropMatrix.m11 = scaleY;
+      cropMatrix.m03 = offsetX;
+      cropMatrix.m13 = offsetY;
+    }
     */ }
     /** @internal */ static fetchShadowMapParams() {
         if (this._shadowMapParams.length > 0) {

package/dist/shadow/ssm.js

@@ -53,40 +53,40 @@ import { computeShadowMapDepth } from '../shaders/shadow.js';
     }
     computeShadowMapDepth(shadowMapParams, scope) {
         return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
-    /*
-    if (this.useNativeShadowMap(shadowMapParams)) {
-      return scope.$builder.vec4(
-        scope.$builder.emulateDepthClamp
-          ? scope.$builder.clamp(scope.$inputs.clamppedDepth, 0, 1)
-          : scope.$builtins.fragCoord.z,
-        0,
-        0,
-        1
-      );
-    } else {
-      const pb = scope.$builder;
-      let depth: PBShaderExp = null;
-      if (shadowMapParams.lightType === LIGHT_TYPE_DIRECTIONAL) {
-        depth = pb.emulateDepthClamp
-          ? pb.clamp(scope.$inputs.clamppedDepth, 0, 1)
-          : scope.$builtins.fragCoord.z;
-      } else if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
-        const lightSpacePos = pb.mul(
-          ShaderFramework.getLightViewMatrixForShadow(scope),
-          ShaderFramework.getWorldPosition(scope)
-        );
-        depth = pb.div(pb.length(lightSpacePos.xyz), ShaderFramework.getLightPositionAndRangeForShadow(scope).w);
-      } else if (shadowMapParams.lightType === LIGHT_TYPE_SPOT) {
-        const lightSpacePos = pb.mul(
-          ShaderFramework.getLightViewMatrixForShadow(scope),
-          ShaderFramework.getWorldPosition(scope)
-        );
-        depth = pb.min(pb.div(pb.neg(lightSpacePos.z), ShaderFramework.getLightPositionAndRangeForShadow(scope).w), 1);
-      }
-      return shadowMapParams.shadowMap.format === 'rgba8unorm'
-        ? encodeNormalizedFloatToRGBA(scope, depth)
-        : pb.vec4(depth, 0, 0, 1);
-    }
+    /*
+    if (this.useNativeShadowMap(shadowMapParams)) {
+      return scope.$builder.vec4(
+        scope.$builder.emulateDepthClamp
+          ? scope.$builder.clamp(scope.$inputs.clamppedDepth, 0, 1)
+          : scope.$builtins.fragCoord.z,
+        0,
+        0,
+        1
+      );
+    } else {
+      const pb = scope.$builder;
+      let depth: PBShaderExp = null;
+      if (shadowMapParams.lightType === LIGHT_TYPE_DIRECTIONAL) {
+        depth = pb.emulateDepthClamp
+          ? pb.clamp(scope.$inputs.clamppedDepth, 0, 1)
+          : scope.$builtins.fragCoord.z;
+      } else if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
+        const lightSpacePos = pb.mul(
+          ShaderFramework.getLightViewMatrixForShadow(scope),
+          ShaderFramework.getWorldPosition(scope)
+        );
+        depth = pb.div(pb.length(lightSpacePos.xyz), ShaderFramework.getLightPositionAndRangeForShadow(scope).w);
+      } else if (shadowMapParams.lightType === LIGHT_TYPE_SPOT) {
+        const lightSpacePos = pb.mul(
+          ShaderFramework.getLightViewMatrixForShadow(scope),
+          ShaderFramework.getWorldPosition(scope)
+        );
+        depth = pb.min(pb.div(pb.neg(lightSpacePos.z), ShaderFramework.getLightPositionAndRangeForShadow(scope).w), 1);
+      }
+      return shadowMapParams.shadowMap.format === 'rgba8unorm'
+        ? encodeNormalizedFloatToRGBA(scope, depth)
+        : pb.vec4(depth, 0, 0, 1);
+    }
     */ }
     computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
         const funcNameComputeShadowCSM = 'lib_computeShadowCSM';

package/dist/utility/bounding_volume.js

@@ -1,14 +1,17 @@
 import { AABB, Frustum, ClipState } from '@zephyr3d/base';
 import { AABBTree } from './aabbtree.js';
 
-/**
- * The bounding box class
- * @public
+/**
+ * The bounding box class
+ * @public
  */ class BoundingBox extends AABB {
     constructor(arg0, arg1){
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         super(arg0, arg1);
     }
+    /** {@inheritDoc BoundingVolume.behindPlane} */ behindPlane(plane) {
+        return this.toAABB().behindPlane(plane);
+    }
     /** {@inheritDoc BoundingVolume.clone} */ clone() {
         return new BoundingBox(this);
     }
@@ -22,9 +25,9 @@ import { AABBTree } from './aabbtree.js';
         return this;
     }
 }
-/**
- * Bounding box tree
- * @public
+/**
+ * Bounding box tree
+ * @public
  */ class BoundingBoxTree extends AABBTree {
     constructor(arg){
         super(arg);
@@ -51,27 +54,27 @@ import { AABBTree } from './aabbtree.js';
     /** {@inheritDoc BoundingVolume.toAABB} */ toAABB() {
         return this.getTopLevelAABB();
     }
-} /*
-export class BoundingFrustum implements BoundingVolume {
-    protected _frustum: Frustum;
-    constructor ();
-    constructor (other: BoundingFrustum|Frustum|Matrix4x4);
-    constructor (arg0?: BoundingFrustum|Frustum|Matrix4x4) {
-        if (arg0 instanceof BoundingFrustum) {
-            this._frustum = arg0._frustum ? new Frustum (arg0._frustum) : null;
-        } else if (arg0 instanceof Frustum) {
-            this._frustum = new Frustum (arg0);
-        } else if (arg0 instanceof Matrix4x4) {
-            this._frustum = new Frustum (arg0);
-        } else {
-            this._frustum = null;
-        }
-    }
-    clone (): BoundingVolume {
-        return new BoundingFrustum (this);
-    }
-    transform (matrix: Matrix4x4)
-}
+} /*
+export class BoundingFrustum implements BoundingVolume {
+    protected _frustum: Frustum;
+    constructor ();
+    constructor (other: BoundingFrustum|Frustum|Matrix4x4);
+    constructor (arg0?: BoundingFrustum|Frustum|Matrix4x4) {
+        if (arg0 instanceof BoundingFrustum) {
+            this._frustum = arg0._frustum ? new Frustum (arg0._frustum) : null;
+        } else if (arg0 instanceof Frustum) {
+            this._frustum = new Frustum (arg0);
+        } else if (arg0 instanceof Matrix4x4) {
+            this._frustum = new Frustum (arg0);
+        } else {
+            this._frustum = null;
+        }
+    }
+    clone (): BoundingVolume {
+        return new BoundingFrustum (this);
+    }
+    transform (matrix: Matrix4x4)
+}
 */
 
 export { BoundingBox, BoundingBoxTree };

package/dist/utility/bounding_volume.js.map

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

package/dist/utility/shprojection.js

@@ -300,13 +300,13 @@ async function doProjectCubemap(srcTexture, coeff) {
     }
     return result;
 }
-/**
- * Projects a function represented in a cubemap into spherical harmonics using GPU
- *
- * @param input - The input cubemap
- * @returns The evaluated SH data
- *
- * @public
+/**
+ * Projects a function represented in a cubemap into spherical harmonics using GPU
+ *
+ * @param input - The input cubemap
+ * @returns The evaluated SH data
+ *
+ * @public
  */ async function projectCubemap(tex) {
     const device = Application.instance.device;
     const srcTex = tex;
@@ -364,13 +364,13 @@ function directionFromCubemapTexel(face, x, y, invSize) {
     }
     return dir.inplaceNormalize();
 }
-/**
- * Projects a function represented in a cubemap into spherical harmonics using CPU
- *
- * @param input - The input cubemap
- * @returns The evaluated SH data
- *
- * @public
+/**
+ * Projects a function represented in a cubemap into spherical harmonics using CPU
+ *
+ * @param input - The input cubemap
+ * @returns The evaluated SH data
+ *
+ * @public
  */ async function projectCubemapCPU(input) {
     let srcTex = input;
     const device = Application.instance.device;

package/package.json

@@ -1,70 +1,70 @@
-{
-  "name": "@zephyr3d/scene",
-  "version": "0.1.0",
-  "description": "scene system for zephyr3d",
-  "homepage": "https://github.com/gavinyork/zephyr3d#readme",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "**/*.js",
-    "**/*.d.ts",
-    "**/*.js.map"
-  ],
-  "sideEffects": false,
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gavinyork/zephyr3d.git"
-  },
-  "scripts": {
-    "clean": "shx rm -rf ./dist .tsbuildinfo",
-    "tsc": "tsc -p . --noEmit",
-    "build": "cross-env NODE_OPTIONS=--max_old_space_size=8192 rollup -c --silent"
-  },
-  "keywords": [
-    "javascript",
-    "3d",
-    "rendering",
-    "engine",
-    "webgl",
-    "webgpu",
-    "canvas",
-    "zephyr3d",
-    "device"
-  ],
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/gavinyork/zephyr3d/issues"
-  },
-  "engines": {
-    "node": ">=16.18.0"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.20.12",
-    "@babel/preset-env": "^7.20.2",
-    "@rollup/plugin-babel": "^6.0.3",
-    "@rollup/plugin-node-resolve": "^15.0.1",
-    "@rollup/plugin-strip": "^3.0.2",
-    "@rollup/plugin-terser": "^0.4.0",
-    "@rollup/pluginutils": "^5.0.2",
-    "@swc/core": "^1.3.62",
-    "rollup-plugin-swc3": "^0.8.2",
-    "rollup": "^3.15.0",
-    "rollup-plugin-dts": "^5.2.0",
-    "rollup-plugin-copy": "^3.4.0",
-    "rollup-plugin-typescript2": "^0.34.1",
-    "shx": "^0.3.4",
-    "cross-env": "^7.0.3",
-    "typescript": "^5.1.3",
-    "@zephyr3d/base": "workspace:^0.1.0",
-    "@zephyr3d/device": "workspace:^0.1.0"
-  },
-  "peerDependencies": {
-    "@zephyr3d/base": "workspace:^0.1.0",
-    "@zephyr3d/device": "workspace:^0.1.0"
-  },
-  "dependencies": {
-    "@webgpu/types": "^0.1.31"
-  }
-}
+{
+	"name": "@zephyr3d/scene",
+	"version": "0.1.2",
+	"description": "scene system for zephyr3d",
+	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts",
+		"**/*.js.map"
+	],
+	"sideEffects": false,
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gavinyork/zephyr3d.git"
+	},
+	"keywords": [
+		"javascript",
+		"3d",
+		"rendering",
+		"engine",
+		"webgl",
+		"webgpu",
+		"canvas",
+		"zephyr3d",
+		"device"
+	],
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/gavinyork/zephyr3d/issues"
+	},
+	"engines": {
+		"node": ">=16.18.0"
+	},
+	"devDependencies": {
+		"@babel/core": "^7.20.12",
+		"@babel/preset-env": "^7.20.2",
+		"@rollup/plugin-babel": "^6.0.3",
+		"@rollup/plugin-node-resolve": "^15.0.1",
+		"@rollup/plugin-strip": "^3.0.2",
+		"@rollup/plugin-terser": "^0.4.0",
+		"@rollup/pluginutils": "^5.0.2",
+		"@swc/core": "^1.3.62",
+		"@zephyr3d/base": "^0.1.2",
+		"@zephyr3d/device": "^0.1.2",
+		"cross-env": "^7.0.3",
+		"rollup": "^3.15.0",
+		"rollup-plugin-copy": "^3.4.0",
+		"rollup-plugin-dts": "^5.2.0",
+		"rollup-plugin-swc3": "^0.8.2",
+		"rollup-plugin-typescript2": "^0.34.1",
+		"shx": "^0.3.4",
+		"typescript": "^5.1.3"
+	},
+	"peerDependencies": {
+		"@zephyr3d/base": "^0.1.2",
+		"@zephyr3d/device": "^0.1.2"
+	},
+	"dependencies": {
+		"@webgpu/types": "^0.1.31"
+	},
+	"scripts": {
+		"clean": "shx rm -rf ./dist .tsbuildinfo",
+		"tsc": "tsc -p . --noEmit",
+		"build": "cross-env NODE_OPTIONS=--max_old_space_size=8192 rollup -c --silent"
+	}
+}

package/dist/material/mixins/texture.js

@@ -1,110 +0,0 @@
-function mixinTextureProps(name) {
-    return function(BaseCls) {
-        const capName = `${name[0].toUpperCase()}${name.slice(1)}`;
-        const upperName = name.toUpperCase();
-        const id = `mixinTexture${capName}`;
-        const feature = `FEATURE_TEXTURE_${upperName}`;
-        const featureTexIndex = `FEATURE_TEXTURE_TEXCOORD_INDEX_${upperName}`;
-        const featureTexMatrix = `FEATURE_TEXTURE_TEXCOORD_MATRIX_${upperName}`;
-        if (BaseCls[id]) {
-            return BaseCls;
-        }
-        const cls = class extends BaseCls {
-            constructor(...args){
-                super(...args);
-                let textureValue = null;
-                let textureSampler = null;
-                let textureCoordIndex = 0;
-                let textureCoordMatrix = null;
-                this[`get${capName}TextureUniform`] = function(scope) {
-                    return scope.$builder.shaderKind === 'fragment' ? scope[`kk${capName}Tex`] : null;
-                };
-                this[`get${capName}TexCoord`] = function(scope) {
-                    return scope.$builder.shaderKind === 'fragment' ? scope[`kk${capName}TexCoord`] : scope.$outputs[`kk${capName}TexCoord`];
-                };
-                Object.defineProperty(this, `${name}Texture`, {
-                    get: ()=>textureValue,
-                    set: (newValue)=>{
-                        if (textureValue !== newValue) {
-                            textureValue = newValue ?? null;
-                            this.useFeature(feature, !!textureValue);
-                            if (textureValue) {
-                                this.useFeature(featureTexIndex, textureCoordIndex);
-                                this.useFeature(featureTexMatrix, !!textureCoordMatrix);
-                                this.optionChanged(false);
-                            }
-                        }
-                        textureValue = newValue;
-                    },
-                    enumerable: true,
-                    configurable: true
-                });
-                Object.defineProperty(this, `${name}TextureSampler`, {
-                    get: ()=>textureSampler,
-                    set: (newValue)=>null,
-                    enumerable: true,
-                    configurable: true
-                });
-                Object.defineProperty(this, `${name}TexCoordIndex`, {
-                    get: ()=>textureCoordMatrix,
-                    set: (newValue)=>{
-                        if (textureCoordMatrix !== newValue) {
-                            textureCoordMatrix = newValue;
-                            if (textureValue) {
-                                this.useFeature(featureTexMatrix, !!textureCoordMatrix);
-                            }
-                        }
-                    },
-                    enumerable: true,
-                    configurable: true
-                });
-                Object.defineProperty(this, `${name}TexCoordMatrix`, {
-                    get: ()=>textureCoordIndex,
-                    set: (newValue)=>{
-                        if (textureCoordIndex !== newValue) {
-                            textureCoordIndex = newValue;
-                            if (textureValue) {
-                                this.useFeature(featureTexIndex, textureCoordIndex);
-                            }
-                        }
-                    },
-                    enumerable: true,
-                    configurable: true
-                });
-            }
-            vertexShader(scope, ctx) {
-                super.vertexShader(scope, ctx);
-                if (this.needFragmentColor(ctx)) {
-                    const pb = scope.$builder;
-                    if (this.featureUsed(feature, ctx.renderPass.type)) {
-                        const semantic = `texCoord${this[`${name}TexCoordIndex`]}`;
-                        if (!scope.$getVertexAttrib(semantic)) {
-                            scope.$inputs[semantic] = pb.vec2().attrib(semantic);
-                        }
-                        if (this.featureUsed(featureTexMatrix, ctx.renderPass.type)) {
-                            scope.$g[`kk${capName}TextureMatrix`] = pb.mat4().uniform(2);
-                            scope.$outputs[`kk${capName}TexCoord`] = pb.mul(scope[`kk${capName}TextureMatrix`], pb.vec4(scope.$inputs[semantic], 0, 1)).xy;
-                        } else {
-                            scope.$outputs[`kk${capName}TexCoord`] = scope.$inputs[semantic];
-                        }
-                    }
-                }
-            }
-            fragmentShader(scope, ctx) {
-                super.fragmentShader(scope, ctx);
-                if (this.needFragmentColor(ctx)) {
-                    const pb = scope.$builder;
-                    if (this.featureUsed(feature, ctx.renderPass.type)) {
-                        scope.$g[`kk${capName}Tex`] = pb.tex2D().uniform(2);
-                    }
-                }
-            }
-        };
-        cls[id] = true;
-        cls[`FEATURE_TEXTURE_${upperName}`] = feature;
-        return cls;
-    };
-}
-
-export { mixinTextureProps };
-//# sourceMappingURL=texture.js.map

package/dist/material/mixins/texture.js.map

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