@gnsx/three 0.186.6 → 0.186.8

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, 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';
+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, EqualDepth, 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, 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 = [
@@ -21768,7 +21768,8 @@ function bufferVisualizationOutput( buffer ) {
 const DEBUG_VIEW_NONE = 'none';
 
 /**
- * Material-cost heatmap. Overlapping draws accumulate, then a fullscreen pass applies the ramp.
+ * Material-cost heatmap. The nearest opaque surface wins, translucent draws add on top,
+ * then a fullscreen pass applies the ramp.
  *
  * @type {string}
  */
@@ -21787,16 +21788,16 @@ const DEBUG_VIEW_LIGHTING_COMPLEXITY = 'lightingComplexity';
  *
  * @type {string}
  */
-const DEBUG_VIEW_QUAD_OVERDRAW = 'quadOverdraw';
+const DEBUG_VIEW_OVERDRAW = 'overdraw';
 
 /**
  * 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.
+ * One opaque surface matches {@link DEBUG_VIEW_SHADER_COMPLEXITY}. Each extra translucent 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';
+const DEBUG_VIEW_SHADER_COMPLEXITY_AND_OVERDRAW = 'shaderComplexityAndOverdraw';
 
 /**
  * Proxy budget that fills the shader-complexity ramp.
@@ -21816,7 +21817,7 @@ const DEFAULT_SHADER_COMPLEXITY_BUDGET = 800;
 const DEFAULT_QUAD_OVERDRAW_BUDGET = 10;
 
 /**
- * Storage scale for the overdraw count in {@link DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS}.
+ * Storage scale for the overdraw count in {@link DEBUG_VIEW_SHADER_COMPLEXITY_AND_OVERDRAW}.
  * 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.
  *
@@ -21974,7 +21975,7 @@ const colorizeQuadOverdraw = ( cost ) => {
  */
 function debugViewAccumulates( view ) {
 
-	return view === DEBUG_VIEW_SHADER_COMPLEXITY || view === DEBUG_VIEW_QUAD_OVERDRAW || view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS;
+	return view === DEBUG_VIEW_SHADER_COMPLEXITY || view === DEBUG_VIEW_OVERDRAW || view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_OVERDRAW;
 
 }
 
@@ -21997,6 +21998,22 @@ function debugDrawAccumulates( renderer, material, object ) {
 
 }
 
+/**
+ * Whether an accumulating draw replaces the stored cost instead of adding to it.
+ * Three.js has no depth pre-pass, so adding every opaque fragment counts hidden surfaces
+ * and changes as the camera reorders draws. Replacing, with the material's own depth test
+ * and depth write, leaves the nearest opaque surface. Translucent draws and quad overdraw still add.
+ *
+ * @param {string} view - `renderer.debug.view`.
+ * @param {Material} material - The material being drawn.
+ * @return {boolean} `true` when the draw replaces the stored cost.
+ */
+function debugDrawReplacesCost( view, material ) {
+
+	return ( view === DEBUG_VIEW_SHADER_COMPLEXITY || view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_OVERDRAW ) && material.transparent !== true;
+
+}
+
 /**
  * Views that output data or a heatmap, so tone mapping would distort them.
  *
@@ -22128,7 +22145,7 @@ function shaderComplexityOutput( resultNode ) {
  * @param {Node} resultNode - The material's shaded output.
  * @return {Node<vec4>} Cost ratio in red, one scaled fragment in green.
  */
-function shaderComplexityAndQuadsOutput( resultNode ) {
+function shaderComplexityAndOverdrawOutput( resultNode ) {
 
 	const shaded = vec4( resultNode ).toVar();
 	const ratio = new ShaderComplexityRatioNode();
@@ -22966,6 +22983,303 @@ function applyDrawCallDebug( builder, material ) {
 
 }
 
+// WITH_GENESYS
+// Front/back face. Both windings are drawn. The side facing the camera uses one color, the other side another.
+// !WITH_GENESYS
+
+
+/**
+ * Front/back face. Culling is off. A fragment whose winding faces the camera is one color.
+ * The opposite winding is another. Depth still hides a face behind the shell.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_FRONT_BACK_FACE = 'frontBackFace';
+
+/**
+ * Rasterizer front face, ignoring the material side shortcut in {@link frontFacing}.
+ * `BackSide` materials otherwise report every fragment as back facing.
+ */
+let GeometricFrontFacingNode$1 = class GeometricFrontFacingNode extends Node {
+
+	static get type() {
+
+		return 'GeometricFrontFacingNode';
+
+	}
+
+	constructor() {
+
+		super( 'bool' );
+
+	}
+
+	generate( builder ) {
+
+		if ( builder.shaderStage !== 'fragment' ) return 'true';
+
+		return builder.getFrontFacing();
+
+	}
+
+};
+
+const geometricFrontFacing$1 = /*@__PURE__*/ nodeImmutable( GeometricFrontFacingNode$1 );
+
+const FRONT_COLOR$1 = /*@__PURE__*/ vec3( 0.72, 0.70, 0.66 );
+const BACK_COLOR$1 = /*@__PURE__*/ vec3( 0.25, 0.45, 0.85 );
+
+/**
+ * Replaces albedo with the front or back color after the material has written its channels.
+ * Lit materials become a matte dielectric. Unlit materials become flat.
+ *
+ * @param {NodeBuilder} builder - The current node builder.
+ * @param {NodeMaterial} material - The node material being set up.
+ */
+function applyFrontBackFaceDebug( builder, material ) {
+
+	const colorNode = select( geometricFrontFacing$1, FRONT_COLOR$1, BACK_COLOR$1 );
+
+	diffuseColor.rgb.assign( colorNode );
+
+	if ( material.lights !== true ) return;
+
+	metalness.assign( float( 0 ) );
+	diffuseContribution.assign( colorNode );
+	roughness.assign( float( 1 ) );
+	specularColor.assign( vec3( 0 ) );
+	specularColorBlended.assign( vec3( 0 ) );
+	specularF90.assign( float( 0 ) );
+
+	builder.context.ambientOcclusion = null;
+
+	if ( material.useClearcoat === true ) clearcoat.assign( float( 0 ) );
+
+	if ( material.useSheen === true ) sheen.assign( vec3( 0 ) );
+
+	if ( material.useIridescence === true ) iridescence.assign( float( 0 ) );
+
+	if ( material.useAnisotropy === true ) anisotropy.assign( float( 0 ) );
+
+	if ( material.useTransmission === true ) transmission.assign( float( 0 ) );
+
+	if ( material.useRetroreflection === true ) retroreflectivity.assign( float( 0 ) );
+
+}
+
+// WITH_GENESYS
+// Shadow casters. Green when the object casts a shadow, gray when it does not.
+// !WITH_GENESYS
+
+
+/**
+ * Shadow casters. A mesh that casts shadows is green. One that does not is gray.
+ * The color is lit, so form stays readable.
+ *
+ * Matches Unreal's simplified shadow-caster view (`GetCachedShadowCasterColorSimplified`):
+ * green `(0, 1, 0)` casts, gray `(0.5, 0.5, 0.5)` does not. Contact-shadow yellow is omitted;
+ * Three.js has no per-object contact-shadow flag.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_SHADOW_CASTER = 'shadowCaster';
+
+const CASTS_COLOR = new Color( 0, 1, 0 );
+const NONE_COLOR = new Color( 0.5, 0.5, 0.5 );
+
+/**
+ * Replaces albedo with the caster color after the material has written its channels.
+ * Lit materials become a matte dielectric. 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 applyShadowCasterDebug( builder, material ) {
+
+	const colorNode = uniform( new Color() ).onObjectUpdate( ( { object }, self ) => {
+
+		if ( object === null ) return;
+
+		return self.value.copy( object.castShadow === true ? CASTS_COLOR : NONE_COLOR );
+
+	} );
+
+	diffuseColor.rgb.assign( colorNode );
+
+	if ( material.lights !== true ) return;
+
+	metalness.assign( float( 0 ) );
+	diffuseContribution.assign( colorNode );
+	roughness.assign( float( 1 ) );
+	specularColor.assign( vec3( 0 ) );
+	specularColorBlended.assign( vec3( 0 ) );
+	specularF90.assign( float( 0 ) );
+
+	builder.context.ambientOcclusion = null;
+
+	if ( material.useClearcoat === true ) clearcoat.assign( float( 0 ) );
+
+	if ( material.useSheen === true ) sheen.assign( vec3( 0 ) );
+
+	if ( material.useIridescence === true ) iridescence.assign( float( 0 ) );
+
+	if ( material.useAnisotropy === true ) anisotropy.assign( float( 0 ) );
+
+	if ( material.useTransmission === true ) transmission.assign( float( 0 ) );
+
+	if ( material.useRetroreflection === true ) retroreflectivity.assign( float( 0 ) );
+
+}
+
+// WITH_GENESYS
+// Double sided. Gray is a single-sided surface or the front of a double-sided one.
+// Blue is a double-sided back face you can see. Red is a double-sided back face hidden behind the front.
+// !WITH_GENESYS
+
+
+/**
+ * Double sided. A single-sided material is gray. A double-sided front face is gray.
+ * A double-sided back face that is the nearest surface is blue. A later pass paints
+ * a hidden double-sided back face red over the front.
+ *
+ * @type {string}
+ */
+const DEBUG_VIEW_DOUBLE_SIDE = 'doubleSide';
+
+/**
+ * Rasterizer front face, ignoring the material side shortcut in {@link frontFacing}.
+ */
+class GeometricFrontFacingNode extends Node {
+
+	static get type() {
+
+		return 'GeometricFrontFacingNode';
+
+	}
+
+	constructor() {
+
+		super( 'bool' );
+
+	}
+
+	generate( builder ) {
+
+		if ( builder.shaderStage !== 'fragment' ) return 'true';
+
+		return builder.getFrontFacing();
+
+	}
+
+}
+
+const geometricFrontFacing = /*@__PURE__*/ nodeImmutable( GeometricFrontFacingNode );
+
+const hideCache = new WeakMap();
+
+/**
+ * A flat card or wall has normals that all point the same way, so its back face is the same
+ * surface. A box or a closed shell has normals that face each other, so one side can hide the other.
+ *
+ * @param {BufferGeometry} geometry - The mesh geometry.
+ * @return {boolean} `true` when some normals oppose the first one.
+ */
+function meshCanHideOwnBack( geometry ) {
+
+	const normal = geometry.getAttribute( 'normal' );
+	const cached = hideCache.get( geometry );
+
+	if ( cached !== undefined && cached.version === geometry.version ) return cached.hides;
+
+	let hides = false;
+
+	if ( normal !== undefined && normal.count > 1 ) {
+
+		const ax = normal.getX( 0 );
+		const ay = normal.getY( 0 );
+		const az = normal.getZ( 0 );
+		const step = Math.max( 1, Math.floor( normal.count / 64 ) );
+
+		for ( let i = step; i < normal.count; i += step ) {
+
+			if ( ax * normal.getX( i ) + ay * normal.getY( i ) + az * normal.getZ( i ) < 0.25 ) {
+
+				hides = true;
+				break;
+
+			}
+
+		}
+
+	}
+
+	hideCache.set( geometry, { version: geometry.version, hides } );
+
+	return hides;
+
+}
+
+const FRONT_COLOR = /*@__PURE__*/ vec3( 0.5, 0.5, 0.5 );
+const BACK_COLOR = /*@__PURE__*/ vec3( 0.25, 0.45, 0.85 );
+const HIDDEN_COLOR = /*@__PURE__*/ vec3( 0.85, 0.12, 0.1 );
+
+/**
+ * Makes a lit material a matte dielectric in the debug color. An unlit material stays flat.
+ *
+ * @param {NodeBuilder} builder - The current node builder.
+ * @param {NodeMaterial} material - The node material being set up.
+ * @param {Node} colorNode - The albedo written for this fragment.
+ */
+function assignLitColor( builder, material, colorNode ) {
+
+	diffuseColor.rgb.assign( colorNode );
+
+	if ( material.lights !== true ) return;
+
+	metalness.assign( float( 0 ) );
+	diffuseContribution.assign( colorNode );
+	roughness.assign( float( 1 ) );
+	specularColor.assign( vec3( 0 ) );
+	specularColorBlended.assign( vec3( 0 ) );
+	specularF90.assign( float( 0 ) );
+
+	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 ) );
+
+}
+
+/**
+ * Replaces albedo after the material has written its channels.
+ * The hidden pass forces red. The first pass uses gray, or blue on a visible double-sided back face.
+ *
+ * @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 applyDoubleSideDebug( builder, material ) {
+
+	const hidden = builder.renderer.debug.doubleSideHidden === true;
+	const visibleBack = builder.renderer.debug.doubleSideBack === true;
+	const doubleSided = material.side === DoubleSide;
+	const colorNode = hidden ? HIDDEN_COLOR : ( visibleBack ? BACK_COLOR : ( doubleSided ? select( geometricFrontFacing, FRONT_COLOR, BACK_COLOR ) : FRONT_COLOR ) );
+
+	assignLitColor( builder, material, colorNode );
+
+}
+
 /**
  * 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
@@ -23508,6 +23822,18 @@ class NodeMaterial extends Material {
 
 				applyDrawCallDebug( builder, this );
 
+			} else if ( renderer.debug.view === DEBUG_VIEW_FRONT_BACK_FACE && this.isShadowPassMaterial !== true ) {
+
+				applyFrontBackFaceDebug( builder, this );
+
+			} else if ( renderer.debug.view === DEBUG_VIEW_SHADOW_CASTER && this.isShadowPassMaterial !== true ) {
+
+				applyShadowCasterDebug( builder, this );
+
+			} else if ( renderer.debug.view === DEBUG_VIEW_DOUBLE_SIDE && this.isShadowPassMaterial !== true ) {
+
+				applyDoubleSideDebug( builder, this );
+
 			}
 			// !WITH_GENESYS
 
@@ -23591,10 +23917,10 @@ class NodeMaterial extends Material {
 				builder.shaderComplexityBase = this.getShaderComplexity();
 				resultNode = replaceColorOutput( resultNode, shaderComplexityOutput );
 
-			} else if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS ) {
+			} else if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_OVERDRAW ) {
 
 				builder.shaderComplexityBase = this.getShaderComplexity();
-				resultNode = replaceColorOutput( resultNode, shaderComplexityAndQuadsOutput );
+				resultNode = replaceColorOutput( resultNode, shaderComplexityAndOverdrawOutput );
 
 			} else {
 
@@ -23966,7 +24292,7 @@ class NodeMaterial extends Material {
 	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 ) {
+		if ( ( builder.renderer.debug.view === DEBUG_VIEW_LIGHTING_ONLY || builder.renderer.debug.view === DEBUG_VIEW_DRAW_CALL || builder.renderer.debug.view === DEBUG_VIEW_FRONT_BACK_FACE || builder.renderer.debug.view === DEBUG_VIEW_SHADOW_CASTER || builder.renderer.debug.view === DEBUG_VIEW_DOUBLE_SIDE ) && this.isShadowPassMaterial !== true && this.fragmentNode === null ) {
 
 			return lightingOnlyNormal();
 
@@ -24171,7 +24497,7 @@ class NodeMaterial extends Material {
 			// 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 ) {
+			if ( ( builder.renderer.debug.view === DEBUG_VIEW_LIGHTING_ONLY || builder.renderer.debug.view === DEBUG_VIEW_DRAW_CALL || builder.renderer.debug.view === DEBUG_VIEW_FRONT_BACK_FACE || builder.renderer.debug.view === DEBUG_VIEW_SHADOW_CASTER || builder.renderer.debug.view === DEBUG_VIEW_DOUBLE_SIDE ) && this.isShadowPassMaterial !== true ) {
 
 				return outgoingLightNode;
 
@@ -33082,7 +33408,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 ), hashString( this.renderer.debug.buffer ), this.renderer.debug.shaderComplexityBudget, this.renderer.debug.quadOverdrawBudget );
+		cacheKey = hash$1( cacheKey, hashString( this.renderer.debug.view ), hashString( this.renderer.debug.buffer ), this.renderer.debug.shaderComplexityBudget, this.renderer.debug.quadOverdrawBudget, this.renderer.debug.doubleSideHidden === true ? 1 : 0, this.renderer.debug.doubleSideBack === true ? 1 : 0 );
 		// !WITH_GENESYS
 
 		return cacheKey;
@@ -53194,9 +53520,11 @@ class Background extends DataMap {
 		//
 
 		// WITH_GENESYS
+		// Accumulating views start from zero cost. Alpha keeps the shaded pass coverage, so an
+		// overlay pass such as a HUD stays transparent where it draws nothing when composited.
 		if ( debugViewAccumulates( renderer.debug.view ) ) {
 
-			_clearColor.set( 0, 0, 0, 1 );
+			_clearColor.set( 0, 0, 0, background !== null ? 1 : _clearColor.a );
 
 		}
 		// !WITH_GENESYS
@@ -60484,9 +60812,9 @@ class NodeManager extends DataMap {
 		}
 
 		// WITH_GENESYS
-		if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY || renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS ) {
+		if ( renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY || renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_OVERDRAW ) {
 
-			const complexity = renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_QUADS
+			const complexity = renderer.debug.view === DEBUG_VIEW_SHADER_COMPLEXITY_AND_OVERDRAW
 				? sampled.r.mul( sampled.g ).mul( SHADER_COMPLEXITY_QUAD_COUNT_SCALE )
 				: sampled.r;
 
@@ -60494,7 +60822,7 @@ class NodeManager extends DataMap {
 
 		}
 
-		if ( renderer.debug.view === DEBUG_VIEW_QUAD_OVERDRAW ) {
+		if ( renderer.debug.view === DEBUG_VIEW_OVERDRAW ) {
 
 			return vec4( colorizeQuadOverdraw( sampled.r ), 1 ).renderOutput( NoToneMapping, renderer.currentColorSpace );
 
@@ -64459,7 +64787,7 @@ 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} view - Debug view. `shaderComplexity`, `lightingComplexity`, `overdraw`, and `shaderComplexityAndOverdraw` replace the shaded color with a heatmap. `shaderComplexityAndOverdraw` 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. `frontBackFace` draws both windings and tints the side facing the camera. `shadowCaster` lights a mesh green when it casts shadows and gray when it does not. `doubleSide` lights a single-sided surface gray, a visible double-sided back face blue, and a hidden double-sided back face red.
 		 * @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.
@@ -64482,6 +64810,8 @@ class Renderer {
 			buffer: DEFAULT_BUFFER,
 			shaderComplexityBudget: DEFAULT_SHADER_COMPLEXITY_BUDGET,
 			quadOverdrawBudget: DEFAULT_QUAD_OVERDRAW_BUDGET,
+			doubleSideHidden: false,
+			doubleSideBack: false,
 			// !WITH_GENESYS
 			getShaderAsync: async ( scene, camera, object ) => {
 
@@ -65702,6 +66032,10 @@ class Renderer {
 		if ( this.opaque === true && opaqueObjects.length > 0 ) this._renderObjects( opaqueObjects, camera, sceneRef, lightsNode );
 		if ( this.transparent === true && transparentObjects.length > 0 ) this._renderTransparents( transparentObjects, transparentDoublePassObjects, camera, sceneRef, lightsNode );
 
+		// WITH_GENESYS
+		this._renderDoubleSideHidden( opaqueObjects, transparentObjects, camera, sceneRef, lightsNode );
+		// !WITH_GENESYS
+
 		// finish render pass
 
 		this.backend.finishRender( renderContext );
@@ -67272,6 +67606,82 @@ class Renderer {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Paints a double-sided mesh red where its own front face is the nearest surface and the
+	 * mesh has faces pointing the other way. A different mesh in front keeps its own color.
+	 * A flat card has no opposing faces, so it stays gray or blue. A shadow pass is left alone.
+	 *
+	 * @private
+	 * @param {Array<Object>} opaqueObjects - The opaque render list.
+	 * @param {Array<Object>} transparentObjects - The transparent render list.
+	 * @param {Camera} camera - The camera.
+	 * @param {Scene} scene - The scene.
+	 * @param {LightsNode} lightsNode - The current lights node.
+	 */
+	_renderDoubleSideHidden( opaqueObjects, transparentObjects, camera, scene, lightsNode ) {
+
+		if ( this.debug.view !== DEBUG_VIEW_DOUBLE_SIDE ) return;
+
+		if ( scene.overrideMaterial !== null && scene.overrideMaterial.isShadowPassMaterial === true ) return;
+
+		const list = [];
+		const saved = new Map();
+
+		const collect = ( objects ) => {
+
+			for ( let i = 0, l = objects.length; i < l; i ++ ) {
+
+				const entry = objects[ i ];
+				const material = entry.material;
+				const geometry = entry.object.geometry;
+
+				if ( entry.object.isMesh !== true || material.side !== DoubleSide || material.isShadowPassMaterial === true ) continue;
+
+				if ( geometry === undefined || meshCanHideOwnBack( geometry ) !== true ) continue;
+
+				list.push( entry );
+
+				if ( saved.has( material ) ) continue;
+
+				saved.set( material, {
+					side: material.side,
+					depthFunc: material.depthFunc,
+					depthWrite: material.depthWrite
+				} );
+
+			}
+
+		};
+
+		collect( opaqueObjects );
+		collect( transparentObjects );
+
+		if ( list.length === 0 ) return;
+
+		for ( const material of saved.keys() ) {
+
+			material.side = FrontSide;
+			material.depthFunc = EqualDepth;
+			material.depthWrite = false;
+
+		}
+
+		this.debug.doubleSideHidden = true;
+		this._renderObjects( list, camera, scene, lightsNode, 'doubleSideHidden' );
+		this.debug.doubleSideHidden = false;
+
+		for ( const [ material, state ] of saved ) {
+
+			material.side = state.side;
+			material.depthFunc = state.depthFunc;
+			material.depthWrite = state.depthWrite;
+
+		}
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Renders the transparent objects from the given render lists.
 	 *
@@ -72553,7 +72963,7 @@ class WebGLState {
 
 	}
 
-	setMRTBlending( textures, mrt, material ) {
+	setMRTBlending( textures, mrt, material, object = null ) {
 
 		const gl = this.gl;
 		const drawBuffersIndexedExt = this.backend.drawBuffersIndexedExt;
@@ -72566,6 +72976,24 @@ class WebGLState {
 
 		}
 
+		// WITH_GENESYS
+		// Every attachment matches the single-target path. Opaque material blending would replace a sum that should add.
+		if ( debugDrawAccumulates( this.backend.renderer, material, object ) ) {
+
+			const dst = debugDrawReplacesCost( this.backend.renderer.debug.view, material ) ? gl.ZERO : gl.ONE;
+
+			for ( let i = 0; i < textures.length; i ++ ) {
+
+				drawBuffersIndexedExt.blendEquationSeparateiOES( i, gl.FUNC_ADD, gl.FUNC_ADD );
+				drawBuffersIndexedExt.blendFuncSeparateiOES( i, gl.ONE, dst, gl.ONE, gl.ZERO );
+
+			}
+
+			return;
+
+		}
+		// !WITH_GENESYS
+
 		for ( let i = 0; i < textures.length; i ++ ) {
 
 			const texture = textures[ i ];
@@ -73194,9 +73622,16 @@ class WebGLState {
 
 		const { gl } = this;
 
-		material.side === DoubleSide
+		// WITH_GENESYS
+		const drawBothSides = material.side === DoubleSide || ( this.backend.renderer.debug.view === DEBUG_VIEW_FRONT_BACK_FACE && material.isShadowPassMaterial !== true );
+
+		drawBothSides
 			? this.disable( gl.CULL_FACE )
 			: this.enable( gl.CULL_FACE );
+		// !WITH_GENESYS
+		// material.side === DoubleSide
+		// 	? this.disable( gl.CULL_FACE )
+		// 	: this.enable( gl.CULL_FACE );
 
 		let flipSided = ( material.side === BackSide );
 		if ( frontFaceCW ) flipSided = ! flipSided;
@@ -73204,10 +73639,13 @@ class WebGLState {
 		this.setFlipSided( flipSided );
 
 		// WITH_GENESYS
-		// WebGL has no cached render pipeline. One+One is applied on each draw instead.
+		// WebGL has no cached render pipeline. The accumulate blend is applied on each draw instead.
+		// Alpha is replaced so it stays coverage, as in a shaded pass, for later compositing.
 		if ( debugDrawAccumulates( this.backend.renderer, material, object ) ) {
 
-			this.setBlending( AdditiveBlending, AddEquation, OneFactor, OneFactor, AddEquation, OneFactor, OneFactor, material.blendColor, material.blendAlpha, true );
+			const dstFactor = debugDrawReplacesCost( this.backend.renderer.debug.view, material ) ? ZeroFactor : OneFactor;
+
+			this.setBlending( CustomBlending, AddEquation, OneFactor, dstFactor, AddEquation, OneFactor, ZeroFactor, material.blendColor, material.blendAlpha, true );
 
 		} else if ( material.blending === NormalBlending && material.transparent === false ) {
 
@@ -77462,7 +77900,10 @@ class WebGLBackend extends Backend {
 
 		if ( context.mrt !== null && context.textures !== null ) {
 
-			state.setMRTBlending( context.textures, context.mrt, material );
+			// WITH_GENESYS
+			state.setMRTBlending( context.textures, context.mrt, material, object );
+			// !WITH_GENESYS
+			// state.setMRTBlending( context.textures, context.mrt, material );
 
 		}
 
@@ -87912,18 +88353,22 @@ class WebGPUPipelineUtils {
 		}
 
 		// WITH_GENESYS
-		// Accumulate shader cost with One+One. Opaque materials normally disable blending.
+		// Quad overdraw and translucent shader complexity add. Opaque shader complexity replaces
+		// the stored cost, so the nearest surface wins without a depth pre-pass.
+		// Alpha is replaced so it stays coverage, as in a shaded pass, for later compositing.
 		if ( debugDrawAccumulates( backend.renderer, material, object ) ) {
 
+			const replaceCost = debugDrawReplacesCost( backend.renderer.debug.view, material );
+
 			materialBlending = {
 				color: {
 					srcFactor: GPUBlendFactor.One,
-					dstFactor: GPUBlendFactor.One,
+					dstFactor: replaceCost ? GPUBlendFactor.Zero : GPUBlendFactor.One,
 					operation: GPUBlendOperation.Add
 				},
 				alpha: {
 					srcFactor: GPUBlendFactor.One,
-					dstFactor: GPUBlendFactor.One,
+					dstFactor: GPUBlendFactor.Zero,
 					operation: GPUBlendOperation.Add
 				}
 			};
@@ -88744,7 +89189,12 @@ class WebGPUPipelineUtils {
 
 		//
 
-		descriptor.cullMode = ( material.side === DoubleSide ) ? GPUCullMode.None : GPUCullMode.Back;
+		// WITH_GENESYS
+		// Front/back face draws both windings. Depth still hides a face behind the shell.
+		const drawBothSides = material.side === DoubleSide || ( this.backend.renderer.debug.view === DEBUG_VIEW_FRONT_BACK_FACE && material.isShadowPassMaterial !== true );
+		descriptor.cullMode = drawBothSides ? GPUCullMode.None : GPUCullMode.Back;
+		// !WITH_GENESYS
+		// descriptor.cullMode = ( material.side === DoubleSide ) ? GPUCullMode.None : GPUCullMode.Back;
 
 		return descriptor;