@zephyr3d/scene 0.5.0 → 0.6.1

package/dist/values.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zephyr3d/scene",
-	"version": "0.5.0",
+	"version": "0.6.1",
 	"description": "Scene API for zephyr3d",
 	"homepage": "https://github.com/gavinyork/zephyr3d#readme",
 	"type": "module",
@@ -44,8 +44,6 @@
 		"@rollup/plugin-terser": "^0.4.0",
 		"@rollup/pluginutils": "^5.0.2",
 		"@swc/core": "^1.3.62",
-		"@zephyr3d/base": "^0.1.4",
-		"@zephyr3d/device": "^0.2.3",
 		"cross-env": "^7.0.3",
 		"rollup": "^3.15.0",
 		"rollup-plugin-copy": "^3.4.0",
@@ -55,13 +53,11 @@
 		"shx": "^0.3.4",
 		"typescript": "^5.1.3"
 	},
-	"peerDependencies": {
-		"@zephyr3d/base": "^0.1.4",
-		"@zephyr3d/device": "^0.2.3"
-	},
 	"dependencies": {
+		"@types/draco3d": "^1.4.9",
 		"@webgpu/types": "^0.1.40",
-		"@types/draco3d": "^1.4.9"
+		"@zephyr3d/base": "^0.1.5",
+		"@zephyr3d/device": "^0.2.4"
 	},
 	"scripts": {
 		"clean": "shx rm -rf ./dist .tsbuildinfo",

package/dist/animation/usertrack.js

@@ -1,47 +0,0 @@
-import { Interpolator } from '@zephyr3d/base';
-import { AnimationTrack } from './animationtrack.js';
-
-const tmpValue = new Float32Array(4);
-/**
- * User-defined animation track
- * @public
- */ class UserTrack extends AnimationTrack {
-    _handler;
-    /**
-   * Create an instance of UserTrack
-   * @param mode - Interpolation mode for keyframe values
-   * @param target - Type of keyframe values
-   * @param keyFrames - Keyframe values
-   * @param handler - Handler to apply the keyframe values
-   */ constructor(mode, target, keyFrames, handler){
-        const stride = Interpolator.getTargetStride(target);
-        if (!stride) {
-            throw new Error(`UserTrack(): invalid target: ${target}`);
-        }
-        const inputs = new Float32Array(keyFrames.map((val)=>val.time));
-        const outputs = new Float32Array(keyFrames.length * stride);
-        for(let i = 0; i < keyFrames.length; i++){
-            for(let j = 0; j < stride; j++){
-                const value = keyFrames[i].value;
-                if (typeof value === 'number') {
-                    outputs[i * stride + j] = value;
-                } else if (value instanceof Float32Array) {
-                    outputs[i * stride + j] = value[j] ?? 0;
-                } else {
-                    throw new Error(`UserTrack(): invalid keyframe value: ${value}`);
-                }
-            }
-        }
-        const interpolator = new Interpolator(mode, target, inputs, outputs);
-        super(interpolator);
-        this._handler = handler;
-    }
-    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime) {
-        this._interpolator.interpolate(currentTime, tmpValue);
-        this._handler && this._handler(node, tmpValue);
-        return true;
-    }
-}
-
-export { UserTrack };
-//# sourceMappingURL=usertrack.js.map

package/dist/animation/usertrack.js.map

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

package/dist/material/grassmat.js

@@ -1,127 +0,0 @@
-import { Vector4, Vector2 } from '@zephyr3d/base';
-import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
-import { mixinLight } from './mixins/lit.js';
-import { mixinPBRMetallicRoughness } from './mixins/pbr/metallicroughness.js';
-
-class NewGrassMaterial extends applyMaterialMixins(MeshMaterial, mixinLight, mixinPBRMetallicRoughness) {
-    /** @internal */ _terrainSize;
-    /** @internal */ _terrainNormalMap;
-    /** @internal */ _textureSize;
-    constructor(terrainSize, normalMap, grassTexture){
-        super();
-        this.metallic = 0;
-        this.roughness = 1;
-        this.specularFactor = new Vector4(1, 1, 1, 0.2);
-        this.doubleSidedLighting = false;
-        this.vertexNormal = false;
-        this._terrainSize = terrainSize;
-        this._terrainNormalMap = normalMap;
-        this._textureSize = Vector2.one();
-        if (grassTexture) {
-            this.albedoTexture = grassTexture;
-            this._textureSize.setXY(grassTexture.width, grassTexture.height);
-        }
-    }
-    /**
-   * {@inheritDoc Material.isTransparent}
-   * @override
-   */ isTransparent() {
-        return false;
-    }
-    /**
-   * {@inheritDoc Material.supportLighting}
-   * @override
-   */ supportLighting() {
-        return true;
-    }
-    calculateObjectSpacePosition(scope, pos, skinMatrix) {
-        const pb = scope.$builder;
-        const funcName = 'kkGetDisplacedPosition';
-        pb.func(funcName, [
-            pb.vec3('pos'),
-            pb.vec4('placement'),
-            pb.vec3('normal')
-        ], function() {
-            this.$l.axisX = pb.vec3(1, 0, 0);
-            this.$l.axisZ = pb.cross(this.axisX, this.normal);
-            this.$l.axisX = pb.cross(this.normal, this.axisZ);
-            this.$l.rotPos = pb.mul(pb.mat3(this.axisX, this.normal, this.axisZ), this.pos);
-            this.$return(pb.add(this.rotPos, this.placement.xyz));
-        });
-        return scope.$g[funcName](scope.$inputs.pos, scope.$inputs.placement, scope.kkNormal);
-    }
-    calculateObjectSpaceNormal(scope, normal, skinMatrix) {
-        return scope.kkNormal;
-    }
-    applyUniformValues(bindGroup, ctx) {
-        super.applyUniformValues(bindGroup, ctx);
-        bindGroup.setTexture('kkTerrainNormalMap', this._terrainNormalMap);
-        bindGroup.setValue('kkTerrainSize', this._terrainSize);
-        if (this.needFragmentColor(ctx)) {
-            bindGroup.setValue('albedoTextureSize', this._textureSize);
-        }
-    }
-    vertexShader(scope) {
-        super.vertexShader(scope);
-        const pb = scope.$builder;
-        scope.$inputs.pos = pb.vec3().attrib('position');
-        scope.$inputs.placement = pb.vec4().attrib('texCoord1');
-        scope.$g.kkTerrainNormalMap = pb.tex2D().uniform(2);
-        scope.$g.kkTerrainSize = pb.vec2().uniform(2);
-        scope.$g.kkNormal = pb.vec3();
-        const normalSample = pb.textureSampleLevel(scope.kkTerrainNormalMap, pb.div(scope.$inputs.placement.xz, scope.kkTerrainSize), 0).rgb;
-        scope.kkNormal = pb.normalize(pb.sub(pb.mul(normalSample, 2), pb.vec3(1)));
-        this.transformVertexAndNormal(scope);
-    }
-    fragmentShader(scope) {
-        super.fragmentShader(scope);
-        const pb = scope.$builder;
-        const that = this;
-        if (this.needFragmentColor()) {
-            scope.$g.albedoTextureSize = pb.vec2().uniform(2);
-            pb.func('calcMipLevel', [
-                pb.vec2('coord')
-            ], function() {
-                this.$l.dx = pb.dpdx(this.coord);
-                this.$l.dy = pb.dpdy(this.coord);
-                this.$l.deltaMaxSqr = pb.max(pb.dot(this.dx, this.dx), pb.dot(this.dy, this.dy));
-                this.$return(pb.max(0, pb.mul(pb.log2(this.deltaMaxSqr), 0.5)));
-            });
-            scope.$l.albedo = this.calculateAlbedoColor(scope);
-            scope.$l.normalInfo = this.calculateNormalAndTBN(scope);
-            scope.$l.normal = scope.normalInfo.normal;
-            scope.$l.viewVec = this.calculateViewVector(scope);
-            scope.$l.pbrData = this.getCommonData(scope, scope.albedo, scope.viewVec, scope.normalInfo.TBN);
-            scope.$l.lightingColor = pb.vec3(0);
-            scope.$l.emissiveColor = this.calculateEmissiveColor(scope);
-            this.indirectLighting(scope, scope.normal, scope.viewVec, scope.pbrData, scope.lightingColor);
-            this.forEachLight(scope, function(type, posRange, dirCutoff, colorIntensity, shadow) {
-                this.$l.diffuse = pb.vec3();
-                this.$l.specular = pb.vec3();
-                this.$l.lightAtten = that.calculateLightAttenuation(this, type, posRange, dirCutoff);
-                this.$l.lightDir = that.calculateLightDirection(this, type, posRange, dirCutoff);
-                this.$l.NoL = pb.clamp(pb.dot(this.normal, this.lightDir), 0, 1);
-                this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten, this.NoL);
-                if (shadow) {
-                    this.lightColor = pb.mul(this.lightColor, that.calculateShadow(this, this.NoL));
-                }
-                that.directLighting(this, this.lightDir, this.lightColor, this.normal, this.viewVec, this.pbrData, this.lightingColor);
-            });
-            scope.$l.litColor = pb.add(scope.lightingColor, scope.emissiveColor);
-            scope.albedo.a = pb.mul(scope.albedo.a, pb.add(1, pb.mul(pb.max(0, scope.$g.calcMipLevel(pb.mul(that.getAlbedoTexCoord(scope), scope.albedoTextureSize))), 0.25)));
-            if (that.alphaToCoverage) {
-                scope.albedo.a = pb.add(pb.div(pb.sub(scope.albedo.a, 0.4), pb.max(pb.fwidth(scope.albedo.a), 0.0001)), 0.5);
-            } else {
-                scope.$if(pb.lessThan(scope.albedo.a, 0.8), function() {
-                    pb.discard();
-                });
-            }
-            this.outputFragmentColor(scope, pb.vec4(scope.litColor, scope.albedo.a));
-        } else {
-            this.outputFragmentColor(scope, null);
-        }
-    }
-}
-
-export { NewGrassMaterial };
-//# sourceMappingURL=grassmat.js.map

package/dist/material/grassmat.js.map

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