@gnsx/three 0.186.3 → 0.186.5

package/src/nodes/display/LightingDebug.js

@@ -0,0 +1,108 @@
+// WITH_GENESYS
+// Lighting only and detail lighting. Both replace the shaded albedo with a flat gray.
+// !WITH_GENESYS
+
+import { diffuseColor, diffuseContribution, metalness, roughness, specularColor, specularColorBlended, specularF90, clearcoat, sheen, iridescence, anisotropy, transmission, retroreflectivity } from '../core/PropertyNode.js';
+import { normalViewGeometry } from '../accessors/Normal.js';
+import { negateOnBackSide } from './FrontFacingNode.js';
+import { float, vec3, Fn } from '../tsl/TSLCore.js';
+
+/**
+ * Lighting only. Flat gray, no specular, geometry normals. Material detail is dropped.
+ *
+ * @type {string}
+ */
+export const DEBUG_VIEW_LIGHTING_ONLY = 'lightingOnly';
+
+/**
+ * Detail lighting. Flat gray and a constant specular, with normal maps and roughness kept.
+ *
+ * @type {string}
+ */
+export 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>}
+ */
+export 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`.
+ */
+export 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 ) );
+
+	}
+
+}

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

@@ -7,6 +7,9 @@ import { Mesh } from '../../objects/Mesh.js';
 import { SphereGeometry } from '../../geometries/SphereGeometry.js';
 import { BackSide } from '../../constants.js';
 import { error } from '../../utils.js';
+// WITH_GENESYS
+import { debugViewAccumulates } from '../../nodes/display/ComplexityDebug.js';
+// !WITH_GENESYS
 
 const _clearColor = /*@__PURE__*/ new Color4();
 
@@ -191,7 +194,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 {
 
@@ -215,6 +226,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;

package/src/renderers/common/RenderObject.js

@@ -950,6 +950,11 @@ class RenderObject {
 
 		cacheKey = hash( 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( cacheKey, hashString( this.renderer.debug.view ), hashString( this.renderer.debug.buffer ), this.renderer.debug.shaderComplexityBudget, this.renderer.debug.quadOverdrawBudget );
+		// !WITH_GENESYS
+
 		return cacheKey;
 
 	}

package/src/renderers/common/Renderer.js

@@ -37,6 +37,8 @@ import { float, vec3, vec4, Fn } from '../../nodes/tsl/TSLCore.js';
 import { detachRendererReference } from '../../nodes/accessors/RendererReferenceNode.js';
 import { toneMappingExposure } from '../../nodes/display/ToneMappingNode.js';
 import { ProfilerService } from '../../profiler/ProfilerService.js';
+import { DEBUG_VIEW_LIGHTING_COMPLEXITY, DEBUG_VIEW_NONE, DEBUG_VIEW_QUAD_OVERDRAW, DEBUG_VIEW_SHADER_COMPLEXITY, DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS, DEFAULT_QUAD_OVERDRAW_BUDGET, DEFAULT_SHADER_COMPLEXITY_BUDGET, debugViewAccumulates } from '../../nodes/display/ComplexityDebug.js';
+import { DEBUG_VIEW_BUFFER, DEFAULT_BUFFER } from '../../nodes/display/BufferDebug.js';
 // !WITH_GENESYS
 import { reference } from '../../nodes/accessors/ReferenceNode.js';
 import { highpModelNormalViewMatrix, highpModelViewMatrix } from '../../nodes/accessors/ModelNode.js';
@@ -743,6 +745,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.
 		 */
 
 		/**
@@ -757,6 +763,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 );
@@ -2691,7 +2703,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;
 
 	}
 
@@ -2742,6 +2758,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;
 
 	}

package/src/renderers/common/nodes/NodeManager.js

@@ -7,7 +7,11 @@ import { NodeFrame, NodeUpdateType, StackTrace } from '../../../nodes/Nodes.js';
 import { renderGroup, cubeTexture, texture, fog, rangeFogFactor, densityFogFactor, reference, pmremTexture, screenUV, uniform } from '../../../nodes/TSL.js';
 import { builtin } from '../../../nodes/accessors/BuiltinNode.js';
 
-import { CubeUVReflectionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping } from '../../../constants.js';
+import { CubeUVReflectionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping, NoToneMapping } from '../../../constants.js';
+// WITH_GENESYS
+import { vec4 } from '../../../nodes/tsl/TSLCore.js';
+import { colorizeQuadOverdraw, colorizeShaderComplexity, DEBUG_VIEW_QUAD_OVERDRAW, DEBUG_VIEW_SHADER_COMPLEXITY, DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS, SHADER_COMPLEXITY_QUAD_COUNT_SCALE } from '../../../nodes/display/ComplexityDebug.js';
+// !WITH_GENESYS
 import { hashArray } from '../../../nodes/core/NodeUtils.js';
 import { error } from '../../../utils.js';
 
@@ -992,7 +996,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;
 
 	}
 
@@ -1007,27 +1014,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 );
 
 	}
 

package/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js

@@ -635,6 +635,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 ) {
@@ -678,6 +682,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 ) {

package/src/renderers/webgl-fallback/utils/WebGLState.js

@@ -11,6 +11,9 @@ import {
 import { Color } from '../../../math/Color.js';
 import { Vector4 } from '../../../math/Vector4.js';
 import { error, ReversedDepthFuncs, warnOnce } from '../../../utils.js';
+// WITH_GENESYS
+import { debugViewAccumulates } from '../../../nodes/display/ComplexityDebug.js';
+// !WITH_GENESYS
 
 let equationToGL, factorToGL;
 
@@ -934,9 +937,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 );

package/src/renderers/webgpu/WebGPUBackend.js

@@ -2389,6 +2389,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;
 
@@ -2406,7 +2409,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;
@@ -2427,6 +2433,9 @@ class WebGPUBackend extends Backend {
 			data.primitiveTopology = primitiveTopology;
 			data.frontFaceCW = frontFaceCW;
 			data.clippingContextCacheKey = renderObject.clippingContextCacheKey;
+			// WITH_GENESYS
+			data.debugView = debugView;
+			// !WITH_GENESYS
 
 			needsUpdate = true;
 
@@ -2470,7 +2479,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();
 
 	}

package/src/renderers/webgpu/nodes/WGSLNodeBuilder.js

@@ -376,6 +376,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 ) {
@@ -656,6 +660,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 );
 
@@ -693,6 +701,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 ) {
 
@@ -1071,6 +1083,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 ) {

package/src/renderers/webgpu/utils/WebGPUPipelineUtils.js

@@ -15,6 +15,9 @@ import {
 } from '../../../constants.js';
 
 import { error, ReversedDepthFuncs, warn, warnOnce } from '../../../utils.js';
+// WITH_GENESYS
+import { debugViewAccumulates } from '../../../nodes/display/ComplexityDebug.js';
+// !WITH_GENESYS
 
 import GPUComputePipelineDescriptor from '../descriptors/GPUComputePipelineDescriptor.js';
 import GPUPipelineLayoutDescriptor from '../descriptors/GPUPipelineLayoutDescriptor.js';
@@ -106,6 +109,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 = {};