@zephyr3d/scene 0.9.1 → 0.9.3

package/dist/src/material/meshmaterial.js

@@ -0,0 +1,704 @@
+import { ProgramBuilder } from '@zephyr3d/device';
+import { RENDER_PASS_TYPE_OBJECT_COLOR, QUEUE_OPAQUE, RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_LIGHT, MaterialVaryingFlags, RENDER_PASS_TYPE_DEPTH, QUEUE_TRANSPARENT } from '../values.js';
+import { Material } from './material.js';
+import { encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
+import { Application } from '../app/app.js';
+import { ShaderHelper } from './shader/helper.js';
+import { Vector4, DRef, DWeakRef, Vector3, Vector2, applyMixins } from '@zephyr3d/base';
+import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
+
+/**
+ * Apply material mixins to specific material class
+ * @param target - Material class
+ * @param mixins - mixins
+ * @returns Mixed mesh material class
+ *
+ * @public
+ */ function applyMaterialMixins(target, ...mixins) {
+    return applyMixins(target, ...mixins);
+}
+let FEATURE_ALPHATEST = 0;
+let FEATURE_ALPHABLEND = 0;
+let FEATURE_ALPHATOCOVERAGE = 0;
+let FEATURE_DISABLE_TAA = 0;
+/**
+ * Base class for any kind of mesh materials
+ *
+ * @public
+ */ class MeshMaterial extends Material {
+    /** @internal */ static INSTANCE_UNIFORMS = [];
+    /** @internal */ static NEXT_FEATURE_INDEX = 3;
+    /** @internal */ static OBJECT_COLOR_UNIFORM = this.defineInstanceUniform('objectColor', 'rgba');
+    /** @internal */ static OPACITY_UNIFORM = this.defineInstanceUniform('opacity', 'float');
+    /** @internal */ _featureStates;
+    /** @internal */ _alphaCutoff;
+    /** @internal */ _blendMode;
+    /** @internal */ _cullMode;
+    /** @internal */ _opacity;
+    /** @internal */ _taaStrength;
+    /** @internal */ _objectColor;
+    /** @internal */ _ctx;
+    /** @internal */ _materialPass;
+    /**
+   * Creates an instance of MeshMaterial class
+   * @param args - constructor arguments
+   */ constructor(){
+        super();
+        this._featureStates = [];
+        this._alphaCutoff = 0;
+        this._blendMode = 'none';
+        this._cullMode = 'back';
+        this._opacity = 1;
+        this._taaStrength = 1 - 1 / 16;
+        this._objectColor = Vector4.one();
+        this._ctx = null;
+        this._materialPass = -1;
+        this.useFeature(FEATURE_ALPHABLEND, this._blendMode);
+    }
+    clone() {
+        const other = new MeshMaterial();
+        other.copyFrom(this);
+        return other;
+    }
+    copyFrom(other) {
+        super.copyFrom(other);
+        this.alphaCutoff = other.alphaCutoff;
+        this.blendMode = other.blendMode;
+        this.cullMode = other.cullMode;
+        this.opacity = other.opacity;
+        this.objectColor = other.objectColor;
+    }
+    /** Indicate that the uniform has changed and needs to be resubmitted. */ uniformChanged() {
+        this.optionChanged(false);
+    }
+    /** Define feature index */ static defineFeature() {
+        const val = this.NEXT_FEATURE_INDEX;
+        this.NEXT_FEATURE_INDEX++;
+        return val;
+    }
+    /** @internal */ static getNumComponents(type) {
+        if (type === 'float') {
+            return 1;
+        }
+        if (type === 'vec2') {
+            return 2;
+        }
+        if (type === 'rgb' || type === 'vec3') {
+            return 3;
+        }
+        if (type === 'rgba' || type === 'vec4') {
+            return 4;
+        }
+        return 0;
+    }
+    /** Define instance uniform index */ static defineInstanceUniform(prop, type) {
+        if (this.INSTANCE_UNIFORMS.findIndex((val)=>val.prop === prop) >= 0) {
+            throw new Error(`${this.name}.defineInstanceUniform(): ${prop} was already defined`);
+        }
+        const numComponents = this.getNumComponents(type);
+        if (numComponents === 0) {
+            throw new Error(`${this.name}.defineInstanceUniform(): invalid uniform type ${type}`);
+        }
+        let index = this.INSTANCE_UNIFORMS.length;
+        let offset = 0;
+        if (this.INSTANCE_UNIFORMS.length > 0) {
+            const lastUniform = this.INSTANCE_UNIFORMS[this.INSTANCE_UNIFORMS.length - 1];
+            const finalOffset = lastUniform.offset + 4 & -4;
+            offset = finalOffset;
+            for(let i = 0; i < this.INSTANCE_UNIFORMS.length; i++){
+                const offset1 = this.INSTANCE_UNIFORMS[i].offset;
+                const numComps1 = this.getNumComponents(this.INSTANCE_UNIFORMS[i].type);
+                const offset2 = i === this.INSTANCE_UNIFORMS.length - 1 ? finalOffset : this.INSTANCE_UNIFORMS[i + 1].offset;
+                if (offset1 + numComps1 + numComponents <= offset2) {
+                    index = i + 1;
+                    offset = offset1 + numComps1;
+                    if (offset + numComponents === offset2) {
+                        break;
+                    }
+                }
+            }
+        }
+        this.INSTANCE_UNIFORMS = this.INSTANCE_UNIFORMS.slice();
+        this.INSTANCE_UNIFORMS.splice(index, 0, {
+            prop,
+            offset,
+            type
+        });
+        return offset << 2 | numComponents - 1;
+    }
+    getInstancedUniform(scope, uniformIndex) {
+        const pb = scope.$builder;
+        const instanceID = scope.$builtins.instanceIndex;
+        const uniformName = ShaderHelper.getInstanceDataUniformName();
+        const strideName = ShaderHelper.getInstanceDataStrideUniformName();
+        const offsetName = ShaderHelper.getInstanceDataOffsetUniformName();
+        const numComponents = (uniformIndex & 3) + 1;
+        const vecIndex = uniformIndex >> 4;
+        const vecOffset = uniformIndex >> 2 & 3;
+        const u = scope[uniformName].at(pb.add(pb.mul(scope[strideName], instanceID), ShaderHelper.MATERIAL_INSTANCE_DATA_OFFSET + vecIndex, scope[offsetName]));
+        const m = [
+            'x',
+            'y',
+            'z',
+            'w'
+        ].slice(vecOffset, vecOffset + numComponents).join('');
+        return u[m];
+    }
+    /** Get instanced material property list */ getInstancedUniforms() {
+        return this.constructor.INSTANCE_UNIFORMS;
+    }
+    /** Create material instance */ createInstance() {
+        if (this.$isInstance) {
+            return this.coreMaterial.createInstance();
+        }
+        const isWebGL1 = Application.instance.device.type === 'webgl';
+        if (isWebGL1 || !this.supportInstancing) {
+            return this.clone();
+        }
+        const instanceUniforms = this.getInstancedUniforms();
+        const uniformsHolder = instanceUniforms.length > 0 ? new Float32Array(instanceUniforms[instanceUniforms.length - 1].offset + 4 & -4) : null;
+        const instance = {};
+        const that = this;
+        const coreMaterial = new DRef(that);
+        let disposed = false;
+        instance.isBatchable = ()=>true; //!isWebGL1 && that.supportInstancing();
+        instance.dispose = ()=>{
+            if (!disposed) {
+                disposed = true;
+                coreMaterial.dispose();
+            }
+        };
+        instance.$instanceUniforms = uniformsHolder;
+        instance.$isInstance = true;
+        let persistentId = crypto.randomUUID();
+        Material._registry.set(persistentId, new DWeakRef(instance));
+        Object.defineProperty(instance, 'coreMaterial', {
+            get: function() {
+                return coreMaterial.get();
+            }
+        });
+        Object.defineProperty(instance, 'persistentId', {
+            get: function() {
+                return persistentId;
+            },
+            set: function(val) {
+                if (val !== persistentId) {
+                    const m = Material._registry.get(persistentId);
+                    if (!m || m.get() !== instance) {
+                        throw new Error('Registry material mismatch');
+                    }
+                    Material._registry.delete(persistentId);
+                    persistentId = val;
+                    Material._registry.set(persistentId, m);
+                }
+            }
+        });
+        // Copy original uniform values
+        for(let i = 0; i < instanceUniforms.length; i++){
+            const { prop, offset, type } = instanceUniforms[i];
+            const value = that[prop];
+            switch(type){
+                case 'float':
+                    {
+                        uniformsHolder[offset] = Number(value);
+                        Object.defineProperty(instance, prop, {
+                            get () {
+                                return uniformsHolder[offset];
+                            },
+                            set (value) {
+                                uniformsHolder[offset] = value;
+                                RenderBundleWrapper.materialUniformsChanged(instance);
+                            }
+                        });
+                        break;
+                    }
+                case 'vec2':
+                    {
+                        if (!(value instanceof Vector2)) {
+                            throw new Error(`Instance uniform property ${prop} must be of type Vector2`);
+                        }
+                        uniformsHolder[offset] = value.x;
+                        uniformsHolder[offset + 1] = value.y;
+                        Object.defineProperty(instance, prop, {
+                            get () {
+                                return new Vector2(uniformsHolder[offset], uniformsHolder[offset + 1]);
+                            },
+                            set (value) {
+                                if (!(value instanceof Vector2)) {
+                                    throw new Error(`Instance uniform property ${prop} must be of type Vector2`);
+                                }
+                                uniformsHolder[offset] = value.x;
+                                uniformsHolder[offset + 1] = value.y;
+                                RenderBundleWrapper.materialUniformsChanged(instance);
+                            }
+                        });
+                        break;
+                    }
+                case 'vec3':
+                case 'rgb':
+                    {
+                        if (!(value instanceof Vector3)) {
+                            throw new Error(`Instance uniform property ${prop} must be of type Vector3`);
+                        }
+                        uniformsHolder[offset] = value.x;
+                        uniformsHolder[offset + 1] = value.y;
+                        uniformsHolder[offset + 2] = value.z;
+                        Object.defineProperty(instance, prop, {
+                            get () {
+                                return new Vector3(uniformsHolder[offset], uniformsHolder[offset + 1], uniformsHolder[offset + 2]);
+                            },
+                            set (value) {
+                                if (!(value instanceof Vector3)) {
+                                    throw new Error(`Instance uniform property ${prop} must be of type Vector3`);
+                                }
+                                uniformsHolder[offset] = value.x;
+                                uniformsHolder[offset + 1] = value.y;
+                                uniformsHolder[offset + 2] = value.z;
+                                RenderBundleWrapper.materialUniformsChanged(instance);
+                            }
+                        });
+                        break;
+                    }
+                case 'vec4':
+                case 'rgba':
+                    {
+                        if (!(value instanceof Vector4)) {
+                            throw new Error(`Instance uniform property ${prop} must be of type Vector4`);
+                        }
+                        uniformsHolder[offset] = value.x;
+                        uniformsHolder[offset + 1] = value.y;
+                        uniformsHolder[offset + 2] = value.z;
+                        uniformsHolder[offset + 3] = value.w;
+                        Object.defineProperty(instance, prop, {
+                            get () {
+                                return new Vector4(uniformsHolder[offset], uniformsHolder[offset + 1], uniformsHolder[offset + 2], uniformsHolder[offset + 3]);
+                            },
+                            set (value) {
+                                if (!(value instanceof Vector4)) {
+                                    throw new Error(`Instance uniform property ${prop} must be of type Vector4`);
+                                }
+                                uniformsHolder[offset] = value.x;
+                                uniformsHolder[offset + 1] = value.y;
+                                uniformsHolder[offset + 2] = value.z;
+                                uniformsHolder[offset + 3] = value.w;
+                                RenderBundleWrapper.materialUniformsChanged(instance);
+                            }
+                        });
+                        break;
+                    }
+            }
+        }
+        Object.setPrototypeOf(instance, that);
+        return instance;
+    }
+    /** Draw context for shader creation */ get drawContext() {
+        return this._ctx;
+    }
+    /**
+   * Current material pass
+   * @internal
+   **/ get pass() {
+        return this._materialPass;
+    }
+    /** A value between 0 and 1, presents the cutoff for alpha testing */ get alphaCutoff() {
+        return this._alphaCutoff;
+    }
+    set alphaCutoff(val) {
+        if (this._alphaCutoff !== val) {
+            this.useFeature(FEATURE_ALPHATEST, val > 0);
+            this._alphaCutoff = val;
+            this.uniformChanged();
+        }
+    }
+    /** Whether TAA should be disabled on this material */ get TAADisabled() {
+        return !!this.featureUsed(FEATURE_DISABLE_TAA);
+    }
+    set TAADisabled(val) {
+        this.useFeature(FEATURE_DISABLE_TAA, !!val);
+    }
+    /** TAA strength */ get TAAStrength() {
+        return this._taaStrength;
+    }
+    set TAAStrength(val) {
+        val = val > 1 ? 1 : val < 0 ? 0 : val;
+        if (this._taaStrength !== val) {
+            this._taaStrength = val;
+            this.uniformChanged();
+        }
+    }
+    get alphaToCoverage() {
+        return this.featureUsed(FEATURE_ALPHATOCOVERAGE);
+    }
+    set alphaToCoverage(val) {
+        this.useFeature(FEATURE_ALPHATOCOVERAGE, !!val);
+    }
+    /** Blending mode */ get blendMode() {
+        return this._blendMode;
+    }
+    set blendMode(val) {
+        if (this._blendMode !== val) {
+            this._blendMode = val;
+            this.useFeature(FEATURE_ALPHABLEND, this._blendMode);
+        }
+    }
+    /** Cull mode */ get cullMode() {
+        return this._cullMode;
+    }
+    set cullMode(val) {
+        this._cullMode = val;
+    }
+    /** A value between 0 and 1, presents the opacity */ get opacity() {
+        return this._opacity;
+    }
+    set opacity(val) {
+        val = val < 0 ? 0 : val > 1 ? 1 : val;
+        if (this._opacity !== val) {
+            this._opacity = val;
+            this.uniformChanged();
+        }
+    }
+    /** Object color used for GPU picking */ get objectColor() {
+        return this._objectColor;
+    }
+    set objectColor(val) {
+        if (val !== this._objectColor) {
+            this._objectColor.set(val ?? Vector4.one());
+            this.uniformChanged();
+        }
+    }
+    /** Returns true if shading of the material will be affected by lights  */ supportLighting() {
+        return true;
+    }
+    /**
+   * {@inheritDoc Material.updateRenderStates}
+   */ updateRenderStates(pass, stateSet, ctx) {
+        const isObjectColorPass = ctx.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR;
+        const blending = !isObjectColorPass && (this.featureUsed(FEATURE_ALPHABLEND) !== 'none' || ctx.lightBlending);
+        const a2c = !isObjectColorPass && this.featureUsed(FEATURE_ALPHATOCOVERAGE);
+        const ztestEq = ctx.queue === QUEUE_OPAQUE && !!ctx.depthTexture && !ctx.sceneColorTexture;
+        if (blending || a2c) {
+            const blendingState = stateSet.useBlendingState();
+            if (blending) {
+                blendingState.enable(true);
+                blendingState.setBlendFuncAlpha('zero', 'one');
+                blendingState.setBlendEquation('add', 'add');
+                if (this._blendMode === 'additive' || ctx.lightBlending) {
+                    blendingState.setBlendFuncRGB('one', 'one');
+                } else {
+                    blendingState.setBlendFuncRGB('one', 'inv-src-alpha');
+                }
+            } else {
+                blendingState.enable(false);
+            }
+            blendingState.enableAlphaToCoverage(a2c);
+            if (ztestEq) {
+                stateSet.useDepthState().setCompareFunc('eq').enableTest(true).enableWrite(false);
+            } else if (blendingState.enabled) {
+                stateSet.useDepthState().enableTest(true).enableWrite(false);
+            } else {
+                stateSet.defaultDepthState();
+            }
+        } else {
+            stateSet.defaultBlendingState();
+            if (ztestEq) {
+                stateSet.useDepthState().setCompareFunc('eq').enableTest(true).enableWrite(false);
+            } else {
+                stateSet.defaultDepthState();
+            }
+        }
+        if (ctx.forceCullMode || this._cullMode !== 'back') {
+            stateSet.useRasterizerState().cullMode = ctx.forceCullMode || this._cullMode;
+        } else if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {
+            stateSet.useRasterizerState().cullMode = 'none';
+        } else {
+            stateSet.defaultRasterizerState();
+        }
+        if (ctx.forceColorState) {
+            stateSet.useColorState(ctx.forceColorState);
+        } else {
+            stateSet.defaultColorState();
+        }
+        stateSet.defaultStencilState();
+        if (ctx.oit) {
+            ctx.oit.setRenderStates(stateSet);
+        }
+    }
+    /**
+   * Submit Uniform values before rendering with this material.
+   *
+   * @param bindGroup - Bind group for this material
+   * @param ctx - Draw context
+   * @param pass - Current pass of the material
+   */ applyUniformValues(bindGroup, ctx, pass) {
+        if (this.featureUsed(FEATURE_ALPHATEST)) {
+            bindGroup.setValue('zAlphaCutoff', this._alphaCutoff);
+        }
+        if (this.isTransparentPass(pass) && ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT && !(ctx.materialFlags & MaterialVaryingFlags.INSTANCING)) {
+            bindGroup.setValue('zOpacity', this._opacity);
+        }
+        if (ctx.oit) {
+            ctx.oit.applyUniforms(ctx, bindGroup);
+        }
+        if (!(ctx.materialFlags & MaterialVaryingFlags.INSTANCING) && ctx.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {
+            bindGroup.setValue('zObjectColor', this._objectColor);
+        }
+        if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH && ctx.motionVectors) {
+            bindGroup.setValue('zTAAStrength', (1 - this._taaStrength) * 50000);
+        }
+    }
+    /**
+   * Determine which queue should be used to render this material.
+   * @returns QUEUE_TRANSPARENT or QUEUE_OPAQUE
+   */ getQueueType() {
+        return this.isTransparentPass(0) ? QUEUE_TRANSPARENT : QUEUE_OPAQUE;
+    }
+    /**
+   * Determine if a certain pass of this material is translucent.
+   * @param pass - Pass of the material
+   * @returns True if it is translucent, otherwise false.
+   */ isTransparentPass(_pass) {
+        return this.featureUsed(FEATURE_ALPHABLEND) !== 'none';
+    }
+    /** @internal */ createProgram(ctx, pass) {
+        const pb = new ProgramBuilder(ctx.device);
+        if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {
+            const shadowMapParams = ctx.shadowMapInfo.get(ctx.renderPass.light);
+            pb.emulateDepthClamp = !!shadowMapParams.depthClampEnabled;
+        }
+        return this._createProgram(pb, ctx, pass);
+    }
+    /**
+   * Check if a feature is in use for given render pass type.
+   *
+   * @param feature - The feature index
+   * @returns true if the feature is in use, otherwise false.
+   */ featureUsed(feature) {
+        return this._featureStates[feature];
+    }
+    /**
+   * Use or unuse a feature of the material, this will cause the shader to be rebuild.
+   *
+   * @param feature - Which feature will be used or unused
+   * @param use - true if use the feature, otherwise false
+   */ useFeature(feature, use) {
+        if (this._featureStates[feature] !== use) {
+            this._featureStates[feature] = use;
+            this.optionChanged(true);
+        }
+    }
+    /**
+   * {@inheritDoc Material._createHash}
+   * @override
+   *
+   * @internal
+   */ _createHash() {
+        return this._featureStates.map((val)=>val === undefined ? '' : val).join('|');
+    }
+    /**
+   * {@inheritDoc Material._applyUniforms}
+   * @override
+   *
+   * @internal
+   */ _applyUniforms(bindGroup, ctx, pass) {
+        this.applyUniformValues(bindGroup, ctx, pass);
+    }
+    /**
+   * Check if the color should be computed in fragment shader, this is required for forward render pass or alpha test is in use or alpha to coverage is in use.
+   *
+   * @returns - true if the color should be computed in fragment shader, otherwise false.
+   */ needFragmentColor(ctx) {
+        return (ctx ?? this.drawContext).renderPass.type === RENDER_PASS_TYPE_LIGHT || this._alphaCutoff > 0 || this.alphaToCoverage;
+    }
+    /**
+   * Vertex shader implementation of this material
+   * @param scope - Shader scope
+   */ vertexShader(scope) {
+        const pb = scope.$builder;
+        ShaderHelper.prepareVertexShader(pb, this.drawContext);
+        if (this.drawContext.materialFlags & MaterialVaryingFlags.SKIN_ANIMATION) {
+            scope.$inputs.zBlendIndices = pb.vec4().attrib('blendIndices');
+            scope.$inputs.zBlendWeights = pb.vec4().attrib('blendWeights');
+            ShaderHelper.prepareSkinAnimation(scope);
+        }
+        if (this.drawContext.materialFlags & MaterialVaryingFlags.MORPH_ANIMATION && this.drawContext.device.type === 'webgl') {
+            scope.$inputs.zFakeVertexID = pb.float().attrib('texCoord7');
+        }
+        if (this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING) {
+            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {
+                scope.$outputs.zObjectColor = this.getInstancedUniform(scope, MeshMaterial.OBJECT_COLOR_UNIFORM);
+            }
+            if (this.isTransparentPass(this.pass)) {
+                scope.$outputs.zOpacity = this.getInstancedUniform(scope, MeshMaterial.OPACITY_UNIFORM);
+            }
+        }
+    }
+    /**
+   * Fragment shader implementation of this material
+   * @param scope - Shader scope
+   */ fragmentShader(scope) {
+        const pb = scope.$builder;
+        ShaderHelper.prepareFragmentShader(pb, this.drawContext);
+        if (this._alphaCutoff > 0) {
+            scope.zAlphaCutoff = pb.float().uniform(2);
+        }
+        if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+            if (this.isTransparentPass(this.pass) && !(this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING)) {
+                scope.zOpacity = pb.float().uniform(2);
+            }
+        } else if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR && !(this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING)) {
+            scope.zObjectColor = pb.vec4().uniform(2);
+        }
+    }
+    /**
+   * {@inheritDoc Material._createProgram}
+   * @override
+   *
+   * @internal
+   */ _createProgram(pb, ctx, pass) {
+        const that = this;
+        this._ctx = ctx;
+        this._materialPass = pass;
+        const program = pb.buildRenderProgram({
+            vertex (pb) {
+                pb.main(function() {
+                    that.vertexShader(this);
+                });
+            },
+            fragment (pb) {
+                if (that.drawContext.oit) {
+                    that.drawContext.oit.setupFragmentOutput(this);
+                } else {
+                    this.$outputs.zFragmentOutput = pb.vec4();
+                    if (ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
+                        this.$outputs.zSSRRoughness = pb.vec4();
+                        this.$outputs.zSSRNormal = pb.vec4();
+                    }
+                    if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH && ctx.motionVectors) {
+                        this.$outputs.zMotionVector = pb.vec4();
+                        this.zTAAStrength = pb.float().uniform(2);
+                    }
+                    if (ctx.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {
+                        this.$outputs.zDistance = pb.vec4();
+                    }
+                }
+                pb.main(function() {
+                    that.fragmentShader(this);
+                });
+            }
+        });
+        return program;
+    }
+    /**
+   * Calculate final fragment color for output.
+   *
+   * @param scope - Shader scope
+   * @param color - Lit fragment color
+   *
+   * @returns The final fragment color
+   */ outputFragmentColor(scope, worldPos, color, ssrRoughness, ssrNormal) {
+        const pb = scope.$builder;
+        const that = this;
+        const funcName = 'Z_outputFragmentColor';
+        pb.func(funcName, color ? [
+            pb.vec3('worldPos'),
+            pb.vec4('color')
+        ] : [
+            pb.vec3('worldPos')
+        ], function() {
+            this.$l.outColor = color ? this.color : pb.vec4();
+            if (that.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+                ShaderHelper.discardIfClipped(this, this.worldPos);
+                let output = true;
+                if (!that.isTransparentPass(that.pass) && !that.alphaToCoverage) {
+                    this.outColor.a = 1;
+                } else if (that.isTransparentPass(that.pass)) {
+                    const opacity = that.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING ? this.$inputs.zOpacity : this.zOpacity;
+                    this.outColor.a = pb.mul(this.outColor.a, opacity);
+                }
+                if (that.isTransparentPass(that.pass)) {
+                    if (this.zAlphaCutoff) {
+                        this.$if(pb.lessThan(this.outColor.a, this.zAlphaCutoff), function() {
+                            pb.discard();
+                        });
+                    }
+                    if (!that.drawContext.oit || that.drawContext.oit.wantsPremultipliedAlpha()) {
+                        this.outColor = pb.vec4(pb.mul(this.outColor.rgb, this.outColor.a), that.featureUsed(FEATURE_ALPHABLEND) === 'additive' ? 0 : this.outColor.a);
+                    }
+                    output = !that.drawContext.oit || !that.drawContext.oit.outputFragmentColor(this, this.outColor);
+                }
+                if (output) {
+                    ShaderHelper.applyFog(this, this.worldPos, this.outColor, that.drawContext);
+                    this.$outputs.zFragmentOutput = ShaderHelper.encodeColorOutput(this, this.outColor);
+                }
+            } else if (that.drawContext.renderPass.type === RENDER_PASS_TYPE_DEPTH) {
+                if (color) {
+                    if (this.zAlphaCutoff) {
+                        this.$if(pb.lessThan(this.outColor.a, this.zAlphaCutoff), function() {
+                            pb.discard();
+                        });
+                    }
+                }
+                ShaderHelper.discardIfClipped(this, this.worldPos);
+                const depthPass = that.drawContext.renderPass;
+                this.$l.depth = ShaderHelper.nonLinearDepthToLinearNormalized(this, this.$builtins.fragCoord.z);
+                if (depthPass.encodeDepth) {
+                    this.$outputs.zFragmentOutput = encodeNormalizedFloatToRGBA(this, this.depth);
+                } else if (depthPass.renderBackface) {
+                    this.$outputs.zFragmentOutput = pb.vec4(0, this.depth, 0, 1);
+                } else {
+                    this.$outputs.zFragmentOutput = pb.vec4(this.depth, 0, 0, 1);
+                }
+                if (that.drawContext.motionVectors) {
+                    if (that.featureUsed(FEATURE_DISABLE_TAA)) {
+                        this.$outputs.zMotionVector = pb.vec4(6e4, 6e4, 1, 1);
+                    } else {
+                        if (this.$inputs.zMotionVectorPosCurrent && this.$inputs.zMotionVectorPosPrev) {
+                            this.$outputs.zMotionVector = pb.vec4(pb.mul(pb.sub(pb.div(this.$inputs.zMotionVectorPosCurrent.xy, this.$inputs.zMotionVectorPosCurrent.w), pb.div(this.$inputs.zMotionVectorPosPrev.xy, this.$inputs.zMotionVectorPosPrev.w)), 0.5), this.zTAAStrength, 1);
+                        } else {
+                            this.$outputs.zMotionVector = pb.vec4(0, 0, 1, 1);
+                        }
+                    }
+                }
+            } else if (that.drawContext.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {
+                if (color) {
+                    this.$if(pb.lessThan(this.outColor.a, this.zAlphaCutoff), function() {
+                        pb.discard();
+                    });
+                }
+                ShaderHelper.discardIfClipped(this, this.worldPos);
+                this.$outputs.zFragmentOutput = that.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING ? scope.$inputs.zObjectColor : scope.zObjectColor;
+                if (that.drawContext.device.type === 'webgl') {
+                    this.$l.linearDepth = ShaderHelper.nonLinearDepthToLinearNormalized(this, this.$builtins.fragCoord.z);
+                    this.$outputs.zDistance = encodeNormalizedFloatToRGBA(this, this.linearDepth);
+                } else {
+                    this.$outputs.zDistance = pb.vec4(this.worldPos, pb.distance(ShaderHelper.getCameraPosition(this), this.worldPos));
+                }
+            } else {
+                if (color) {
+                    this.$if(pb.lessThan(this.outColor.a, this.zAlphaCutoff), function() {
+                        pb.discard();
+                    });
+                }
+                ShaderHelper.discardIfClipped(this, this.worldPos);
+                const shadowMapParams = that.drawContext.shadowMapInfo.get(that.drawContext.renderPass.light);
+                this.$outputs.zFragmentOutput = shadowMapParams.impl.computeShadowMapDepth(shadowMapParams, this, this.worldPos);
+            }
+        });
+        if (color) {
+            pb.getGlobalScope()[funcName](worldPos, color);
+        } else {
+            pb.getGlobalScope()[funcName](worldPos);
+        }
+        if (that.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
+            scope.$outputs.zSSRRoughness = ssrRoughness ?? pb.vec4(1, 0, 0, 1);
+            scope.$outputs.zSSRNormal = ssrNormal ?? pb.vec4(0);
+        }
+    }
+}
+FEATURE_ALPHATEST = MeshMaterial.defineFeature();
+FEATURE_ALPHABLEND = MeshMaterial.defineFeature();
+FEATURE_ALPHATOCOVERAGE = MeshMaterial.defineFeature();
+FEATURE_DISABLE_TAA = MeshMaterial.defineFeature();
+
+export { MeshMaterial, applyMaterialMixins };
+//# sourceMappingURL=meshmaterial.js.map