@gnsx/three 0.186.3 → 0.186.4

package/examples/jsm/inspector/tabs/Settings.js

@@ -134,10 +134,46 @@ class Settings extends Parameters {
 
 		} ).info( 'Shows how many times each pixel is shaded.' );
 
+		// WITH_GENESYS
+		// Values match Renderer.debug.view. Not stored with inspector settings.
+		const debugViewState = { view: 'none' };
+
+		this._debugViewState = debugViewState;
+		this._debugViewControl = modesGroup.add( debugViewState, 'view', {
+			'Shaded': 'none',
+			'Shader Complexity': 'shaderComplexity',
+			'Lighting Complexity': 'lightingComplexity'
+		} ).name( 'Debug View' ).onChange( ( view ) => {
+
+			const renderer = this.inspector.getRenderer();
+
+			if ( renderer === null || renderer.debug === undefined ) return;
+
+			renderer.debug.view = view;
+			window.dispatchEvent( new Event( 'genesys-debug-view' ) );
+
+		} ).info( 'Shaded color, a shader-cost heatmap, or a direct-light count. Overdraw draws on top when both are enabled.' );
+		// !WITH_GENESYS
+
 	}
 
 	init() {
 
+		// WITH_GENESYS
+		const renderer = this.inspector.getRenderer();
+		const view = renderer !== null && renderer.debug !== undefined ? renderer.debug.view : null;
+
+		if ( view === 'none' || view === 'shaderComplexity' || view === 'lightingComplexity' ) {
+
+			if ( this._debugViewState.view !== view ) {
+
+				this._debugViewControl.setValue( view );
+
+			}
+
+		}
+		// !WITH_GENESYS
+
 		const extensionsGroup = this.createGroup( 'Extensions' );
 
 		const storageGroup = this.createGroup( 'Storage' );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gnsx/three",
-  "version": "0.186.3",
+  "version": "0.186.4",
   "description": "JavaScript 3D library",
   "type": "module",
   "main": "./build/three.cjs",

package/src/materials/nodes/NodeMaterial.js

@@ -25,6 +25,9 @@ import { modelViewMatrix } from '../../nodes/accessors/ModelNode.js';
 import { vertexColor } from '../../nodes/accessors/VertexColorNode.js';
 import { premultiplyAlpha } from '../../nodes/display/PremultiplyAlphaFunctions.js';
 import { subBuild } from '../../nodes/core/SubBuildNode.js';
+// WITH_GENESYS
+import { DEBUG_VIEW_LIGHTING_COMPLEXITY, DEBUG_VIEW_SHADER_COMPLEXITY, getShaderComplexityBase, shaderComplexityOutput } from '../../nodes/display/ComplexityDebug.js';
+// !WITH_GENESYS
 
 /**
  * Base class for all node materials.
@@ -597,6 +600,17 @@ class NodeMaterial extends Material {
 
 		}
 
+		// WITH_GENESYS
+		// The screen output pass colorizes the accumulated ratio. Wrapping that pass
+		// would replace the heatmap with this material's own constant cost.
+		if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY && this.isShadowPassMaterial !== true && renderer.isOutputTarget !== true ) {
+
+			builder.shaderComplexityBase = getShaderComplexityBase( this );
+			resultNode = shaderComplexityOutput( resultNode );
+
+		}
+		// !WITH_GENESYS
+
 		builder.stack.outputNode = resultNode;
 
 		builder.addFlow( 'fragment', builder.removeStack() );
@@ -1110,6 +1124,22 @@ class NodeMaterial extends Material {
 
 		}
 
+		// WITH_GENESYS
+		if ( builder.renderer.debug.view === DEBUG_VIEW_LIGHTING_COMPLEXITY && this.isShadowPassMaterial !== true ) {
+
+			const hasLightLoop = lightsNode && ( materialLightings.length > 0 || lightsNode.getScope().hasLights );
+
+			if ( hasLightLoop !== true ) {
+
+				outgoingLightNode = vec3( 0 );
+
+			}
+
+			return outgoingLightNode;
+
+		}
+		// !WITH_GENESYS
+
 		// EMISSIVE
 
 		if ( ( emissiveNode && emissiveNode.isNode === true ) || ( material.emissive && material.emissive.isColor === true ) ) {

package/src/nodes/core/NodeBuilder.js

@@ -24,6 +24,9 @@ import CubeRenderTarget from '../../renderers/common/CubeRenderTarget.js';
 import BindGroup from '../../renderers/common/BindGroup.js';
 
 import { REVISION, IntType, UnsignedIntType, LinearFilter, LinearMipmapNearestFilter, NearestMipmapLinearFilter, LinearMipmapLinearFilter, NormalBlending } from '../../constants.js';
+// WITH_GENESYS
+import { SHADER_COMPLEXITY_TEXTURE_COST } from '../display/ComplexityDebug.js';
+// !WITH_GENESYS
 import { RenderTarget } from '../../core/RenderTarget.js';
 import { Color } from '../../math/Color.js';
 import { Vector2 } from '../../math/Vector2.js';
@@ -268,6 +271,31 @@ class NodeBuilder {
 		 */
 		this.fragmentShader = null;
 
+		// WITH_GENESYS
+		/**
+		 * Static material-feature cost for the shader-complexity debug view.
+		 *
+		 * @type {number}
+		 * @default 0
+		 */
+		this.shaderComplexityBase = 0;
+
+		/**
+		 * Fragment texture samples counted while generating the shader.
+		 *
+		 * @type {number}
+		 * @default 0
+		 */
+		this.fragmentTextureSamples = 0;
+
+		/**
+		 * Sample sites already counted, so a node that is generated twice is not double-counted.
+		 *
+		 * @type {Set<string>}
+		 */
+		this.shaderComplexitySampleKeys = new Set();
+		// !WITH_GENESYS
+
 		/**
 		 * The generated compute shader.
 		 *
@@ -1296,6 +1324,46 @@ class NodeBuilder {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Counts one fragment texture sample toward the shader-complexity proxy.
+	 * Depth and cube textures are shadow maps and environment maps, and rect-area
+	 * LTC tables belong to the light loop, so they are not material cost.
+	 *
+	 * @param {?Texture} texture - The texture being sampled.
+	 * @param {string} [shaderStage=this.shaderStage] - The stage the sample is emitted for.
+	 * @param {string} [key=''] - Stable id for this sample site. Repeated generation of the same site counts once.
+	 */
+	recordFragmentTextureSample( texture, shaderStage = this.shaderStage, key = '' ) {
+
+		if ( shaderStage !== 'fragment' ) return;
+
+		if ( texture && ( texture.isDepthTexture === true || texture.isCubeTexture === true || texture.isRectAreaLTC === true ) ) return;
+
+		if ( key !== '' ) {
+
+			if ( this.shaderComplexitySampleKeys.has( key ) ) return;
+
+			this.shaderComplexitySampleKeys.add( key );
+
+		}
+
+		this.fragmentTextureSamples ++;
+
+	}
+
+	/**
+	 * Returns the shader-complexity proxy for the material currently being built.
+	 *
+	 * @return {number} Base feature cost plus weighted fragment texture samples.
+	 */
+	getShaderComplexityCost() {
+
+		return this.shaderComplexityBase + this.fragmentTextureSamples * SHADER_COMPLEXITY_TEXTURE_COST;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Generates a texture LOD shader string for the given texture data.
 	 *
@@ -3119,6 +3187,12 @@ class NodeBuilder {
 	 */
 	prebuild() {
 
+		// WITH_GENESYS
+		this.shaderComplexityBase = 0;
+		this.fragmentTextureSamples = 0;
+		this.shaderComplexitySampleKeys.clear();
+		// !WITH_GENESYS
+
 		const { renderer, material } = this;
 
 		// < renderer.contextNode >

package/src/nodes/display/ComplexityDebug.js

@@ -0,0 +1,278 @@
+// WITH_GENESYS
+// Shader and lighting complexity debug views. Costs are a material proxy, not ISA instruction counts.
+// !WITH_GENESYS
+
+import Node from '../core/Node.js';
+import { float, vec3, vec4, If, Fn } from '../tsl/TSLCore.js';
+import { fract, min, mix } from '../math/MathNode.js';
+
+/**
+ * Shaded output. No complexity debug view.
+ *
+ * @type {string}
+ */
+export const DEBUG_VIEW_NONE = 'none';
+
+/**
+ * Material-cost heatmap. Overlapping draws accumulate, then a fullscreen pass applies the ramp.
+ *
+ * @type {string}
+ */
+export const DEBUG_VIEW_SHADER_COMPLEXITY = 'shaderComplexity';
+
+/**
+ * Direct-light count heatmap. The visible surface wins.
+ *
+ * @type {string}
+ */
+export const DEBUG_VIEW_LIGHTING_COMPLEXITY = 'lightingComplexity';
+
+/**
+ * Proxy budget that fills the shader-complexity ramp.
+ * A plain lit material stays in the green stops. Transmission plus several
+ * texture samples climbs toward red.
+ *
+ * @type {number}
+ */
+export const DEFAULT_SHADER_COMPLEXITY_BUDGET = 800;
+
+/** @type {number} */
+export const SHADER_COMPLEXITY_BASE_UNLIT = 20;
+
+/** @type {number} */
+export const SHADER_COMPLEXITY_BASE_LIT = 40;
+
+/** @type {number} */
+export const SHADER_COMPLEXITY_TEXTURE_COST = 16;
+
+/** @type {number} */
+export const SHADER_COMPLEXITY_FEATURE_COST = 30;
+
+/** @type {number} */
+export const SHADER_COMPLEXITY_TRANSMISSION_COST = 60;
+
+/**
+ * Attenuation above this counts as a light that shades the pixel.
+ *
+ * @type {number}
+ */
+export const LIGHTING_COMPLEXITY_EPSILON = 0.001;
+
+/**
+ * Added on top of 1 when a received light casts a shadow.
+ * Applied even where the shadow map is black.
+ *
+ * @type {number}
+ */
+export const LIGHTING_COMPLEXITY_SHADOW_WEIGHT = 0.5;
+
+/**
+ * Unreal `ShaderComplexityColors` from `BaseEngine.ini`.
+ *
+ * @type {Array<Array<number>>}
+ */
+const SHADER_COMPLEXITY_COLORS = [
+	[ 0.0, 1.0, 0.127 ],
+	[ 0.0, 1.0, 0.0 ],
+	[ 0.046, 0.52, 0.0 ],
+	[ 0.215, 0.215, 0.0 ],
+	[ 0.52, 0.046, 0.0 ],
+	[ 0.7, 0.0, 0.0 ],
+	[ 1.0, 0.0, 0.0 ],
+	[ 1.0, 0.0, 0.5 ],
+	[ 1.0, 0.9, 0.9 ]
+];
+
+/**
+ * Unreal `LightComplexityColors` from `BaseEngine.ini`.
+ *
+ * @type {Array<Array<number>>}
+ */
+const LIGHT_COMPLEXITY_COLORS = [
+	[ 0.0, 0.0, 0.0 ],
+	[ 0.0, 0.0, 0.4 ],
+	[ 0.0, 0.3, 1.0 ],
+	[ 0.0, 0.7, 0.4 ],
+	[ 0.0, 1.0, 0.0 ],
+	[ 0.8, 0.8, 0.0 ],
+	[ 1.0, 0.3, 0.0 ],
+	[ 0.7, 0.0, 0.0 ],
+	[ 0.5, 0.0, 0.5 ],
+	[ 0.7, 0.3, 0.7 ],
+	[ 1.0, 0.9, 0.9 ]
+];
+
+const rgb = ( colors, index ) => vec3( colors[ index ][ 0 ], colors[ index ][ 1 ], colors[ index ][ 2 ] );
+
+/**
+ * Linear sample of a fixed RGB ramp. `cost` is in steps, and one step is one light.
+ *
+ * @param {Node<float>} cost - Complexity in ramp steps.
+ * @param {Array<Array<number>>} colors - Ramp stops.
+ * @return {Node<vec3>} The ramp color.
+ */
+const colorizeLinear = ( cost, colors ) => {
+
+	const steps = colors.length - 1;
+	const expanded = cost.div( steps ).clamp( 0, 0.999 ).mul( steps );
+	const index = expanded.floor();
+	const frac = fract( expanded );
+
+	let color = rgb( colors, 0 );
+
+	for ( let i = 0; i < steps; i ++ ) {
+
+		const sample = mix( rgb( colors, i ), rgb( colors, i + 1 ), frac );
+
+		color = index.greaterThanEqual( float( i ) ).and( index.lessThan( float( i + 1 ) ) ).select( sample, color );
+
+	}
+
+	return color;
+
+};
+
+/**
+ * Maps a direct-light cost through Unreal's light-complexity ramp.
+ * Ten lights saturate at white.
+ *
+ * @param {Node<float>} cost - Accumulated light weight.
+ * @return {Node<vec3>} The ramp color.
+ */
+export const colorizeLightComplexity = ( cost ) => colorizeLinear( cost, LIGHT_COMPLEXITY_COLORS );
+
+/**
+ * Unreal's nonlinear shader-complexity ramp (`ColorizeComplexity`).
+ * The first third of the normalized cost spreads across the first seven stops.
+ *
+ * @param {Node<float>} complexity - Accumulated cost divided by the budget.
+ * @return {Node<vec3>} The ramp color.
+ */
+export const colorizeShaderComplexity = /*@__PURE__*/ Fn( ( [ complexity ] ) => {
+
+	const c = complexity.clamp( 0, 0.999 );
+	const expanded = min( float( SHADER_COMPLEXITY_COLORS.length - 2 ), c.mul( 18 ) );
+	const color = vec3( 0 ).toVar();
+	const frac = fract( expanded );
+
+	If( expanded.lessThan( 1 ), () => {
+
+		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 0 ), rgb( SHADER_COMPLEXITY_COLORS, 1 ), frac ) );
+
+	} ).ElseIf( expanded.lessThan( 2 ), () => {
+
+		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 1 ), rgb( SHADER_COMPLEXITY_COLORS, 2 ), frac ) );
+
+	} ).ElseIf( expanded.lessThan( 3 ), () => {
+
+		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 2 ), rgb( SHADER_COMPLEXITY_COLORS, 3 ), frac ) );
+
+	} ).ElseIf( expanded.lessThan( 4 ), () => {
+
+		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 3 ), rgb( SHADER_COMPLEXITY_COLORS, 4 ), frac ) );
+
+	} ).ElseIf( expanded.lessThan( 5 ), () => {
+
+		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 4 ), rgb( SHADER_COMPLEXITY_COLORS, 5 ), frac ) );
+
+	} ).ElseIf( expanded.lessThan( 6 ), () => {
+
+		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 5 ), rgb( SHADER_COMPLEXITY_COLORS, 6 ), frac ) );
+
+	} ).Else( () => {
+
+		// Nine stops, so the upper range uses the `count > 8` scale of 3.
+		const upper = c.sub( 0.33333333 ).mul( 3.0 );
+		const upperFrac = fract( upper );
+
+		If( upper.lessThanEqual( 1 ), () => {
+
+			color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 6 ), rgb( SHADER_COMPLEXITY_COLORS, 7 ), upperFrac ) );
+
+		} ).Else( () => {
+
+			color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 7 ), rgb( SHADER_COMPLEXITY_COLORS, 8 ), upperFrac ) );
+
+		} );
+
+	} );
+
+	return color;
+
+} );
+
+/**
+ * Reads the builder's shader-complexity proxy at code-generation time,
+ * after the real material graph has been generated and texture samples counted.
+ *
+ * @augments Node
+ */
+class ShaderComplexityRatioNode extends Node {
+
+	static get type() {
+
+		return 'ShaderComplexityRatioNode';
+
+	}
+
+	constructor() {
+
+		super( 'float' );
+
+	}
+
+	generate( builder ) {
+
+		const budget = builder.renderer.debug.shaderComplexityBudget;
+		const safeBudget = ( typeof budget === 'number' && budget > 0 ) ? budget : 1;
+		const ratio = builder.getShaderComplexityCost() / safeBudget;
+
+		return ratio.toFixed( 6 );
+
+	}
+
+}
+
+/**
+ * Static fragment proxy for a material. Texture samples are counted later, during generation.
+ *
+ * @param {NodeMaterial} material - The material being built.
+ * @return {number} The base cost, excluding texture samples.
+ */
+export function getShaderComplexityBase( material ) {
+
+	let cost = material.lights === true ? SHADER_COMPLEXITY_BASE_LIT : SHADER_COMPLEXITY_BASE_UNLIT;
+
+	if ( material.useClearcoat === true ) cost += SHADER_COMPLEXITY_FEATURE_COST;
+
+	if ( material.useSheen === true ) cost += SHADER_COMPLEXITY_FEATURE_COST;
+
+	if ( material.useIridescence === true ) cost += SHADER_COMPLEXITY_FEATURE_COST;
+
+	if ( material.useAnisotropy === true ) cost += SHADER_COMPLEXITY_FEATURE_COST;
+
+	if ( material.useTransmission === true ) cost += SHADER_COMPLEXITY_TRANSMISSION_COST;
+
+	return cost;
+
+}
+
+/**
+ * Replaces the shaded color with `vec4(cost / budget, 0, 0, 1)`.
+ * The real graph is still generated so texture samples are counted first.
+ *
+ * @param {Node} resultNode - The material's shaded output.
+ * @return {Node<vec4>} The complexity ratio in the red channel.
+ */
+export function shaderComplexityOutput( resultNode ) {
+
+	// Generate the shaded graph first so texture samples are counted, then
+	// replace the color. A bypass of a value node emits a bare expression
+	// statement, which WGSL rejects.
+	const shaded = vec4( resultNode ).toVar();
+
+	const ratio = new ShaderComplexityRatioNode();
+
+	return vec4( ratio, 0, 0, 1 ).add( shaded.mul( 0 ) );
+
+}

package/src/nodes/lighting/LightsNode.js

@@ -1,8 +1,11 @@
 import Node from '../core/Node.js';
-import { property, vec3 } from '../tsl/TSLBase.js';
+import { float, property, vec3 } from '../tsl/TSLBase.js';
 import { hashArray } from '../core/NodeUtils.js';
 import { warn } from '../../utils.js';
 // WITH_GENESYS
+import { colorizeLightComplexity, DEBUG_VIEW_LIGHTING_COMPLEXITY, LIGHTING_COMPLEXITY_EPSILON, LIGHTING_COMPLEXITY_SHADOW_WEIGHT } from '../display/ComplexityDebug.js';
+// !WITH_GENESYS
+// WITH_GENESYS
 import LightProbeGridNode from './LightProbeGridNode.js';
 // !WITH_GENESYS
 
@@ -27,6 +30,10 @@ const totalSpecular = property( 'vec3', 'totalSpecular' );
  */
 const outgoingLight = property( 'vec3', 'outgoingLight' );
 
+// WITH_GENESYS
+const lightingComplexity = property( 'float', 'lightingComplexity' );
+// !WITH_GENESYS
+
 /**
  * Sorts an array of lights in ascending order by their IDs.
  *
@@ -380,6 +387,10 @@ class LightsNode extends Node {
 			reflectedLight
 		}, builder );
 
+		// WITH_GENESYS
+		this._addLightingComplexity( builder, lightNode, lightData );
+		// !WITH_GENESYS
+
 	}
 
 	/**
@@ -399,7 +410,39 @@ class LightsNode extends Node {
 			reflectedLight
 		}, builder );
 
+		// WITH_GENESYS
+		this._addLightingComplexity( builder, lightNode, lightData );
+		// !WITH_GENESYS
+
+	}
+
+	// WITH_GENESYS
+	/**
+	 * Adds this direct light's weight to the lighting-complexity accumulator.
+	 * Point, spot, and rect-area lights count only where attenuation is in range.
+	 * Directional lights have no falloff, so they always count. Shadow-casting
+	 * lights add extra weight even where the shadow map is black.
+	 *
+	 * @private
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @param {LightingNode} lightNode - The light node being shaded.
+	 * @param {Object} lightData - Direct light terms, including an optional attenuation node.
+	 */
+	_addLightingComplexity( builder, lightNode, lightData ) {
+
+		if ( builder.renderer.debug.view !== DEBUG_VIEW_LIGHTING_COMPLEXITY ) return;
+
+		if ( builder.material && builder.material.isShadowPassMaterial === true ) return;
+
+		const attenuation = lightData.attenuation !== undefined ? lightData.attenuation : float( 1 );
+		const light = lightNode.light;
+		const castsShadow = light !== undefined && light !== null && light.castShadow === true && builder.object.receiveShadow === true;
+		const weight = castsShadow ? float( 1 + LIGHTING_COMPLEXITY_SHADOW_WEIGHT ) : float( 1 );
+
+		lightingComplexity.addAssign( attenuation.greaterThan( LIGHTING_COMPLEXITY_EPSILON ).select( weight, float( 0 ) ) );
+
 	}
+	// !WITH_GENESYS
 
 	/**
 	 * Setups the internal lights by building all respective
@@ -463,6 +506,14 @@ class LightsNode extends Node {
 
 			properties.nodes = stack.nodes;
 
+			// WITH_GENESYS
+			if ( builder.renderer.debug.view === DEBUG_VIEW_LIGHTING_COMPLEXITY && ( builder.material === null || builder.material.isShadowPassMaterial !== true ) ) {
+
+				lightingComplexity.assign( 0 );
+
+			}
+			// !WITH_GENESYS
+
 			lightingModel.start( builder );
 
 			const { backdrop, backdropAlpha } = context;
@@ -487,10 +538,28 @@ class LightsNode extends Node {
 			totalDiffuseNode.assign( totalDiffuse );
 			totalSpecularNode.assign( directSpecular.add( indirectSpecular ) );
 
-			outgoingLightNode.assign( totalDiffuseNode.add( totalSpecularNode ) );
+			// WITH_GENESYS
+			const lightingComplexityView = builder.renderer.debug.view === DEBUG_VIEW_LIGHTING_COMPLEXITY && ( builder.material === null || builder.material.isShadowPassMaterial !== true );
+
+			if ( lightingComplexityView !== true ) {
+
+				outgoingLightNode.assign( totalDiffuseNode.add( totalSpecularNode ) );
+
+			}
+			// !WITH_GENESYS
+			// outgoingLightNode.assign( totalDiffuseNode.add( totalSpecularNode ) );
 
 			lightingModel.finish( builder );
 
+			// WITH_GENESYS
+			// After finish(), so clearcoat and sheen cannot draw over the heatmap.
+			if ( lightingComplexityView === true ) {
+
+				outgoingLightNode.assign( colorizeLightComplexity( lightingComplexity ) );
+
+			}
+			// !WITH_GENESYS
+
 			outgoingLightNode = outgoingLightNode.bypass( builder.removeStack() );
 
 		} else {

package/src/nodes/lighting/PointLightNode.js

@@ -17,7 +17,10 @@ export const directPointLight = ( { color, lightVector, cutoffDistance, decayExp
 
 	const lightColor = color.mul( attenuation );
 
-	return { lightDirection, lightColor };
+	// WITH_GENESYS
+	return { lightDirection, lightColor, attenuation };
+	// !WITH_GENESYS
+	// return { lightDirection, lightColor };
 
 };
 

package/src/nodes/lighting/RectAreaLightNode.js

@@ -88,6 +88,20 @@ class RectAreaLightNode extends AnalyticLightNode {
 
 	setupDirectRectArea( builder ) {
 
+		// WITH_GENESYS
+		// LTC lookups are part of the light loop, not the material's shader cost.
+		if ( _ltcLib !== null ) {
+
+			_ltcLib.LTC_FLOAT_1.isRectAreaLTC = true;
+			_ltcLib.LTC_FLOAT_2.isRectAreaLTC = true;
+
+			if ( _ltcLib.LTC_HALF_1 ) _ltcLib.LTC_HALF_1.isRectAreaLTC = true;
+
+			if ( _ltcLib.LTC_HALF_2 ) _ltcLib.LTC_HALF_2.isRectAreaLTC = true;
+
+		}
+		// !WITH_GENESYS
+
 		let ltc_1, ltc_2;
 
 		if ( builder.isAvailable( 'float32Filterable' ) ) {

package/src/nodes/lighting/SpotLightNode.js

@@ -135,7 +135,12 @@ class SpotLightNode extends AnalyticLightNode {
 			decayExponent: decayExponentNode
 		} );
 
-		let lightColor = colorNode.mul( spotAttenuation ).mul( lightAttenuation );
+		// WITH_GENESYS
+		const attenuation = spotAttenuation.mul( lightAttenuation );
+
+		let lightColor = colorNode.mul( attenuation );
+		// !WITH_GENESYS
+		// let lightColor = colorNode.mul( spotAttenuation ).mul( lightAttenuation );
 
 		let projected, lightCoord;
 
@@ -159,7 +164,10 @@ class SpotLightNode extends AnalyticLightNode {
 
 		}
 
-		return { lightColor, lightDirection };
+		// WITH_GENESYS
+		return { lightColor, lightDirection, attenuation };
+		// !WITH_GENESYS
+		// return { lightColor, lightDirection };
 
 	}
 

package/src/renderers/common/Background.js

@@ -191,7 +191,15 @@ class Background extends DataMap {
 
 			}
 
-			renderList.unshift( backgroundMesh, backgroundMesh.geometry, backgroundMesh.material, 0, 0, null, null );
+			// WITH_GENESYS
+			// The background is depth-tested off, so additive shader complexity would add it to every pixel.
+			if ( renderer.debug.view !== 'shaderComplexity' ) {
+
+				renderList.unshift( backgroundMesh, backgroundMesh.geometry, backgroundMesh.material, 0, 0, null, null );
+
+			}
+			// !WITH_GENESYS
+			// renderList.unshift( backgroundMesh, backgroundMesh.geometry, backgroundMesh.material, 0, 0, null, null );
 
 		} else {
 
@@ -215,6 +223,14 @@ class Background extends DataMap {
 
 		//
 
+		// WITH_GENESYS
+		if ( renderer.debug.view === 'shaderComplexity' ) {
+
+			_clearColor.set( 0, 0, 0, 1 );
+
+		}
+		// !WITH_GENESYS
+
 		if ( renderer.autoClear === true || forceClear === true ) {
 
 			const clearColorValue = renderContext.clearColorValue;