@zephyr3d/scene 0.1.0

package/dist/scene/xform.js

@@ -0,0 +1,224 @@
+import { ObservableVector3, ObservableQuaternion, Matrix4x4, Vector3, Vector4 } from '@zephyr3d/base';
+
+/**
+ * Presents a transformation from one space to another
+ * @public
+ */ class XForm {
+    /** @internal */ _parent;
+    /** @internal */ _children;
+    /** @internal */ _position;
+    /** @internal */ _scaling;
+    /** @internal */ _rotation;
+    /** @internal */ _localMatrix;
+    /** @internal */ _worldMatrix;
+    /** @internal */ _worldMatrixDet;
+    /** @internal */ _invWorldMatrix;
+    /** @internal */ _tmpLocalMatrix;
+    /** @internal */ _tmpWorldMatrix;
+    /** @internal */ _transformTag;
+    /**
+   * Creates an instance of XForm
+   */ constructor(){
+        this._parent = null;
+        this._children = [];
+        const cb = ()=>{
+            this._onTransformChanged(true);
+        };
+        this._position = new ObservableVector3(0, 0, 0);
+        this._position.callback = cb;
+        this._scaling = new ObservableVector3(1, 1, 1);
+        this._scaling.callback = cb;
+        this._rotation = new ObservableQuaternion();
+        this._rotation.callback = cb;
+        this._worldMatrix = null;
+        this._worldMatrixDet = null;
+        this._invWorldMatrix = null;
+        this._localMatrix = null;
+        this._transformTag = 0;
+        this._tmpLocalMatrix = Matrix4x4.identity();
+        this._tmpWorldMatrix = Matrix4x4.identity();
+    }
+    /** Parent of the xform */ get parent() {
+        return this._parent;
+    }
+    set parent(p) {
+        p = p || null;
+        if (p !== this._parent) {
+            this._setParent(p);
+        }
+    }
+    /** Children of this xform */ get children() {
+        return this._children;
+    }
+    /**
+   * Resets the transformation matrix
+   * @returns self
+   */ resetTransform() {
+        this._position.setXYZ(0, 0, 0);
+        this._rotation.identity();
+        this._scaling.setXYZ(1, 1, 1);
+        return this;
+    }
+    /**
+   * Position of the xform relative to it's parent
+   */ get position() {
+        return this._position;
+    }
+    set position(val) {
+        this._position.setXYZ(val[0], val[1], val[2]);
+    }
+    worldToThis(v, result) {
+        if (v instanceof Vector3) {
+            result = result || new Vector3();
+            this.invWorldMatrix.transformPointAffine(v, result);
+            return result;
+        } else {
+            result = result || new Vector4();
+            this.invWorldMatrix.transformAffine(v, result);
+            return result;
+        }
+    }
+    otherToThis(other, v, result) {
+        return this.worldToThis(other.thisToWorld(v, result), result);
+    }
+    thisToWorld(v, result) {
+        if (v instanceof Vector3) {
+            result = result || new Vector3();
+            this.worldMatrix.transformPointAffine(v, result);
+            return result;
+        } else {
+            result = result || new Vector4();
+            this.worldMatrix.transformAffine(v, result);
+            return result;
+        }
+    }
+    thisToOther(other, v, result) {
+        return other.worldToThis(this.thisToWorld(v, result), result);
+    }
+    /**
+   * Gets the position of the xform in world space
+   * @returns position of the xform in world space
+   */ getWorldPosition() {
+        return new Vector3(this.worldMatrix.m03, this.worldMatrix.m13, this.worldMatrix.m23);
+    }
+    /**
+   * Moves the xform by an offset vector
+   * @param delta - The offset vector
+   * @returns self
+   */ moveBy(delta) {
+        this._position.addBy(delta);
+        return this;
+    }
+    /**
+   * Scales the xform by a given scale factor
+   * @param factor - The scale factor
+   * @returns self
+   */ scaleBy(factor) {
+        this._scaling.mulBy(factor);
+        return this;
+    }
+    /**
+   * Scaling of the xform
+   */ get scale() {
+        return this._scaling;
+    }
+    set scale(val) {
+        this._scaling.setXYZ(val[0], val[1], val[2]);
+    }
+    /**
+   * Rotation of the xform
+   */ get rotation() {
+        return this._rotation;
+    }
+    set rotation(val) {
+        this._rotation.setXYZW(val[0], val[1], val[2], val[3]);
+    }
+    /**
+   * Sets the local transform matrix of the xform
+   * @param m - The transform matrix to set
+   * @returns self
+   */ setLocalTransform(m) {
+        m.decompose(this._scaling, this._rotation, this._position);
+        return this;
+    }
+    /** Local transformation matrix of the xform */ get localMatrix() {
+        if (!this._localMatrix) {
+            this._localMatrix = this._tmpLocalMatrix;
+            this._localMatrix.scaling(this._scaling).rotateLeft(new Matrix4x4(this._rotation)).translateLeft(this._position);
+        }
+        return this._localMatrix;
+    }
+    /** World transformation matrix of the xform */ get worldMatrix() {
+        if (!this._worldMatrix) {
+            this._worldMatrix = this._tmpWorldMatrix;
+            if (this._parent) {
+                Matrix4x4.multiplyAffine(this._parent.worldMatrix, this.localMatrix, this._worldMatrix);
+            } else {
+                this._worldMatrix.set(this.localMatrix);
+            }
+        }
+        return this._worldMatrix;
+    }
+    /** The determinant of world matrix */ get worldMatrixDet() {
+        if (this._worldMatrixDet === null) {
+            this._worldMatrixDet = this.worldMatrix.det();
+        }
+        return this._worldMatrixDet;
+    }
+    /** Inverse of the world transformation matrix of the xform */ get invWorldMatrix() {
+        if (!this._invWorldMatrix) {
+            this._invWorldMatrix = Matrix4x4.invertAffine(this.worldMatrix);
+        }
+        return this._invWorldMatrix;
+    }
+    /**
+   * Sets the local tranformation matrix by a look-at matrix
+   * @param eye - The eye position used to make the look-at matrix
+   * @param target - The target position used to make the look-at matrix
+   * @param up - The up vector used to make the look-at matrix
+   * @returns self
+   */ lookAt(eye, target, up) {
+        Matrix4x4.lookAt(eye, target, up).decompose(this._scaling, this._rotation, this._position);
+        return this;
+    }
+    /**
+   * Removes this node from it's parent and add this node to another parent node if required
+   * @param p - The new parent node that this node should be added to or null
+   * @returns self
+   */ reparent(p) {
+        this.parent = p;
+        return this;
+    }
+    /** @internal */ getTag() {
+        return this._transformTag;
+    }
+    /** @internal */ _onTransformChanged(invalidateLocal) {
+        if (invalidateLocal) {
+            this._localMatrix = null;
+        }
+        if (this._worldMatrix) {
+            this._worldMatrix = null;
+            this._invWorldMatrix = null;
+            this._transformTag++;
+            for (const child of this._children){
+                child._onTransformChanged(false);
+            }
+        }
+        this._worldMatrixDet = null;
+    }
+    /** @internal */ _setParent(p) {
+        if (this._parent !== p) {
+            if (this._parent) {
+                this._parent._children.splice(this._parent._children.indexOf(this), 1);
+            }
+            this._parent = p;
+            if (this._parent) {
+                this._parent._children.push(this);
+            }
+            this._onTransformChanged(false);
+        }
+    }
+}
+
+export { XForm };
+//# sourceMappingURL=xform.js.map

package/dist/scene/xform.js.map

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

package/dist/shaders/builtins.js

@@ -0,0 +1,110 @@
+import { ShaderFramework } from './framework.js';
+import { encodeColorOutput } from './misc.js';
+import '../app.js';
+import { ScatteringLut } from '../render/scatteringlut.js';
+
+const MESH_MATERIAL = {
+    FRAGMENT_SHADER (scope, ctx) {
+        ShaderFramework.prepareFragmentShader(scope.$builder, ctx);
+    },
+    VERTEX_SHADER (scope, ctx) {
+        ShaderFramework.prepareVertexShader(scope.$builder, ctx);
+    },
+    FTRANSFORM (scope) {
+        ShaderFramework.ftransform(scope);
+    },
+    DEFINE_VERTEX_COLOR (color) {
+        return color.tag(ShaderFramework.USAGE_VERTEX_COLOR);
+    },
+    DEFINE_WORLD_NORMAL (normal) {
+        return normal.tag(ShaderFramework.USAGE_WORLD_NORMAL);
+    },
+    DEFINE_WORLD_TANGENT (tangent) {
+        return tangent.tag(ShaderFramework.USAGE_WORLD_TANGENT);
+    },
+    DEFINE_WORLD_BINORMAL (binormal) {
+        return binormal.tag(ShaderFramework.USAGE_WORLD_BINORMAL);
+    },
+    DEFINE_WORLD_POSITION (pos) {
+        return pos.tag(ShaderFramework.USAGE_WORLD_POSITION);
+    },
+    FRAGMENT_OUTPUT (scope, color) {
+        return encodeColorOutput(scope, color);
+    },
+    GET_WORLD_MATRIX (scope) {
+        return ShaderFramework.getWorldMatrix(scope);
+    },
+    GET_VIEW_PROJ_MATRIX (scope) {
+        return ShaderFramework.getViewProjectionMatrix(scope);
+    },
+    GET_ENVLIGHT_STRENGTH (scope) {
+        return ShaderFramework.getEnvLightStrength(scope);
+    },
+    GET_CAMERA_POSITION (scope) {
+        return ShaderFramework.getCameraPosition(scope);
+    },
+    GET_CAMERA_PARAMS (scope) {
+        return ShaderFramework.getCameraParams(scope);
+    },
+    GET_WORLD_POSITION (scope) {
+        return ShaderFramework.getWorldPosition(scope);
+    },
+    GET_WORLD_NORMAL (scope) {
+        return ShaderFramework.getWorldNormal(scope);
+    },
+    GET_WORLD_TANGENT (scope) {
+        return ShaderFramework.getWorldTangent(scope);
+    },
+    GET_WORLD_BINORMAL (scope) {
+        return ShaderFramework.getWorldBinormal(scope);
+    },
+    SET_CLIP_SPACE_POSITION (scope, pos) {
+        ShaderFramework.setClipSpacePosition(scope, pos);
+    },
+    DISCARD_IF_CLIPPED (scope) {
+        ShaderFramework.discardIfClipped(scope);
+    },
+    APPLY_FOG (scope, color, ctx) {
+        if (ctx.applyFog) {
+            const pb = scope.$builder;
+            if (ctx.env.sky.drawScatteredFog(ctx)) {
+                const funcName = 'applyAerialPerspective';
+                pb.func(funcName, [
+                    pb.vec4('color').inout()
+                ], function() {
+                    this.$l.viewDir = pb.sub(ShaderFramework.getWorldPosition(this).xyz, ShaderFramework.getCameraPosition(this));
+                    this.viewDir.y = pb.max(this.viewDir.y, 0);
+                    this.$l.distance = pb.mul(pb.length(this.viewDir), ShaderFramework.getWorldUnit(this));
+                    this.$l.sliceDist = pb.div(pb.mul(ShaderFramework.getCameraParams(this).y, ShaderFramework.getWorldUnit(this)), ScatteringLut.aerialPerspectiveSliceZ);
+                    this.$l.slice0 = pb.floor(pb.div(this.distance, this.sliceDist));
+                    this.$l.slice1 = pb.add(this.slice0, 1);
+                    this.$l.factor = pb.sub(pb.div(this.distance, this.sliceDist), this.slice0);
+                    this.$l.viewNormal = pb.normalize(this.viewDir);
+                    this.$l.zenithAngle = pb.asin(this.viewNormal.y);
+                    this.$l.horizonAngle = pb.atan2(this.viewNormal.z, this.viewNormal.x);
+                    this.$l.u0 = pb.div(pb.add(this.slice0, pb.div(this.horizonAngle, Math.PI * 2)), ScatteringLut.aerialPerspectiveSliceZ);
+                    this.$l.u1 = pb.add(this.u0, 1 / ScatteringLut.aerialPerspectiveSliceZ);
+                    this.$l.v = pb.div(this.zenithAngle, Math.PI / 2);
+                    this.$l.t0 = pb.textureSampleLevel(ShaderFramework.getAerialPerspectiveLUT(this), pb.vec2(this.u0, this.v), 0);
+                    this.$l.t1 = pb.textureSampleLevel(ShaderFramework.getAerialPerspectiveLUT(this), pb.vec2(this.u1, this.v), 0);
+                    this.$l.t = pb.mix(this.t0, this.t1, this.factor);
+                    this.color = pb.vec4(pb.add(pb.mul(this.color.rgb, this.factor), this.t.rgb), this.color.a);
+                });
+                scope[funcName](color);
+            } else {
+                const funcName = 'applyFog';
+                pb.func(funcName, [
+                    pb.vec4('color').inout()
+                ], function() {
+                    this.$l.viewDir = pb.sub(ShaderFramework.getWorldPosition(this).xyz, ShaderFramework.getCameraPosition(this));
+                    this.$l.fogFactor = ShaderFramework.computeFogFactor(this, this.viewDir, ShaderFramework.getFogType(this), ShaderFramework.getFogParams(this));
+                    this.color = pb.vec4(pb.mix(this.color.rgb, ShaderFramework.getFogColor(this).rgb, pb.mul(this.fogFactor, this.color.a, this.color.a)), this.color.a);
+                });
+                scope[funcName](color);
+            }
+        }
+    }
+};
+
+export { MESH_MATERIAL };
+//# sourceMappingURL=builtins.js.map

package/dist/shaders/builtins.js.map

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