@zephyr3d/scene 0.6.1 → 0.7.0

package/dist/src/index.js

@@ -0,0 +1,120 @@
+export { prefilterCubemap } from './utility/pmrem.js';
+export { panoramaToCubemap } from './utility/panorama.js';
+export { CubemapSHProjector } from './utility/shprojector.js';
+export { AABBTree } from './utility/aabbtree.js';
+export { BoundingBox } from './utility/bounding_volume.js';
+export { copyTexture, fetchSampler } from './utility/misc.js';
+export { debugTexture } from './utility/debug.js';
+export { getBatchGroupClass } from './utility/serialization/scene/batch.js';
+export { getCameraClass, getOrthoCameraClass, getPerspectiveCameraClass } from './utility/serialization/scene/camera.js';
+export { getDirectionalLightClass, getPointLightClass, getPunctualLightClass, getSpotLightClass } from './utility/serialization/scene/light.js';
+export { getMeshClass } from './utility/serialization/scene/mesh.js';
+export { GatherVisitor, NodeHierarchy, getGraphNodeClass, getNodeHierarchyClass, getSceneNodeClass } from './utility/serialization/scene/node.js';
+export { getParticleNodeClass } from './utility/serialization/scene/particle.js';
+export { SerializationManager } from './utility/serialization/manager.js';
+export { createGradientNoiseTexture } from './utility/textures/gradientnoise.js';
+export { createRandomNoiseTexture } from './utility/textures/randomnoise.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 { TetrahedronFrameShape, TetrahedronShape } from './shapes/tetrahedron.js';
+export { RenderPass } from './render/renderpass.js';
+export { SceneRenderer } from './render/renderer.js';
+export { LightPass } from './render/lightpass.js';
+export { ShadowMapPass } from './render/shadowmap_pass.js';
+export { DepthPass } from './render/depthpass.js';
+export { InstanceBindGroupAllocator, RenderQueue } from './render/render_queue.js';
+export { SkyRenderer } from './render/sky.js';
+export { Clipmap } from './render/clipmap.js';
+export { EnvConstantAmbient, EnvHemisphericAmbient, EnvIBL, EnvShIBL, EnvironmentLighting } from './render/envlight.js';
+export { Primitive } from './render/primitive.js';
+export { CullVisitor } from './render/cull_visitor.js';
+export { WeightedBlendedOIT } from './render/weightedblended_oit.js';
+export { ABufferOIT } from './render/abuffer_oit.js';
+export { FFTWaveGenerator } from './render/fft_wavegenerator.js';
+export { GerstnerWaveGenerator } from './render/gerstner_wavegenerator.js';
+export { FBMWaveGenerator } from './render/fbm_wavegenerator.js';
+export { ShaderHelper } from './material/shader/helper.js';
+export { LambertMaterial } from './material/lambert.js';
+export { BlinnMaterial } from './material/blinn.js';
+export { UnlitMaterial } from './material/unlit.js';
+export { ParticleMaterial } from './material/particle.js';
+export { Material } from './material/material.js';
+export { MeshMaterial, applyMaterialMixins } from './material/meshmaterial.js';
+export { GrassMaterial } from './material/grassmaterial.js';
+export { TerrainMaterial } from './material/terrainmaterial.js';
+export { ClipmapTerrainMaterial } from './material/terrain-cm.js';
+export { PBRMetallicRoughnessMaterial } from './material/pbrmr.js';
+export { PBRSpecularGlossinessMaterial } from './material/pbrsg.js';
+export { mixinPBRCommon } from './material/mixins/pbr/common.js';
+export { mixinPBRMetallicRoughness } from './material/mixins/lightmodel/pbrmetallicroughness.js';
+export { mixinPBRSpecularGlossness } from './material/mixins/lightmodel/pbrspecularglossness.js';
+export { mixinBlinnPhong } from './material/mixins/lightmodel/blinnphong.js';
+export { mixinLambert } from './material/mixins/lightmodel/lambert.js';
+export { mixinAlbedoColor } from './material/mixins/albedocolor.js';
+export { mixinLight } from './material/mixins/lit.js';
+export { mixinTextureProps } from './material/mixins/texture.js';
+export { mixinVertexColor } from './material/mixins/vertexcolor.js';
+export { mixinFoliage } from './material/mixins/foliage.js';
+export { Scene } 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 { Water } from './scene/water.js';
+export { Octree, OctreeNode, OctreeNodeChunk, OctreePlacement } from './scene/octree.js';
+export { SceneNode } from './scene/scene_node.js';
+export { ParticleSystem } from './scene/particlesys.js';
+export { BatchGroup } from './scene/batchgroup.js';
+export { Terrain } from './scene/terrain/terrain.js';
+export { HeightField, HeightfieldBBoxTree } from './scene/terrain/heightfield.js';
+export { TerrainPatch, TerrainPatchBase } from './scene/terrain/patch.js';
+export { Quadtree, QuadtreeNode } from './scene/terrain/quadtree.js';
+export { ClipmapTerrain } from './scene/terrain-cm/terrain-cm.js';
+export { GrassInstances, GrassLayer, GrassQuadtreeNode, GrassRenderer } from './scene/terrain-cm/grass.js';
+export { AnimationClip } from './animation/animation.js';
+export { AnimationSet } from './animation/animationset.js';
+export { AnimationTrack } from './animation/animationtrack.js';
+export { NodeTranslationTrack } from './animation/translationtrack.js';
+export { NodeRotationTrack } from './animation/rotationtrack.js';
+export { NodeEulerRotationTrack } from './animation/eulerrotationtrack.js';
+export { NodeScaleTrack } from './animation/scaletrack.js';
+export { PropertyTrack } from './animation/proptrack.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 { decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, fetchNormalizedFloatForDevice, gammaToLinear, linearToGamma } from './shaders/misc.js';
+export { gradient, hash, interleavedGradientNoise, noise3D, perlinNoise2D, perlinNoise3D, smoothNoise3D, worleyFBM, worleyNoise } from './shaders/noise.js';
+export { WaterShaderImpl, createProgramFFT2H, createProgramFFT2V, createProgramH0, createProgramHk, createProgramOcean, createProgramPostFFT2 } from './shaders/water.js';
+export { TAA_DEBUG_ALAPH, TAA_DEBUG_CURRENT_COLOR, TAA_DEBUG_EDGE, TAA_DEBUG_HISTORY_COLOR, TAA_DEBUG_MOTION_VECTOR, TAA_DEBUG_NONE, TAA_DEBUG_STRENGTH, TAA_DEBUG_VELOCITY, temporalResolve } from './shaders/temporal.js';
+export { CAMERA_POS_Y, aerialPerspective, aerialPerspectiveLut, atmosphereLUTRendered, createAPLutProgram, createMultiScatteringLutProgram, createSkyViewLutProgram, createTransmittanceLutProgram, getAerialPerspectiveLut, getAtmosphereParamsStruct, getDefaultAtmosphereParams, getMultiScattering, getMultiScatteringLut, getSkyView, getSkyViewLut, getTransmittanceLut, integralMultiScattering, mieAbsorption, mieCoefficient, miePhase, multiScatteringLut, ozoneAbsorption, rayIntersectSphere, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, scattering, skyBox, skyViewLut, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, uvToTransmittanceLut, uvToViewDir, viewDirToUV } from './shaders/atmosphere.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 { AssetHierarchyNode, AssetScene, AssetSkeleton, NamedObject, SharedModel } from './asset/model.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 { ATMOSPHERIC_FOG_BIT, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, Fog, HEIGHT_FOG_BIT, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MaterialVaryingFlags, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, uniformSphereSamples } from './values.js';
+export { AbstractPostEffect, PostEffectLayer } 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 { TAA } from './posteffect/taa.js';
+export { Compositor } from './posteffect/compositor.js';
+export { Application } from './app/app.js';
+export { InputManager } from './app/inputmgr.js';
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

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

package/dist/src/material/blinn.js

@@ -0,0 +1,81 @@
+import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
+import { mixinVertexColor } from './mixins/vertexcolor.js';
+import { mixinBlinnPhong } from './mixins/lightmodel/blinnphong.js';
+import { ShaderHelper } from './shader/helper.js';
+import { RENDER_PASS_TYPE_LIGHT, MaterialVaryingFlags } from '../values.js';
+
+/**
+ * Blinn material
+ * @public
+ */ class BlinnMaterial extends applyMaterialMixins(MeshMaterial, mixinBlinnPhong, mixinVertexColor) {
+    /** @internal */ static FEATURE_VERTEX_NORMAL = this.defineFeature();
+    /** @internal */ static FEATURE_VERTEX_TANGENT = this.defineFeature();
+    /**
+   * Creates an instance of BlinnMaterial class
+   */ constructor(){
+        super();
+        this.useFeature(BlinnMaterial.FEATURE_VERTEX_NORMAL, true);
+    }
+    clone() {
+        const other = new BlinnMaterial();
+        other.copyFrom(this);
+        return other;
+    }
+    /** true if vertex normal attribute presents */ get vertexNormal() {
+        return this.featureUsed(BlinnMaterial.FEATURE_VERTEX_NORMAL);
+    }
+    set vertexNormal(val) {
+        this.useFeature(BlinnMaterial.FEATURE_VERTEX_NORMAL, !!val);
+    }
+    /** true if vertex normal attribute presents */ get vertexTangent() {
+        return this.featureUsed(BlinnMaterial.FEATURE_VERTEX_TANGENT);
+    }
+    set vertexTangent(val) {
+        this.useFeature(BlinnMaterial.FEATURE_VERTEX_TANGENT, !!val);
+    }
+    vertexShader(scope) {
+        super.vertexShader(scope);
+        const pb = scope.$builder;
+        scope.$l.oPos = ShaderHelper.resolveVertexPosition(scope);
+        scope.$outputs.worldPos = pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(scope.oPos, 1)).xyz;
+        ShaderHelper.setClipSpacePosition(scope, pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1)));
+        if (this.vertexNormal) {
+            scope.$l.oNorm = ShaderHelper.resolveVertexNormal(scope);
+            scope.$outputs.wNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;
+            if (this.vertexTangent) {
+                scope.$l.oTangent = ShaderHelper.resolveVertexTangent(scope);
+                scope.$outputs.wTangent = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oTangent.xyz, 0)).xyz;
+                scope.$outputs.wBinormal = pb.mul(pb.cross(scope.$outputs.wNorm, scope.$outputs.wTangent), scope.oTangent.w);
+            }
+        }
+    }
+    fragmentShader(scope) {
+        super.fragmentShader(scope);
+        const pb = scope.$builder;
+        if (this.needFragmentColor()) {
+            scope.$l.albedo = this.calculateAlbedoColor(scope);
+            if (this.vertexColor) {
+                scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope));
+            }
+            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+                scope.$l.normal = this.calculateNormal(scope, scope.$inputs.worldPos, scope.$inputs.wNorm, scope.$inputs.wTangent, scope.$inputs.wBinormal);
+                scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
+                if (this.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
+                    scope.$l.outRoughness = pb.vec4();
+                    scope.$l.litColor = this.blinnPhongLight(scope, scope.$inputs.worldPos, scope.normal, scope.viewVec, scope.albedo, scope.outRoughness);
+                    this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a), scope.outRoughness, pb.vec4(pb.add(pb.mul(scope.normal, 0.5), pb.vec3(0.5)), 1));
+                } else {
+                    scope.$l.litColor = this.blinnPhongLight(scope, scope.$inputs.worldPos, scope.normal, scope.viewVec, scope.albedo);
+                    this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a));
+                }
+            } else {
+                this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.albedo);
+            }
+        } else {
+            this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
+        }
+    }
+}
+
+export { BlinnMaterial };
+//# sourceMappingURL=blinn.js.map

package/dist/src/material/blinn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blinn.js","sources":["../../../src/material/blinn.ts"],"sourcesContent":["import { MeshMaterial, applyMaterialMixins } from './meshmaterial';\r\nimport { mixinVertexColor } from './mixins/vertexcolor';\r\nimport type { PBFunctionScope } from '@zephyr3d/device';\r\nimport { mixinBlinnPhong } from './mixins/lightmodel/blinnphong';\r\nimport { ShaderHelper } from './shader/helper';\r\nimport { MaterialVaryingFlags, RENDER_PASS_TYPE_LIGHT } from '../values';\r\nimport type { Clonable } from '@zephyr3d/base';\r\n\r\n/**\r\n * Blinn material\r\n * @public\r\n */\r\nexport class BlinnMaterial\r\n  extends applyMaterialMixins(MeshMaterial, mixinBlinnPhong, mixinVertexColor)\r\n  implements Clonable<BlinnMaterial>\r\n{\r\n  /** @internal */\r\n  private static readonly FEATURE_VERTEX_NORMAL = this.defineFeature();\r\n  /** @internal */\r\n  private static readonly FEATURE_VERTEX_TANGENT = this.defineFeature();\r\n  /**\r\n   * Creates an instance of BlinnMaterial class\r\n   */\r\n  constructor() {\r\n    super();\r\n    this.useFeature(BlinnMaterial.FEATURE_VERTEX_NORMAL, true);\r\n  }\r\n  clone(): BlinnMaterial {\r\n    const other = new BlinnMaterial();\r\n    other.copyFrom(this);\r\n    return other;\r\n  }\r\n  /** true if vertex normal attribute presents */\r\n  get vertexNormal(): boolean {\r\n    return this.featureUsed(BlinnMaterial.FEATURE_VERTEX_NORMAL);\r\n  }\r\n  set vertexNormal(val: boolean) {\r\n    this.useFeature(BlinnMaterial.FEATURE_VERTEX_NORMAL, !!val);\r\n  }\r\n  /** true if vertex normal attribute presents */\r\n  get vertexTangent(): boolean {\r\n    return this.featureUsed(BlinnMaterial.FEATURE_VERTEX_TANGENT);\r\n  }\r\n  set vertexTangent(val: boolean) {\r\n    this.useFeature(BlinnMaterial.FEATURE_VERTEX_TANGENT, !!val);\r\n  }\r\n  vertexShader(scope: PBFunctionScope) {\r\n    super.vertexShader(scope);\r\n    const pb = scope.$builder;\r\n    scope.$l.oPos = ShaderHelper.resolveVertexPosition(scope);\r\n    scope.$outputs.worldPos = pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(scope.oPos, 1)).xyz;\r\n    ShaderHelper.setClipSpacePosition(\r\n      scope,\r\n      pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1))\r\n    );\r\n    if (this.vertexNormal) {\r\n      scope.$l.oNorm = ShaderHelper.resolveVertexNormal(scope);\r\n      scope.$outputs.wNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;\r\n      if (this.vertexTangent) {\r\n        scope.$l.oTangent = ShaderHelper.resolveVertexTangent(scope);\r\n        scope.$outputs.wTangent = pb.mul(\r\n          ShaderHelper.getNormalMatrix(scope),\r\n          pb.vec4(scope.oTangent.xyz, 0)\r\n        ).xyz;\r\n        scope.$outputs.wBinormal = pb.mul(\r\n          pb.cross(scope.$outputs.wNorm, scope.$outputs.wTangent),\r\n          scope.oTangent.w\r\n        );\r\n      }\r\n    }\r\n  }\r\n  fragmentShader(scope: PBFunctionScope) {\r\n    super.fragmentShader(scope);\r\n    const pb = scope.$builder;\r\n    if (this.needFragmentColor()) {\r\n      scope.$l.albedo = this.calculateAlbedoColor(scope);\r\n      if (this.vertexColor) {\r\n        scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope));\r\n      }\r\n      if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {\r\n        scope.$l.normal = this.calculateNormal(\r\n          scope,\r\n          scope.$inputs.worldPos,\r\n          scope.$inputs.wNorm,\r\n          scope.$inputs.wTangent,\r\n          scope.$inputs.wBinormal\r\n        );\r\n        scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);\r\n        if (this.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {\r\n          scope.$l.outRoughness = pb.vec4();\r\n          scope.$l.litColor = this.blinnPhongLight(\r\n            scope,\r\n            scope.$inputs.worldPos,\r\n            scope.normal,\r\n            scope.viewVec,\r\n            scope.albedo,\r\n            scope.outRoughness\r\n          );\r\n          this.outputFragmentColor(\r\n            scope,\r\n            scope.$inputs.worldPos,\r\n            pb.vec4(scope.litColor, scope.albedo.a),\r\n            scope.outRoughness,\r\n            pb.vec4(pb.add(pb.mul(scope.normal, 0.5), pb.vec3(0.5)), 1)\r\n          );\r\n        } else {\r\n          scope.$l.litColor = this.blinnPhongLight(\r\n            scope,\r\n            scope.$inputs.worldPos,\r\n            scope.normal,\r\n            scope.viewVec,\r\n            scope.albedo\r\n          );\r\n          this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a));\r\n        }\r\n      } else {\r\n        this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.albedo);\r\n      }\r\n    } else {\r\n      this.outputFragmentColor(scope, scope.$inputs.worldPos, null);\r\n    }\r\n  }\r\n}\r\n"],"names":["BlinnMaterial","applyMaterialMixins","MeshMaterial","mixinBlinnPhong","mixinVertexColor","FEATURE_VERTEX_NORMAL","defineFeature","FEATURE_VERTEX_TANGENT","useFeature","clone","other","copyFrom","vertexNormal","featureUsed","val","vertexTangent","vertexShader","scope","pb","$builder","$l","oPos","ShaderHelper","resolveVertexPosition","$outputs","worldPos","mul","getWorldMatrix","vec4","xyz","setClipSpacePosition","getViewProjectionMatrix","oNorm","resolveVertexNormal","wNorm","getNormalMatrix","oTangent","resolveVertexTangent","wTangent","wBinormal","cross","w","fragmentShader","needFragmentColor","albedo","calculateAlbedoColor","vertexColor","getVertexColor","drawContext","renderPass","type","RENDER_PASS_TYPE_LIGHT","normal","calculateNormal","$inputs","viewVec","calculateViewVector","materialFlags","MaterialVaryingFlags","SSR_STORE_ROUGHNESS","outRoughness","litColor","blinnPhongLight","outputFragmentColor","a","add","vec3"],"mappings":"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"}

package/dist/src/material/grassmaterial.js

@@ -0,0 +1,113 @@
+import { Vector4, Vector2 } from '@zephyr3d/base';
+import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
+import { mixinPBRMetallicRoughness } from './mixins/lightmodel/pbrmetallicroughness.js';
+import { RENDER_PASS_TYPE_LIGHT } from '../values.js';
+import { ShaderHelper } from './shader/helper.js';
+import { mixinFoliage } from './mixins/foliage.js';
+
+/**
+ * Terrain grass material
+ * @public
+ */ class GrassMaterial extends applyMaterialMixins(MeshMaterial, mixinPBRMetallicRoughness, mixinFoliage) {
+    /** @internal */ _terrainSize;
+    /** @internal */ _terrainNormalMap;
+    /** @internal */ _textureSize;
+    /**
+   * Creates an instance of GrassMaterial class
+   * @param terrainSize - terrain size
+   * @param normalMap - normal map
+   * @param grassTexture - grass texture
+   */ constructor(terrainSize, normalMap, grassTexture){
+        super();
+        this.metallic = 0;
+        this.roughness = 1;
+        this.specularFactor = new Vector4(1, 1, 1, 0.2);
+        this.doubleSidedLighting = false;
+        this._terrainSize = terrainSize;
+        this._terrainNormalMap = normalMap;
+        this._textureSize = Vector2.one();
+        if (grassTexture) {
+            this.albedoTexture = grassTexture;
+            this._textureSize.setXY(grassTexture.width, grassTexture.height);
+        }
+    }
+    clone() {
+        const other = new GrassMaterial(this._terrainSize, this._terrainNormalMap, this.albedoTexture);
+        other.copyFrom(this);
+        return other;
+    }
+    /**
+   * {@inheritDoc MeshMaterial.isTransparentPass}
+   * @override
+   */ isTransparentPass(_pass) {
+        return false;
+    }
+    /**
+   * {@inheritDoc Material.supportLighting}
+   * @override
+   */ supportLighting() {
+        return true;
+    }
+    /**
+   * {@inheritDoc Material.supportInstancing}
+   * @override
+   */ supportInstancing() {
+        return false;
+    }
+    applyUniformValues(bindGroup, ctx, pass) {
+        super.applyUniformValues(bindGroup, ctx, pass);
+        bindGroup.setTexture('terrainNormalMap', this._terrainNormalMap);
+        bindGroup.setValue('terrainSize', 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.terrainNormalMap = pb.tex2D().uniform(2);
+        scope.terrainSize = pb.vec2().uniform(2);
+        const normalSample = pb.textureSampleLevel(scope.terrainNormalMap, pb.div(scope.$inputs.placement.xz, scope.terrainSize), 0).rgb;
+        scope.$l.normal = pb.normalize(pb.sub(pb.mul(normalSample, 2), pb.vec3(1)));
+        scope.$l.axisX = pb.vec3(1, 0, 0);
+        scope.$l.axisZ = pb.cross(scope.axisX, scope.normal);
+        scope.$l.axisX = pb.cross(scope.normal, scope.axisZ);
+        scope.$l.rotPos = pb.mul(pb.mat3(scope.axisX, scope.normal, scope.axisZ), scope.$inputs.pos);
+        scope.$outputs.worldPos = pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(pb.add(scope.rotPos, scope.$inputs.placement.xyz), 1)).xyz;
+        ShaderHelper.setClipSpacePosition(scope, pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1)));
+        scope.$outputs.worldNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.normal, 0)).xyz;
+    }
+    fragmentShader(scope) {
+        super.fragmentShader(scope);
+        const pb = scope.$builder;
+        const that = this;
+        if (this.needFragmentColor()) {
+            scope.albedoTextureSize = pb.vec2().uniform(2);
+            scope.$l.albedo = this.calculateAlbedoColor(scope);
+            scope.albedo = that.calculateFoliageAlbedo(scope, scope.albedo, pb.mul(that.getAlbedoTexCoord(scope), scope.albedoTextureSize));
+            scope.$l.litColor = pb.vec3(0);
+            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+                scope.$l.normalInfo = this.calculateNormalAndTBN(scope, scope.$inputs.worldPos, scope.$inputs.worldNorm);
+                scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
+                scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.normalInfo.normal, scope.viewVec, scope.albedo, scope.normalInfo.TBN);
+            }
+            this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a));
+        } else {
+            this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
+        }
+    }
+    apply(ctx) {
+        this.alphaToCoverage = ctx.device.getFrameBufferSampleCount() > 1;
+        this.alphaCutoff = this.alphaToCoverage ? 1 : 0.8;
+        return super.apply(ctx);
+    }
+    updateRenderStates(pass, stateSet, ctx) {
+        super.updateRenderStates(pass, stateSet, ctx);
+        stateSet.useRasterizerState().setCullMode('none');
+    }
+}
+
+export { GrassMaterial };
+//# sourceMappingURL=grassmaterial.js.map

package/dist/src/material/grassmaterial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grassmaterial.js","sources":["../../../src/material/grassmaterial.ts"],"sourcesContent":["import type { Clonable } from '@zephyr3d/base';\r\nimport { Vector2, Vector4 } from '@zephyr3d/base';\r\nimport { MeshMaterial, applyMaterialMixins } from './meshmaterial';\r\nimport { mixinPBRMetallicRoughness } from './mixins/lightmodel/pbrmetallicroughness';\r\nimport type { BindGroup, PBFunctionScope, RenderStateSet, Texture2D } from '@zephyr3d/device';\r\nimport type { DrawContext } from '../render';\r\nimport { RENDER_PASS_TYPE_LIGHT } from '../values';\r\nimport { ShaderHelper } from './shader/helper';\r\nimport { mixinFoliage } from './mixins/foliage';\r\n\r\n/**\r\n * Terrain grass material\r\n * @public\r\n */\r\nexport class GrassMaterial\r\n  extends applyMaterialMixins(MeshMaterial, mixinPBRMetallicRoughness, mixinFoliage)\r\n  implements Clonable<GrassMaterial>\r\n{\r\n  /** @internal */\r\n  private readonly _terrainSize: Vector2;\r\n  /** @internal */\r\n  private readonly _terrainNormalMap: Texture2D;\r\n  /** @internal */\r\n  private readonly _textureSize: Vector2;\r\n  /**\r\n   * Creates an instance of GrassMaterial class\r\n   * @param terrainSize - terrain size\r\n   * @param normalMap - normal map\r\n   * @param grassTexture - grass texture\r\n   */\r\n  constructor(terrainSize: Vector2, normalMap: Texture2D, grassTexture?: Texture2D) {\r\n    super();\r\n    this.metallic = 0;\r\n    this.roughness = 1;\r\n    this.specularFactor = new Vector4(1, 1, 1, 0.2);\r\n    this.doubleSidedLighting = false;\r\n    this._terrainSize = terrainSize;\r\n    this._terrainNormalMap = normalMap;\r\n    this._textureSize = Vector2.one();\r\n    if (grassTexture) {\r\n      this.albedoTexture = grassTexture;\r\n      this._textureSize.setXY(grassTexture.width, grassTexture.height);\r\n    }\r\n  }\r\n  clone(): GrassMaterial {\r\n    const other = new GrassMaterial(this._terrainSize, this._terrainNormalMap, this.albedoTexture);\r\n    other.copyFrom(this);\r\n    return other;\r\n  }\r\n  /**\r\n   * {@inheritDoc MeshMaterial.isTransparentPass}\r\n   * @override\r\n   */\r\n  isTransparentPass(_pass: number): boolean {\r\n    return false;\r\n  }\r\n  /**\r\n   * {@inheritDoc Material.supportLighting}\r\n   * @override\r\n   */\r\n  supportLighting(): boolean {\r\n    return true;\r\n  }\r\n  /**\r\n   * {@inheritDoc Material.supportInstancing}\r\n   * @override\r\n   */\r\n  supportInstancing(): boolean {\r\n    return false;\r\n  }\r\n  applyUniformValues(bindGroup: BindGroup, ctx: DrawContext, pass: number): void {\r\n    super.applyUniformValues(bindGroup, ctx, pass);\r\n    bindGroup.setTexture('terrainNormalMap', this._terrainNormalMap);\r\n    bindGroup.setValue('terrainSize', this._terrainSize);\r\n    if (this.needFragmentColor(ctx)) {\r\n      bindGroup.setValue('albedoTextureSize', this._textureSize);\r\n    }\r\n  }\r\n  vertexShader(scope: PBFunctionScope): void {\r\n    super.vertexShader(scope);\r\n    const pb = scope.$builder;\r\n    scope.$inputs.pos = pb.vec3().attrib('position');\r\n    scope.$inputs.placement = pb.vec4().attrib('texCoord1');\r\n    scope.terrainNormalMap = pb.tex2D().uniform(2);\r\n    scope.terrainSize = pb.vec2().uniform(2);\r\n    const normalSample = pb.textureSampleLevel(\r\n      scope.terrainNormalMap,\r\n      pb.div(scope.$inputs.placement.xz, scope.terrainSize),\r\n      0\r\n    ).rgb;\r\n    scope.$l.normal = pb.normalize(pb.sub(pb.mul(normalSample, 2), pb.vec3(1)));\r\n    scope.$l.axisX = pb.vec3(1, 0, 0);\r\n    scope.$l.axisZ = pb.cross(scope.axisX, scope.normal);\r\n    scope.$l.axisX = pb.cross(scope.normal, scope.axisZ);\r\n    scope.$l.rotPos = pb.mul(pb.mat3(scope.axisX, scope.normal, scope.axisZ), scope.$inputs.pos);\r\n\r\n    scope.$outputs.worldPos = pb.mul(\r\n      ShaderHelper.getWorldMatrix(scope),\r\n      pb.vec4(pb.add(scope.rotPos, scope.$inputs.placement.xyz), 1)\r\n    ).xyz;\r\n    ShaderHelper.setClipSpacePosition(\r\n      scope,\r\n      pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1))\r\n    );\r\n    scope.$outputs.worldNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.normal, 0)).xyz;\r\n  }\r\n  fragmentShader(scope: PBFunctionScope): void {\r\n    super.fragmentShader(scope);\r\n    const pb = scope.$builder;\r\n    const that = this;\r\n    if (this.needFragmentColor()) {\r\n      scope.albedoTextureSize = pb.vec2().uniform(2);\r\n      scope.$l.albedo = this.calculateAlbedoColor(scope);\r\n      scope.albedo = that.calculateFoliageAlbedo(\r\n        scope,\r\n        scope.albedo,\r\n        pb.mul(that.getAlbedoTexCoord(scope), scope.albedoTextureSize)\r\n      );\r\n      scope.$l.litColor = pb.vec3(0);\r\n      if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {\r\n        scope.$l.normalInfo = this.calculateNormalAndTBN(\r\n          scope,\r\n          scope.$inputs.worldPos,\r\n          scope.$inputs.worldNorm\r\n        );\r\n        scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);\r\n        scope.$l.litColor = this.PBRLight(\r\n          scope,\r\n          scope.$inputs.worldPos,\r\n          scope.normalInfo.normal,\r\n          scope.viewVec,\r\n          scope.albedo,\r\n          scope.normalInfo.TBN\r\n        );\r\n      }\r\n      this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a));\r\n    } else {\r\n      this.outputFragmentColor(scope, scope.$inputs.worldPos, null);\r\n    }\r\n  }\r\n  apply(ctx: DrawContext): boolean {\r\n    this.alphaToCoverage = ctx.device.getFrameBufferSampleCount() > 1;\r\n    this.alphaCutoff = this.alphaToCoverage ? 1 : 0.8;\r\n    return super.apply(ctx);\r\n  }\r\n  protected updateRenderStates(pass: number, stateSet: RenderStateSet, ctx: DrawContext): void {\r\n    super.updateRenderStates(pass, stateSet, ctx);\r\n    stateSet.useRasterizerState().setCullMode('none');\r\n  }\r\n}\r\n"],"names":["GrassMaterial","applyMaterialMixins","MeshMaterial","mixinPBRMetallicRoughness","mixinFoliage","terrainSize","normalMap","grassTexture","metallic","roughness","specularFactor","Vector4","doubleSidedLighting","_terrainSize","_terrainNormalMap","_textureSize","Vector2","one","albedoTexture","setXY","width","height","clone","other","copyFrom","isTransparentPass","_pass","supportLighting","supportInstancing","applyUniformValues","bindGroup","ctx","pass","setTexture","setValue","needFragmentColor","vertexShader","scope","pb","$builder","$inputs","pos","vec3","attrib","placement","vec4","terrainNormalMap","tex2D","uniform","vec2","normalSample","textureSampleLevel","div","xz","rgb","$l","normal","normalize","sub","mul","axisX","axisZ","cross","rotPos","mat3","$outputs","worldPos","ShaderHelper","getWorldMatrix","add","xyz","setClipSpacePosition","getViewProjectionMatrix","worldNorm","getNormalMatrix","fragmentShader","that","albedoTextureSize","albedo","calculateAlbedoColor","calculateFoliageAlbedo","getAlbedoTexCoord","litColor","drawContext","renderPass","type","RENDER_PASS_TYPE_LIGHT","normalInfo","calculateNormalAndTBN","viewVec","calculateViewVector","PBRLight","TBN","outputFragmentColor","a","apply","alphaToCoverage","device","getFrameBufferSampleCount","alphaCutoff","updateRenderStates","stateSet","useRasterizerState","setCullMode"],"mappings":"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"}

package/dist/src/material/lambert.js

@@ -0,0 +1,92 @@
+import { mixinLight } from './mixins/lit.js';
+import { mixinVertexColor } from './mixins/vertexcolor.js';
+import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
+import { ShaderHelper } from './shader/helper.js';
+import { RENDER_PASS_TYPE_LIGHT, MaterialVaryingFlags } from '../values.js';
+
+/**
+ * Lambert material
+ * @public
+ */ class LambertMaterial extends applyMaterialMixins(MeshMaterial, mixinLight, mixinVertexColor) {
+    static FEATURE_VERTEX_NORMAL = this.defineFeature();
+    static FEATURE_VERTEX_TANGENT = this.defineFeature();
+    constructor(){
+        super();
+        this.useFeature(LambertMaterial.FEATURE_VERTEX_NORMAL, true);
+    }
+    clone() {
+        const other = new LambertMaterial();
+        other.copyFrom(this);
+        return other;
+    }
+    /** true if vertex normal attribute presents */ get vertexNormal() {
+        return this.featureUsed(LambertMaterial.FEATURE_VERTEX_NORMAL);
+    }
+    set vertexNormal(val) {
+        this.useFeature(LambertMaterial.FEATURE_VERTEX_NORMAL, !!val);
+    }
+    /** true if vertex normal attribute presents */ get vertexTangent() {
+        return this.featureUsed(LambertMaterial.FEATURE_VERTEX_TANGENT);
+    }
+    set vertexTangent(val) {
+        this.useFeature(LambertMaterial.FEATURE_VERTEX_TANGENT, !!val);
+    }
+    vertexShader(scope) {
+        super.vertexShader(scope);
+        const pb = scope.$builder;
+        scope.$l.oPos = ShaderHelper.resolveVertexPosition(scope);
+        scope.$outputs.worldPos = pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(scope.oPos, 1)).xyz;
+        ShaderHelper.setClipSpacePosition(scope, pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1)));
+        if (this.vertexNormal) {
+            scope.$l.oNorm = ShaderHelper.resolveVertexNormal(scope);
+            scope.$outputs.wNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;
+            if (this.vertexTangent) {
+                scope.$l.oTangent = ShaderHelper.resolveVertexTangent(scope);
+                scope.$outputs.wTangent = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oTangent.xyz, 0)).xyz;
+                scope.$outputs.wBinormal = pb.mul(pb.cross(scope.$outputs.wNorm, scope.$outputs.wTangent), scope.oTangent.w);
+            }
+        }
+    }
+    fragmentShader(scope) {
+        super.fragmentShader(scope);
+        const pb = scope.$builder;
+        const that = this;
+        if (this.needFragmentColor()) {
+            scope.$l.albedo = this.calculateAlbedoColor(scope);
+            if (this.vertexColor) {
+                scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope));
+            }
+            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+                scope.$l.color = pb.vec3(0);
+                scope.$l.normal = this.calculateNormal(scope, scope.$inputs.worldPos, scope.$inputs.wNorm, scope.$inputs.wTangent, scope.$inputs.wBinormal);
+                if (this.needCalculateEnvLight()) {
+                    scope.color = pb.add(scope.color, this.getEnvLightIrradiance(scope, scope.normal));
+                }
+                this.forEachLight(scope, function(type, posRange, dirCutoff, colorIntensity, shadow) {
+                    this.$l.lightAtten = that.calculateLightAttenuation(this, type, scope.$inputs.worldPos, posRange, dirCutoff);
+                    this.$l.lightDir = that.calculateLightDirection(this, type, scope.$inputs.worldPos, posRange, dirCutoff);
+                    this.$l.NoL = pb.clamp(pb.dot(this.normal, this.lightDir), 0, 1);
+                    this.$l.lightContrib = pb.mul(colorIntensity.rgb, colorIntensity.a, this.NoL, this.lightAtten, 1 / Math.PI);
+                    if (shadow) {
+                        this.$l.shadow = pb.vec3(that.calculateShadow(this, scope.$inputs.worldPos, this.NoL));
+                        this.lightContrib = pb.mul(this.lightContrib, this.shadow);
+                    }
+                    this.color = pb.add(this.color, this.lightContrib);
+                });
+                scope.$l.litColor = pb.mul(scope.albedo, pb.vec4(scope.color, 1));
+                if (this.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
+                    this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.litColor, pb.vec4(0, 0, 0, 1), pb.vec4(pb.add(pb.mul(scope.normal, 0.5), pb.vec3(0.5)), 1));
+                } else {
+                    this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.litColor);
+                }
+            } else {
+                this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.albedo);
+            }
+        } else {
+            this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
+        }
+    }
+}
+
+export { LambertMaterial };
+//# sourceMappingURL=lambert.js.map

package/dist/src/material/lambert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambert.js","sources":["../../../src/material/lambert.ts"],"sourcesContent":["import { mixinLight } from './mixins/lit';\r\nimport { mixinVertexColor } from './mixins/vertexcolor';\r\nimport { MeshMaterial, applyMaterialMixins } from './meshmaterial';\r\nimport type { PBFunctionScope } from '@zephyr3d/device';\r\nimport { ShaderHelper } from './shader/helper';\r\nimport { MaterialVaryingFlags, RENDER_PASS_TYPE_LIGHT } from '../values';\r\nimport type { Clonable } from '@zephyr3d/base';\r\n\r\n/**\r\n * Lambert material\r\n * @public\r\n */\r\nexport class LambertMaterial\r\n  extends applyMaterialMixins(MeshMaterial, mixinLight, mixinVertexColor)\r\n  implements Clonable<LambertMaterial>\r\n{\r\n  private static readonly FEATURE_VERTEX_NORMAL = this.defineFeature();\r\n  private static readonly FEATURE_VERTEX_TANGENT = this.defineFeature();\r\n  constructor() {\r\n    super();\r\n    this.useFeature(LambertMaterial.FEATURE_VERTEX_NORMAL, true);\r\n  }\r\n  clone(): LambertMaterial {\r\n    const other = new LambertMaterial();\r\n    other.copyFrom(this);\r\n    return other;\r\n  }\r\n  /** true if vertex normal attribute presents */\r\n  get vertexNormal(): boolean {\r\n    return this.featureUsed(LambertMaterial.FEATURE_VERTEX_NORMAL);\r\n  }\r\n  set vertexNormal(val: boolean) {\r\n    this.useFeature(LambertMaterial.FEATURE_VERTEX_NORMAL, !!val);\r\n  }\r\n  /** true if vertex normal attribute presents */\r\n  get vertexTangent(): boolean {\r\n    return this.featureUsed(LambertMaterial.FEATURE_VERTEX_TANGENT);\r\n  }\r\n  set vertexTangent(val: boolean) {\r\n    this.useFeature(LambertMaterial.FEATURE_VERTEX_TANGENT, !!val);\r\n  }\r\n  vertexShader(scope: PBFunctionScope) {\r\n    super.vertexShader(scope);\r\n    const pb = scope.$builder;\r\n    scope.$l.oPos = ShaderHelper.resolveVertexPosition(scope);\r\n    scope.$outputs.worldPos = pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(scope.oPos, 1)).xyz;\r\n    ShaderHelper.setClipSpacePosition(\r\n      scope,\r\n      pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1))\r\n    );\r\n    if (this.vertexNormal) {\r\n      scope.$l.oNorm = ShaderHelper.resolveVertexNormal(scope);\r\n      scope.$outputs.wNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;\r\n      if (this.vertexTangent) {\r\n        scope.$l.oTangent = ShaderHelper.resolveVertexTangent(scope);\r\n        scope.$outputs.wTangent = pb.mul(\r\n          ShaderHelper.getNormalMatrix(scope),\r\n          pb.vec4(scope.oTangent.xyz, 0)\r\n        ).xyz;\r\n        scope.$outputs.wBinormal = pb.mul(\r\n          pb.cross(scope.$outputs.wNorm, scope.$outputs.wTangent),\r\n          scope.oTangent.w\r\n        );\r\n      }\r\n    }\r\n  }\r\n  fragmentShader(scope: PBFunctionScope) {\r\n    super.fragmentShader(scope);\r\n    const pb = scope.$builder;\r\n    const that = this;\r\n    if (this.needFragmentColor()) {\r\n      scope.$l.albedo = this.calculateAlbedoColor(scope);\r\n      if (this.vertexColor) {\r\n        scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope));\r\n      }\r\n      if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {\r\n        scope.$l.color = pb.vec3(0);\r\n        scope.$l.normal = this.calculateNormal(\r\n          scope,\r\n          scope.$inputs.worldPos,\r\n          scope.$inputs.wNorm,\r\n          scope.$inputs.wTangent,\r\n          scope.$inputs.wBinormal\r\n        );\r\n        if (this.needCalculateEnvLight()) {\r\n          scope.color = pb.add(scope.color, this.getEnvLightIrradiance(scope, scope.normal));\r\n        }\r\n        this.forEachLight(scope, function (type, posRange, dirCutoff, colorIntensity, shadow) {\r\n          this.$l.lightAtten = that.calculateLightAttenuation(\r\n            this,\r\n            type,\r\n            scope.$inputs.worldPos,\r\n            posRange,\r\n            dirCutoff\r\n          );\r\n          this.$l.lightDir = that.calculateLightDirection(\r\n            this,\r\n            type,\r\n            scope.$inputs.worldPos,\r\n            posRange,\r\n            dirCutoff\r\n          );\r\n          this.$l.NoL = pb.clamp(pb.dot(this.normal, this.lightDir), 0, 1);\r\n          this.$l.lightContrib = pb.mul(\r\n            colorIntensity.rgb,\r\n            colorIntensity.a,\r\n            this.NoL,\r\n            this.lightAtten,\r\n            1 / Math.PI\r\n          );\r\n          if (shadow) {\r\n            this.$l.shadow = pb.vec3(that.calculateShadow(this, scope.$inputs.worldPos, this.NoL));\r\n            this.lightContrib = pb.mul(this.lightContrib, this.shadow);\r\n          }\r\n          this.color = pb.add(this.color, this.lightContrib);\r\n        });\r\n        scope.$l.litColor = pb.mul(scope.albedo, pb.vec4(scope.color, 1));\r\n        if (this.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {\r\n          this.outputFragmentColor(\r\n            scope,\r\n            scope.$inputs.worldPos,\r\n            scope.litColor,\r\n            pb.vec4(0, 0, 0, 1),\r\n            pb.vec4(pb.add(pb.mul(scope.normal, 0.5), pb.vec3(0.5)), 1)\r\n          );\r\n        } else {\r\n          this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.litColor);\r\n        }\r\n      } else {\r\n        this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.albedo);\r\n      }\r\n    } else {\r\n      this.outputFragmentColor(scope, scope.$inputs.worldPos, null);\r\n    }\r\n  }\r\n}\r\n"],"names":["LambertMaterial","applyMaterialMixins","MeshMaterial","mixinLight","mixinVertexColor","FEATURE_VERTEX_NORMAL","defineFeature","FEATURE_VERTEX_TANGENT","useFeature","clone","other","copyFrom","vertexNormal","featureUsed","val","vertexTangent","vertexShader","scope","pb","$builder","$l","oPos","ShaderHelper","resolveVertexPosition","$outputs","worldPos","mul","getWorldMatrix","vec4","xyz","setClipSpacePosition","getViewProjectionMatrix","oNorm","resolveVertexNormal","wNorm","getNormalMatrix","oTangent","resolveVertexTangent","wTangent","wBinormal","cross","w","fragmentShader","that","needFragmentColor","albedo","calculateAlbedoColor","vertexColor","getVertexColor","drawContext","renderPass","type","RENDER_PASS_TYPE_LIGHT","color","vec3","normal","calculateNormal","$inputs","needCalculateEnvLight","add","getEnvLightIrradiance","forEachLight","posRange","dirCutoff","colorIntensity","shadow","lightAtten","calculateLightAttenuation","lightDir","calculateLightDirection","NoL","clamp","dot","lightContrib","rgb","a","Math","PI","calculateShadow","litColor","materialFlags","MaterialVaryingFlags","SSR_STORE_ROUGHNESS","outputFragmentColor"],"mappings":"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"}