@zephyr3d/scene 0.1.0

package/dist/material/meshmaterial.js

@@ -0,0 +1,311 @@
+import { ProgramBuilder } from '@zephyr3d/device';
+import { RENDER_PASS_TYPE_FORWARD, RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH_ONLY } from '../values.js';
+import { Material } from './material.js';
+import { ShaderFramework } from '../shaders/framework.js';
+import { encodeColorOutput, nonLinearDepthToLinearNormalized, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
+import { Application } from '../app.js';
+
+const allRenderPassTypes = [
+    RENDER_PASS_TYPE_FORWARD,
+    RENDER_PASS_TYPE_SHADOWMAP,
+    RENDER_PASS_TYPE_DEPTH_ONLY
+];
+function applyMaterialMixins(target, ...mixins) {
+    let r = target;
+    for (const m of mixins){
+        r = m(r);
+    }
+    return r;
+}
+class MeshMaterial extends Material {
+    static FEATURE_ALPHATEST = 'mm_alphatest';
+    static FEATURE_ALPHABLEND = 'mm_alphablend';
+    static FEATURE_ALPHATOCOVERAGE = 'mm_alphatocoverage';
+    _features;
+    _featureStates;
+    _featureIndex;
+    _alphaCutoff;
+    _blendMode;
+    _opacity;
+    constructor(){
+        super();
+        this._features = new Map();
+        this._featureStates = [];
+        this._featureStates[RENDER_PASS_TYPE_FORWARD] = [];
+        this._featureStates[RENDER_PASS_TYPE_SHADOWMAP] = [];
+        this._featureStates[RENDER_PASS_TYPE_DEPTH_ONLY] = [];
+        this._featureIndex = 0;
+        this._alphaCutoff = 0;
+        this._blendMode = 'none';
+        this._opacity = 1;
+    }
+    /** 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(MeshMaterial.FEATURE_ALPHATEST, val > 0);
+            this._alphaCutoff = val;
+            this.optionChanged(false);
+        }
+    }
+    get alphaToCoverage() {
+        return this.featureUsed(MeshMaterial.FEATURE_ALPHATOCOVERAGE, RENDER_PASS_TYPE_FORWARD);
+    }
+    set alphaToCoverage(val) {
+        this.useFeature(MeshMaterial.FEATURE_ALPHATOCOVERAGE, !!val, RENDER_PASS_TYPE_FORWARD);
+    }
+    /** Blending mode */ get blendMode() {
+        return this._blendMode;
+    }
+    set blendMode(val) {
+        if (this._blendMode !== val) {
+            this._blendMode = val;
+            this.useFeature(MeshMaterial.FEATURE_ALPHABLEND, this._blendMode !== 'none' || this._opacity < 1, RENDER_PASS_TYPE_FORWARD);
+        }
+    }
+    /** 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.useFeature(MeshMaterial.FEATURE_ALPHABLEND, this._opacity < 1, RENDER_PASS_TYPE_FORWARD);
+            this.optionChanged(false);
+        }
+    }
+    /** @internal */ updateBlendingState(ctx) {
+        const blending = this.featureUsed(MeshMaterial.FEATURE_ALPHABLEND, ctx.renderPass.type);
+        const a2c = this.featureUsed(MeshMaterial.FEATURE_ALPHATOCOVERAGE, ctx.renderPass.type);
+        if (blending || a2c) {
+            const blendingState = this.stateSet.useBlendingState();
+            if (blending) {
+                blendingState.enable(true);
+                if (this._blendMode === 'additive') {
+                    blendingState.setBlendEquation('add', 'add');
+                    blendingState.setBlendFunc('one', 'one');
+                } else if (this._blendMode === 'max') {
+                    blendingState.setBlendEquation('max', 'add');
+                    blendingState.setBlendFuncRGB('one', 'one');
+                    blendingState.setBlendFuncAlpha('zero', 'one');
+                } else if (this._blendMode === 'min') {
+                    blendingState.setBlendEquation('min', 'add');
+                    blendingState.setBlendFuncRGB('one', 'one');
+                    blendingState.setBlendFuncAlpha('zero', 'one');
+                } else {
+                    blendingState.setBlendEquation('add', 'add');
+                    blendingState.setBlendFunc('one', 'inv-src-alpha');
+                }
+            } else {
+                blendingState.enable(false);
+            }
+            blendingState.enableAlphaToCoverage(a2c);
+        } else if (this.stateSet.blendingState?.enabled && !blending) {
+            this.stateSet.defaultBlendingState();
+        }
+    }
+    applyUniformValues(bindGroup, ctx) {
+        if (this.featureUsed(MeshMaterial.FEATURE_ALPHATEST, ctx.renderPass.type)) {
+            bindGroup.setValue('kkAlphaCutoff', this._alphaCutoff);
+        }
+        if (this.featureUsed(MeshMaterial.FEATURE_ALPHABLEND, ctx.renderPass.type)) {
+            bindGroup.setValue('kkOpacity', this._opacity);
+        }
+    }
+    /** true if the material is transparency */ isTransparent() {
+        return this._blendMode !== 'none' || this._opacity < 1;
+    }
+    beginDraw(ctx) {
+        this.updateBlendingState(ctx);
+        return super.beginDraw(ctx);
+    }
+    /** @internal */ createProgram(ctx) {
+        const pb = new ProgramBuilder(Application.instance.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);
+    }
+    /**
+   * Check if a feature is in use for given render pass type.
+   *
+   * @param feature - The feature name
+   * @param renderPassType - Render pass type
+   * @returns true if the feature is in use, otherwise false.
+   */ featureUsed(feature, renderPassType) {
+        const index = this._features.get(feature);
+        return this._featureStates[renderPassType][index];
+    }
+    /**
+   * 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, renderPassType) {
+        renderPassType = renderPassType ?? allRenderPassTypes;
+        if (typeof renderPassType === 'number') {
+            renderPassType = [
+                renderPassType
+            ];
+        }
+        let index = this._features.get(feature);
+        if (index === void 0) {
+            index = this._featureIndex++;
+            this._features.set(feature, index);
+        }
+        let changed = false;
+        for (const type of renderPassType){
+            if (type !== RENDER_PASS_TYPE_FORWARD && type !== RENDER_PASS_TYPE_SHADOWMAP && type !== RENDER_PASS_TYPE_DEPTH_ONLY) {
+                console.error(`useFeature(): invalid render pass type: ${type}`);
+            }
+            if (this._featureStates[type][index] !== use) {
+                this._featureStates[type][index] = use;
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.optionChanged(true);
+        }
+    }
+    /**
+   * {@inheritDoc Material._createHash}
+   * @override
+   */ _createHash(renderPassType) {
+        return this._featureStates[renderPassType].join('');
+    }
+    /**
+   * {@inheritDoc Material._applyUniforms}
+   * @override
+   */ _applyUniforms(bindGroup, ctx) {
+        this.applyUniformValues(bindGroup, ctx);
+    }
+    /**
+   * 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.
+   *
+   * @param ctx - The drawing context
+   * @returns - true if the color should be computed in fragment shader, otherwise false.
+   */ needFragmentColor(ctx) {
+        return ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD || this._alphaCutoff > 0 || this.alphaToCoverage;
+    }
+    /**
+   * Transform vertex position to the clip space and calcuate the world position, world normal and tangent frame if needed
+   *
+   * @remarks
+   * This function handles skin animation and geometry instancing if needed
+   *
+   * @param scope - Current shader scope
+   */ transformVertexAndNormal(scope) {
+        ShaderFramework.ftransform(scope);
+    }
+    /**
+   * Vertex shader implementation of this material
+   * @param scope - Shader scope
+   * @param ctx - The drawing context
+   */ vertexShader(scope, ctx) {
+        const pb = scope.$builder;
+        ShaderFramework.prepareVertexShader(pb, ctx);
+        if (ctx.target.getBoneMatrices()) {
+            scope.$inputs.kkBlendIndices = pb.vec4().attrib('blendIndices');
+            scope.$inputs.kkBlendWeights = pb.vec4().attrib('blendWeights');
+        }
+    }
+    /**
+   * Fragment shader implementation of this material
+   * @param scope - Shader scope
+   * @param ctx - The drawing context
+   */ fragmentShader(scope, ctx) {
+        const pb = scope.$builder;
+        ShaderFramework.prepareFragmentShader(pb, ctx);
+        if (this._alphaCutoff > 0) {
+            scope.$g.kkAlphaCutoff = pb.float().uniform(2);
+        }
+        if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+            if (this.isTransparent()) {
+                scope.$g.kkOpacity = pb.float().uniform(2);
+            }
+        }
+    }
+    /**
+   * {@inheritDoc Material._createProgram}
+   * @override
+   */ _createProgram(pb, ctx) {
+        const that = this;
+        const program = pb.buildRenderProgram({
+            vertex (pb) {
+                pb.main(function() {
+                    that.vertexShader(this, ctx);
+                });
+            },
+            fragment (pb) {
+                this.$outputs.zFragmentOutput = pb.vec4();
+                pb.main(function() {
+                    that.fragmentShader(this, ctx);
+                });
+            }
+        });
+        return program;
+    }
+    /**
+   * Calculate final fragment color for output.
+   *
+   * @param scope - Shader scope
+   * @param color - Lit fragment color
+   * @param ctx - The drawing context
+   *
+   * @returns The final fragment color
+   */ outputFragmentColor(scope, color, ctx) {
+        const pb = scope.$builder;
+        const that = this;
+        pb.func('zOutputFragmentColor', color ? [
+            pb.vec4('color')
+        ] : [], function() {
+            this.$l.outColor = color ? this.color : pb.vec4();
+            if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+                ShaderFramework.discardIfClipped(this);
+                if (!that.isTransparent() && !this.kkAlphaCutoff && !that.alphaToCoverage) {
+                    this.outColor.a = 1;
+                } else if (this.kkOpacity) {
+                    this.outColor.a = pb.mul(this.outColor.a, this.kkOpacity);
+                }
+                if (this.kkAlphaCutoff) {
+                    this.$if(pb.lessThan(this.outColor.a, this.kkAlphaCutoff), function() {
+                        pb.discard();
+                    });
+                }
+                if (that.isTransparent()) {
+                    this.outColor = pb.vec4(pb.mul(this.outColor.rgb, this.outColor.a), this.outColor.a);
+                }
+                ShaderFramework.applyFog(this, this.outColor, ctx);
+                this.$outputs.zFragmentOutput = encodeColorOutput(this, this.outColor);
+            } else if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH_ONLY) {
+                if (color) {
+                    this.$if(pb.lessThan(this.outColor.a, this.kkAlphaCutoff), function() {
+                        pb.discard();
+                    });
+                }
+                ShaderFramework.discardIfClipped(this);
+                this.$l.kkDepth = nonLinearDepthToLinearNormalized(this, this.$builtins.fragCoord.z);
+                if (Application.instance.device.type === 'webgl') {
+                    this.$outputs.zFragmentOutput = encodeNormalizedFloatToRGBA(this, this.kkDepth);
+                } else {
+                    this.$outputs.zFragmentOutput = pb.vec4(this.kkDepth, 0, 0, 1);
+                }
+            } else /*if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP)*/ {
+                if (color) {
+                    this.$if(pb.lessThan(this.outColor.a, this.kkAlphaCutoff), function() {
+                        pb.discard();
+                    });
+                }
+                ShaderFramework.discardIfClipped(this);
+                const shadowMapParams = ctx.shadowMapInfo.get(ctx.renderPass.light);
+                this.$outputs.zFragmentOutput = shadowMapParams.impl.computeShadowMapDepth(shadowMapParams, this);
+            }
+        });
+        color ? pb.getGlobalScope().zOutputFragmentColor(color) : pb.getGlobalScope().zOutputFragmentColor();
+    }
+}
+
+export { MeshMaterial, applyMaterialMixins };
+//# sourceMappingURL=meshmaterial.js.map

package/dist/material/meshmaterial.js.map

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

package/dist/material/mixins/albedocolor.js

@@ -0,0 +1,130 @@
+import { Vector4 } from '@zephyr3d/base';
+
+function mixinAlbedoColor(BaseCls) {
+    if (BaseCls.albedoColorMixed) {
+        return BaseCls;
+    }
+    const FEATURE_ALBEDO_MAP = 'z-feature-albedo-map';
+    const FEATURE_ALBEDO_TEXCOORD_INDEX = 'z-feature-albedo-texcoord-index';
+    const FEATURE_ALBEDO_TEXCOORD_MATRIX = 'z-feature-albedo-texcoord-matrix';
+    return class extends BaseCls {
+        static albedoColorMixed = true;
+        _albedoColor;
+        _albedoTexture;
+        _albedoSampler;
+        _albedoTexCoordIndex;
+        _albedoTexCoordMatrix;
+        constructor(...args){
+            super(...args);
+            this._albedoColor = Vector4.one();
+            this._albedoTexture = null;
+            this._albedoSampler = null;
+            this._albedoTexCoordIndex = 0;
+            this._albedoTexCoordMatrix = null;
+        }
+        /** Albedo color */ get albedoColor() {
+            return this._albedoColor;
+        }
+        set albedoColor(val) {
+            this._albedoColor.set(val);
+            this.optionChanged(false);
+        }
+        /** Albedo texture coordinate index */ get albedoTexCoordIndex() {
+            return this._albedoTexCoordIndex;
+        }
+        set albedoTexCoordIndex(val) {
+            if (val !== this._albedoTexCoordIndex) {
+                this._albedoTexCoordIndex = val;
+                if (this._albedoTexture) {
+                    this.useFeature(FEATURE_ALBEDO_TEXCOORD_INDEX, this._albedoTexCoordIndex);
+                }
+            }
+        }
+        /** Albedo texture */ get albedoTexture() {
+            return this._albedoTexture;
+        }
+        set albedoTexture(tex) {
+            if (this._albedoTexture !== tex) {
+                this.useFeature(FEATURE_ALBEDO_MAP, !!tex);
+                if (tex) {
+                    this.useFeature(FEATURE_ALBEDO_TEXCOORD_INDEX, this._albedoTexCoordIndex);
+                    this.useFeature(FEATURE_ALBEDO_TEXCOORD_MATRIX, !!this._albedoTexCoordMatrix);
+                }
+                this._albedoTexture = tex ?? null;
+                this.optionChanged(false);
+            }
+        }
+        /** Albedo texture sampler */ get albedoTextureSampler() {
+            return this._albedoSampler;
+        }
+        set albedoTextureSampler(sampler) {
+            this._albedoSampler = sampler ?? null;
+        }
+        /** Albedo texture coordinate transform matrix */ get albedoTexMatrix() {
+            return this._albedoTexCoordMatrix;
+        }
+        set albedoTexMatrix(val) {
+            if (val !== this._albedoTexCoordMatrix) {
+                this._albedoTexCoordMatrix = val;
+                if (this._albedoTexture) {
+                    this.useFeature(FEATURE_ALBEDO_TEXCOORD_MATRIX, !!this._albedoTexCoordMatrix);
+                }
+                this.optionChanged(false);
+            }
+        }
+        calculateAlbedoColor(scope, ctx) {
+            if (!this.needFragmentColor(ctx)) {
+                throw new Error('mixinAlbedoColor.calculateAlbedoColor(): No need to calculate albedo color, make sure needFragmentColor() returns true');
+            }
+            const pb = scope.$builder;
+            let color = scope.kkAlbedo;
+            if (this.featureUsed(FEATURE_ALBEDO_MAP, ctx.renderPass.type)) {
+                color = pb.mul(color, pb.textureSample(scope.kkAlbedoTex, scope.$inputs.kkAlbedoTexCoord));
+            }
+            return color;
+        }
+        vertexShader(scope, ctx) {
+            super.vertexShader(scope, ctx);
+            if (this.needFragmentColor(ctx)) {
+                const pb = scope.$builder;
+                if (this.featureUsed(FEATURE_ALBEDO_MAP, ctx.renderPass.type)) {
+                    const semantic = `texCoord${this.albedoTexCoordIndex}`;
+                    if (!scope.$getVertexAttrib(semantic)) {
+                        scope.$inputs[semantic] = pb.vec2().attrib(semantic);
+                    }
+                    if (this.featureUsed(FEATURE_ALBEDO_TEXCOORD_MATRIX, ctx.renderPass.type)) {
+                        scope.$g.kkAlbedoTextureMatrix = pb.mat4().uniform(2);
+                        scope.$outputs.kkAlbedoTexCoord = pb.mul(scope.kkAlbedoTextureMatrix, pb.vec4(scope.$inputs[semantic], 0, 1)).xy;
+                    } else {
+                        scope.$outputs.kkAlbedoTexCoord = scope.$inputs[semantic];
+                    }
+                }
+            }
+        }
+        fragmentShader(scope, ctx) {
+            super.fragmentShader(scope, ctx);
+            if (this.needFragmentColor(ctx)) {
+                const pb = scope.$builder;
+                scope.$g.kkAlbedo = pb.vec4().uniform(2);
+                if (this.featureUsed(FEATURE_ALBEDO_MAP, ctx.renderPass.type)) {
+                    scope.$g.kkAlbedoTex = pb.tex2D().uniform(2);
+                }
+            }
+        }
+        applyUniformValues(bindGroup, ctx) {
+            super.applyUniformValues(bindGroup, ctx);
+            if (this.needFragmentColor(ctx)) {
+                bindGroup.setValue('kkAlbedo', this._albedoColor);
+                if (this.featureUsed(FEATURE_ALBEDO_MAP, ctx.renderPass.type)) {
+                    bindGroup.setTexture('kkAlbedoTex', this._albedoTexture, this._albedoSampler);
+                    if (this.featureUsed(FEATURE_ALBEDO_TEXCOORD_MATRIX, ctx.renderPass.type)) {
+                        bindGroup.setValue('kkAlbedoTextureMatrix', this._albedoTexCoordMatrix);
+                    }
+                }
+            }
+        }
+    };
+}
+
+export { mixinAlbedoColor };
+//# sourceMappingURL=albedocolor.js.map

package/dist/material/mixins/albedocolor.js.map

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

package/dist/material/mixins/texture.js

@@ -0,0 +1,110 @@
+function mixinTextureProps(name) {
+    return function(BaseCls) {
+        const capName = `${name[0].toUpperCase()}${name.slice(1)}`;
+        const upperName = name.toUpperCase();
+        const id = `mixinTexture${capName}`;
+        const feature = `FEATURE_TEXTURE_${upperName}`;
+        const featureTexIndex = `FEATURE_TEXTURE_TEXCOORD_INDEX_${upperName}`;
+        const featureTexMatrix = `FEATURE_TEXTURE_TEXCOORD_MATRIX_${upperName}`;
+        if (BaseCls[id]) {
+            return BaseCls;
+        }
+        const cls = class extends BaseCls {
+            constructor(...args){
+                super(...args);
+                let textureValue = null;
+                let textureSampler = null;
+                let textureCoordIndex = 0;
+                let textureCoordMatrix = null;
+                this[`get${capName}TextureUniform`] = function(scope) {
+                    return scope.$builder.shaderKind === 'fragment' ? scope[`kk${capName}Tex`] : null;
+                };
+                this[`get${capName}TexCoord`] = function(scope) {
+                    return scope.$builder.shaderKind === 'fragment' ? scope[`kk${capName}TexCoord`] : scope.$outputs[`kk${capName}TexCoord`];
+                };
+                Object.defineProperty(this, `${name}Texture`, {
+                    get: ()=>textureValue,
+                    set: (newValue)=>{
+                        if (textureValue !== newValue) {
+                            textureValue = newValue ?? null;
+                            this.useFeature(feature, !!textureValue);
+                            if (textureValue) {
+                                this.useFeature(featureTexIndex, textureCoordIndex);
+                                this.useFeature(featureTexMatrix, !!textureCoordMatrix);
+                                this.optionChanged(false);
+                            }
+                        }
+                        textureValue = newValue;
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+                Object.defineProperty(this, `${name}TextureSampler`, {
+                    get: ()=>textureSampler,
+                    set: (newValue)=>null,
+                    enumerable: true,
+                    configurable: true
+                });
+                Object.defineProperty(this, `${name}TexCoordIndex`, {
+                    get: ()=>textureCoordMatrix,
+                    set: (newValue)=>{
+                        if (textureCoordMatrix !== newValue) {
+                            textureCoordMatrix = newValue;
+                            if (textureValue) {
+                                this.useFeature(featureTexMatrix, !!textureCoordMatrix);
+                            }
+                        }
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+                Object.defineProperty(this, `${name}TexCoordMatrix`, {
+                    get: ()=>textureCoordIndex,
+                    set: (newValue)=>{
+                        if (textureCoordIndex !== newValue) {
+                            textureCoordIndex = newValue;
+                            if (textureValue) {
+                                this.useFeature(featureTexIndex, textureCoordIndex);
+                            }
+                        }
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+            vertexShader(scope, ctx) {
+                super.vertexShader(scope, ctx);
+                if (this.needFragmentColor(ctx)) {
+                    const pb = scope.$builder;
+                    if (this.featureUsed(feature, ctx.renderPass.type)) {
+                        const semantic = `texCoord${this[`${name}TexCoordIndex`]}`;
+                        if (!scope.$getVertexAttrib(semantic)) {
+                            scope.$inputs[semantic] = pb.vec2().attrib(semantic);
+                        }
+                        if (this.featureUsed(featureTexMatrix, ctx.renderPass.type)) {
+                            scope.$g[`kk${capName}TextureMatrix`] = pb.mat4().uniform(2);
+                            scope.$outputs[`kk${capName}TexCoord`] = pb.mul(scope[`kk${capName}TextureMatrix`], pb.vec4(scope.$inputs[semantic], 0, 1)).xy;
+                        } else {
+                            scope.$outputs[`kk${capName}TexCoord`] = scope.$inputs[semantic];
+                        }
+                    }
+                }
+            }
+            fragmentShader(scope, ctx) {
+                super.fragmentShader(scope, ctx);
+                if (this.needFragmentColor(ctx)) {
+                    const pb = scope.$builder;
+                    if (this.featureUsed(feature, ctx.renderPass.type)) {
+                        scope.$g[`kk${capName}Tex`] = pb.tex2D().uniform(2);
+                    }
+                }
+            }
+        };
+        cls[id] = true;
+        cls[`FEATURE_TEXTURE_${upperName}`] = feature;
+        return cls;
+    };
+}
+
+export { mixinTextureProps };
+//# sourceMappingURL=texture.js.map

package/dist/material/mixins/texture.js.map

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

package/dist/material/mixins/vertexcolor.js

@@ -0,0 +1,45 @@
+import { RENDER_PASS_TYPE_FORWARD } from '../../values.js';
+
+function mixinVertexColor(BaseCls) {
+    if (BaseCls.vertexColorMixed) {
+        return BaseCls;
+    }
+    const FEATURE_VERTEX_COLOR = 'z-feature-vertex-color';
+    return class extends BaseCls {
+        static vertexColorMixed = true;
+        constructor(...args){
+            super(...args);
+        }
+        /** Albedo color */ get vertexColor() {
+            return this.featureUsed(FEATURE_VERTEX_COLOR, RENDER_PASS_TYPE_FORWARD);
+        }
+        set vertexColor(val) {
+            this.useFeature(FEATURE_VERTEX_COLOR, !!val);
+        }
+        vertexShader(scope, ctx) {
+            super.vertexShader(scope, ctx);
+            if (this.needFragmentColor(ctx)) {
+                if (this.vertexColor) {
+                    if (scope.$getVertexAttrib('diffuse')) {
+                        throw new Error('mixinVertexColor.vertexShader(): diffuse vertex stream already defined');
+                    }
+                    scope.$inputs.zDiffuse = scope.$builder.vec4().attrib('diffuse');
+                    scope.$outputs.zOutDiffuse = scope.$inputs.zDiffuse;
+                }
+            }
+        }
+        getVertexColor(scope, ctx) {
+            if (!this.needFragmentColor(ctx)) {
+                throw new Error('mixinVertexColor.getVertexColor(): No need to calculate albedo color, make sure needFragmentColor() returns true');
+            }
+            if (scope.$builder.shaderKind === 'fragment') {
+                return scope.$inputs.zOutDiffuse;
+            } else {
+                return scope.$inputs.zDiffuse;
+            }
+        }
+    };
+}
+
+export { mixinVertexColor };
+//# sourceMappingURL=vertexcolor.js.map

package/dist/material/mixins/vertexcolor.js.map

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

package/dist/material/pbr.js

@@ -0,0 +1,27 @@
+import { StandardMaterial } from './standard.js';
+import { PBRLightModelMR, PBRLightModelSG } from './lightmodel.js';
+
+/**
+ * PBR material for metallic-roughenss work flow
+ * @public
+ */ class PBRMetallicRoughnessMaterial extends StandardMaterial {
+    constructor(){
+        super();
+        this.lightModel = new PBRLightModelMR();
+    }
+    get GGXLUT() {
+        return PBRLightModelMR.getGGXLUT();
+    }
+}
+/**
+ * PBR material for specular-glossness workflow
+ * @public
+ */ class PBRSpecularGlossinessMaterial extends StandardMaterial {
+    constructor(){
+        super();
+        this.lightModel = new PBRLightModelSG();
+    }
+}
+
+export { PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial };
+//# sourceMappingURL=pbr.js.map

package/dist/material/pbr.js.map

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