@zephyr3d/scene 0.1.0

package/dist/index.js

@@ -0,0 +1,87 @@
+export { prefilterCubemap } from './utility/pmrem.js';
+export { panoramaToCubemap } from './utility/panorama.js';
+export { projectCubemap, projectCubemapCPU } from './utility/shprojection.js';
+export { AABBTree } from './utility/aabbtree.js';
+export { BoundingBox, BoundingBoxTree } from './utility/bounding_volume.js';
+export { Shape } from './shapes/shape.js';
+export { BoxFrameShape, BoxShape } from './shapes/box.js';
+export { CylinderShape } from './shapes/cylinder.js';
+export { TorusShape } from './shapes/torus.js';
+export { PlaneShape } from './shapes/plane.js';
+export { SphereShape } from './shapes/sphere.js';
+export { RenderScheme } from './render/renderscheme.js';
+export { RenderPass } from './render/renderpass.js';
+export { ForwardRenderScheme } from './render/forward.js';
+export { ForwardRenderPass } from './render/forward_pass.js';
+export { ShadowMapPass } from './render/shadowmap_pass.js';
+export { DepthRenderPass } from './render/depth_pass.js';
+export { RenderQueue } from './render/render_queue.js';
+export { SkyRenderer } from './render/sky.js';
+export { Clipmap } from './render/clipmap.js';
+export { EnvConstantAmbient, EnvHemisphericAmbient, EnvIBL, EnvironmentLighting } from './render/envlight.js';
+export { Primitive } from './render/primitive.js';
+export { CullVisitor } from './render/cull_visitor.js';
+export { TemporalCache } from './render/temporalcache.js';
+export { WaterMesh, defaultBuildParams } from './render/watermesh.js';
+export { StandardMaterial } from './material/standard.js';
+export { LambertMaterial } from './material/lambert.js';
+export { BlinnMaterial } from './material/blinn.js';
+export { UnlitMaterial } from './material/unlit.js';
+export { PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial } from './material/pbr.js';
+export { BlinnLightModel, LambertLightModel, LightModel, PBRLightModelBase, PBRLightModelMR, PBRLightModelSG, UnlitLightModel } from './material/lightmodel.js';
+export { Material } from './material/material.js';
+export { GrassMaterial } from './material/grassmaterial.js';
+export { MAX_DETAIL_TEXTURE_LEVELS, TerrainMaterial } from './material/terrainmaterial.js';
+export { Scene, SceneUpdateEvent } from './scene/scene.js';
+export { EnvLightWrapper, Environment } from './scene/environment.js';
+export { GraphNode } from './scene/graph_node.js';
+export { BaseLight, DirectionalLight, PointLight, PunctualLight, SpotLight } from './scene/light.js';
+export { Mesh } from './scene/mesh.js';
+export { Model } from './scene/model.js';
+export { Octree, OctreeNode, OctreeNodeChunk, OctreePlacement } from './scene/octree.js';
+export { SceneNode } from './scene/scene_node.js';
+export { Terrain } from './scene/terrain/terrain.js';
+export { HeightField, HeightfieldBBoxTree } from './scene/terrain/heightfield.js';
+export { TerrainPatch } from './scene/terrain/patch.js';
+export { Quadtree, QuadtreeNode } from './scene/terrain/quadtree.js';
+export { XForm } from './scene/xform.js';
+export { AnimationClip } from './animation/animation.js';
+export { AnimationSet } from './animation/animationset.js';
+export { AnimationTrack } from './animation/animationtrack.js';
+export { TranslationTrack } from './animation/translationtrack.js';
+export { RotationTrack } from './animation/rotationtrack.js';
+export { EulerRotationTrack } from './animation/eulerrotationtrack.js';
+export { UserTrack } from './animation/usertrack.js';
+export { ScaleTrack } from './animation/scaletrack.js';
+export { Skeleton } from './animation/skeleton.js';
+export { Camera } from './camera/camera.js';
+export { OrthoCamera } from './camera/orthocamera.js';
+export { PerspectiveCamera } from './camera/perspectivecamera.js';
+export { BaseCameraController } from './camera/base.js';
+export { FPSCameraController } from './camera/fps.js';
+export { OrbitCameraController } from './camera/orbit.js';
+export { ShaderFramework } from './shaders/framework.js';
+export { calculateTBN, calculateTBNWithNormal, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, encode2HalfToRGBA, encodeColorOutput, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, gammaToLinear, linearDepthToNonLinear, linearToGamma, nonLinearDepthToLinear, nonLinearDepthToLinearNormalized } from './shaders/misc.js';
+export { noise3D, noisef, smoothNoise3D, worleyFBM, worleyNoise } from './shaders/noise.js';
+export { createProgramFFT2H, createProgramFFT2V, createProgramH0, createProgramHk, createProgramOcean, createProgramPostFFT2 } from './shaders/water.js';
+export { ShadowMapper } from './shadow/shadowmapper.js';
+export { ESM } from './shadow/esm.js';
+export { PCFPD } from './shadow/pcf_pd.js';
+export { PCFOPT } from './shadow/pcf_opt.js';
+export { VSM } from './shadow/vsm.js';
+export { AssetManager } from './asset/assetmanager.js';
+export { Blitter } from './blitter/blitter.js';
+export { GaussianBlurBlitter } from './blitter/gaussianblur.js';
+export { BoxFilterBlitter } from './blitter/box.js';
+export { CopyBlitter } from './blitter/copy.js';
+export { BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, DEBUG_CASCADED_SHADOW_MAPS, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, MAX_CLUSTERED_LIGHTS, MAX_FORWARD_LIGHT_COUNT, RENDER_PASS_TYPE_DEPTH_ONLY, RENDER_PASS_TYPE_FORWARD, RENDER_PASS_TYPE_SHADOWMAP } from './values.js';
+export { AbstractPostEffect } from './posteffect/posteffect.js';
+export { Grayscale } from './posteffect/grayscale.js';
+export { Tonemap } from './posteffect/tonemap.js';
+export { Bloom } from './posteffect/bloom.js';
+export { SAO } from './posteffect/sao.js';
+export { FXAA } from './posteffect/fxaa.js';
+export { PostWater } from './posteffect/water.js';
+export { Compositor } from './posteffect/compositor.js';
+export { AppResizeEvent, AppTickEvent, Application } from './app.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/input/inputmgr.js

@@ -0,0 +1,242 @@
+/**
+ * Input manager class
+ * @public
+ */ class InputManager {
+    _app;
+    _target;
+    _started;
+    _clickDistTolerance;
+    _clickTimeTolerance;
+    _dblclickDistTolerance;
+    _dblclickTimeTolerance;
+    _pointerDownHandler;
+    _pointerUpHandler;
+    _pointerMoveHandler;
+    _pointerCancelHandler;
+    _keyboardHandler;
+    _dragHandler;
+    _wheelHandler;
+    _captureId;
+    _middlewares;
+    _lastEventDatas;
+    /**
+   * Creates an instance of InputManager
+   * @param app
+   */ constructor(app){
+        this._app = app;
+        this._target = app.options.canvas;
+        this._started = false;
+        this._clickDistTolerance = 4 * 4;
+        this._clickTimeTolerance = 400;
+        this._dblclickDistTolerance = 4 * 4;
+        this._dblclickTimeTolerance = 400;
+        this._lastEventDatas = [];
+        this._pointerDownHandler = this._getPointerDownHandler();
+        this._pointerUpHandler = this._getPointerUpHandler();
+        this._pointerMoveHandler = this._getPointerMoveHander();
+        this._pointerCancelHandler = this._getPointerCancelHandler();
+        this._keyboardHandler = this._getKeyboardHandler();
+        this._dragHandler = this._getDragHandler();
+        this._wheelHandler = this._getWheelHandler();
+        this._captureId = -1;
+        this._middlewares = [];
+    }
+    /** @internal */ start() {
+        if (!this._started) {
+            this._started = true;
+            this._target.addEventListener('pointerdown', this._pointerDownHandler);
+            this._target.addEventListener('pointerup', this._pointerUpHandler);
+            this._target.addEventListener('pointermove', this._pointerMoveHandler);
+            this._target.addEventListener('pointercancel', this._pointerCancelHandler);
+            this._target.addEventListener('keydown', this._keyboardHandler);
+            this._target.addEventListener('keyup', this._keyboardHandler);
+            this._target.addEventListener('keypress', this._keyboardHandler);
+            this._target.addEventListener('drag', this._dragHandler);
+            this._target.addEventListener('dragenter', this._dragHandler);
+            this._target.addEventListener('dragleave', this._dragHandler);
+            this._target.addEventListener('dragstart', this._dragHandler);
+            this._target.addEventListener('dragend', this._dragHandler);
+            this._target.addEventListener('dragover', this._dragHandler);
+            this._target.addEventListener('drop', this._dragHandler);
+            this._target.addEventListener('wheel', this._wheelHandler);
+        }
+    }
+    /** @internal */ stop() {
+        if (this._started) {
+            this._started = false;
+            this._target.removeEventListener('pointerdown', this._pointerDownHandler);
+            this._target.removeEventListener('pointerup', this._pointerUpHandler);
+            this._target.removeEventListener('pointermove', this._pointerMoveHandler);
+            this._target.removeEventListener('pointercancel', this._pointerCancelHandler);
+            this._target.removeEventListener('keydown', this._keyboardHandler);
+            this._target.removeEventListener('keyup', this._keyboardHandler);
+            this._target.removeEventListener('keypress', this._keyboardHandler);
+            this._target.removeEventListener('drag', this._dragHandler);
+            this._target.removeEventListener('dragenter', this._dragHandler);
+            this._target.removeEventListener('dragleave', this._dragHandler);
+            this._target.removeEventListener('dragstart', this._dragHandler);
+            this._target.removeEventListener('dragend', this._dragHandler);
+            this._target.removeEventListener('dragover', this._dragHandler);
+            this._target.removeEventListener('drop', this._dragHandler);
+            this._target.removeEventListener('wheel', this._wheelHandler);
+            this._lastEventDatas = [];
+        }
+    }
+    /**
+   * Adds a event handler middleware.
+   *
+   * @remarks
+   * All handlers will be called in the order in which they were added
+   * until a handler returns true.
+   * If either handler returns true, the event that the Application
+   * listens to will not be triggered
+   *
+   * @param handler The event handler to be added
+   * @returns self
+   */ use(handler) {
+        if (handler) {
+            this._middlewares.push(handler);
+        }
+        return this;
+    }
+    _callMiddlewares(ev, type) {
+        for (const handler of this._middlewares){
+            if (handler(ev, type ?? ev.type)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _getPointerCancelHandler() {
+        const that = this;
+        return function(ev) {
+            const eventData = that._getPointerEventData(ev.pointerId);
+            eventData.lastDown = false;
+            eventData.lastClick = false;
+            if (!that._callMiddlewares(ev)) {
+                that._app.dispatchEvent(ev);
+            }
+        };
+    }
+    _getPointerMoveHander() {
+        const that = this;
+        return function(ev) {
+            const eventData = that._getPointerEventData(ev.pointerId);
+            eventData.lastMoveX = ev.offsetX;
+            eventData.lastMoveY = ev.offsetY;
+            if (!that._callMiddlewares(ev)) {
+                that._app.dispatchEvent(ev);
+            }
+        };
+    }
+    _getPointerDownHandler() {
+        const that = this;
+        return function(ev) {
+            if (ev.pointerType === 'mouse' && ev.button === 0) {
+                that._captureId = ev.pointerId;
+                that._app.options.canvas.setPointerCapture(ev.pointerId);
+            }
+            const eventData = that._getPointerEventData(ev.pointerId);
+            eventData.lastDown = true;
+            eventData.lastDownX = ev.offsetX;
+            eventData.lastDownY = ev.offsetY;
+            eventData.lastDownTime = Date.now();
+            that._app.focus();
+            if (!that._callMiddlewares(ev)) {
+                that._app.dispatchEvent(ev);
+            }
+        };
+    }
+    _getPointerUpHandler() {
+        const that = this;
+        return function(ev) {
+            if (ev.pointerType === 'mouse' && ev.button === 0 && that._captureId === ev.pointerId) {
+                that._app.options.canvas.releasePointerCapture(ev.pointerId);
+                that._captureId = -1;
+            }
+            const eventData = that._getPointerEventData(ev.pointerId);
+            let emitClickEvent = false;
+            let emitDoubleClickEvent = false;
+            const now = Date.now();
+            if (eventData.lastDown) {
+                if (now <= eventData.lastDownTime + that._clickTimeTolerance) {
+                    let deltaX = ev.offsetX - eventData.lastDownX;
+                    let deltaY = ev.offsetY - eventData.lastDownY;
+                    if (deltaX * deltaX + deltaY * deltaY <= that._clickDistTolerance) {
+                        emitClickEvent = true;
+                        if (eventData.lastClick && now <= eventData.lastClickTime + that._dblclickTimeTolerance) {
+                            deltaX = ev.offsetX - eventData.lastClickX;
+                            deltaY = ev.offsetY - eventData.lastClickY;
+                            if (deltaX * deltaX + deltaY * deltaY <= that._dblclickDistTolerance) {
+                                emitDoubleClickEvent = true;
+                            }
+                        }
+                    }
+                }
+            }
+            eventData.lastDown = false;
+            eventData.lastMoveX = ev.offsetX;
+            eventData.lastMoveY = ev.offsetY;
+            if (!that._callMiddlewares(ev)) {
+                that._app.dispatchEvent(ev);
+            }
+            if (emitClickEvent) {
+                if (!that._callMiddlewares(ev, 'click')) {
+                    that._app.dispatchEvent(ev, 'click');
+                }
+                if (emitDoubleClickEvent) {
+                    if (!that._callMiddlewares(ev, 'dblclick')) {
+                        that._app.dispatchEvent(ev, 'dblclick');
+                    }
+                    eventData.lastClick = false;
+                } else {
+                    eventData.lastClick = true;
+                    eventData.lastClickX = ev.offsetX;
+                    eventData.lastClickY = ev.offsetY;
+                    eventData.lastClickTime = now;
+                }
+            }
+        };
+    }
+    _getKeyboardHandler() {
+        const that = this;
+        return function(ev) {
+            if (!that._callMiddlewares(ev)) {
+                that._app.dispatchEvent(ev);
+            }
+        };
+    }
+    _getDragHandler() {
+        const that = this;
+        return function(ev) {
+            if (!that._callMiddlewares(ev)) {
+                that._app.dispatchEvent(ev);
+            }
+        };
+    }
+    _getWheelHandler() {
+        const that = this;
+        return function(ev) {
+            if (!that._callMiddlewares(ev)) {
+                that._app.dispatchEvent(ev);
+            }
+        };
+    }
+    _getPointerEventData(pointerId) {
+        return this._lastEventDatas[pointerId] ?? (this._lastEventDatas[pointerId] = {
+            lastClick: false,
+            lastClickX: 0,
+            lastClickY: 0,
+            lastClickTime: 0,
+            lastDown: false,
+            lastDownX: 0,
+            lastDownY: 0,
+            lastDownTime: 0,
+            lastMoveX: 0,
+            lastMoveY: 0
+        });
+    }
+}
+
+export { InputManager };
+//# sourceMappingURL=inputmgr.js.map

package/dist/input/inputmgr.js.map

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

package/dist/material/blinn.js

@@ -0,0 +1,75 @@
+import { applyMaterialMixins } from './meshmaterial.js';
+import { LitMaterial } from './lit.js';
+import { mixinVertexColor } from './mixins/vertexcolor.js';
+import { mixinAlbedoColor } from './mixins/albedocolor.js';
+
+class BlinnMaterial extends applyMaterialMixins(LitMaterial, mixinVertexColor, mixinAlbedoColor) {
+    _shininess;
+    constructor(){
+        super();
+        this._shininess = 32;
+    }
+    /** Shininess */ get shininess() {
+        return this._shininess;
+    }
+    set shininess(val) {
+        if (val !== this._shininess) {
+            this._shininess = val;
+            this.optionChanged(false);
+        }
+    }
+    applyUniformValues(bindGroup, ctx) {
+        super.applyUniformValues(bindGroup, ctx);
+        if (this.needFragmentColor(ctx)) {
+            bindGroup.setValue('kkShininess', this._shininess);
+        }
+    }
+    vertexShader(scope, ctx) {
+        super.vertexShader(scope, ctx);
+        scope.$inputs.zPos = scope.$builder.vec3().attrib('position');
+        this.transformVertexAndNormal(scope);
+    }
+    fragmentShader(scope, ctx) {
+        super.fragmentShader(scope, ctx);
+        const pb = scope.$builder;
+        const that = this;
+        if (this.needFragmentColor(ctx)) {
+            scope.$g.kkShininess = scope.$builder.float().uniform(2);
+            scope.$l.albedo = this.calculateAlbedoColor(scope, ctx);
+            if (this.vertexColor) {
+                scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope, ctx));
+            }
+            scope.$l.diffuseColor = pb.vec3(0);
+            scope.$l.specularColor = pb.vec3(0);
+            scope.$l.normal = this.calculateNormal(scope, ctx);
+            if (this.needCalculateEnvLight(ctx)) {
+                scope.diffuseColor = pb.add(scope.diffuseColor, this.getEnvLightIrradiance(scope, scope.normal, ctx));
+            }
+            this.forEachLight(scope, ctx, function(type, posRange, dirCutoff, colorIntensity, shadow) {
+                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.viewVec = that.calculateViewVector(this);
+                this.$l.halfVec = pb.normalize(pb.add(this.viewVec, this.lightDir));
+                this.$l.NoH = pb.clamp(pb.dot(this.normal, this.halfVec), 0, 1);
+                this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten);
+                this.$l.diffuse = pb.mul(this.lightColor, this.NoL);
+                this.$l.specular = pb.mul(this.lightColor, pb.pow(this.NoH, this.kkShininess));
+                if (shadow) {
+                    this.$l.shadow = pb.vec3(that.calculateShadow(this, this.NoL, ctx));
+                    this.diffuse = pb.mul(this.diffuse, this.shadow);
+                    this.specular = pb.mul(this.specular, this.shadow);
+                }
+                this.diffuseColor = pb.add(this.diffuseColor, this.diffuse);
+                this.specularColor = pb.add(this.specularColor, this.specular);
+            });
+            scope.$l.litColor = pb.add(pb.mul(scope.albedo, pb.vec4(scope.diffuseColor, 1)), pb.vec4(scope.specularColor, 0));
+            this.outputFragmentColor(scope, scope.litColor, ctx);
+        } else {
+            this.outputFragmentColor(scope, null, ctx);
+        }
+    }
+}
+
+export { BlinnMaterial };
+//# sourceMappingURL=blinn.js.map

package/dist/material/blinn.js.map

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

package/dist/material/grassmaterial.js

@@ -0,0 +1,221 @@
+import { Material } from './material.js';
+import { forwardComputeLighting } from '../shaders/lighting.js';
+import { RENDER_PASS_TYPE_FORWARD, RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH_ONLY } from '../values.js';
+import { ShaderFramework } from '../shaders/framework.js';
+import { nonLinearDepthToLinearNormalized, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
+import { Application } from '../app.js';
+import { MESH_MATERIAL } from '../shaders/builtins.js';
+import './lambert.js';
+import './blinn.js';
+import './unlit.js';
+import { PBRLightModelMR } from './lightmodel.js';
+import { Vector4, Vector2 } from '@zephyr3d/base';
+
+/**
+ * The terrain material
+ * @public
+ */ class GrassMaterial extends Material {
+    /** @internal */ _lightModel;
+    /** @internal */ _terrainSize;
+    /** @internal */ _normalMap;
+    /** @internal */ _textureSize;
+    /** @internal */ _useAlphaToCoverage;
+    /**
+   * Creates an instance of TerrainMaterial
+   */ constructor(terrainSize, normalMap, grassTexture){
+        super();
+        this._lightModel = new PBRLightModelMR();
+        this._lightModel.metallic = 0;
+        this._lightModel.roughness = 1;
+        this._lightModel.specularFactor = new Vector4(1, 1, 1, 0.2);
+        this._lightModel.doubleSideLighting = false;
+        this._terrainSize = terrainSize;
+        this._normalMap = normalMap;
+        this._textureSize = Vector2.one();
+        this._useAlphaToCoverage = false;
+        if (grassTexture) {
+            this._lightModel.setAlbedoMap(grassTexture, null, 0);
+            this._textureSize.setXY(grassTexture.width, grassTexture.height);
+        }
+    }
+    /** enable alpha to coverage */ get alphaToCoverage() {
+        return this._useAlphaToCoverage;
+    }
+    set alphaToCoverage(val) {
+        if (this._useAlphaToCoverage !== !!val) {
+            this._useAlphaToCoverage = !!val;
+            if (this._useAlphaToCoverage) {
+                this.stateSet.useBlendingState().enableAlphaToCoverage(true);
+            } else {
+                this.stateSet.defaultBlendingState();
+            }
+            this.optionChanged(true);
+        }
+    }
+    /** Light model */ get lightModel() {
+        return this._lightModel;
+    }
+    /** Base map */ get colorMap() {
+        return this._lightModel.albedoMap;
+    }
+    set colorMap(tex) {
+        this._lightModel.setAlbedoMap(tex, null, 0);
+    }
+    /** Color */ get color() {
+        return this._lightModel.albedo;
+    }
+    set color(val) {
+        this._lightModel.albedo = val;
+    }
+    /**
+   * {@inheritDoc Material.isTransparent}
+   * @override
+   */ isTransparent() {
+        return false;
+    }
+    /**
+   * {@inheritDoc Material.supportLighting}
+   * @override
+   */ supportLighting() {
+        return this._lightModel.supportLighting();
+    }
+    /**
+   * {@inheritDoc Material.applyUniforms}
+   * @override
+   */ applyUniforms(bindGroup, ctx, needUpdate) {
+        super.applyUniforms(bindGroup, ctx, needUpdate);
+        this._lightModel.applyUniformsIfOutdated(bindGroup, ctx);
+    }
+    /**
+   * {@inheritDoc Material._applyUniforms}
+   * @override
+   */ _applyUniforms(bindGroup, ctx) {
+        bindGroup.setValue('terrainSize', this._terrainSize);
+        bindGroup.setTexture('terrainNormalMap', this._normalMap);
+        bindGroup.setValue('albedoTextureSize', this._textureSize);
+    }
+    /** @internal */ getHash(renderPassType) {
+        if (this._hash[renderPassType] === void 0 || !this._lightModel.peekHash()) {
+            this._hash[renderPassType] = this.createHash(renderPassType);
+        }
+        return this._hash[renderPassType];
+    }
+    /** @internal */ _createHash(renderPassType) {
+        return renderPassType === RENDER_PASS_TYPE_FORWARD ? `${Number(this._useAlphaToCoverage)}:${this._lightModel.getHash()}` : `${Number(this._useAlphaToCoverage)}`;
+    }
+    /** @internal */ _createProgram(pb, ctx) {
+        const that = this;
+        if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {
+            const shadowMapParams = ctx.shadowMapInfo.get(ctx.renderPass.light);
+            pb.emulateDepthClamp = !!shadowMapParams.depthClampEnabled;
+        }
+        const program = pb.buildRenderProgram({
+            vertex (pb) {
+                ShaderFramework.prepareVertexShader(pb, ctx);
+                this.$inputs.pos = pb.vec3().attrib('position');
+                this.$inputs.uv = pb.vec2().attrib('texCoord0');
+                this.$inputs.placement = pb.vec4().attrib('texCoord1');
+                this.terrainNormalMap = pb.tex2D().uniform(2);
+                this.terrainSize = pb.vec2().uniform(2);
+                that._lightModel.setupUniforms(this, ctx);
+                pb.main(function() {
+                    this.$l.normalSample = pb.getDevice().type === 'webgl' ? pb.textureSample(this.terrainNormalMap, pb.div(this.$inputs.placement.xz, this.terrainSize)).rgb : pb.textureSampleLevel(this.terrainNormalMap, pb.div(this.$inputs.placement.xz, this.terrainSize), 0).rgb;
+                    this.$l.normal = pb.normalize(pb.sub(pb.mul(this.normalSample, 2), pb.vec3(1)));
+                    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.$inputs.pos);
+                    this.$l.p = pb.vec4(pb.add(this.rotPos, this.$inputs.placement.xyz), 1);
+                    this.$outputs.texcoord0 = this.$inputs.uv;
+                    this.$outputs.worldPosition = pb.mul(ShaderFramework.getWorldMatrix(this), this.$l.p).tag(ShaderFramework.USAGE_WORLD_POSITION);
+                    ShaderFramework.setClipSpacePosition(this, pb.mul(ShaderFramework.getViewProjectionMatrix(this), this.$outputs.worldPosition));
+                    if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+                        this.$outputs.worldNormal = pb.normalize(pb.mul(ShaderFramework.getWorldMatrix(this), pb.vec4(this.normal, 0)).xyz).tag(ShaderFramework.USAGE_WORLD_NORMAL);
+                        this.$outputs.outVertexColor = pb.vec4(1, 1, 1, 1).tag(ShaderFramework.USAGE_VERTEX_COLOR);
+                    }
+                });
+            },
+            fragment (pb) {
+                ShaderFramework.prepareFragmentShader(pb, ctx);
+                that._lightModel.setupUniforms(this, ctx);
+                this.albedoTextureSize = pb.vec2().uniform(2);
+                this.$outputs.outColor = pb.vec4();
+                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)));
+                });
+                if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+                    pb.main(function() {
+                        this.$l.litColor = forwardComputeLighting(this, that._lightModel, ctx);
+                        MESH_MATERIAL.DISCARD_IF_CLIPPED(this);
+                        this.$l.a = pb.mul(this.litColor.a, pb.add(1, pb.mul(pb.max(0, this.calcMipLevel(pb.mul(this.$inputs.texcoord0, this.albedoTextureSize))), 0.25)));
+                        if (that._useAlphaToCoverage) {
+                            // alpha to coverage
+                            this.a = pb.add(pb.div(pb.sub(this.litColor.a, 0.4), pb.max(pb.fwidth(this.litColor.a), 0.0001)), 0.5);
+                            this.litColor = pb.vec4(this.litColor.rgb, this.a); //pb.vec4(pb.mul(this.litColor.rgb, this.litColor.a), this.litColor.a);
+                        } else {
+                            // alpha test
+                            this.$if(pb.lessThan(this.a, 0.8), function() {
+                                pb.discard();
+                            });
+                        }
+                        MESH_MATERIAL.APPLY_FOG(this, this.litColor, ctx);
+                        this.$outputs.outColor = MESH_MATERIAL.FRAGMENT_OUTPUT(this, this.litColor);
+                    });
+                } else if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH_ONLY) {
+                    pb.main(function() {
+                        this.$l.litColor = that._lightModel.calculateAlbedo(this);
+                        MESH_MATERIAL.DISCARD_IF_CLIPPED(this);
+                        this.$l.a = pb.mul(this.litColor.a, pb.add(1, pb.mul(pb.max(0, this.calcMipLevel(pb.mul(this.$inputs.texcoord0, this.albedoTextureSize))), 0.25)));
+                        if (that._useAlphaToCoverage) {
+                            // alpha to coverage
+                            this.a = pb.add(pb.div(pb.sub(this.litColor.a, 0.4), pb.max(pb.fwidth(this.litColor.a), 0.0001)), 0.5);
+                            this.litColor = pb.vec4(this.litColor.rgb, this.a); //pb.vec4(pb.mul(this.litColor.rgb, this.litColor.a), this.litColor.a);
+                        } else {
+                            // alpha test
+                            this.$if(pb.lessThan(this.a, 0.8), function() {
+                                pb.discard();
+                            });
+                        }
+                        this.$l.depth = nonLinearDepthToLinearNormalized(this, this.$builtins.fragCoord.z);
+                        if (Application.instance.device.type === 'webgl') {
+                            this.$outputs.outColor = encodeNormalizedFloatToRGBA(this, this.depth);
+                        } else {
+                            this.$outputs.outColor = pb.vec4(this.depth, 0, 0, this.a);
+                        }
+                    });
+                } else if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {
+                    pb.main(function() {
+                        this.$l.litColor = that._lightModel.calculateAlbedo(this);
+                        MESH_MATERIAL.DISCARD_IF_CLIPPED(this);
+                        this.$l.a = pb.mul(this.litColor.a, pb.add(1, pb.mul(pb.max(0, this.calcMipLevel(pb.mul(this.$inputs.texcoord0, this.albedoTextureSize))), 0.25)));
+                        if (that._useAlphaToCoverage) {
+                            // alpha to coverage
+                            this.a = pb.add(pb.div(pb.sub(this.litColor.a, 0.4), pb.max(pb.fwidth(this.litColor.a), 0.0001)), 0.5);
+                            this.litColor = pb.vec4(this.litColor.rgb, this.a); //pb.vec4(pb.mul(this.litColor.rgb, this.litColor.a), this.litColor.a);
+                        } else {
+                            // alpha test
+                            this.$if(pb.lessThan(this.a, 0.8), function() {
+                                pb.discard();
+                            });
+                        }
+                        const shadowMapParams = ctx.shadowMapInfo.get(ctx.renderPass.light);
+                        this.$outputs.outColor = shadowMapParams.impl.computeShadowMapDepth(shadowMapParams, this);
+                    });
+                } else {
+                    throw new Error(`unknown render pass type: ${ctx.renderPass.type}`);
+                }
+            }
+        });
+        // console.log(program?.getShaderSource('vertex'));
+        // console.log(program?.getShaderSource('fragment'));
+        return program;
+    }
+}
+
+export { GrassMaterial };
+//# sourceMappingURL=grassmaterial.js.map

package/dist/material/grassmaterial.js.map

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