LitOptions class to hold backend options

src/deprecated/deprecated.js

@@ -71,6 +71,8 @@ import { SkinInstance } from '../scene/skin-instance.js';
 import { StandardMaterial } from '../scene/materials/standard-material.js';
 import { Batch } from '../scene/batching/batch.js';
 import { getDefaultMaterial } from '../scene/materials/default-material.js';
+import { Options } from '../scene/materials/options.js';
+import { LitOptions } from '../scene/materials/lit-options.js';
 
 import { Animation, Key, Node } from '../scene/animation/animation.js';
 import { Skeleton } from '../scene/animation/skeleton.js';
@@ -785,6 +787,24 @@ _defineAlias('glossVertexColor', 'glossMapVertexColor');
 _defineAlias('opacityVertexColor', 'opacityMapVertexColor');
 _defineAlias('lightVertexColor', 'lightMapVertexColor');
 
+function _defineOption(name) {
+    Object.defineProperty(Options.prototype, name, {
+        get: function () {
+            Debug.deprecated(`Getting pc.Options#${name} has been deprecated as the property has been moved to pc.Options.LitOptions.`);
+            return null;
+        },
+        set: function (value) {
+            Debug.deprecated(`Setting pc.Options#${name} has been deprecated as the property has been moved to pc.Options.LitOptions.`);
+        }
+    });
+}
+
+const tempOptions = new LitOptions();
+const litOptionProperties = Object.getOwnPropertyNames(tempOptions);
+for (const litOption in litOptionProperties) {
+    _defineOption(litOptionProperties[litOption]);
+}
+
 // ANIMATION
 
 export const anim = {

src/scene/materials/lit-options.js

@@ -0,0 +1,102 @@
+import {
+    BLEND_NONE, GAMMA_NONE
+} from '../constants.js';
+
+class LitOptions {
+    constructor() {
+        this.hasTangents = false;
+        this.chunks = [];
+
+        this.pass = 0;
+        this.alphaTest = false;
+        this.forceFragmentPrecision = false;
+        this.blendType = BLEND_NONE;
+        this.separateAmbient = false;
+        this.screenSpace = false;
+        this.skin = false;
+        this.useInstancing = false;
+        this.useMorphPosition = false;
+        this.useMorphNormal = false;
+        this.useMorphTextureBased = false;
+
+        this.nineSlicedMode = false;
+
+        this.clusteredLightingEnabled = true;
+
+        this.clusteredLightingCookiesEnabled = false;
+        this.clusteredLightingShadowsEnabled = false;
+        this.clusteredLightingShadowType = 0;
+        this.clusteredLightingAreaLightsEnabled = false;
+
+        this.vertexColors = false;
+        this.lightMapEnabled = false;
+        this.useLightMapVertexColors = false;
+        this.dirLightMapEnabled = false;
+        this.heightMapEnabled = false;
+        this.normalMapEnabled = false;
+        this.clearCoatNormalMapEnabled = false;
+        this.aoMapEnabled = false;
+        this.useAoVertexColors = false;
+        this.diffuseMapEnabled = false;
+
+        this.useAmbientTint = false;
+        this.customFragmentShader = null;
+        this.pixelSnap = false;
+
+        this.useClearCoatNormalMap = false;
+        this.useDiffuseMap = false;
+        this.useAoMap = false;
+
+        this.detailModes = 0;
+        this.shadingModel = 0;
+        this.ambientSH = false;
+        this.fastTbn = false;
+        this.twoSidedLighting = false;
+        this.occludeSpecular = false;
+        this.occludeSpecularFloat = false;
+
+        this.useMsdf = false;
+        this.msdfTextAttribute = 0;
+
+        this.alphaToCoverage = false;
+        this.opacityFadesSpecular = false;
+
+        this.cubeMapProjection = false;
+
+        this.occludeDirect = false;
+        this.conserveEnergy = false;
+        this.useSpecular = false;
+        this.useSpecularityFactor = false;
+        this.useSpecularColor = false;
+        this.enableGGXSpecular = false;
+        this.fresnelModel = 0;
+        this.useRefraction = false;
+        this.useClearCoat = false;
+        this.useSheen = false;
+        this.useIridescence = false;
+        this.useMetalness = false;
+        this.useDynamicRefraction = false;
+
+        this.fog = 'none';
+        this.gamma = GAMMA_NONE;
+        this.toneMap = -1;
+        this.fixSeams = false;
+
+        this.reflectionSource = null;
+        this.reflectionEncoding = null;
+        this.ambientSource = 'constant';
+        this.ambientEncoding = null;
+
+        // TODO: add a test for if non skybox cubemaps have rotation (when this is supported) - for now assume no non-skybox cubemap rotation
+        this.skyboxIntensity = 1.0;
+        this.useCubeMapRotation = false;
+
+        this.lightMapWithoutAmbient = false;
+
+        this.lights = [];
+        this.noShadow = false;
+        this.lightMaskDynamic = 0x0;
+    }
+}
+
+export { LitOptions };

src/scene/materials/options.js

@@ -0,0 +1,7 @@
+class Options {
+    constructor() {
+        this.chunks = [];
+    }
+}
+
+export { Options };

src/scene/materials/standard-material-options-builder.js

@@ -17,6 +17,8 @@ import {
 } from '../constants.js';
 import { _matTex2D } from '../shader-lib/programs/standard.js';
 
+import { LitOptions } from './lit-options.js';
+
 const arraysEqual = (a, b) => {
     if (a.length !== b.length) {
         return false;
@@ -44,15 +46,15 @@ class StandardMaterialOptionsBuilder {
 
     // Minimal options for Depth and Shadow passes
     updateMinRef(options, scene, stdMat, objDefs, staticLightList, pass, sortedLights) {
-        options.litOptions = {};
+        options.litOptions = new LitOptions();
         this._updateSharedOptions(options, scene, stdMat, objDefs, pass);
         this._updateMinOptions(options, stdMat);
         this._updateUVOptions(options, stdMat, objDefs, true);
         options.litOptions.chunks = options.chunks;
     }
 
     updateRef(options, scene, stdMat, objDefs, staticLightList, pass, sortedLights) {
-        options.litOptions = {};
+        options.litOptions = new LitOptions();
         this._updateSharedOptions(options, scene, stdMat, objDefs, pass);
         this._updateEnvOptions(options, stdMat, scene);
         this._updateMaterialOptions(options, stdMat);
@@ -120,13 +122,13 @@ class StandardMaterialOptionsBuilder {
 
         // All texture related lit options
         options.litOptions.lightMapEnabled = options.lightMap;
-        options.litOptions.lightMapVertexColors = options.lightVertexColors;
+        options.litOptions.useLightMapVertexColors = options.lightVertexColors;
         options.litOptions.dirLightMapEnabled = options.dirLightMap;
         options.litOptions.heightMapEnabled = options.heightMap;
         options.litOptions.normalMapEnabled = options.normalMap;
         options.litOptions.clearCoatNormalMapEnabled = options.clearCoatNormalMap;
         options.litOptions.aoMapEnabled = options.aoMap;
-        options.litOptions.aoVertexColors = options.aoVertexColors;
+        options.litOptions.useAoVertexColors = options.aoVertexColors;
         options.litOptions.diffuseMapEnabled = options.diffuseMap;
     }
 
@@ -248,7 +250,7 @@ class StandardMaterialOptionsBuilder {
         options.sheenGlossinessTint = 1;
 
         // LIT OPTIONS
-        options.litOptions.ambientTint = options.ambientTint;
+        options.litOptions.useAmbientTint = options.ambientTint;
         options.litOptions.customFragmentShader = stdMat.customFragmentShader;
         options.litOptions.pixelSnap = stdMat.pixelSnap;
 

src/scene/shader-lib/program-library.js

@@ -95,7 +95,7 @@ class ProgramLibrary {
 
             const device = this._device;
             def = generator.createShaderDefinition(device, options);
-            def.name = `${name}-pass:${options.pass}`;
+            def.name = `${name}-pass:${options.litOptions?.pass}`;
             this.definitionsCache.set(key, def);
         }
         return def;
@@ -151,7 +151,7 @@ class ProgramLibrary {
         let opt = {};
         if (name === "standard") {
             // For standard material saving all default values is overkill, so we store only diff
-            const defaultMat = this._getDefaultStdMatOptions(options.pass);
+            const defaultMat = this._getDefaultStdMatOptions(options.litOptions?.pass);
 
             for (const p in options) {
                 if ((options.hasOwnProperty(p) && defaultMat[p] !== options[p]) || p === "pass")
@@ -234,7 +234,7 @@ class ProgramLibrary {
                 // back into the loaded options
                 if (cache[i].name === "standard") {
                     const opt = cache[i].options;
-                    const defaultMat = this._getDefaultStdMatOptions(opt.pass);
+                    const defaultMat = this._getDefaultStdMatOptions(opt.litOptions?.pass);
                     for (const p in defaultMat) {
                         if (defaultMat.hasOwnProperty(p) && opt[p] === undefined)
                             opt[p] = defaultMat[p];

src/scene/shader-lib/programs/lit-shader.js

@@ -750,7 +750,7 @@ class LitShader {
             }
         }
 
-        const useAo = options.aoMapEnabled || options.aoVertexColors;
+        const useAo = options.aoMapEnabled || options.useAoVertexColors;
 
         if (useAo) {
             code += chunks.aoDiffuseOccPS;
@@ -876,11 +876,11 @@ class LitShader {
         code += chunks.combinePS;
 
         // lightmap support
-        if (options.lightMapEnabled || options.lightMapVertexColors) {
+        if (options.lightMapEnabled || options.useLightMapVertexColors) {
             code += (options.useSpecular && options.dirLightMapEnabled) ? chunks.lightmapDirAddPS : chunks.lightmapAddPS;
         }
 
-        const addAmbient = (!options.lightMapEnabled && !options.lightMapVertexColors) || options.lightMapWithoutAmbient;
+        const addAmbient = (!options.lightMapEnabled && !options.useLightMapVertexColors) || options.lightMapWithoutAmbient;
 
         if (addAmbient) {
             if (options.ambientSource === 'ambientSH') {
@@ -895,7 +895,7 @@ class LitShader {
             }
         }
 
-        if (options.ambientTint && !useOldAmbient) {
+        if (options.useAmbientTint && !useOldAmbient) {
             code += "uniform vec3 material_ambient;\n";
         }
 
@@ -1017,15 +1017,15 @@ class LitShader {
             }
         }
 
-        if (options.ambientTint && !useOldAmbient) {
+        if (options.useAmbientTint && !useOldAmbient) {
             code += "    dDiffuseLight *= material_ambient;\n";
         }
 
         if (useAo && !options.occludeDirect) {
             code += "    occludeDiffuse();\n";
         }
 
-        if (options.lightMapEnabled || options.lightMapVertexColors) {
+        if (options.lightMapEnabled || options.useLightMapVertexColors) {
             code += "    addLightMap();\n";
         }
 

src/scene/shader-lib/programs/standard.js

@@ -10,13 +10,14 @@ import { ShaderPass } from '../../shader-pass.js';
 import { LitShader } from './lit-shader.js';
 import { ChunkBuilder } from '../chunk-builder.js';
 import { ChunkUtils } from '../chunk-utils.js';
+import { Options } from '../../materials/options.js';
 
 const _matTex2D = [];
 
 const standard = {
     // Shared Standard Material option structures
-    optionsContext: {},
-    optionsContextMin: {},
+    optionsContext: new Options(),
+    optionsContextMin: new Options(),
 
     /** @type { Function } */
     generateKey: function (options) {