@gnsx/three 0.186.3 → 0.186.5

package/build/three.webgpu.js

@@ -21614,6 +21614,767 @@ class VertexColorNode extends AttributeNode {
  */
 const vertexColor = ( index = 0 ) => new VertexColorNode( index );
 
+// WITH_GENESYS
+// Shader and lighting complexity debug views. Costs are a material proxy, not ISA instruction counts.
+// !WITH_GENESYS
+
+
+/**
+ * Shaded output. No complexity debug view.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_NONE = 'none';
+
+/**
+ * Material-cost heatmap. Overlapping draws accumulate, then a fullscreen pass applies the ramp.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_SHADER_COMPLEXITY = 'shaderComplexity';
+
+/**
+ * Direct-light count heatmap. The visible surface wins.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_LIGHTING_COMPLEXITY = 'lightingComplexity';
+
+/**
+ * Per-pixel overdraw heatmap. Each fragment that passes the depth test adds one.
+ * This is the portable stand-in for Unreal's 2×2 quad-coverage count.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_QUAD_OVERDRAW = 'quadOverdraw';
+
+/**
+ * Shader cost multiplied by the number of fragments that shaded the pixel, then the shader-complexity ramp.
+ * One opaque surface matches {@link DEBUG_VIEW_SHADER_COMPLEXITY}. Each extra overlapping fragment scales the summed cost.
+ * WebGPU cannot count wasted lanes in a 2×2 quad, so the count is fragments that pass the depth test.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS = 'shaderComplexityAndQuads';
+
+/**
+ * Proxy budget that fills the shader-complexity ramp.
+ * Unlit and basic stay green. Phong and standard move through yellow into red.
+ * Transmission plus several texture samples climbs toward white.
+ *
+ * @type {number}
+ */
+const DEFAULT_SHADER_COMPLEXITY_BUDGET = 800;
+
+/**
+ * Overlapping fragments that fill the quad-overdraw ramp.
+ * Unreal's stair reaches white at ten layers (`1 / 16` stored, then scaled by 1.6).
+ *
+ * @type {number}
+ */
+const DEFAULT_QUAD_OVERDRAW_BUDGET = 10;
+
+/**
+ * Storage scale for the overdraw count in {@link DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS}.
+ * Each fragment adds `1 / scale`, so an 8-bit target can hold this many layers.
+ * The output pass multiplies that channel back to a count. Half-float targets hold the same count exactly.
+ *
+ * @type {number}
+ */
+const SHADER_COMPLEXITY_QUAD_COUNT_SCALE = 16;
+
+/**
+ * Added for each fragment texture sample. Lighting-model costs are returned
+ * directly by {@link NodeMaterial#getShaderComplexity}.
+ *
+ * @type {number}
+ */
+const SHADER_COMPLEXITY_TEXTURE_COST = 16;
+
+/**
+ * Attenuation above this counts as a light that shades the pixel.
+ *
+ * @type {number}
+ */
+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}
+ */
+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 `QuadComplexityColors` from `BaseEngine.ini`.
+ * Sampled as a stair: one overlapping fragment is one stop.
+ *
+ * @type {Array<Array<number>>}
+ */
+const QUAD_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 ]
+];
+
+/**
+ * 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.
+ */
+const colorizeLightComplexity = ( cost ) => colorizeLinear( cost, LIGHT_COMPLEXITY_COLORS );
+
+/**
+ * Unreal's stair sample for quad overdraw (`CS_STAIR`).
+ * `cost` is the accumulated fragment count divided by the budget.
+ *
+ * @param {Node<float>} cost - Overdraw count divided by the budget.
+ * @return {Node<vec3>} The ramp color.
+ */
+const colorizeQuadOverdraw = ( cost ) => {
+
+	const steps = QUAD_COMPLEXITY_COLORS.length - 1;
+	const index = round( cost.clamp( 0, 1 ).mul( steps ) );
+
+	let color = rgb( QUAD_COMPLEXITY_COLORS, 0 );
+
+	for ( let i = 0; i <= steps; i ++ ) {
+
+		color = index.equal( float( i ) ).select( rgb( QUAD_COMPLEXITY_COLORS, i ), color );
+
+	}
+
+	return color;
+
+};
+
+/**
+ * Views that add a scalar per fragment, then colorize that sum in the output pass.
+ *
+ * @param {string} view - `renderer.debug.view`.
+ * @return {boolean} `true` when the view accumulates.
+ */
+function debugViewAccumulates( view ) {
+
+	return view === DEBUG_VIEW_SHADER_COMPLEXITY || view === DEBUG_VIEW_QUAD_OVERDRAW || view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS;
+
+}
+
+/**
+ * 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.
+ */
+const colorizeShaderComplexity = /*@__PURE__*/ Fn( ( [ complexity ] ) => {
+
+	const c = complexity.clamp( 0, 0.999 );
+	const expanded = min$1( 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 );
+
+	}
+
+}
+
+/**
+ * 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.
+ */
+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 ) );
+
+}
+
+/**
+ * Same cost as {@link shaderComplexityOutput}, plus one overdraw step in green.
+ * The output pass multiplies red by the accumulated green count.
+ *
+ * @param {Node} resultNode - The material's shaded output.
+ * @return {Node<vec4>} Cost ratio in red, one scaled fragment in green.
+ */
+function shaderComplexityAndQuadsOutput( resultNode ) {
+
+	const shaded = vec4( resultNode ).toVar();
+	const ratio = new ShaderComplexityRatioNode();
+	const step = float( 1 / SHADER_COMPLEXITY_QUAD_COUNT_SCALE );
+
+	return vec4( ratio, step, 0, 1 ).add( shaded.mul( 0 ) );
+
+}
+
+/**
+ * Reads `1 / quadOverdrawBudget` at code-generation time.
+ *
+ * @augments Node
+ */
+class QuadOverdrawRatioNode extends Node {
+
+	static get type() {
+
+		return 'QuadOverdrawRatioNode';
+
+	}
+
+	constructor() {
+
+		super( 'float' );
+
+	}
+
+	generate( builder ) {
+
+		const budget = builder.renderer.debug.quadOverdrawBudget;
+		const safeBudget = ( typeof budget === 'number' && budget > 0 ) ? budget : 1;
+
+		return ( 1 / safeBudget ).toFixed( 6 );
+
+	}
+
+}
+
+/**
+ * Replaces the shaded color with `vec4(1 / budget, 0, 0, 1)`.
+ * The real graph is still generated so clipped fragments are not counted.
+ *
+ * @param {Node} resultNode - The material's shaded output.
+ * @return {Node<vec4>} One overdraw step in the red channel.
+ */
+function quadOverdrawOutput( resultNode ) {
+
+	const shaded = vec4( resultNode ).toVar();
+	const ratio = new QuadOverdrawRatioNode();
+
+	return vec4( ratio, 0, 0, 1 ).add( shaded.mul( 0 ) );
+
+}
+
+// WITH_GENESYS
+// Buffer visualization. Shows one material channel in place of the shaded color.
+// !WITH_GENESYS
+
+
+/**
+ * Buffer visualization. The visible surface wins, and one material channel replaces the shaded color.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_BUFFER = 'bufferVisualization';
+
+/**
+ * Albedo before lighting, including maps and vertex colors.
+ *
+ * @type {string}
+ */
+const BUFFER_BASE_COLOR = 'baseColor';
+
+/**
+ * Shading normal in world space, packed to RGB with `n * 0.5 + 0.5`.
+ *
+ * @type {string}
+ */
+const BUFFER_WORLD_NORMAL = 'worldNormal';
+
+/**
+ * Scalar roughness used by the lighting model. Black is smooth.
+ *
+ * @type {string}
+ */
+const BUFFER_ROUGHNESS = 'roughness';
+
+/**
+ * Scalar metalness. White is metal. Unreal calls this buffer Metallic.
+ *
+ * @type {string}
+ */
+const BUFFER_METALLIC = 'metallic';
+
+/**
+ * Material ambient occlusion. White means no occlusion map.
+ *
+ * @type {string}
+ */
+const BUFFER_AMBIENT_OCCLUSION = 'ambientOcclusion';
+
+/**
+ * Emissive color before it is added to the lit result.
+ *
+ * @type {string}
+ */
+const BUFFER_EMISSIVE = 'emissive';
+
+/**
+ * Channel drawn when buffer visualization is first enabled.
+ *
+ * @type {string}
+ */
+const DEFAULT_BUFFER = BUFFER_BASE_COLOR;
+
+/**
+ * Writes a defined value for channels a material may never assign.
+ * Standard and physical materials overwrite roughness and metalness in `setupVariants`,
+ * and emissive is overwritten when the material has one.
+ *
+ * @param {string} buffer - `renderer.debug.buffer`.
+ */
+function assignBufferDefaults( buffer ) {
+
+	if ( buffer === BUFFER_ROUGHNESS ) {
+
+		roughness.assign( float( 0 ) );
+
+	} else if ( buffer === BUFFER_METALLIC ) {
+
+		metalness.assign( float( 0 ) );
+
+	} else if ( buffer === BUFFER_EMISSIVE ) {
+
+		emissive.assign( vec3( 0 ) );
+
+	}
+
+}
+
+/**
+ * The color for one buffer channel. Scalar channels are copied into RGB.
+ *
+ * @param {string} buffer - `renderer.debug.buffer`.
+ * @return {Node<vec3>} The channel color.
+ */
+function bufferVisualizationColor( buffer ) {
+
+	if ( buffer === BUFFER_WORLD_NORMAL ) {
+
+		return normalWorld.mul( 0.5 ).add( 0.5 );
+
+	}
+
+	if ( buffer === BUFFER_ROUGHNESS ) {
+
+		return vec3( roughness );
+
+	}
+
+	if ( buffer === BUFFER_METALLIC ) {
+
+		return vec3( metalness );
+
+	}
+
+	if ( buffer === BUFFER_AMBIENT_OCCLUSION ) {
+
+		return vec3( ambientOcclusion );
+
+	}
+
+	if ( buffer === BUFFER_EMISSIVE ) {
+
+		return emissive;
+
+	}
+
+	return diffuseColor.rgb;
+
+}
+
+/**
+ * Replaces the shaded color with the selected buffer. Alpha stays the material's coverage
+ * so masked and transparent surfaces keep their shape.
+ *
+ * @param {string} buffer - `renderer.debug.buffer`.
+ * @return {Node<vec4>} The buffer color.
+ */
+function bufferVisualizationOutput( buffer ) {
+
+	return vec4( bufferVisualizationColor( buffer ), diffuseColor.a );
+
+}
+
+// WITH_GENESYS
+// Lighting only and detail lighting. Both replace the shaded albedo with a flat gray.
+// !WITH_GENESYS
+
+
+/**
+ * Lighting only. Flat gray, no specular, geometry normals. Material detail is dropped.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_LIGHTING_ONLY = 'lightingOnly';
+
+/**
+ * Detail lighting. Flat gray and a constant specular, with normal maps and roughness kept.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_DETAIL_LIGHTING = 'detailLighting';
+
+/**
+ * Neutral albedo shared by both views. Matches Unreal's `LightingOnlyBrightness`.
+ *
+ * @type {number}
+ */
+const LIGHTING_ONLY_BRIGHTNESS = 0.3;
+
+/**
+ * Specular color used by detail lighting. Unreal writes `0.1` into the specular override.
+ *
+ * @type {number}
+ */
+const DETAIL_LIGHTING_SPECULAR = 0.1;
+
+/**
+ * Geometry normal for lighting only, so normal maps and `normalNode` do not shade the surface.
+ *
+ * @type {Node<vec3>}
+ */
+const lightingOnlyNormal = /*@__PURE__*/ Fn( ( builder ) => {
+
+	let node = normalViewGeometry;
+
+	if ( builder.isFlatShading() !== true ) {
+
+		node = negateOnBackSide( node );
+
+	}
+
+	return node;
+
+}, 'vec3' );
+
+/**
+ * Replaces albedo and specular after the material has written its channels.
+ * Lit materials become a dielectric gray. Unlit materials become flat gray.
+ *
+ * @param {NodeBuilder} builder - The current node builder.
+ * @param {string} view - `renderer.debug.view`.
+ */
+function applyLightingDebug( builder, view ) {
+
+	const material = builder.material;
+	const gray = vec3( LIGHTING_ONLY_BRIGHTNESS );
+
+	diffuseColor.rgb.assign( gray );
+
+	if ( material.lights !== true ) return;
+
+	metalness.assign( float( 0 ) );
+	diffuseContribution.assign( gray );
+
+	if ( view === DEBUG_VIEW_LIGHTING_ONLY ) {
+
+		roughness.assign( float( 1 ) );
+		specularColor.assign( vec3( 0 ) );
+		specularColorBlended.assign( vec3( 0 ) );
+		specularF90.assign( float( 0 ) );
+
+		// Ambient occlusion was stored for the lighting model. Lighting only has no material.
+		builder.context.ambientOcclusion = null;
+
+		if ( material.useClearcoat === true ) clearcoat.assign( float( 0 ) );
+
+		if ( material.useSheen === true ) sheen.assign( vec3( 0 ) );
+
+		if ( material.useIridescence === true ) iridescence.assign( float( 0 ) );
+
+		if ( material.useAnisotropy === true ) anisotropy.assign( float( 0 ) );
+
+		if ( material.useTransmission === true ) transmission.assign( float( 0 ) );
+
+		if ( material.useRetroreflection === true ) retroreflectivity.assign( float( 0 ) );
+
+	} else {
+
+		const specular = vec3( DETAIL_LIGHTING_SPECULAR );
+
+		specularColor.assign( specular );
+		specularColorBlended.assign( specular );
+		specularF90.assign( float( 1 ) );
+
+	}
+
+}
+
+// WITH_GENESYS
+// Draw call coloration. One stable diffuse color per submitted draw, then lit.
+// !WITH_GENESYS
+
+
+/**
+ * Draw call coloration. Each submitted draw gets one diffuse color. An instanced mesh is one draw.
+ * The color is lit, so lights and shadows still show. Unlit materials stay flat.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_DRAW_CALL = 'drawCall';
+
+/**
+ * Golden-ratio step. Sequential object ids land on opposite sides of the hue wheel.
+ *
+ * @type {number}
+ */
+const DRAW_CALL_HUE_STEP = 0.618033988749895;
+
+/**
+ * Saturation of a draw color. High enough that neighboring hues stay apart after lighting.
+ *
+ * @type {number}
+ */
+const DRAW_CALL_SATURATION = 0.85;
+
+/**
+ * Value of a draw color. Lighting and shadows darken it from here.
+ *
+ * @type {number}
+ */
+const DRAW_CALL_VALUE = 0.92;
+
+/**
+ * Writes a saturated color for this draw into `color`.
+ * Hue walks the wheel by the golden ratio, so consecutive objects do not share a tint.
+ * Instances of one mesh share the object id, so they share the color.
+ *
+ * @param {Color} color - The uniform color, updated in place.
+ * @param {Object3D} object - The drawn object.
+ * @param {Material} material - The drawn material. A multi-material group is its own draw.
+ * @return {Color} `color`.
+ */
+function writeDrawCallColor( color, object, material ) {
+
+	const hue = ( ( object.id + material.id * 64 ) * DRAW_CALL_HUE_STEP ) % 1;
+	const s = DRAW_CALL_SATURATION;
+	const v = DRAW_CALL_VALUE;
+	const sector = hue * 6;
+	const i = Math.floor( sector );
+	const f = sector - i;
+	const p = v * ( 1 - s );
+	const q = v * ( 1 - f * s );
+	const t = v * ( 1 - ( 1 - f ) * s );
+
+	switch ( i % 6 ) {
+
+		case 0: return color.setRGB( v, t, p );
+		case 1: return color.setRGB( q, v, p );
+		case 2: return color.setRGB( p, v, t );
+		case 3: return color.setRGB( p, q, v );
+		case 4: return color.setRGB( t, p, v );
+		default: return color.setRGB( v, p, q );
+
+	}
+
+}
+
+/**
+ * Replaces albedo with the draw color after the material has written its channels.
+ * Lit materials become a matte dielectric in that color. Unlit materials become flat.
+ * The color is an object uniform, so meshes that share a material still differ.
+ *
+ * @param {NodeBuilder} builder - The current node builder.
+ */
+function applyDrawCallDebug( builder ) {
+
+	const material = builder.material;
+	const colorNode = uniform( new Color() ).onObjectUpdate( ( { object, material: drawnMaterial }, self ) => {
+
+		if ( object === null || drawnMaterial === null ) return;
+
+		return writeDrawCallColor( self.value, object, drawnMaterial );
+
+	} );
+
+	diffuseColor.rgb.assign( colorNode );
+
+	if ( material.lights !== true ) return;
+
+	metalness.assign( float( 0 ) );
+	diffuseContribution.assign( colorNode );
+	roughness.assign( float( 1 ) );
+	specularColor.assign( vec3( 0 ) );
+	specularColorBlended.assign( vec3( 0 ) );
+	specularF90.assign( float( 0 ) );
+
+	// Ambient occlusion belonged to the original material.
+	builder.context.ambientOcclusion = null;
+
+	if ( material.useClearcoat === true ) clearcoat.assign( float( 0 ) );
+
+	if ( material.useSheen === true ) sheen.assign( vec3( 0 ) );
+
+	if ( material.useIridescence === true ) iridescence.assign( float( 0 ) );
+
+	if ( material.useAnisotropy === true ) anisotropy.assign( float( 0 ) );
+
+	if ( material.useTransmission === true ) transmission.assign( float( 0 ) );
+
+	if ( material.useRetroreflection === true ) retroreflectivity.assign( float( 0 ) );
+
+}
+
+// !WITH_GENESYS
+
 /**
  * Base class for all node materials.
  *
@@ -22112,10 +22873,33 @@ class NodeMaterial extends Material {
 
 		if ( this.fragmentNode === null ) {
 
+			// WITH_GENESYS
+			// Fallback for materials that never write the channel. Lit materials overwrite these.
+			if ( renderer.debug.view === DEBUG_VIEW_BUFFER && this.isShadowPassMaterial !== true ) {
+
+				assignBufferDefaults( renderer.debug.buffer );
+
+			}
+			// !WITH_GENESYS
+
 			this.setupDiffuseColor( builder );
 			this.setupAmbientOcclusion( builder );
 			this.setupVariants( builder );
 
+			// WITH_GENESYS
+			// After the material writes its channels, so roughness and normals already exist
+			// for detail lighting and can be replaced for lighting only.
+			if ( ( renderer.debug.view === DEBUG_VIEW_LIGHTING_ONLY || renderer.debug.view === DEBUG_VIEW_DETAIL_LIGHTING ) && this.isShadowPassMaterial !== true ) {
+
+				applyLightingDebug( builder, renderer.debug.view );
+
+			} else if ( renderer.debug.view === DEBUG_VIEW_DRAW_CALL && this.isShadowPassMaterial !== true ) {
+
+				applyDrawCallDebug( builder );
+
+			}
+			// !WITH_GENESYS
+
 			const outgoingLightNode = this.setupLighting( builder );
 
 			if ( clippingNode !== null ) builder.stack.addToStack( clippingNode );
@@ -22185,6 +22969,32 @@ 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 = this.getShaderComplexity();
+			resultNode = shaderComplexityOutput( resultNode );
+
+		} else if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS && this.isShadowPassMaterial !== true && renderer.isOutputTarget !== true ) {
+
+			builder.shaderComplexityBase = this.getShaderComplexity();
+			resultNode = shaderComplexityAndQuadsOutput( resultNode );
+
+		} else if ( renderer.debug.view === DEBUG_VIEW_QUAD_OVERDRAW && this.isShadowPassMaterial !== true && renderer.isOutputTarget !== true ) {
+
+			resultNode = quadOverdrawOutput( resultNode );
+
+		} else if ( renderer.debug.view === DEBUG_VIEW_BUFFER && this.isShadowPassMaterial !== true && this.fragmentNode === null ) {
+
+			// The fullscreen output pass sets fragmentNode. Scene materials do not, including
+			// when the scene is drawn straight to the canvas.
+			resultNode = bufferVisualizationOutput( renderer.debug.buffer );
+
+		}
+		// !WITH_GENESYS
+
 		builder.stack.outputNode = resultNode;
 
 		builder.addFlow( 'fragment', builder.removeStack() );
@@ -22195,6 +23005,21 @@ class NodeMaterial extends Material {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Static shader-complexity proxy for this material's lighting model.
+	 * Fragment texture samples are counted later, while the shader is generated.
+	 * Derived materials override this instead of registering a type flag.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return this.lights === true ? 40 : 20;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the clipping node.
 	 *
@@ -22519,9 +23344,18 @@ class NodeMaterial extends Material {
 	/**
 	 * Setups the normal node from the material.
 	 *
+	 * @param {NodeBuilder} builder - The current node builder.
 	 * @return {Node<vec3>} The normal node.
 	 */
-	setupNormal() {
+	setupNormal( builder ) {
+
+		// WITH_GENESYS
+		if ( ( builder.renderer.debug.view === DEBUG_VIEW_LIGHTING_ONLY || builder.renderer.debug.view === DEBUG_VIEW_DRAW_CALL ) && this.isShadowPassMaterial !== true && this.fragmentNode === null ) {
+
+			return lightingOnlyNormal();
+
+		}
+		// !WITH_GENESYS
 
 		return this.normalNode ? vec3( this.normalNode ) : materialNormal;
 
@@ -22698,10 +23532,36 @@ 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 ) ) {
 
+			// WITH_GENESYS
+			// Lighting only and draw call substitute a plain lit material, so emissive is dropped.
+			// Detail lighting keeps it.
+			if ( ( builder.renderer.debug.view === DEBUG_VIEW_LIGHTING_ONLY || builder.renderer.debug.view === DEBUG_VIEW_DRAW_CALL ) && this.isShadowPassMaterial !== true ) {
+
+				return outgoingLightNode;
+
+			}
+			// !WITH_GENESYS
+
 			emissive.assign( vec3( emissiveNode ? emissiveNode : materialEmissive ) );
 
 			outgoingLightNode = outgoingLightNode.add( emissive );
@@ -24576,6 +25436,19 @@ class MeshBasicNodeMaterial extends NodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Shader-complexity proxy for {@link BasicLightingModel}.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return 80;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the lighting model.
 	 *
@@ -24759,6 +25632,19 @@ class MeshLambertNodeMaterial extends NodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Shader-complexity proxy for Lambert. Specular is forced off.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return 140;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the lighting model.
 	 *
@@ -24860,6 +25746,19 @@ class MeshPhongNodeMaterial extends NodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Shader-complexity proxy for Blinn-Phong.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return 200;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the lighting model.
 	 *
@@ -28348,6 +29247,19 @@ class MeshStandardNodeMaterial extends NodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Shader-complexity proxy for the Cook-Torrance GGX model.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return 240;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the lighting model.
 	 *
@@ -28777,6 +29689,31 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * GGX base from {@link MeshStandardNodeMaterial}, plus each enabled physical feature.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		let cost = super.getShaderComplexity();
+
+		if ( this.useClearcoat === true ) cost += 30;
+
+		if ( this.useSheen === true ) cost += 30;
+
+		if ( this.useIridescence === true ) cost += 30;
+
+		if ( this.useAnisotropy === true ) cost += 30;
+
+		if ( this.useTransmission === true ) cost += 60;
+
+		return cost;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the lighting model.
 	 *
@@ -29061,6 +29998,21 @@ class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Physical complexity, plus the subsurface term when it is evaluated.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		const cost = super.getShaderComplexity();
+
+		return this.useSSS === true ? cost + 40 : cost;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the lighting model.
 	 *
@@ -29182,6 +30134,19 @@ class MeshToonNodeMaterial extends NodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Shader-complexity proxy for toon banding.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return 170;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the lighting model.
 	 *
@@ -29253,6 +30218,19 @@ class MeshMatcapNodeMaterial extends NodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Shader-complexity proxy for matcap UV shading.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return 50;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the matcap specific node variables.
 	 *
@@ -29928,6 +30906,19 @@ class ShadowNodeMaterial extends NodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Shader-complexity proxy for the shadow mask.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return 110;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Setups the lighting model.
 	 *
@@ -30214,6 +31205,19 @@ class VolumeNodeMaterial extends NodeMaterial {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Shader-complexity proxy for volumetric ray integration.
+	 *
+	 * @return {number} The base cost, excluding texture samples.
+	 */
+	getShaderComplexity() {
+
+		return 280;
+
+	}
+	// !WITH_GENESYS
+
 	setupLightingModel() {
 
 		return new VolumetricLightingModel();
@@ -31460,6 +32464,11 @@ class RenderObject {
 
 		cacheKey = hash$1( cacheKey, this.renderer.contextNode.id, this.renderer.contextNode.version );
 
+		// WITH_GENESYS
+		// hash() xors each argument as a number, so a view name has to be hashed first.
+		cacheKey = hash$1( cacheKey, hashString( this.renderer.debug.view ), hashString( this.renderer.debug.buffer ), this.renderer.debug.shaderComplexityBudget, this.renderer.debug.quadOverdrawBudget );
+		// !WITH_GENESYS
+
 		return cacheKey;
 
 	}
@@ -46355,6 +47364,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.
  *
@@ -46708,6 +47721,10 @@ class LightsNode extends Node {
 			reflectedLight
 		}, builder );
 
+		// WITH_GENESYS
+		this._addLightingComplexity( builder, lightNode, lightData );
+		// !WITH_GENESYS
+
 	}
 
 	/**
@@ -46727,8 +47744,40 @@ 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
 	 * light nodes.
@@ -46791,6 +47840,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;
@@ -46815,10 +47872,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 {
@@ -48910,7 +49985,10 @@ const directPointLight = ( { color, lightVector, cutoffDistance, decayExponent }
 
 	const lightColor = color.mul( attenuation );
 
-	return { lightDirection, lightColor };
+	// WITH_GENESYS
+	return { lightDirection, lightColor, attenuation };
+	// !WITH_GENESYS
+	// return { lightDirection, lightColor };
 
 };
 
@@ -51842,6 +52920,8 @@ var TSL = /*#__PURE__*/Object.freeze({
 	xor: xor
 });
 
+// !WITH_GENESYS
+
 const _clearColor = /*@__PURE__*/ new Color4();
 
 /**
@@ -52025,7 +53105,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 ( debugViewAccumulates( renderer.debug.view ) !== true ) {
+
+				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 {
 
@@ -52049,6 +53137,14 @@ class Background extends DataMap {
 
 		//
 
+		// WITH_GENESYS
+		if ( debugViewAccumulates( renderer.debug.view ) ) {
+
+			_clearColor.set( 0, 0, 0, 1 );
+
+		}
+		// !WITH_GENESYS
+
 		if ( renderer.autoClear === true || forceClear === true ) {
 
 			const clearColorValue = renderContext.clearColorValue;
@@ -53689,6 +54785,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.
 		 *
@@ -54717,6 +55838,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.
 	 *
@@ -56540,6 +57701,12 @@ class NodeBuilder {
 	 */
 	prebuild() {
 
+		// WITH_GENESYS
+		this.shaderComplexityBase = 0;
+		this.fragmentTextureSamples = 0;
+		this.shaderComplexitySampleKeys.clear();
+		// !WITH_GENESYS
+
 		const { renderer, material } = this;
 
 		// < renderer.contextNode >
@@ -57564,7 +58731,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;
 
@@ -57588,7 +58760,10 @@ class SpotLightNode extends AnalyticLightNode {
 
 		}
 
-		return { lightColor, lightDirection };
+		// WITH_GENESYS
+		return { lightColor, lightDirection, attenuation };
+		// !WITH_GENESYS
+		// return { lightColor, lightDirection };
 
 	}
 
@@ -57904,6 +59079,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' ) ) {
@@ -59200,7 +60389,10 @@ class NodeManager extends DataMap {
 
 		const renderer = this.renderer;
 
-		return renderer.toneMapping + ',' + renderer.currentColorSpace + ',' + renderer.xr.isPresenting;
+		// WITH_GENESYS
+		return renderer.toneMapping + ',' + renderer.currentColorSpace + ',' + renderer.xr.isPresenting + ',' + renderer.debug.view;
+		// !WITH_GENESYS
+		// return renderer.toneMapping + ',' + renderer.currentColorSpace + ',' + renderer.xr.isPresenting;
 
 	}
 
@@ -59215,27 +60407,45 @@ class NodeManager extends DataMap {
 
 		const renderer = this.renderer;
 
-		let output;
+		let sampled;
 
 		if ( outputTarget.isArrayTexture ) {
 
 			if ( this.backend.isWebGLBackend ) {
 
-				output = texture( outputTarget, screenUV ).depth( builtin( 'gl_ViewID_OVR' ) ).renderOutput( renderer.toneMapping, renderer.currentColorSpace );
+				sampled = texture( outputTarget, screenUV ).depth( builtin( 'gl_ViewID_OVR' ) );
 
 			} else {
 
-				output = texture( outputTarget, screenUV ).depth( _outputLayerIndex ).renderOutput( renderer.toneMapping, renderer.currentColorSpace );
+				sampled = texture( outputTarget, screenUV ).depth( _outputLayerIndex );
 
 			}
 
 		} else {
 
-			output = texture( outputTarget, screenUV ).renderOutput( renderer.toneMapping, renderer.currentColorSpace );
+			sampled = texture( outputTarget, screenUV );
 
 		}
 
-		return output;
+		// WITH_GENESYS
+		if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY || renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS ) {
+
+			const complexity = renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS
+				? sampled.r.mul( sampled.g ).mul( SHADER_COMPLEXITY_QUAD_COUNT_SCALE )
+				: sampled.r;
+
+			return vec4( colorizeShaderComplexity( complexity ), 1 ).renderOutput( NoToneMapping, renderer.currentColorSpace );
+
+		}
+
+		if ( renderer.debug.view === DEBUG_VIEW_QUAD_OVERDRAW ) {
+
+			return vec4( colorizeQuadOverdraw( sampled.r ), 1 ).renderOutput( NoToneMapping, renderer.currentColorSpace );
+
+		}
+		// !WITH_GENESYS
+
+		return sampled.renderOutput( renderer.toneMapping, renderer.currentColorSpace );
 
 	}
 
@@ -63193,6 +64403,10 @@ class Renderer {
 		 * @property {?Function} onNodeBuilderCreated - A callback function that is executed after a node builder has been created and before it is built.
 		 * @property {?Function} onShaderError - A callback function that is executed when a shader error happens. Only supported with WebGL 2 right now.
 		 * @property {Function} getShaderAsync - Allows the get the raw shader code for the given scene, camera and 3D object.
+		 * @property {string} view - Debug view. `shaderComplexity`, `lightingComplexity`, `quadOverdraw`, and `shaderComplexityAndQuads` replace the shaded color with a heatmap. `shaderComplexityAndQuads` multiplies the shader cost by the overdraw count. `bufferVisualization` shows one material channel. `lightingOnly` and `detailLighting` light a flat gray surface. `drawCall` lights each submitted draw with its own diffuse color.
+		 * @property {string} buffer - Channel drawn by `bufferVisualization`: `baseColor`, `worldNormal`, `roughness`, `metallic`, `ambientOcclusion`, or `emissive`.
+		 * @property {number} shaderComplexityBudget - Proxy budget that fills the shader-complexity ramp.
+		 * @property {number} quadOverdrawBudget - Overlapping fragments that fill the quad-overdraw ramp.
 		 */
 
 		/**
@@ -63207,6 +64421,12 @@ class Renderer {
 			},
 			onNodeBuilderCreated: null,
 			onShaderError: null,
+			// WITH_GENESYS
+			view: DEBUG_VIEW_NONE,
+			buffer: DEFAULT_BUFFER,
+			shaderComplexityBudget: DEFAULT_SHADER_COMPLEXITY_BUDGET,
+			quadOverdrawBudget: DEFAULT_QUAD_OVERDRAW_BUDGET,
+			// !WITH_GENESYS
 			getShaderAsync: async ( scene, camera, object ) => {
 
 				await this.compileAsync( object, camera, scene );
@@ -65141,7 +66361,11 @@ class Renderer {
 		const useToneMapping = this.currentToneMapping !== NoToneMapping;
 		const useColorSpace = this.currentColorSpace !== ColorManagement.workingColorSpace;
 
-		return useToneMapping || useColorSpace;
+		// WITH_GENESYS
+		// Accumulating views write a scalar into an intermediate target, then the output pass colorizes it.
+		return useToneMapping || useColorSpace || debugViewAccumulates( this.debug.view );
+		// !WITH_GENESYS
+		// return useToneMapping || useColorSpace;
 
 	}
 
@@ -65192,6 +66416,16 @@ class Renderer {
 	 */
 	get currentToneMapping() {
 
+		// WITH_GENESYS
+		const view = this.debug.view;
+
+		if ( view === DEBUG_VIEW_SHADER_COMPLEXITY || view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS || view === DEBUG_VIEW_LIGHTING_COMPLEXITY || view === DEBUG_VIEW_QUAD_OVERDRAW || view === DEBUG_VIEW_BUFFER ) {
+
+			return NoToneMapping;
+
+		}
+		// !WITH_GENESYS
+
 		return this.isOutputTarget ? this.toneMapping : NoToneMapping;
 
 	}
@@ -68508,6 +69742,10 @@ ${ flowData.code }
 	 */
 	generateTexture( texture, textureProperty, uvSnippet, depthSnippet, offsetSnippet ) {
 
+		// WITH_GENESYS
+		this.recordFragmentTextureSample( texture, this.shaderStage, textureProperty + '|' + uvSnippet );
+		// !WITH_GENESYS
+
 		if ( depthSnippet ) uvSnippet = `vec3( ${ uvSnippet }, ${ depthSnippet } )`;
 
 		if ( texture.isDepthTexture ) {
@@ -68551,6 +69789,10 @@ ${ flowData.code }
 	 */
 	generateTextureLevel( texture, textureProperty, uvSnippet, levelSnippet, depthSnippet, offsetSnippet ) {
 
+		// WITH_GENESYS
+		this.recordFragmentTextureSample( texture, this.shaderStage, textureProperty + '|' + uvSnippet + '|' + levelSnippet );
+		// !WITH_GENESYS
+
 		if ( depthSnippet ) uvSnippet = `vec3( ${ uvSnippet }, ${ depthSnippet } )`;
 
 		if ( offsetSnippet ) {
@@ -70981,6 +72223,8 @@ class WebGLAttributeUtils {
 
 }
 
+// !WITH_GENESYS
+
 let equationToGL, factorToGL;
 
 /**
@@ -71903,9 +73147,25 @@ class WebGLState {
 
 		this.setFlipSided( flipSided );
 
-		( material.blending === NormalBlending && material.transparent === false )
-			? this.setBlending( NoBlending )
-			: this.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.blendColor, material.blendAlpha, material.premultipliedAlpha );
+		// WITH_GENESYS
+		// WebGL has no cached render pipeline. One+One is applied on each draw instead.
+		if ( debugViewAccumulates( this.backend.renderer.debug.view ) && material.isShadowPassMaterial !== true && this.backend.renderer.isOutputTarget !== true ) {
+
+			this.setBlending( AdditiveBlending, AddEquation, OneFactor, OneFactor, AddEquation, OneFactor, OneFactor, material.blendColor, material.blendAlpha, true );
+
+		} else if ( material.blending === NormalBlending && material.transparent === false ) {
+
+			this.setBlending( NoBlending );
+
+		} else {
+
+			this.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.blendColor, material.blendAlpha, material.premultipliedAlpha );
+
+		}
+		// !WITH_GENESYS
+		// ( material.blending === NormalBlending && material.transparent === false )
+		// 	? this.setBlending( NoBlending )
+		// 	: this.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.blendColor, material.blendAlpha, material.premultipliedAlpha );
 
 		this.setDepthFunc( material.depthFunc );
 		this.setDepthTest( material.depthTest );
@@ -82774,6 +84034,10 @@ class WGSLNodeBuilder extends NodeBuilder {
 	 */
 	_generateTextureSample( texture, textureProperty, uvSnippet, depthSnippet, offsetSnippet, shaderStage = this.shaderStage ) {
 
+		// WITH_GENESYS
+		if ( shaderStage === 'fragment' ) this.recordFragmentTextureSample( texture, shaderStage, textureProperty + '|' + uvSnippet );
+		// !WITH_GENESYS
+
 		if ( shaderStage === 'fragment' ) {
 
 			if ( depthSnippet ) {
@@ -83054,6 +84318,10 @@ class WGSLNodeBuilder extends NodeBuilder {
 	 */
 	generateFilteredTexture( texture, textureProperty, uvSnippet, offsetSnippet, levelSnippet = '0u', depthSnippet ) {
 
+		// WITH_GENESYS
+		this.recordFragmentTextureSample( texture, this.shaderStage, textureProperty + '|' + uvSnippet + '|' + levelSnippet );
+		// !WITH_GENESYS
+
 		const wrapFunction = this.generateWrapFunction( texture );
 		const textureDimension = this.generateTextureDimension( texture, textureProperty, levelSnippet );
 
@@ -83091,6 +84359,10 @@ class WGSLNodeBuilder extends NodeBuilder {
 	 */
 	generateTextureLod( texture, textureProperty, uvSnippet, depthSnippet, offsetSnippet, levelSnippet = '0u' ) {
 
+		// WITH_GENESYS
+		this.recordFragmentTextureSample( texture, this.shaderStage, textureProperty + '|' + uvSnippet + '|' + levelSnippet );
+		// !WITH_GENESYS
+
 		// Cube textures cannot use textureLoad in WGSL, must use textureSampleLevel
 		if ( texture.isCubeTexture === true ) {
 
@@ -83469,6 +84741,10 @@ class WGSLNodeBuilder extends NodeBuilder {
 
 		if ( this.isUnfilterable( texture ) === false ) {
 
+			// WITH_GENESYS
+			this.recordFragmentTextureSample( texture, this.shaderStage, textureProperty + '|' + uvSnippet + '|' + levelSnippet );
+			// !WITH_GENESYS
+
 			if ( depthSnippet ) {
 
 				if ( offsetSnippet ) {
@@ -86576,6 +87852,26 @@ class WebGPUPipelineUtils {
 
 		}
 
+		// WITH_GENESYS
+		// Accumulate shader cost with One+One. Opaque materials normally disable blending.
+		if ( debugViewAccumulates( backend.renderer.debug.view ) && material.isShadowPassMaterial !== true && backend.renderer.isOutputTarget !== true ) {
+
+			materialBlending = {
+				color: {
+					srcFactor: GPUBlendFactor.One,
+					dstFactor: GPUBlendFactor.One,
+					operation: GPUBlendOperation.Add
+				},
+				alpha: {
+					srcFactor: GPUBlendFactor.One,
+					dstFactor: GPUBlendFactor.One,
+					operation: GPUBlendOperation.Add
+				}
+			};
+
+		}
+		// !WITH_GENESYS
+
 		// stencil
 
 		let stencilFront = {};
@@ -90378,6 +91674,9 @@ class WebGPUBackend extends Backend {
 		const depthStencilFormat = utils.getCurrentDepthStencilFormat( renderObject.context );
 		const primitiveTopology = utils.getPrimitiveTopology( object, material );
 		const frontFaceCW = ( object.isMesh && object.matrixWorld.determinantAffine() < 0 );
+		// WITH_GENESYS
+		const debugView = renderObject.renderer.debug.view;
+		// !WITH_GENESYS
 
 		let needsUpdate = false;
 
@@ -90395,7 +91694,10 @@ class WebGPUBackend extends Backend {
 			data.colorFormat !== colorFormat || data.depthStencilFormat !== depthStencilFormat ||
 			data.primitiveTopology !== primitiveTopology ||
 			data.frontFaceCW !== frontFaceCW ||
-			data.clippingContextCacheKey !== renderObject.clippingContextCacheKey
+			data.clippingContextCacheKey !== renderObject.clippingContextCacheKey ||
+			// WITH_GENESYS
+			data.debugView !== debugView
+			// !WITH_GENESYS
 		) {
 
 			data.material = material; data.materialVersion = material.version;
@@ -90416,6 +91718,9 @@ class WebGPUBackend extends Backend {
 			data.primitiveTopology = primitiveTopology;
 			data.frontFaceCW = frontFaceCW;
 			data.clippingContextCacheKey = renderObject.clippingContextCacheKey;
+			// WITH_GENESYS
+			data.debugView = debugView;
+			// !WITH_GENESYS
 
 			needsUpdate = true;
 
@@ -90459,7 +91764,10 @@ class WebGPUBackend extends Backend {
 			utils.getCurrentColorSpace( renderContext ), utils.getCurrentColorFormat( renderContext ), utils.getCurrentDepthStencilFormat( renderContext ),
 			utils.getPrimitiveTopology( object, material ),
 			renderObject.getGeometryCacheKey(),
-			renderObject.clippingContextCacheKey
+			renderObject.clippingContextCacheKey,
+			// WITH_GENESYS
+			renderObject.renderer.debug.view
+			// !WITH_GENESYS
 		].join();
 
 	}