@gnsx/three 0.185.10 → 0.185.12

package/examples/jsm/tsl/display/GTAONode.js

@@ -1,5 +1,5 @@
 import { DataTexture, RenderTarget, RepeatWrapping, Vector2, Vector3, TempNode, QuadMesh, NodeMaterial, RendererUtils, RedFormat } from '@gnsx/three/webgpu';
-import { reference, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getNormalFromDepth, getScreenPosition, getViewPosition, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec2, vec3, vec4, int, dot, max, pow, abs, If, textureSize, sin, cos, PI, texture, passTexture, mat3, add, normalize, mul, cross, div, mix, acos, clamp } from '@gnsx/three/tsl';
+import { reference, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getNormalFromDepth, getScreenPosition, getViewPosition, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec2, vec3, vec4, int, dot, max, min, pow, abs, If, textureSize, sin, cos, PI, texture, passTexture, mat3, add, normalize, mul, cross, div, mix, acos, clamp } from '@gnsx/three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
@@ -70,6 +70,18 @@ class GTAONode extends TempNode {
 		 */
 		this.normalNode = normalNode;
 
+		// WITH_GENESYS
+		/**
+		 * Optional node that marks pixels where GTAO should run. This is sampled only
+		 * for the center pixel, allowing neighbor depth taps to use the raw depth
+		 * texture without repeating an auxiliary validity texture fetch.
+		 *
+		 * @type {?Node<float>}
+		 * @default null
+		 */
+		this.validityNode = null;
+		// !WITH_GENESYS
+
 		/**
 		 * The resolution scale. By default the effect is rendered in full resolution
 		 * for best quality but a value of `0.5` should be sufficient for most scenes.
@@ -106,6 +118,18 @@ class GTAONode extends TempNode {
 		 */
 		this.radius = uniform( 0.25 );
 
+		// WITH_GENESYS
+		/**
+		 * Maximum screen-space radius in pixels. Clamps the projected world-space
+		 * radius when the camera is close to surfaces so sample UVs stay local and
+		 * avoid texture-cache thrashing (Activision GTAO guidance).
+		 *
+		 * @type {UniformNode<float>}
+		 * @default 64
+		 */
+		this.maxScreenRadius = uniform( 64 );
+		// !WITH_GENESYS
+
 		/**
 		 * The resolution of the effect. Can be scaled via
 		 * `resolutionScale`.
@@ -343,12 +367,30 @@ class GTAONode extends TempNode {
 
 			const depth = sampleDepth( uvNode ).toVar();
 
+			// WITH_GENESYS
+			if ( this.validityNode !== null ) {
+
+				this.validityNode.sample( uvNode ).lessThan( 0.5 ).discard();
+
+			}
+			// !WITH_GENESYS
+
 			depth.greaterThanEqual( 1.0 ).discard();
 
 			const viewPosition = getViewPosition( uvNode, depth, this._cameraProjectionMatrixInverse ).toVar();
 			const viewNormal = sampleNormal( uvNode ).toVar();
 
-			const radiusToUse = this.radius;
+			// WITH_GENESYS
+			// Clamp world radius so its screen footprint never exceeds maxScreenRadius
+			// pixels. Without this, near-camera surfaces project a huge UV stride and
+			// the depth/normal taps thrash the texture cache.
+			const probeScreen = getScreenPosition( viewPosition.add( vec3( this.radius, 0.0, 0.0 ) ), this._cameraProjectionMatrix );
+			const centerScreen = getScreenPosition( viewPosition, this._cameraProjectionMatrix );
+			const screenRadiusPx = abs( probeScreen.x.sub( centerScreen.x ) ).mul( this.resolution.x );
+			const radiusScale = min( float( 1.0 ), this.maxScreenRadius.div( max( screenRadiusPx, float( 1e-4 ) ) ) );
+			const radiusToUse = this.radius.mul( radiusScale );
+			// !WITH_GENESYS
+			// const radiusToUse = this.radius;
 
 			const noiseResolution = textureSize( this._noiseNode, 0 );
 			let noiseUv = vec2( uvNode.x, uvNode.y.oneMinus() );
@@ -360,8 +402,16 @@ class GTAONode extends TempNode {
 			const bitangent = vec3( tangent.y.mul( - 1.0 ), tangent.x, 0.0 );
 			const kernelMatrix = mat3( tangent, bitangent, vec3( 0.0, 0.0, 1.0 ) );
 
-			const DIRECTIONS = this.samples.lessThan( 30 ).select( 3, 5 ).toVar();
-			const STEPS = add( this.samples, DIRECTIONS.sub( 1 ) ).div( DIRECTIONS ).toVar();
+			// WITH_GENESYS
+			// A clamped radius covers less screen space, so proportionally reduce the
+			// sample budget as well. Keeping all samples only changes tap locality and
+			// does not address the near-camera shader cost.
+			const samplesToUse = min( this.samples, max( float( 6 ), this.samples.mul( radiusScale ) ) ).toVar();
+			const DIRECTIONS = samplesToUse.lessThan( 30 ).select( 3, 5 ).toVar();
+			const STEPS = add( samplesToUse, DIRECTIONS.sub( 1 ) ).div( DIRECTIONS ).toVar();
+			// !WITH_GENESYS
+			// const DIRECTIONS = this.samples.lessThan( 30 ).select( 3, 5 ).toVar();
+			// const STEPS = add( this.samples, DIRECTIONS.sub( 1 ) ).div( DIRECTIONS ).toVar();
 
 			const ao = float( 0 ).toVar();
 

package/package.json

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

package/src/profiler/ProfilerService.js

@@ -407,6 +407,9 @@ class ProfilerServiceClass {
 
 		if ( label !== null && label !== undefined && label !== '' ) {
 
+			// Queue labelled passes with the active beginGpu span(s). Flushing
+			// immediately would commit them before their parent envelope exists and
+			// can anchor gpuTraceOrigin mid-frame, which breaks Speedscope nesting.
 			const passSpan = {
 				label: `GPU pass: ${label}`,
 				renderer,
@@ -420,7 +423,13 @@ class ProfilerServiceClass {
 			};
 			passSpan._queries[ type ].add( uid );
 			state.pendingSpans.push( passSpan );
-			this._scheduleGpuFlush( state );
+			// Only auto-flush when no beginGpu parent is open. Nested parents flush on endGpu
+			// so pass slices share one origin and nest inside the parent envelope.
+			if ( state.activeSpans.length === 0 ) {
+
+				this._scheduleGpuFlush( state );
+
+			}
 
 		}
 
@@ -481,38 +490,22 @@ class ProfilerServiceClass {
 
 		if ( state.gpuTimestampOrigin === null ) {
 
-			let earliestRange = null;
-			let earliestUid = null;
-			for ( const span of spans ) {
-
-				for ( const type of [ TimestampQuery.RENDER, TimestampQuery.COMPUTE ] ) {
-
-					for ( const uid of span._queries[ type ] ) {
-
-						const range = state.renderer.backend.getTimestampRange( uid );
-						if ( range !== null && ( earliestRange === null || range.start < earliestRange.start ) ) {
-
-							earliestRange = range;
-							earliestUid = uid;
-
-						}
-
-					}
-
-				}
-
-			}
-
-			if ( earliestRange !== null ) {
+			const origin = this._findEarliestGpuTimestampOrigin( state, spans );
+			if ( origin !== null ) {
 
-				state.gpuTimestampOrigin = earliestRange.start;
-				state.gpuTraceOrigin = state.queryCpuTimes.get( earliestUid ) ?? spans[ 0 ].t0;
+				state.gpuTimestampOrigin = origin.gpuTimestampOrigin;
+				state.gpuTraceOrigin = origin.gpuTraceOrigin;
 
 			}
 
 		}
 
 		const resolvedUids = new Set();
+		/** @type {Array<{ label: string, startTime: number, durationMs: number, isPass: boolean }>} */
+		const samples = [];
+		/** @type {Set<string>} */
+		const labelledQueryUids = new Set();
+
 		for ( const span of spans ) {
 
 			if ( span._generation !== this._gpuGeneration ) continue;
@@ -550,20 +543,247 @@ class ProfilerServiceClass {
 			if ( resolvedQueries > 0 ) {
 
 				let startTime = span.t0;
-				if ( rangedQueries === resolvedQueries && gpuStart !== null && gpuEnd !== null && state.gpuTimestampOrigin !== null ) {
+				// Prefer the device envelope whenever any query has a range. Requiring
+				// *all* queries to be ranged forced a CPU-t0 + summed-duration fallback
+				// that often ended before later GPU pass slices, breaking flame nesting.
+				if ( rangedQueries > 0 && gpuStart !== null && gpuEnd !== null && state.gpuTimestampOrigin !== null ) {
 
 					duration = Number( gpuEnd - gpuStart ) / 1e6;
 					startTime = state.gpuTraceOrigin + Number( gpuStart - state.gpuTimestampOrigin ) / 1e6;
 
 				}
 
-				this._commitGpuDurationSample( span.label, startTime, duration );
+				const isPass = span.label.startsWith( 'GPU pass:' );
+				if ( isPass ) {
+
+					for ( const type of [ TimestampQuery.RENDER, TimestampQuery.COMPUTE ] ) {
+
+						for ( const uid of span._queries[ type ] ) labelledQueryUids.add( uid );
+
+					}
+
+				}
+
+				samples.push( {
+					label: span.label,
+					startTime,
+					durationMs: duration,
+					isPass,
+				} );
 
 			}
 
 		}
 
-		for ( const uid of resolvedUids ) state.queryCpuTimes.delete( uid );
+		// Parent beginGpu spans collect every timestamp query, including renders that
+		// had no gpuProfilerLabel. Surface those as pass slices so they are not empty
+		// holes under the parent envelope.
+		for ( const span of spans ) {
+
+			if ( span._generation !== this._gpuGeneration ) continue;
+			if ( span.label.startsWith( 'GPU pass:' ) ) continue;
+			if ( state.gpuTimestampOrigin === null ) continue;
+
+			for ( const type of [ TimestampQuery.RENDER, TimestampQuery.COMPUTE ] ) {
+
+				for ( const uid of span._queries[ type ] ) {
+
+					if ( labelledQueryUids.has( uid ) ) continue;
+					if ( state.renderer.backend.hasTimestampQuery( uid ) === false ) continue;
+
+					const range = state.renderer.backend.getTimestampRange( uid );
+					if ( range === null ) continue;
+
+					const durationMs = Number( range.end - range.start ) / 1e6;
+					if ( durationMs <= 0 ) continue;
+
+					samples.push( {
+						label: 'GPU pass: (unlabeled)',
+						startTime: state.gpuTraceOrigin + Number( range.start - state.gpuTimestampOrigin ) / 1e6,
+						durationMs,
+						isPass: true,
+					} );
+					labelledQueryUids.add( uid );
+
+				}
+
+			}
+
+		}
+
+		const passSamples = samples.filter( sample => sample.isPass );
+		const otherSamples = samples.filter( sample => sample.isPass === false );
+		this._snapHalfOpenGpuPassTraceIntervals( passSamples );
+		this._expandGpuParentTraceToContainPasses( otherSamples, passSamples );
+
+		for ( const sample of otherSamples ) {
+
+			this._commitGpuDurationSample( sample.label, sample.startTime, sample.durationMs, {
+				ts: sample.traceTs,
+				dur: sample.traceDur,
+			} );
+
+		}
+
+		for ( const sample of passSamples ) {
+
+			this._commitGpuDurationSample( sample.label, sample.startTime, sample.durationMs, {
+				ts: sample.traceTs,
+				dur: sample.traceDur,
+			} );
+
+		}
+
+		// Keep CPU times for queries still referenced by active parent spans.
+		for ( const uid of resolvedUids ) {
+
+			if ( this._isGpuQueryReferencedByActiveSpans( state, uid ) ) continue;
+			state.queryCpuTimes.delete( uid );
+
+		}
+
+	}
+
+	/**
+	 * Convert labelled GPU pass samples to non-overlapping half-open µs intervals for
+	 * Chrome/Speedscope traces. Stats keep the raw measured durations.
+	 *
+	 * @param {Array<{ startTime: number, durationMs: number, traceTs?: number, traceDur?: number }>} samples
+	 */
+	_snapHalfOpenGpuPassTraceIntervals( samples ) {
+
+		if ( samples.length === 0 ) return;
+
+		for ( const sample of samples ) {
+
+			sample.traceTs = Math.round( this._getTraceTimestamp( sample.startTime ) );
+			sample.traceDur = Math.max( 1, Math.round( sample.durationMs * 1000 ) );
+
+		}
+
+		// Longer first at the same timestamp so the substantial pass keeps its start.
+		samples.sort( ( a, b ) => a.traceTs - b.traceTs || b.traceDur - a.traceDur );
+
+		let cursor = Number.NEGATIVE_INFINITY;
+		for ( const sample of samples ) {
+
+			if ( sample.traceTs < cursor ) {
+
+				const end = Math.max( sample.traceTs + sample.traceDur, cursor + 1 );
+				sample.traceTs = cursor;
+				sample.traceDur = Math.max( 1, end - sample.traceTs );
+
+			}
+
+			cursor = sample.traceTs + sample.traceDur;
+
+		}
+
+	}
+
+	/**
+	 * Speedscope nests by time containment on a thread. If a snapped GPU pass
+	 * sticks out past its beginGpu parent (rounding / half-open adjust), the
+	 * parent fails containment and is pushed onto a lower lane under renderFrame.
+	 * Expand overlapping parents so they strictly cover their pass children.
+	 *
+	 * @param {Array<{ startTime: number, durationMs: number, traceTs?: number, traceDur?: number }>} parents
+	 * @param {Array<{ traceTs: number, traceDur: number }>} passes
+	 */
+	_expandGpuParentTraceToContainPasses( parents, passes ) {
+
+		if ( parents.length === 0 || passes.length === 0 ) return;
+
+		for ( const parent of parents ) {
+
+			parent.traceTs = Math.round( this._getTraceTimestamp( parent.startTime ) );
+			parent.traceDur = Math.max( 1, Math.round( parent.durationMs * 1000 ) );
+
+			const parentEnd = parent.traceTs + parent.traceDur;
+			let minTs = parent.traceTs;
+			let maxEnd = parentEnd;
+			let touched = false;
+
+			for ( const pass of passes ) {
+
+				const passEnd = pass.traceTs + pass.traceDur;
+				if ( pass.traceTs >= parentEnd || passEnd <= parent.traceTs ) continue;
+
+				touched = true;
+				if ( pass.traceTs < minTs ) minTs = pass.traceTs;
+				if ( passEnd > maxEnd ) maxEnd = passEnd;
+
+			}
+
+			if ( touched === false ) continue;
+
+			// Start 1µs before the first child so equal-start pairs still nest
+			// (Speedscope sorts same-ts by longer-first; a child that begins
+			// strictly after the parent is unambiguous).
+			parent.traceTs = minTs > 0 ? minTs - 1 : minTs;
+			parent.traceDur = Math.max( 1, maxEnd - parent.traceTs );
+
+		}
+
+	}
+
+	/**
+	 * @param {import('./ProfilerService.js').CommonGpuRendererState} state
+	 * @param {import('./ProfilerService.js').GpuSpanHandle[]} spans
+	 * @return {?{ gpuTimestampOrigin: bigint, gpuTraceOrigin: number }}
+	 */
+	_findEarliestGpuTimestampOrigin( state, spans ) {
+
+		let earliestRange = null;
+		let earliestUid = null;
+		const candidates = spans.concat( state.activeSpans );
+
+		for ( const span of candidates ) {
+
+			for ( const type of [ TimestampQuery.RENDER, TimestampQuery.COMPUTE ] ) {
+
+				const queries = span._queries?.[ type ];
+				if ( queries === undefined ) continue;
+
+				for ( const uid of queries ) {
+
+					const range = state.renderer.backend.getTimestampRange( uid );
+					if ( range !== null && ( earliestRange === null || range.start < earliestRange.start ) ) {
+
+						earliestRange = range;
+						earliestUid = uid;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		if ( earliestRange === null ) return null;
+
+		return {
+			gpuTimestampOrigin: earliestRange.start,
+			gpuTraceOrigin: state.queryCpuTimes.get( earliestUid ) ?? spans[ 0 ].t0,
+		};
+
+	}
+
+	/**
+	 * @param {import('./ProfilerService.js').CommonGpuRendererState} state
+	 * @param {string} uid
+	 * @return {boolean}
+	 */
+	_isGpuQueryReferencedByActiveSpans( state, uid ) {
+
+		for ( const span of state.activeSpans ) {
+
+			if ( span._queries.render.has( uid ) || span._queries.compute.has( uid ) ) return true;
+
+		}
+
+		return false;
 
 	}
 
@@ -791,8 +1011,9 @@ class ProfilerServiceClass {
 	 * @param {string} label
 	 * @param {number} startTime
 	 * @param {number} durationMs
+	 * @param {{ ts: number, dur: number }} [traceOverride]
 	 */
-	_commitGpuDurationSample( label, startTime, durationMs ) {
+	_commitGpuDurationSample( label, startTime, durationMs, traceOverride = null ) {
 
 		let buffer = this.gpuBuffers.get( label );
 		if ( buffer === undefined ) {
@@ -815,8 +1036,8 @@ class ProfilerServiceClass {
 			this.traceEvents.push( {
 				name: label,
 				ph: 'X',
-				ts: Math.round( this._getTraceTimestamp( startTime ) ),
-				dur: Math.max( 1, Math.round( durationMs * 1000 ) ),
+				ts: traceOverride?.ts ?? Math.round( this._getTraceTimestamp( startTime ) ),
+				dur: traceOverride?.dur ?? Math.max( 1, Math.round( durationMs * 1000 ) ),
 				pid: 1,
 				tid: TRACE_TID_GPU,
 				cat: 'gnsx-gpu',

package/src/renderers/common/Renderer.js

@@ -1618,8 +1618,23 @@ class Renderer {
 		const renderContext = this._renderContexts.get( renderTarget, this._mrt, this._callDepth );
 
 		// WITH_GENESYS
-		renderContext.gpuProfilerLabel = scene.isQuadMesh === true && scene.name !== '' ? scene.name : null;
+		// Prefer an explicit scene/pass name; otherwise fall back to the render
+		// target texture name so depth/shadow/RTT work is not an invisible hole.
+		let gpuProfilerLabel = scene.name !== '' ? scene.name : null;
+		if ( gpuProfilerLabel === null && renderTarget !== null ) {
+
+			const textureName = renderTarget.texture?.name;
+			if ( textureName !== undefined && textureName !== null && textureName !== '' ) {
+
+				gpuProfilerLabel = textureName;
+
+			}
+
+		}
+
+		renderContext.gpuProfilerLabel = gpuProfilerLabel;
 		// !WITH_GENESYS
+		// renderContext.gpuProfilerLabel = scene.name !== '' ? scene.name : null;
 
 		this._currentRenderContext = renderContext;
 		this._currentRenderObjectFunction = this._renderObjectFunction || this.renderObject;
@@ -2620,7 +2635,7 @@ class Renderer {
 
 			// WITH_GENESYS
 			// Drop the strong reference to the active `RenderContext` so module-level
-			// `WeakMap<RenderContext, �?>` caches can release entries once
+			// `WeakMap<RenderContext, ...>` caches can release entries once
 			// `_renderContexts.dispose()` has cleared its dictionary.
 			this._currentRenderContext = null;
 			// !WITH_GENESYS

package/src/renderers/webgpu/WebGPUBackend.js

@@ -25,7 +25,7 @@ import GPUShaderModuleDescriptor from './descriptors/GPUShaderModuleDescriptor.j
 import GPURenderPassColorAttachment from './descriptors/GPURenderPassColorAttachment.js';
 import GPURenderPassDepthStencilAttachment from './descriptors/GPURenderPassDepthStencilAttachment.js';
 import GPURenderPassDescriptor from './descriptors/GPURenderPassDescriptor.js';
-import GPURenderPassTimestampWrites from './descriptors/GPURenderPassTimestampWrites.js';
+// import GPURenderPassTimestampWrites from './descriptors/GPURenderPassTimestampWrites.js';
 import GPUTexelCopyTextureInfo from './descriptors/GPUTexelCopyTextureInfo.js';
 import GPUTextureViewDescriptor from './descriptors/GPUTextureViewDescriptor.js';
 import GPUExtent3D from './descriptors/GPUExtent3D.js';
@@ -36,7 +36,7 @@ const _commandEncoderDescriptor = new GPUCommandEncoderDescriptor();
 const _computePassDescriptor = new GPUComputePassDescriptor();
 const _querySetDescriptor = new GPUQuerySetDescriptor();
 const _shaderModuleDescriptor = new GPUShaderModuleDescriptor();
-const _renderPassTimestampWrites = new GPURenderPassTimestampWrites();
+// const _renderPassTimestampWrites = new GPURenderPassTimestampWrites();
 const _texelCopyTextureInfoSrc = new GPUTexelCopyTextureInfo();
 const _texelCopyTextureInfoDst = new GPUTexelCopyTextureInfo();
 const _viewDescriptor = new GPUTextureViewDescriptor();
@@ -2279,15 +2279,22 @@ class WebGPUBackend extends Backend {
 		if ( baseOffset === null || timestampQueryPool.querySet === null ) return;
 		// !WITH_GENESYS
 
-		_renderPassTimestampWrites.querySet = timestampQueryPool.querySet;
-		_renderPassTimestampWrites.beginningOfPassWriteIndex = baseOffset;
-		_renderPassTimestampWrites.endOfPassWriteIndex = baseOffset + 1;
-
-		descriptor.timestampWrites = _renderPassTimestampWrites;
-
 		// WITH_GENESYS
+		// Per-pass object: a shared descriptor is mutated by nested beginRender /
+		// copyFramebuffer restarts and can make unrelated passes write the same
+		// query indices (shadow maps collapsing to ~1µs is the common symptom).
+		descriptor.timestampWrites = {
+			querySet: timestampQueryPool.querySet,
+			beginningOfPassWriteIndex: baseOffset,
+			endOfPassWriteIndex: baseOffset + 1,
+		};
+
 		this.notifyTimestampQuery( type, uid, label );
 		// !WITH_GENESYS
+		// _renderPassTimestampWrites.querySet = timestampQueryPool.querySet;
+		// _renderPassTimestampWrites.beginningOfPassWriteIndex = baseOffset;
+		// _renderPassTimestampWrites.endOfPassWriteIndex = baseOffset + 1;
+		// descriptor.timestampWrites = _renderPassTimestampWrites;
 
 	}
 
@@ -2848,6 +2855,17 @@ class WebGPUBackend extends Backend {
 			if ( renderContext.depth ) descriptor.depthStencilAttachment.depthLoadOp = GPULoadOp.Load;
 			if ( renderContext.stencil ) descriptor.depthStencilAttachment.stencilLoadOp = GPULoadOp.Load;
 
+			// WITH_GENESYS
+			// Restarted passes need fresh timestamp slots; reusing the previous
+			// timestampWrites overwrites the first segment's query results.
+			this.initTimestampQuery(
+				TimestampQuery.RENDER,
+				this.getTimestampUID( renderContext ),
+				descriptor,
+				renderContext.gpuProfilerLabel
+			);
+			// !WITH_GENESYS
+
 			renderContextData.currentPass = encoder.beginRenderPass( descriptor );
 			renderContextData.currentSets = { attributes: {}, bindingGroups: [], pipeline: null, index: null };
 

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

@@ -78,7 +78,20 @@ class WebGPUTimestampQueryPool extends TimestampQueryPool {
 		const baseOffset = this.currentQueryIndex;
 		this.currentQueryIndex += 2;
 
-		this.queryOffsets.set( uid, baseOffset );
+		// WITH_GENESYS
+		// One logical uid can own multiple GPU passes (nested interrupt /
+		// copyFramebuffer restart). Keep every offset; resolve sums them.
+		let offsets = this.queryOffsets.get( uid );
+		if ( offsets === undefined ) {
+
+			offsets = [];
+			this.queryOffsets.set( uid, offsets );
+
+		}
+
+		offsets.push( baseOffset );
+		// !WITH_GENESYS
+		// this.queryOffsets.set( uid, baseOffset );
 
 		return baseOffset;
 
@@ -200,7 +213,7 @@ class WebGPUTimestampQueryPool extends TimestampQueryPool {
 
 			const frames = [];
 
-			for ( const [ uid, baseOffset ] of currentOffsets ) {
+			for ( const [ uid, offsetOrOffsets ] of currentOffsets ) {
 
 				const match = uid.match( /^(.*):f(\d+)$/ );
 				const frame = parseInt( match[ 2 ] );
@@ -213,14 +226,34 @@ class WebGPUTimestampQueryPool extends TimestampQueryPool {
 
 				if ( framesDuration[ frame ] === undefined ) framesDuration[ frame ] = 0;
 
-				const startTime = times[ baseOffset ];
-				const endTime = times[ baseOffset + 1 ];
-				const duration = Number( endTime - startTime ) / 1e6;
+				// WITH_GENESYS
+				const offsets = Array.isArray( offsetOrOffsets ) ? offsetOrOffsets : [ offsetOrOffsets ];
+				let duration = 0;
+				let rangeStart = null;
+				let rangeEnd = null;
+
+				for ( const baseOffset of offsets ) {
+
+					const startTime = times[ baseOffset ];
+					const endTime = times[ baseOffset + 1 ];
+					duration += Number( endTime - startTime ) / 1e6;
+
+					if ( rangeStart === null || startTime < rangeStart ) rangeStart = startTime;
+					if ( rangeEnd === null || endTime > rangeEnd ) rangeEnd = endTime;
+
+				}
 
 				this.timestamps.set( uid, duration );
-				// WITH_GENESYS
-				this.timestampRanges.set( uid, { start: startTime, end: endTime } );
+				if ( rangeStart !== null && rangeEnd !== null ) {
+
+					this.timestampRanges.set( uid, { start: rangeStart, end: rangeEnd } );
+
+				}
 				// !WITH_GENESYS
+				// const startTime = times[ baseOffset ];
+				// const endTime = times[ baseOffset + 1 ];
+				// const duration = Number( endTime - startTime ) / 1e6;
+				// this.timestamps.set( uid, duration );
 
 				framesDuration[ frame ] += duration;