@gnsx/three 0.186.4 → 0.186.6

package/build/three.webgpu.js

@@ -3,7 +3,7 @@
  * Copyright 2010-2026 Three.js Authors
  * SPDX-License-Identifier: MIT
  */
-import { DynamicDrawUsage, RenderObjectRefreshType, Color, Vector2, Vector3, Vector4, Matrix2, Matrix3, Matrix4, error, UnsignedIntType, IntType, RedFormat, RedIntegerFormat, DepthFormat, DepthStencilFormat, AlphaFormat, RGFormat, RGIntegerFormat, RGBFormat, RGBIntegerFormat, EventDispatcher, MathUtils, warn, WebGLCoordinateSystem, WebGPUCoordinateSystem, ColorManagement, SRGBTransfer, NoToneMapping, StaticDrawUsage, InterleavedBufferAttribute, InterleavedBuffer, NoColorSpace, log as log$1, warnOnce, Texture, Compatibility, LessCompare, LessEqualCompare, GreaterCompare, GreaterEqualCompare, NearestFilter, Sphere, BackSide, DoubleSide, CubeTexture, CubeReflectionMapping, CubeRefractionMapping, TangentSpaceNormalMap, NoNormalPacking, NormalRGPacking, NormalGAPacking, ObjectSpaceNormalMap, RED_GREEN_RGTC2_Format, RG11_EAC_Format, InstancedBufferAttribute, InstancedInterleavedBuffer, DataTexture, RGBAFormat, FloatType, DataArrayTexture, FramebufferTexture, LinearMipmapLinearFilter, DepthTexture, Material, LineBasicMaterial, LineDashedMaterial, NoBlending, MeshNormalMaterial, SRGBColorSpace, RenderTarget, BoxGeometry, Mesh, Scene, LinearFilter, CubeCamera, EquirectangularReflectionMapping, EquirectangularRefractionMapping, AddOperation, MixOperation, MultiplyOperation, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, HalfFloatType, ClampToEdgeWrapping, BufferGeometry, OrthographicCamera, PerspectiveCamera, LinearSRGBColorSpace, CubeUVReflectionMapping, BufferAttribute, MeshStandardMaterial, MeshPhysicalMaterial, MeshToonMaterial, MeshMatcapMaterial, SpriteMaterial, PointsMaterial, ShadowMaterial, Uint32BufferAttribute, Uint16BufferAttribute, ByteType, UnsignedByteType, ShortType, UnsignedShortType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedInt248Type, UnsignedInt5999Type, UnsignedInt101111Type, NormalBlending, SrcAlphaFactor, OneMinusSrcAlphaFactor, AddEquation, MaterialBlending, Object3D, LinearMipMapLinearFilter, Plane, Float32BufferAttribute, UVMapping, Data3DTexture, VSMShadowMap, PCFShadowMap, ProfilerService, BasicShadowMap, CubeDepthTexture, SphereGeometry, LinearMipmapNearestFilter, NearestMipmapLinearFilter, Float16BufferAttribute, yieldToMain, REVISION, ArrayCamera, PlaneGeometry, FrontSide, CustomBlending, ZeroFactor, CylinderGeometry, Quaternion, WebXRController, RAD2DEG, PCFSoftShadowMap, FrustumArray, Frustum, RGBAIntegerFormat, TimestampQuery, createCanvasElement, MaxEquation, MinEquation, ReverseSubtractEquation, SubtractEquation, OneMinusConstantAlphaFactor, ConstantAlphaFactor, OneMinusConstantColorFactor, ConstantColorFactor, OneMinusDstAlphaFactor, OneMinusDstColorFactor, OneMinusSrcColorFactor, DstAlphaFactor, DstColorFactor, SrcAlphaSaturateFactor, SrcColorFactor, OneFactor, CullFaceNone, CullFaceBack, CullFaceFront, MultiplyBlending, SubtractiveBlending, AdditiveBlending, NotEqualDepth, GreaterDepth, GreaterEqualDepth, EqualDepth, LessEqualDepth, LessDepth, AlwaysDepth, NeverDepth, ReversedDepthFuncs, RGB_S3TC_DXT1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGBA_ETC2_EAC_Format, R11_EAC_Format, SIGNED_R11_EAC_Format, SIGNED_RG11_EAC_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_10x10_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_BPTC_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RED_RGTC1_Format, SIGNED_RED_RGTC1_Format, SIGNED_RED_GREEN_RGTC2_Format, MirroredRepeatWrapping, RepeatWrapping, NearestMipmapNearestFilter, NotEqualCompare, EqualCompare, AlwaysCompare, NeverCompare, LinearTransfer, getByteLength, isTypedArray, NotEqualStencilFunc, GreaterStencilFunc, GreaterEqualStencilFunc, EqualStencilFunc, LessEqualStencilFunc, LessStencilFunc, AlwaysStencilFunc, NeverStencilFunc, DecrementWrapStencilOp, IncrementWrapStencilOp, DecrementStencilOp, IncrementStencilOp, InvertStencilOp, ReplaceStencilOp, ZeroStencilOp, KeepStencilOp, SpotLight, PointLight, DirectionalLight, RectAreaLight, AmbientLight, HemisphereLight, LightProbe, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping, Group, Loader, FileLoader, MaterialLoader, ObjectLoader } from './three.core.js';
+import { DynamicDrawUsage, RenderObjectRefreshType, Color, Vector2, Vector3, Vector4, Matrix2, Matrix3, Matrix4, error, UnsignedIntType, IntType, RedFormat, RedIntegerFormat, DepthFormat, DepthStencilFormat, AlphaFormat, RGFormat, RGIntegerFormat, RGBFormat, RGBIntegerFormat, EventDispatcher, MathUtils, warn, WebGLCoordinateSystem, WebGPUCoordinateSystem, ColorManagement, SRGBTransfer, NoToneMapping, StaticDrawUsage, InterleavedBufferAttribute, InterleavedBuffer, NoColorSpace, log as log$1, warnOnce, Texture, Compatibility, LessCompare, LessEqualCompare, GreaterCompare, GreaterEqualCompare, NearestFilter, Sphere, BackSide, DoubleSide, CubeTexture, CubeReflectionMapping, CubeRefractionMapping, TangentSpaceNormalMap, NoNormalPacking, NormalRGPacking, NormalGAPacking, ObjectSpaceNormalMap, RED_GREEN_RGTC2_Format, RG11_EAC_Format, InstancedBufferAttribute, InstancedInterleavedBuffer, DataTexture, RGBAFormat, FloatType, DataArrayTexture, FramebufferTexture, LinearMipmapLinearFilter, DepthTexture, NormalBlending, SrcAlphaFactor, OneMinusSrcAlphaFactor, AddEquation, MaterialBlending, NoBlending, Material, LineBasicMaterial, LineDashedMaterial, MeshNormalMaterial, SRGBColorSpace, RenderTarget, BoxGeometry, Mesh, Scene, LinearFilter, CubeCamera, EquirectangularReflectionMapping, EquirectangularRefractionMapping, AddOperation, MixOperation, MultiplyOperation, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, HalfFloatType, ClampToEdgeWrapping, BufferGeometry, OrthographicCamera, PerspectiveCamera, LinearSRGBColorSpace, CubeUVReflectionMapping, BufferAttribute, MeshStandardMaterial, MeshPhysicalMaterial, MeshToonMaterial, MeshMatcapMaterial, SpriteMaterial, PointsMaterial, ShadowMaterial, Uint32BufferAttribute, Uint16BufferAttribute, ByteType, UnsignedByteType, ShortType, UnsignedShortType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedInt248Type, UnsignedInt5999Type, UnsignedInt101111Type, Object3D, LinearMipMapLinearFilter, Plane, Float32BufferAttribute, UVMapping, Data3DTexture, VSMShadowMap, PCFShadowMap, ProfilerService, BasicShadowMap, CubeDepthTexture, SphereGeometry, LinearMipmapNearestFilter, NearestMipmapLinearFilter, Float16BufferAttribute, yieldToMain, REVISION, ArrayCamera, PlaneGeometry, FrontSide, CustomBlending, ZeroFactor, CylinderGeometry, Quaternion, WebXRController, RAD2DEG, PCFSoftShadowMap, FrustumArray, Frustum, RGBAIntegerFormat, TimestampQuery, createCanvasElement, MaxEquation, MinEquation, ReverseSubtractEquation, SubtractEquation, OneMinusConstantAlphaFactor, ConstantAlphaFactor, OneMinusConstantColorFactor, ConstantColorFactor, OneMinusDstAlphaFactor, OneMinusDstColorFactor, OneMinusSrcColorFactor, DstAlphaFactor, DstColorFactor, SrcAlphaSaturateFactor, SrcColorFactor, OneFactor, CullFaceNone, CullFaceBack, CullFaceFront, MultiplyBlending, SubtractiveBlending, AdditiveBlending, NotEqualDepth, GreaterDepth, GreaterEqualDepth, EqualDepth, LessEqualDepth, LessDepth, AlwaysDepth, NeverDepth, ReversedDepthFuncs, RGB_S3TC_DXT1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGBA_ETC2_EAC_Format, R11_EAC_Format, SIGNED_R11_EAC_Format, SIGNED_RG11_EAC_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_10x10_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_BPTC_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RED_RGTC1_Format, SIGNED_RED_RGTC1_Format, SIGNED_RED_GREEN_RGTC2_Format, MirroredRepeatWrapping, RepeatWrapping, NearestMipmapNearestFilter, NotEqualCompare, EqualCompare, AlwaysCompare, NeverCompare, LinearTransfer, getByteLength, isTypedArray, NotEqualStencilFunc, GreaterStencilFunc, GreaterEqualStencilFunc, EqualStencilFunc, LessEqualStencilFunc, LessStencilFunc, AlwaysStencilFunc, NeverStencilFunc, DecrementWrapStencilOp, IncrementWrapStencilOp, DecrementStencilOp, IncrementStencilOp, InvertStencilOp, ReplaceStencilOp, ZeroStencilOp, KeepStencilOp, SpotLight, PointLight, DirectionalLight, RectAreaLight, AmbientLight, HemisphereLight, LightProbe, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping, Group, Loader, FileLoader, MaterialLoader, ObjectLoader } from './three.core.js';
 export { AdditiveAnimationBlendMode, AnimationAction, AnimationClip, AnimationLoader, AnimationMixer, AnimationObjectGroup, AnimationUtils, ArcCurve, ArrowHelper, AttachedBindMode, Audio, AudioAnalyser, AudioContext, AudioListener, AudioLoader, AxesHelper, BasicDepthPacking, BatchedMesh, BezierInterpolant, Bone, BooleanKeyframeTrack, Box2, Box3, Box3Helper, BoxHelper, BufferGeometryLoader, Cache, Camera, CameraHelper, CanvasTexture, CapsuleGeometry, CatmullRomCurve3, CircleGeometry, Clock, ColorKeyframeTrack, CompressedArrayTexture, CompressedCubeTexture, CompressedTexture, CompressedTextureLoader, ConeGeometry, Controls, CubeTextureLoader, CubicBezierCurve, CubicBezierCurve3, CubicInterpolant, CullFaceFrontBack, Curve, CurvePath, CustomToneMapping, Cylindrical, DataTextureLoader, DataUtils, DefaultLoadingManager, DetachedBindMode, DirectionalLightHelper, DiscreteInterpolant, DodecahedronGeometry, DynamicCopyUsage, DynamicReadUsage, EdgesGeometry, EllipseCurve, Euler, ExternalTexture, ExtrudeGeometry, Fog, FogExp2, GLBufferAttribute, GLSL1, GLSL3, GridHelper, HTMLTexture, HemisphereLightHelper, IcosahedronGeometry, ImageBitmapLoader, ImageLoader, ImageUtils, InstancedBufferGeometry, InstancedMesh, Int16BufferAttribute, Int32BufferAttribute, Int8BufferAttribute, Interpolant, InterpolateBezier, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, InterpolationSamplingMode, InterpolationSamplingType, KeyframeTrack, LOD, LatheGeometry, Layers, Light, LightShadow, Line, Line3, LineCurve, LineCurve3, LineLoop, LineSegments, LinearInterpolant, LinearMipMapNearestFilter, LoaderUtils, LoadingManager, LoopOnce, LoopPingPong, LoopRepeat, MOUSE, MeshDepthMaterial, MeshDistanceMaterial, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NodePath, NormalAnimationBlendMode, NumberKeyframeTrack, OctahedronGeometry, Path, PlaneHelper, PointLightHelper, Points, PolarGridHelper, PolyhedronGeometry, PositionalAudio, PropertyBinding, PropertyMixer, QuadraticBezierCurve, QuadraticBezierCurve3, QuaternionKeyframeTrack, QuaternionLinearInterpolant, RGBADepthPacking, RGBDepthPacking, RGDepthPacking, RawShaderMaterial, Ray, Raycaster, RenderTarget3D, RingGeometry, ShaderMaterial, Shape, ShapeGeometry, ShapePath, ShapeUtils, Skeleton, SkeletonHelper, SkinnedMesh, Source, Spherical, SphericalHarmonics3, SplineCurve, SpotLightHelper, Sprite, StaticCopyUsage, StaticReadUsage, StereoCamera, StreamCopyUsage, StreamDrawUsage, StreamReadUsage, StringKeyframeTrack, TOUCH, TetrahedronGeometry, TextureLoader, TextureSource, TextureUtils, Timer, TorusGeometry, TorusKnotGeometry, Triangle, TriangleFanDrawMode, TriangleStripDrawMode, TrianglesDrawMode, TubeGeometry, Uint8BufferAttribute, Uint8ClampedBufferAttribute, Uniform, UniformsGroup, VectorKeyframeTrack, VideoFrameTexture, VideoTexture, WebGL3DRenderTarget, WebGLArrayRenderTarget, WebGLRenderTarget, WireframeGeometry, WrapAroundEnding, XorShift32, ZeroCurvatureEnding, ZeroSlopeEnding, allocateNodeId, collectSiblingNodeIds, configureNodeIdSeed, ensureUniqueNodeIdAmongParentChildren, generateNodeId, getConsoleFunction, hashStringToUint32, isValidNodeId, nodeIdFromKey, nodeIdFromString, nodeIdToString, profile, profileClass, randomSeedUint32, setConsoleFunction, xorshift32 } from './three.core.js';
 
 const refreshUniforms = [
@@ -21614,282 +21614,1376 @@ class VertexColorNode extends AttributeNode {
  */
 const vertexColor = ( index = 0 ) => new VertexColorNode( index );
 
+// 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
 // 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';
+/**
+ * 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;
+
+}
+
+/**
+ * Whether a draw adds its scalar to the accumulating target instead of shading normally.
+ * Shadow passes, draws to the screen, and fullscreen quads draw normally. A post-processing
+ * quad copies the accumulated scene target, so its own cost must not replace it.
+ *
+ * @param {Renderer} renderer - The renderer.
+ * @param {Material} material - The material being drawn.
+ * @param {?Object3D} object - The object being drawn.
+ * @return {boolean} `true` when the draw accumulates.
+ */
+function debugDrawAccumulates( renderer, material, object ) {
+
+	return debugViewAccumulates( renderer.debug.view ) &&
+		material.isShadowPassMaterial !== true &&
+		renderer.isOutputTarget !== true &&
+		( object === null || object === undefined || object.isQuadMesh !== true );
+
+}
+
+/**
+ * Views that output data or a heatmap, so tone mapping would distort them.
+ *
+ * @param {string} view - `renderer.debug.view`.
+ * @return {boolean} `true` when the view is drawn without tone mapping.
+ */
+function debugViewSkipsToneMapping( view ) {
+
+	return debugViewAccumulates( view ) || view === DEBUG_VIEW_LIGHTING_COMPLEXITY || view === DEBUG_VIEW_BUFFER;
+
+}
+
+/**
+ * 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 ) );
+
+}
+
+/**
+ * This node can be used to define multiple outputs in a shader programs.
+ *
+ * @augments Node
+ */
+class OutputStructNode extends Node {
+
+	static get type() {
+
+		return 'OutputStructNode';
+
+	}
+
+	/**
+	 * Constructs a new output struct node. The constructor can be invoked with an
+	 * arbitrary number of nodes representing the members.
+	 *
+	 * @param {...Node} members - A parameter list of nodes.
+	 */
+	constructor( ...members ) {
+
+		super();
+
+		/**
+		 * An array of nodes which defines the output.
+		 *
+		 * @type {Array<Node>}
+		 */
+		this.members = members;
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isOutputStructNode = true;
+
+	}
+
+	generateNodeType( /*builder*/ ) {
+
+		return 'OutputType';
+
+	}
+
+	generate( builder ) {
+
+		const nodeData = builder.getDataFromNode( this );
+
+		if ( nodeData.membersLayout === undefined ) {
+
+			const members = this.members;
+			const membersLayout = [];
+
+			for ( let i = 0; i < members.length; i ++ ) {
+
+				const name = 'm' + i;
+				const type = members[ i ].getNodeType( builder );
+
+				membersLayout.push( { name, type, index: i } );
+
+			}
+
+			nodeData.membersLayout = membersLayout;
+			nodeData.structType = builder.getOutputStructTypeFromNode( this, nodeData.membersLayout );
+
+		}
+
+		//
+
+		const propertyName = builder.getOutputStructName();
+		const members = this.members;
+
+		const structPrefix = propertyName !== '' ? propertyName + '.' : '';
+
+		for ( let i = 0; i < members.length; i ++ ) {
+
+			const snippet = members[ i ].build( builder, nodeData.membersLayout[ i ].type );
+
+			builder.addLineFlowCode( `${ structPrefix }m${ i } = ${ snippet }`, this );
+
+		}
+
+		return propertyName;
+
+	}
+
+}
+
+/**
+ * TSL function for creating an output struct node.
+ *
+ * @tsl
+ * @function
+ * @param {...Node} members - A parameter list of nodes.
+ * @returns {OutputStructNode}
+ */
+const outputStruct = /*@__PURE__*/ nodeProxy( OutputStructNode );
+
+/**
+ * Represents blending configuration.
+ *
+ * This class encapsulates all blending-related properties that control how
+ * a material's colors are combined with the colors already in the frame buffer.
+ */
+class BlendMode {
+
+	/**
+	 * Constructs a new blending configuration.
+	 *
+	 * @param {(NoBlending|NormalBlending|AdditiveBlending|SubtractiveBlending|MultiplyBlending|CustomBlending|MaterialBlending)} [blending=NormalBlending] - The blending mode.
+	 */
+	constructor( blending = NormalBlending ) {
+
+		/**
+		 * Defines the blending type.
+		 *
+		 * It must be set to `CustomBlending` if custom blending properties like
+		 * {@link BlendMode#blendSrc}, {@link BlendMode#blendDst} or {@link BlendMode#blendEquation}
+		 * should have any effect.
+		 *
+		 * @type {(NoBlending|NormalBlending|AdditiveBlending|SubtractiveBlending|MultiplyBlending|CustomBlending|MaterialBlending)}
+		 * @default NormalBlending
+		 */
+		this.blending = blending;
+
+		/**
+		 * Defines the blending source factor.
+		 *
+		 * This determines how the source (incoming) fragment color is factored before being added
+		 * to the destination (existing) fragment color in the frame buffer.
+		 *
+		 * @type {(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
+		 * @default SrcAlphaFactor
+		 */
+		this.blendSrc = SrcAlphaFactor;
+
+		/**
+		 * Defines the blending destination factor.
+		 *
+		 * This determines how the destination (existing) fragment color in the frame buffer
+		 * is factored before being combined with the source (incoming) fragment color.
+		 *
+		 * @type {(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
+		 * @default OneMinusSrcAlphaFactor
+		 */
+		this.blendDst = OneMinusSrcAlphaFactor;
+
+		/**
+		 * Defines the blending equation.
+		 *
+		 * This determines how the source and destination colors are combined.
+		 *
+		 * @type {(AddEquation|SubtractEquation|ReverseSubtractEquation|MinEquation|MaxEquation)}
+		 * @default AddEquation
+		 */
+		this.blendEquation = AddEquation;
+
+		/**
+		 * Defines the blending source alpha factor.
+		 *
+		 * When set, this allows separate control of the alpha channel's source blending factor.
+		 * If `null`, {@link BlendMode#blendSrc} is used for the alpha channel as well.
+		 *
+		 * @type {?(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
+		 * @default null
+		 */
+		this.blendSrcAlpha = null;
+
+		/**
+		 * Defines the blending destination alpha factor.
+		 *
+		 * When set, this allows separate control of the alpha channel's destination blending factor.
+		 * If `null`, {@link BlendMode#blendDst} is used for the alpha channel as well.
+		 *
+		 * @type {?(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
+		 * @default null
+		 */
+		this.blendDstAlpha = null;
+
+		/**
+		 * Defines the blending equation of the alpha channel.
+		 *
+		 * When set, this allows separate control of the alpha channel's blending equation.
+		 * If `null`, {@link BlendMode#blendEquation} is used for the alpha channel as well.
+		 *
+		 * @type {?(AddEquation|SubtractEquation|ReverseSubtractEquation|MinEquation|MaxEquation)}
+		 * @default null
+		 */
+		this.blendEquationAlpha = null;
+
+		/**
+		 * Defines whether to premultiply the alpha (transparency) value.
+		 *
+		 * If `true`, the RGB color of the texture or material is multiplied by its alpha value.
+		 * This is useful for transparent textures/materials where the color data
+		 * should already include the transparency information.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
+		this.premultiplyAlpha = false;
+
+	}
+
+	/**
+	 * Copies the blending properties from the given source to this instance.
+	 *
+	 * @param {BlendMode} source - The blending configuration to copy from.
+	 * @return {BlendMode} A reference to this instance.
+	 */
+	copy( source ) {
+
+		this.blending = source.blending;
+		this.blendSrc = source.blendSrc;
+		this.blendDst = source.blendDst;
+		this.blendEquation = source.blendEquation;
+		this.blendSrcAlpha = source.blendSrcAlpha;
+		this.blendDstAlpha = source.blendDstAlpha;
+		this.blendEquationAlpha = source.blendEquationAlpha;
+		this.premultiplyAlpha = source.premultiplyAlpha;
+
+		return this;
+
+	}
+
+	/**
+	 * Returns a clone of this blending configuration.
+	 *
+	 * @return {BlendMode} A new Blending instance with the same properties.
+	 */
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+/**
+ * A four-component version of {@link Color} which is internally
+ * used by the renderer to represents clear color with alpha as
+ * one object.
+ *
+ * @private
+ * @augments Color
+ */
+class Color4 extends Color {
+
+	/**
+	 * Constructs a new four-component color.
+	 * You can also pass a single THREE.Color, hex or
+	 * string argument to this constructor.
+	 *
+	 * @param {number|string} [r=1] - The red value.
+	 * @param {number} [g=1] - The green value.
+	 * @param {number} [b=1] - The blue value.
+	 * @param {number} [a=1] - The alpha value.
+	 */
+	constructor( r, g, b, a = 1 ) {
+
+		super( r, g, b );
+
+		this.a = a;
+
+	}
+
+	/**
+	 * Overwrites the default to honor alpha.
+	 * You can also pass a single THREE.Color, hex or
+	 * string argument to this method.
+	 *
+	 * @param {number|string|Color} r - The red value.
+	 * @param {number} [g] - The green value.
+	 * @param {number} [b] - The blue value.
+	 * @param {number} [a=1] - The alpha value.
+	 * @return {Color4} A reference to this object.
+	 */
+	set( r, g, b, a = 1 ) {
+
+		this.a = a;
+
+		return super.set( r, g, b );
+
+	}
+
+	/**
+	 * Overwrites the default to honor alpha.
+	 *
+	 * @param {Color4} color - The color to copy.
+	 * @return {Color4} A reference to this object.
+	 */
+	copy( color ) {
+
+		if ( color.a !== undefined ) this.a = color.a;
+
+		return super.copy( color );
+
+	}
+
+	/**
+	 * Overwrites the default to honor alpha.
+	 *
+	 * @return {Color4} The cloned color.
+	 */
+	clone() {
+
+		return new this.constructor( this.r, this.g, this.b, this.a );
+
+	}
+
+	*[ Symbol.iterator ]() {
+
+		yield this.r;
+		yield this.g;
+		yield this.b;
+		yield this.a;
+
+	}
+
+}
+
+// Predefined blend modes for MRT nodes.
+const _noBlending = /**@__PURE__*/ new BlendMode( NoBlending );
+const _materialBlending = /**@__PURE__*/ new BlendMode( MaterialBlending );
+
+/**
+ * Returns the MRT texture index for the given name.
+ *
+ * @param {Array<Texture>} textures - The textures of a MRT-configured render target.
+ * @param {string} name - The name of the MRT texture which index is requested.
+ * @return {number} The texture index.
+ */
+function getTextureIndex( textures, name ) {
+
+	for ( let i = 0; i < textures.length; i ++ ) {
+
+		if ( textures[ i ].name === name ) {
+
+			return i;
+
+		}
+
+	}
+
+	return -1;
+
+}
+
+/**
+ * This node can be used setup a MRT context for rendering. A typical MRT setup for
+ * post-processing is shown below:
+ * ```js
+ * const mrtNode = mrt( {
+ *   output: output,
+ *   normal: normalView
+ * } ) ;
+ * ```
+ * The MRT output is defined as a dictionary.
+ *
+ * @augments OutputStructNode
+ */
+class MRTNode extends OutputStructNode {
+
+	static get type() {
+
+		return 'MRTNode';
+
+	}
+
+	/**
+	 * Constructs a new output struct node.
+	 *
+	 * @param {Object<string, Node>} outputNodes - The MRT outputs.
+	 */
+	constructor( outputNodes ) {
+
+		super();
+
+		/**
+		 * A dictionary representing the MRT outputs. The key
+		 * is the name of the output, the value the node which produces
+		 * the output result.
+		 *
+		 * @type {Object<string, Node>}
+		 */
+		this.outputNodes = outputNodes;
+
+		/**
+		 * A dictionary storing the blend modes for each output.
+		 *
+		 * @type {Object<string, BlendMode>}
+		 */
+		this.blendModes = {
+			output: _materialBlending
+		};
+
+		/**
+		 * A dictionary storing the clear colors for each output.
+		 *
+		 * @type {Object<string, Color4>}
+		 */
+		this.clearColors = {};
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isMRTNode = true;
+
+	}
+
+	/**
+	 * Sets the blend mode for the given output name.
+	 *
+	 * @param {string} name - The name of the output.
+	 * @param {BlendMode} blend - The blending mode.
+	 * @return {MRTNode} The current MRT node.
+	 */
+	setBlendMode( name, blend ) {
+
+		this.blendModes[ name ] = blend;
+
+		return this;
+
+	}
+
+	/**
+	 * Returns the blend mode for the given output name.
+	 *
+	 * @param {string} name - The name of the output.
+	 * @return {BlendMode} The blend mode.
+	 */
+	getBlendMode( name ) {
+
+		return this.blendModes[ name ] || _noBlending;
+
+	}
+
+	/**
+	 * Sets the clear color for the given output name.
+	 *
+	 * @param {string} name - The name of the output.
+	 * @param {number|string|Color} color - The clear color.
+	 * @param {number} [alpha=1] - The clear alpha.
+	 * @return {MRTNode} The current MRT node.
+	 */
+	setClearColor( name, color, alpha = 1 ) {
+
+		const clearColor = this.clearColors[ name ] || ( this.clearColors[ name ] = new Color4() );
+
+		clearColor.set( color );
+		clearColor.a = alpha;
+
+		return this;
 
-/**
- * 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';
+	/**
+	 * Returns the clear color for the given output name.
+	 *
+	 * @param {string} name - The name of the output.
+	 * @return {?Color4} The clear color. Returns `null` if no clear color is defined
+	 * which means the renderer's default clear policy is applied.
+	 */
+	getClearColor( name ) {
 
-/**
- * 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}
- */
-const DEFAULT_SHADER_COMPLEXITY_BUDGET = 800;
+		return this.clearColors[ name ] || null;
 
-/** @type {number} */
-const SHADER_COMPLEXITY_BASE_UNLIT = 20;
+	}
 
-/** @type {number} */
-const SHADER_COMPLEXITY_BASE_LIT = 40;
+	/**
+	 * Returns `true` if the MRT node has an output with the given name.
+	 *
+	 * @param {string} name - The name of the output.
+	 * @return {NodeBuilder} Whether the MRT node has an output for the given name or not.
+	 */
+	has( name ) {
 
-/** @type {number} */
-const SHADER_COMPLEXITY_TEXTURE_COST = 16;
+		return this.outputNodes[ name ] !== undefined;
+
+	}
+
+	/**
+	 * Returns the output node for the given name.
+	 *
+	 * @param {string} name - The name of the output.
+	 * @return {Node} The output node.
+	 */
+	get( name ) {
+
+		return this.outputNodes[ name ];
+
+	}
+
+	/**
+	 * Merges the outputs of the given MRT node with the outputs of this node.
+	 *
+	 * @param {MRTNode} mrtNode - The MRT to merge.
+	 * @return {MRTNode} A new MRT node with merged outputs..
+	 */
+	merge( mrtNode ) {
+
+		const outputs = { ...this.outputNodes, ...mrtNode.outputNodes };
+		const blendModes = { ...this.blendModes, ...mrtNode.blendModes };
+		const clearColors = { ...this.clearColors, ...mrtNode.clearColors };
+
+		const mrtTarget = mrt( outputs );
+		mrtTarget.blendModes = blendModes;
+		mrtTarget.clearColors = clearColors;
+
+		return mrtTarget;
+
+	}
+
+	setup( builder ) {
+
+		const outputNodes = this.outputNodes;
+		const mrt = builder.renderer.getRenderTarget();
+
+		const members = [];
+
+		const textures = mrt.textures;
+
+		for ( const name in outputNodes ) {
+
+			const index = getTextureIndex( textures, name );
+
+			// Ignore if the output exists in the MRT but has never been used.
+			if ( index === -1 ) continue;
+
+			const type = builder.getOutputType( index );
+
+			members[ index ] = outputNodes[ name ].convert( type );
+
+		}
 
-/** @type {number} */
-const SHADER_COMPLEXITY_FEATURE_COST = 30;
+		this.members = members;
+
+		return super.setup( builder );
+
+	}
 
-/** @type {number} */
-const SHADER_COMPLEXITY_TRANSMISSION_COST = 60;
+}
 
 /**
- * Attenuation above this counts as a light that shades the pixel.
+ * TSL function for creating a MRT node.
  *
- * @type {number}
+ * @tsl
+ * @function
+ * @param {Object<string, Node>} outputNodes - The MRT outputs.
+ * @returns {MRTNode}
  */
-const LIGHTING_COMPLEXITY_EPSILON = 0.001;
+const mrt = /*@__PURE__*/ nodeProxy( MRTNode );
+
+// WITH_GENESYS
+// Lighting only and detail lighting. Both replace the shaded albedo with a flat gray.
+// !WITH_GENESYS
+
 
 /**
- * Added on top of 1 when a received light casts a shadow.
- * Applied even where the shadow map is black.
+ * Lighting only. Flat gray, no specular, geometry normals. Material detail is dropped.
  *
- * @type {number}
+ * @type {string}
  */
-const LIGHTING_COMPLEXITY_SHADOW_WEIGHT = 0.5;
+const DEBUG_VIEW_LIGHTING_ONLY = 'lightingOnly';
 
 /**
- * Unreal `ShaderComplexityColors` from `BaseEngine.ini`.
+ * Detail lighting. Flat gray and a constant specular, with normal maps and roughness kept.
  *
- * @type {Array<Array<number>>}
+ * @type {string}
  */
-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 ]
-];
+const DEBUG_VIEW_DETAIL_LIGHTING = 'detailLighting';
 
 /**
- * Unreal `LightComplexityColors` from `BaseEngine.ini`.
+ * Neutral albedo shared by both views. Matches Unreal's `LightingOnlyBrightness`.
  *
- * @type {Array<Array<number>>}
+ * @type {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 ] );
+const LIGHTING_ONLY_BRIGHTNESS = 0.3;
 
 /**
- * Linear sample of a fixed RGB ramp. `cost` is in steps, and one step is one light.
+ * Specular color used by detail lighting. Unreal writes `0.1` into the specular override.
  *
- * @param {Node<float>} cost - Complexity in ramp steps.
- * @param {Array<Array<number>>} colors - Ramp stops.
- * @return {Node<vec3>} The ramp color.
+ * @type {number}
  */
-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 );
+const DETAIL_LIGHTING_SPECULAR = 0.1;
 
-	let color = rgb( colors, 0 );
+/**
+ * Geometry normal for lighting only, so normal maps and `normalNode` do not shade the surface.
+ *
+ * @type {Node<vec3>}
+ */
+const lightingOnlyNormal = /*@__PURE__*/ Fn( ( builder ) => {
 
-	for ( let i = 0; i < steps; i ++ ) {
+	let node = normalViewGeometry;
 
-		const sample = mix( rgb( colors, i ), rgb( colors, i + 1 ), frac );
+	if ( builder.isFlatShading() !== true ) {
 
-		color = index.greaterThanEqual( float( i ) ).and( index.lessThan( float( i + 1 ) ) ).select( sample, color );
+		node = negateOnBackSide( node );
 
 	}
 
-	return color;
+	return node;
 
-};
+}, 'vec3' );
 
 /**
- * Maps a direct-light cost through Unreal's light-complexity ramp.
- * Ten lights saturate at white.
+ * Replaces albedo and specular after the material has written its channels.
+ * Lit materials become a dielectric gray. Unlit materials become flat gray.
  *
- * @param {Node<float>} cost - Accumulated light weight.
- * @return {Node<vec3>} The ramp color.
+ * @param {NodeBuilder} builder - The current node builder.
+ * @param {NodeMaterial} material - The node material being set up. `builder.material` can be the
+ * source material of a converted one, such as a glTF `MeshStandardMaterial`.
+ * @param {string} view - `renderer.debug.view`.
  */
-const colorizeLightComplexity = ( cost ) => colorizeLinear( cost, LIGHT_COMPLEXITY_COLORS );
+function applyLightingDebug( builder, material, view ) {
 
-/**
- * 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 gray = vec3( LIGHTING_ONLY_BRIGHTNESS );
 
-	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 );
+	diffuseColor.rgb.assign( gray );
 
-	If( expanded.lessThan( 1 ), () => {
+	if ( material.lights !== true ) return;
 
-		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 0 ), rgb( SHADER_COMPLEXITY_COLORS, 1 ), frac ) );
+	metalness.assign( float( 0 ) );
+	diffuseContribution.assign( gray );
 
-	} ).ElseIf( expanded.lessThan( 2 ), () => {
+	if ( view === DEBUG_VIEW_LIGHTING_ONLY ) {
 
-		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 1 ), rgb( SHADER_COMPLEXITY_COLORS, 2 ), frac ) );
+		roughness.assign( float( 1 ) );
+		specularColor.assign( vec3( 0 ) );
+		specularColorBlended.assign( vec3( 0 ) );
+		specularF90.assign( float( 0 ) );
 
-	} ).ElseIf( expanded.lessThan( 3 ), () => {
+		// Ambient occlusion was stored for the lighting model. Lighting only has no material.
+		builder.context.ambientOcclusion = null;
 
-		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 2 ), rgb( SHADER_COMPLEXITY_COLORS, 3 ), frac ) );
+		if ( material.useClearcoat === true ) clearcoat.assign( float( 0 ) );
 
-	} ).ElseIf( expanded.lessThan( 4 ), () => {
+		if ( material.useSheen === true ) sheen.assign( vec3( 0 ) );
 
-		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 3 ), rgb( SHADER_COMPLEXITY_COLORS, 4 ), frac ) );
+		if ( material.useIridescence === true ) iridescence.assign( float( 0 ) );
 
-	} ).ElseIf( expanded.lessThan( 5 ), () => {
+		if ( material.useAnisotropy === true ) anisotropy.assign( float( 0 ) );
 
-		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 4 ), rgb( SHADER_COMPLEXITY_COLORS, 5 ), frac ) );
+		if ( material.useTransmission === true ) transmission.assign( float( 0 ) );
 
-	} ).ElseIf( expanded.lessThan( 6 ), () => {
+		if ( material.useRetroreflection === true ) retroreflectivity.assign( float( 0 ) );
 
-		color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 5 ), rgb( SHADER_COMPLEXITY_COLORS, 6 ), frac ) );
+	} else {
 
-	} ).Else( () => {
+		const specular = vec3( DETAIL_LIGHTING_SPECULAR );
 
-		// 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 );
+		specularColor.assign( specular );
+		specularColorBlended.assign( specular );
+		specularF90.assign( float( 1 ) );
 
-		If( upper.lessThanEqual( 1 ), () => {
+	}
 
-			color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 6 ), rgb( SHADER_COMPLEXITY_COLORS, 7 ), upperFrac ) );
+}
 
-		} ).Else( () => {
+// WITH_GENESYS
+// Draw call coloration. One stable diffuse color per submitted draw, then lit.
+// !WITH_GENESYS
 
-			color.assign( mix( rgb( SHADER_COMPLEXITY_COLORS, 7 ), rgb( SHADER_COMPLEXITY_COLORS, 8 ), upperFrac ) );
 
-		} );
+/**
+ * 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;
 
-	return color;
+/**
+ * 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;
 
 /**
- * Reads the builder's shader-complexity proxy at code-generation time,
- * after the real material graph has been generated and texture samples counted.
+ * 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.
  *
- * @augments Node
+ * @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`.
  */
-class ShaderComplexityRatioNode extends Node {
+function writeDrawCallColor( color, object, material ) {
 
-	static get type() {
+	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 );
 
-		return 'ShaderComplexityRatioNode';
+	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 );
 
 	}
 
-	constructor() {
+}
 
-		super( 'float' );
+/**
+ * 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.
+ * @param {NodeMaterial} material - The node material being set up. `builder.material` can be the
+ * source material of a converted one, such as a glTF `MeshStandardMaterial`.
+ */
+function applyDrawCallDebug( builder, material ) {
 
-	}
+	const colorNode = uniform( new Color() ).onObjectUpdate( ( { object, material: drawnMaterial }, self ) => {
 
-	generate( builder ) {
+		if ( object === null || drawnMaterial === null ) return;
 
-		const budget = builder.renderer.debug.shaderComplexityBudget;
-		const safeBudget = ( typeof budget === 'number' && budget > 0 ) ? budget : 1;
-		const ratio = builder.getShaderComplexityCost() / safeBudget;
+		return writeDrawCallColor( self.value, object, drawnMaterial );
 
-		return ratio.toFixed( 6 );
+	} );
 
-	}
+	diffuseColor.rgb.assign( colorNode );
 
-}
+	if ( material.lights !== true ) return;
 
-/**
- * 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.
- */
-function getShaderComplexityBase( material ) {
+	metalness.assign( float( 0 ) );
+	diffuseContribution.assign( colorNode );
+	roughness.assign( float( 1 ) );
+	specularColor.assign( vec3( 0 ) );
+	specularColorBlended.assign( vec3( 0 ) );
+	specularF90.assign( float( 0 ) );
 
-	let cost = material.lights === true ? SHADER_COMPLEXITY_BASE_LIT : SHADER_COMPLEXITY_BASE_UNLIT;
+	// Ambient occlusion belonged to the original material.
+	builder.context.ambientOcclusion = null;
 
-	if ( material.useClearcoat === true ) cost += SHADER_COMPLEXITY_FEATURE_COST;
+	if ( material.useClearcoat === true ) clearcoat.assign( float( 0 ) );
 
-	if ( material.useSheen === true ) cost += SHADER_COMPLEXITY_FEATURE_COST;
+	if ( material.useSheen === true ) sheen.assign( vec3( 0 ) );
 
-	if ( material.useIridescence === true ) cost += SHADER_COMPLEXITY_FEATURE_COST;
+	if ( material.useIridescence === true ) iridescence.assign( float( 0 ) );
 
-	if ( material.useAnisotropy === true ) cost += SHADER_COMPLEXITY_FEATURE_COST;
+	if ( material.useAnisotropy === true ) anisotropy.assign( float( 0 ) );
 
-	if ( material.useTransmission === true ) cost += SHADER_COMPLEXITY_TRANSMISSION_COST;
+	if ( material.useTransmission === true ) transmission.assign( float( 0 ) );
 
-	return cost;
+	if ( material.useRetroreflection === true ) retroreflectivity.assign( float( 0 ) );
 
 }
 
 /**
- * Replaces the shaded color with `vec4(cost / budget, 0, 0, 1)`.
- * The real graph is still generated so texture samples are counted first.
+ * Replaces the color a material writes with a debug output. With MRT, only the `output`
+ * attachment is replaced so the other attachments keep their members. Converting the
+ * whole MRT struct to a color leaves WGSL with an empty output struct.
  *
- * @param {Node} resultNode - The material's shaded output.
- * @return {Node<vec4>} The complexity ratio in the red channel.
+ * @param {Node} resultNode - The material's fragment result, possibly an MRT node.
+ * @param {function(Node): Node} createOutput - Builds the debug color from the shaded color.
+ * @return {Node} The fragment result with the debug color in place.
  */
-function shaderComplexityOutput( resultNode ) {
+function replaceColorOutput( resultNode, createOutput ) {
 
-	// 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();
+	if ( resultNode.isMRTNode !== true ) return createOutput( resultNode );
 
-	const ratio = new ShaderComplexityRatioNode();
+	if ( resultNode.has( 'output' ) !== true ) return resultNode;
 
-	return vec4( ratio, 0, 0, 1 ).add( shaded.mul( 0 ) );
+	return resultNode.merge( mrt( { output: createOutput( resultNode.get( 'output' ) ) } ) );
 
 }
-
 // !WITH_GENESYS
 
 /**
@@ -22390,10 +23484,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, this, renderer.debug.view );
+
+			} else if ( renderer.debug.view === DEBUG_VIEW_DRAW_CALL && this.isShadowPassMaterial !== true ) {
+
+				applyDrawCallDebug( builder, this );
+
+			}
+			// !WITH_GENESYS
+
 			const outgoingLightNode = this.setupLighting( builder );
 
 			if ( clippingNode !== null ) builder.stack.addToStack( clippingNode );
@@ -22464,12 +23581,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 ) {
+		// The screen output pass colorizes the accumulated ratio. Wrapping that pass, or a
+		// post-processing quad that copies the scene target, would replace the heatmap with
+		// that quad's own constant cost.
+		if ( debugDrawAccumulates( renderer, this, builder.object ) ) {
+
+			if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY ) {
+
+				builder.shaderComplexityBase = this.getShaderComplexity();
+				resultNode = replaceColorOutput( resultNode, shaderComplexityOutput );
+
+			} else if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS ) {
+
+				builder.shaderComplexityBase = this.getShaderComplexity();
+				resultNode = replaceColorOutput( resultNode, shaderComplexityAndQuadsOutput );
+
+			} else {
+
+				resultNode = replaceColorOutput( resultNode, quadOverdrawOutput );
+
+			}
 
-			builder.shaderComplexityBase = getShaderComplexityBase( this );
-			resultNode = shaderComplexityOutput( 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 = replaceColorOutput( resultNode, () => bufferVisualizationOutput( renderer.debug.buffer ) );
 
 		}
 		// !WITH_GENESYS
@@ -22484,6 +23621,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.
 	 *
@@ -22808,9 +23960,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;
 
@@ -23007,6 +24168,16 @@ class NodeMaterial extends Material {
 
 		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 );
@@ -24881,6 +26052,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.
 	 *
@@ -25064,6 +26248,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.
 	 *
@@ -25165,6 +26362,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.
 	 *
@@ -28653,6 +29863,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.
 	 *
@@ -29082,6 +30305,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.
 	 *
@@ -29366,6 +30614,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.
 	 *
@@ -29487,6 +30750,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.
 	 *
@@ -29558,6 +30834,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.
 	 *
@@ -30233,6 +31522,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.
 	 *
@@ -30519,6 +31821,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();
@@ -31767,7 +33082,7 @@ class RenderObject {
 
 		// 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 ), this.renderer.debug.shaderComplexityBudget );
+		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;
@@ -36202,89 +37517,6 @@ class Textures extends DataMap {
 
 }
 
-/**
- * A four-component version of {@link Color} which is internally
- * used by the renderer to represents clear color with alpha as
- * one object.
- *
- * @private
- * @augments Color
- */
-class Color4 extends Color {
-
-	/**
-	 * Constructs a new four-component color.
-	 * You can also pass a single THREE.Color, hex or
-	 * string argument to this constructor.
-	 *
-	 * @param {number|string} [r=1] - The red value.
-	 * @param {number} [g=1] - The green value.
-	 * @param {number} [b=1] - The blue value.
-	 * @param {number} [a=1] - The alpha value.
-	 */
-	constructor( r, g, b, a = 1 ) {
-
-		super( r, g, b );
-
-		this.a = a;
-
-	}
-
-	/**
-	 * Overwrites the default to honor alpha.
-	 * You can also pass a single THREE.Color, hex or
-	 * string argument to this method.
-	 *
-	 * @param {number|string|Color} r - The red value.
-	 * @param {number} [g] - The green value.
-	 * @param {number} [b] - The blue value.
-	 * @param {number} [a=1] - The alpha value.
-	 * @return {Color4} A reference to this object.
-	 */
-	set( r, g, b, a = 1 ) {
-
-		this.a = a;
-
-		return super.set( r, g, b );
-
-	}
-
-	/**
-	 * Overwrites the default to honor alpha.
-	 *
-	 * @param {Color4} color - The color to copy.
-	 * @return {Color4} A reference to this object.
-	 */
-	copy( color ) {
-
-		if ( color.a !== undefined ) this.a = color.a;
-
-		return super.copy( color );
-
-	}
-
-	/**
-	 * Overwrites the default to honor alpha.
-	 *
-	 * @return {Color4} The cloned color.
-	 */
-	clone() {
-
-		return new this.constructor( this.r, this.g, this.b, this.a );
-
-	}
-
-	*[ Symbol.iterator ]() {
-
-		yield this.r;
-		yield this.g;
-		yield this.b;
-		yield this.a;
-
-	}
-
-}
-
 /**
  * A specialized context node designed to override specific target nodes within a
  * node sub-graph or flow. This allows replacing specific inputs (e.g., normal
@@ -37233,483 +38465,6 @@ const struct = ( membersLayout, name = null ) => {
 
 };
 
-/**
- * This node can be used to define multiple outputs in a shader programs.
- *
- * @augments Node
- */
-class OutputStructNode extends Node {
-
-	static get type() {
-
-		return 'OutputStructNode';
-
-	}
-
-	/**
-	 * Constructs a new output struct node. The constructor can be invoked with an
-	 * arbitrary number of nodes representing the members.
-	 *
-	 * @param {...Node} members - A parameter list of nodes.
-	 */
-	constructor( ...members ) {
-
-		super();
-
-		/**
-		 * An array of nodes which defines the output.
-		 *
-		 * @type {Array<Node>}
-		 */
-		this.members = members;
-
-		/**
-		 * This flag can be used for type testing.
-		 *
-		 * @type {boolean}
-		 * @readonly
-		 * @default true
-		 */
-		this.isOutputStructNode = true;
-
-	}
-
-	generateNodeType( /*builder*/ ) {
-
-		return 'OutputType';
-
-	}
-
-	generate( builder ) {
-
-		const nodeData = builder.getDataFromNode( this );
-
-		if ( nodeData.membersLayout === undefined ) {
-
-			const members = this.members;
-			const membersLayout = [];
-
-			for ( let i = 0; i < members.length; i ++ ) {
-
-				const name = 'm' + i;
-				const type = members[ i ].getNodeType( builder );
-
-				membersLayout.push( { name, type, index: i } );
-
-			}
-
-			nodeData.membersLayout = membersLayout;
-			nodeData.structType = builder.getOutputStructTypeFromNode( this, nodeData.membersLayout );
-
-		}
-
-		//
-
-		const propertyName = builder.getOutputStructName();
-		const members = this.members;
-
-		const structPrefix = propertyName !== '' ? propertyName + '.' : '';
-
-		for ( let i = 0; i < members.length; i ++ ) {
-
-			const snippet = members[ i ].build( builder, nodeData.membersLayout[ i ].type );
-
-			builder.addLineFlowCode( `${ structPrefix }m${ i } = ${ snippet }`, this );
-
-		}
-
-		return propertyName;
-
-	}
-
-}
-
-/**
- * TSL function for creating an output struct node.
- *
- * @tsl
- * @function
- * @param {...Node} members - A parameter list of nodes.
- * @returns {OutputStructNode}
- */
-const outputStruct = /*@__PURE__*/ nodeProxy( OutputStructNode );
-
-/**
- * Represents blending configuration.
- *
- * This class encapsulates all blending-related properties that control how
- * a material's colors are combined with the colors already in the frame buffer.
- */
-class BlendMode {
-
-	/**
-	 * Constructs a new blending configuration.
-	 *
-	 * @param {(NoBlending|NormalBlending|AdditiveBlending|SubtractiveBlending|MultiplyBlending|CustomBlending|MaterialBlending)} [blending=NormalBlending] - The blending mode.
-	 */
-	constructor( blending = NormalBlending ) {
-
-		/**
-		 * Defines the blending type.
-		 *
-		 * It must be set to `CustomBlending` if custom blending properties like
-		 * {@link BlendMode#blendSrc}, {@link BlendMode#blendDst} or {@link BlendMode#blendEquation}
-		 * should have any effect.
-		 *
-		 * @type {(NoBlending|NormalBlending|AdditiveBlending|SubtractiveBlending|MultiplyBlending|CustomBlending|MaterialBlending)}
-		 * @default NormalBlending
-		 */
-		this.blending = blending;
-
-		/**
-		 * Defines the blending source factor.
-		 *
-		 * This determines how the source (incoming) fragment color is factored before being added
-		 * to the destination (existing) fragment color in the frame buffer.
-		 *
-		 * @type {(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
-		 * @default SrcAlphaFactor
-		 */
-		this.blendSrc = SrcAlphaFactor;
-
-		/**
-		 * Defines the blending destination factor.
-		 *
-		 * This determines how the destination (existing) fragment color in the frame buffer
-		 * is factored before being combined with the source (incoming) fragment color.
-		 *
-		 * @type {(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
-		 * @default OneMinusSrcAlphaFactor
-		 */
-		this.blendDst = OneMinusSrcAlphaFactor;
-
-		/**
-		 * Defines the blending equation.
-		 *
-		 * This determines how the source and destination colors are combined.
-		 *
-		 * @type {(AddEquation|SubtractEquation|ReverseSubtractEquation|MinEquation|MaxEquation)}
-		 * @default AddEquation
-		 */
-		this.blendEquation = AddEquation;
-
-		/**
-		 * Defines the blending source alpha factor.
-		 *
-		 * When set, this allows separate control of the alpha channel's source blending factor.
-		 * If `null`, {@link BlendMode#blendSrc} is used for the alpha channel as well.
-		 *
-		 * @type {?(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
-		 * @default null
-		 */
-		this.blendSrcAlpha = null;
-
-		/**
-		 * Defines the blending destination alpha factor.
-		 *
-		 * When set, this allows separate control of the alpha channel's destination blending factor.
-		 * If `null`, {@link BlendMode#blendDst} is used for the alpha channel as well.
-		 *
-		 * @type {?(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
-		 * @default null
-		 */
-		this.blendDstAlpha = null;
-
-		/**
-		 * Defines the blending equation of the alpha channel.
-		 *
-		 * When set, this allows separate control of the alpha channel's blending equation.
-		 * If `null`, {@link BlendMode#blendEquation} is used for the alpha channel as well.
-		 *
-		 * @type {?(AddEquation|SubtractEquation|ReverseSubtractEquation|MinEquation|MaxEquation)}
-		 * @default null
-		 */
-		this.blendEquationAlpha = null;
-
-		/**
-		 * Defines whether to premultiply the alpha (transparency) value.
-		 *
-		 * If `true`, the RGB color of the texture or material is multiplied by its alpha value.
-		 * This is useful for transparent textures/materials where the color data
-		 * should already include the transparency information.
-		 *
-		 * @type {boolean}
-		 * @default false
-		 */
-		this.premultiplyAlpha = false;
-
-	}
-
-	/**
-	 * Copies the blending properties from the given source to this instance.
-	 *
-	 * @param {BlendMode} source - The blending configuration to copy from.
-	 * @return {BlendMode} A reference to this instance.
-	 */
-	copy( source ) {
-
-		this.blending = source.blending;
-		this.blendSrc = source.blendSrc;
-		this.blendDst = source.blendDst;
-		this.blendEquation = source.blendEquation;
-		this.blendSrcAlpha = source.blendSrcAlpha;
-		this.blendDstAlpha = source.blendDstAlpha;
-		this.blendEquationAlpha = source.blendEquationAlpha;
-		this.premultiplyAlpha = source.premultiplyAlpha;
-
-		return this;
-
-	}
-
-	/**
-	 * Returns a clone of this blending configuration.
-	 *
-	 * @return {BlendMode} A new Blending instance with the same properties.
-	 */
-	clone() {
-
-		return new this.constructor().copy( this );
-
-	}
-
-}
-
-// Predefined blend modes for MRT nodes.
-const _noBlending = /**@__PURE__*/ new BlendMode( NoBlending );
-const _materialBlending = /**@__PURE__*/ new BlendMode( MaterialBlending );
-
-/**
- * Returns the MRT texture index for the given name.
- *
- * @param {Array<Texture>} textures - The textures of a MRT-configured render target.
- * @param {string} name - The name of the MRT texture which index is requested.
- * @return {number} The texture index.
- */
-function getTextureIndex( textures, name ) {
-
-	for ( let i = 0; i < textures.length; i ++ ) {
-
-		if ( textures[ i ].name === name ) {
-
-			return i;
-
-		}
-
-	}
-
-	return -1;
-
-}
-
-/**
- * This node can be used setup a MRT context for rendering. A typical MRT setup for
- * post-processing is shown below:
- * ```js
- * const mrtNode = mrt( {
- *   output: output,
- *   normal: normalView
- * } ) ;
- * ```
- * The MRT output is defined as a dictionary.
- *
- * @augments OutputStructNode
- */
-class MRTNode extends OutputStructNode {
-
-	static get type() {
-
-		return 'MRTNode';
-
-	}
-
-	/**
-	 * Constructs a new output struct node.
-	 *
-	 * @param {Object<string, Node>} outputNodes - The MRT outputs.
-	 */
-	constructor( outputNodes ) {
-
-		super();
-
-		/**
-		 * A dictionary representing the MRT outputs. The key
-		 * is the name of the output, the value the node which produces
-		 * the output result.
-		 *
-		 * @type {Object<string, Node>}
-		 */
-		this.outputNodes = outputNodes;
-
-		/**
-		 * A dictionary storing the blend modes for each output.
-		 *
-		 * @type {Object<string, BlendMode>}
-		 */
-		this.blendModes = {
-			output: _materialBlending
-		};
-
-		/**
-		 * A dictionary storing the clear colors for each output.
-		 *
-		 * @type {Object<string, Color4>}
-		 */
-		this.clearColors = {};
-
-		/**
-		 * This flag can be used for type testing.
-		 *
-		 * @type {boolean}
-		 * @readonly
-		 * @default true
-		 */
-		this.isMRTNode = true;
-
-	}
-
-	/**
-	 * Sets the blend mode for the given output name.
-	 *
-	 * @param {string} name - The name of the output.
-	 * @param {BlendMode} blend - The blending mode.
-	 * @return {MRTNode} The current MRT node.
-	 */
-	setBlendMode( name, blend ) {
-
-		this.blendModes[ name ] = blend;
-
-		return this;
-
-	}
-
-	/**
-	 * Returns the blend mode for the given output name.
-	 *
-	 * @param {string} name - The name of the output.
-	 * @return {BlendMode} The blend mode.
-	 */
-	getBlendMode( name ) {
-
-		return this.blendModes[ name ] || _noBlending;
-
-	}
-
-	/**
-	 * Sets the clear color for the given output name.
-	 *
-	 * @param {string} name - The name of the output.
-	 * @param {number|string|Color} color - The clear color.
-	 * @param {number} [alpha=1] - The clear alpha.
-	 * @return {MRTNode} The current MRT node.
-	 */
-	setClearColor( name, color, alpha = 1 ) {
-
-		const clearColor = this.clearColors[ name ] || ( this.clearColors[ name ] = new Color4() );
-
-		clearColor.set( color );
-		clearColor.a = alpha;
-
-		return this;
-
-	}
-
-	/**
-	 * Returns the clear color for the given output name.
-	 *
-	 * @param {string} name - The name of the output.
-	 * @return {?Color4} The clear color. Returns `null` if no clear color is defined
-	 * which means the renderer's default clear policy is applied.
-	 */
-	getClearColor( name ) {
-
-		return this.clearColors[ name ] || null;
-
-	}
-
-	/**
-	 * Returns `true` if the MRT node has an output with the given name.
-	 *
-	 * @param {string} name - The name of the output.
-	 * @return {NodeBuilder} Whether the MRT node has an output for the given name or not.
-	 */
-	has( name ) {
-
-		return this.outputNodes[ name ] !== undefined;
-
-	}
-
-	/**
-	 * Returns the output node for the given name.
-	 *
-	 * @param {string} name - The name of the output.
-	 * @return {Node} The output node.
-	 */
-	get( name ) {
-
-		return this.outputNodes[ name ];
-
-	}
-
-	/**
-	 * Merges the outputs of the given MRT node with the outputs of this node.
-	 *
-	 * @param {MRTNode} mrtNode - The MRT to merge.
-	 * @return {MRTNode} A new MRT node with merged outputs..
-	 */
-	merge( mrtNode ) {
-
-		const outputs = { ...this.outputNodes, ...mrtNode.outputNodes };
-		const blendModes = { ...this.blendModes, ...mrtNode.blendModes };
-		const clearColors = { ...this.clearColors, ...mrtNode.clearColors };
-
-		const mrtTarget = mrt( outputs );
-		mrtTarget.blendModes = blendModes;
-		mrtTarget.clearColors = clearColors;
-
-		return mrtTarget;
-
-	}
-
-	setup( builder ) {
-
-		const outputNodes = this.outputNodes;
-		const mrt = builder.renderer.getRenderTarget();
-
-		const members = [];
-
-		const textures = mrt.textures;
-
-		for ( const name in outputNodes ) {
-
-			const index = getTextureIndex( textures, name );
-
-			// Ignore if the output exists in the MRT but has never been used.
-			if ( index === -1 ) continue;
-
-			const type = builder.getOutputType( index );
-
-			members[ index ] = outputNodes[ name ].convert( type );
-
-		}
-
-		this.members = members;
-
-		return super.setup( builder );
-
-	}
-
-}
-
-/**
- * TSL function for creating a MRT node.
- *
- * @tsl
- * @function
- * @param {Object<string, Node>} outputNodes - The MRT outputs.
- * @returns {MRTNode}
- */
-const mrt = /*@__PURE__*/ nodeProxy( MRTNode );
-
 /**
  * This node represents an operation that reinterprets the bit representation of a value
  * in one type as a value in another type.
@@ -52221,6 +52976,8 @@ var TSL = /*#__PURE__*/Object.freeze({
 	xor: xor
 });
 
+// !WITH_GENESYS
+
 const _clearColor = /*@__PURE__*/ new Color4();
 
 /**
@@ -52406,7 +53163,7 @@ class Background extends DataMap {
 
 			// WITH_GENESYS
 			// The background is depth-tested off, so additive shader complexity would add it to every pixel.
-			if ( renderer.debug.view !== 'shaderComplexity' ) {
+			if ( debugViewAccumulates( renderer.debug.view ) !== true ) {
 
 				renderList.unshift( backgroundMesh, backgroundMesh.geometry, backgroundMesh.material, 0, 0, null, null );
 
@@ -52437,7 +53194,7 @@ class Background extends DataMap {
 		//
 
 		// WITH_GENESYS
-		if ( renderer.debug.view === 'shaderComplexity' ) {
+		if ( debugViewAccumulates( renderer.debug.view ) ) {
 
 			_clearColor.set( 0, 0, 0, 1 );
 
@@ -59727,9 +60484,19 @@ class NodeManager extends DataMap {
 		}
 
 		// WITH_GENESYS
-		if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY ) {
+		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( sampled.r ), 1 ).renderOutput( NoToneMapping, renderer.currentColorSpace );
+			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
@@ -63692,8 +64459,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` and `lightingComplexity` replace the shaded color with a heatmap.
+		 * @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.
 		 */
 
 		/**
@@ -63710,7 +64479,9 @@ class Renderer {
 			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 ) => {
 
@@ -65647,10 +66418,9 @@ class Renderer {
 		const useColorSpace = this.currentColorSpace !== ColorManagement.workingColorSpace;
 
 		// WITH_GENESYS
-		// Shader complexity writes a scalar into an intermediate target, then the output pass colorizes it.
-		const shaderComplexity = this.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY;
-
-		return useToneMapping || useColorSpace || shaderComplexity;
+		// Accumulating views write a scalar into an intermediate target, then the output pass colorizes it.
+		// Only screen output needs one. An off-screen target, such as a scene pass, already is the target.
+		return useToneMapping || useColorSpace || ( debugViewAccumulates( this.debug.view ) && this.isOutputTarget );
 		// !WITH_GENESYS
 		// return useToneMapping || useColorSpace;
 
@@ -65704,9 +66474,7 @@ class Renderer {
 	get currentToneMapping() {
 
 		// WITH_GENESYS
-		const view = this.debug.view;
-
-		if ( view === DEBUG_VIEW_SHADER_COMPLEXITY || view === DEBUG_VIEW_LIGHTING_COMPLEXITY ) {
+		if ( debugViewSkipsToneMapping( this.debug.view ) ) {
 
 			return NoToneMapping;
 
@@ -71510,6 +72278,8 @@ class WebGLAttributeUtils {
 
 }
 
+// !WITH_GENESYS
+
 let equationToGL, factorToGL;
 
 /**
@@ -72418,8 +73188,9 @@ class WebGLState {
 	 * @param {Material} material - The material to configure the state for.
 	 * @param {number} frontFaceCW - Whether the front faces are counter-clockwise or not.
 	 * @param {number} hardwareClippingPlanes - The number of hardware clipping planes.
+	 * @param {?Object3D} [object=null] - The object being drawn. Used by the accumulating debug views.
 	 */
-	setMaterial( material, frontFaceCW, hardwareClippingPlanes ) {
+	setMaterial( material, frontFaceCW, hardwareClippingPlanes, object = null ) {
 
 		const { gl } = this;
 
@@ -72434,7 +73205,7 @@ class WebGLState {
 
 		// WITH_GENESYS
 		// WebGL has no cached render pipeline. One+One is applied on each draw instead.
-		if ( this.backend.renderer.debug.view === 'shaderComplexity' && material.isShadowPassMaterial !== true && this.backend.renderer.isOutputTarget !== true ) {
+		if ( debugDrawAccumulates( this.backend.renderer, material, object ) ) {
 
 			this.setBlending( AdditiveBlending, AddEquation, OneFactor, OneFactor, AddEquation, OneFactor, OneFactor, material.blendColor, material.blendAlpha, true );
 
@@ -76684,7 +77455,10 @@ class WebGLBackend extends Backend {
 
 		const frontFaceCW = ( object.isMesh && object.matrixWorld.determinantAffine() < 0 );
 
-		state.setMaterial( material, frontFaceCW, hardwareClippingPlanes );
+		// WITH_GENESYS
+		state.setMaterial( material, frontFaceCW, hardwareClippingPlanes, object );
+		// !WITH_GENESYS
+		// state.setMaterial( material, frontFaceCW, hardwareClippingPlanes );
 
 		if ( context.mrt !== null && context.textures !== null ) {
 
@@ -87139,7 +87913,7 @@ class WebGPUPipelineUtils {
 
 		// WITH_GENESYS
 		// Accumulate shader cost with One+One. Opaque materials normally disable blending.
-		if ( backend.renderer.debug.view === 'shaderComplexity' && material.isShadowPassMaterial !== true && backend.renderer.isOutputTarget !== true ) {
+		if ( debugDrawAccumulates( backend.renderer, material, object ) ) {
 
 			materialBlending = {
 				color: {
@@ -92217,6 +92991,8 @@ class BundleGroup extends Group {
 
 }
 
+// !WITH_GENESYS
+
 /**
  * This module is responsible to manage the rendering pipeline setups in apps.
  * You usually create a single instance of this class and use it to define
@@ -92351,7 +93127,12 @@ class RenderPipeline {
 		const outputColorSpace = renderer.outputColorSpace;
 
 		renderer.toneMapping = NoToneMapping;
-		renderer.outputColorSpace = ColorManagement.workingColorSpace;
+
+		// WITH_GENESYS
+		// Accumulating views colorize in the renderer's output pass, which must still encode the color space.
+		if ( debugViewAccumulates( renderer.debug.view ) !== true ) renderer.outputColorSpace = ColorManagement.workingColorSpace;
+		// !WITH_GENESYS
+		// renderer.outputColorSpace = ColorManagement.workingColorSpace;
 
 		//
 
@@ -92427,19 +93208,40 @@ class RenderPipeline {
 	 */
 	_update() {
 
-		if ( this._toneMapping !== this.renderer.toneMapping ) {
+		// WITH_GENESYS
+		// Debug views drawn without tone mapping must match the direct path. An accumulating
+		// view copies the raw ratio here, and the renderer's output pass colorizes it.
+		const view = this.renderer.debug.view;
+		const toneMapping = debugViewSkipsToneMapping( view ) ? NoToneMapping : this.renderer.toneMapping;
+		const outputColorSpace = debugViewAccumulates( view ) ? ColorManagement.workingColorSpace : this.renderer.outputColorSpace;
 
-			this._toneMapping = this.renderer.toneMapping;
+		if ( this._toneMapping !== toneMapping ) {
+
+			this._toneMapping = toneMapping;
 			this.needsUpdate = true;
 
 		}
 
-		if ( this._outputColorSpace !== this.renderer.outputColorSpace ) {
+		if ( this._outputColorSpace !== outputColorSpace ) {
 
-			this._outputColorSpace = this.renderer.outputColorSpace;
+			this._outputColorSpace = outputColorSpace;
 			this.needsUpdate = true;
 
 		}
+		// !WITH_GENESYS
+		// if ( this._toneMapping !== this.renderer.toneMapping ) {
+		//
+		// 	this._toneMapping = this.renderer.toneMapping;
+		// 	this.needsUpdate = true;
+		//
+		// }
+		//
+		// if ( this._outputColorSpace !== this.renderer.outputColorSpace ) {
+		//
+		// 	this._outputColorSpace = this.renderer.outputColorSpace;
+		// 	this.needsUpdate = true;
+		//
+		// }
 
 		if ( this.needsUpdate === true ) {