rayzee 6.5.0 → 7.0.0

package/src/TSL/PathTracer.js

@@ -1,384 +0,0 @@
-/**
- * PathTracer.js - Main Path Tracer Entry Point (Compute Shader)
- *
- * Contains:
- *  - dithering              — anti-banding dither pattern
- *  - computeNDCDepth        — world position to NDC depth [0,1]
- *  - getRequiredSamples     — adaptive sampling sample count
- *  - pathTracerMain         — main entry (sample loop, accumulation, textureStore output)
- *
- * Compute Outputs (via textureStore):
- *  - writeColorTex:       RGB + alpha (transparent bg: per-sample hit/miss alpha, opaque: 1.0)
- *  - writeNDTex:          Normal(RGB) + depth(A)
- *  - writeAlbedoTex:      Albedo(RGB) for OIDN denoiser
- */
-
-import {
-	Fn,
-	wgslFn,
-	float,
-	vec2,
-	vec3,
-	vec4,
-	int,
-	uint,
-	uvec2,
-	clamp,
-	mix,
-	normalize,
-	floor,
-	If,
-	Loop,
-	Break,
-	texture,
-	textureStore,
-	select,
-} from 'three/tsl';
-
-import {
-	RandomValue,
-	getDecorrelatedSeed,
-	getStratifiedSample,
-	pcgHash,
-} from './Random.js';
-
-import { generateRayFromCamera } from './BVHTraversal.js';
-import { Trace, TraceResult } from './PathTracerCore.js';
-import { TraceDebugMode } from './Debugger.js';
-import { Ray } from './Struct.js';
-
-// =============================================================================
-// Helper Functions
-// =============================================================================
-
-// Dithering to prevent banding in 8-bit output
-export const dithering = Fn( ( [ color, seed ] ) => {
-
-	const gridPosition = RandomValue( seed );
-	const ditherShiftRGB = vec3( 0.25 / 255.0, - 0.25 / 255.0, 0.25 / 255.0 ).toVar();
-
-	ditherShiftRGB.assign(
-		mix( ditherShiftRGB.mul( 2.0 ), ditherShiftRGB.mul( - 2.0 ), gridPosition ),
-	);
-
-	return color.add( ditherShiftRGB );
-
-} );
-
-// Compute NDC depth from world position for motion vector reprojection
-export const computeNDCDepth = /*@__PURE__*/ wgslFn( `
-	fn computeNDCDepth( worldPos: vec3f, cameraProjectionMatrix: mat4x4f, cameraViewMatrix: mat4x4f ) -> f32 {
-		let clipPos = cameraProjectionMatrix * cameraViewMatrix * vec4f( worldPos, 1.0f );
-		let ndcDepth = clipPos.z / clipPos.w * 0.5f + 0.5f;
-		return clamp( ndcDepth, 0.0f, 1.0f );
-	}
-` );
-
-// NaN/Inf detector for debug mode 11. x != x catches NaN; the abs threshold catches Inf.
-const nanInfToRed = /*@__PURE__*/ wgslFn( `
-	fn nanInfToRed( c: vec3f ) -> vec3f {
-		let isNan = c.x != c.x || c.y != c.y || c.z != c.z;
-		let isInf = abs( c.x ) > 1e30f || abs( c.y ) > 1e30f || abs( c.z ) > 1e30f;
-		if ( isNan || isInf ) { return vec3f( 1.0f, 0.0f, 0.0f ); }
-		return vec3f( 0.0f );
-	}
-` );
-
-// Get required samples from adaptive sampling texture
-export const getRequiredSamples = Fn( ( [
-	pixelCoord, resolution,
-	adaptiveSamplingTexture, adaptiveSamplingMin, adaptiveSamplingMax,
-] ) => {
-
-	const texCoord = pixelCoord.div( resolution );
-	const samplingData = texture( adaptiveSamplingTexture, texCoord, 0 );
-
-	const result = int( 0 ).toVar();
-
-	// Early exit for converged pixels
-	If( samplingData.b.greaterThan( 0.5 ), () => {
-
-		result.assign( 0 );
-
-	} ).Else( () => {
-
-		const normalizedSamples = samplingData.r;
-		const targetSamples = normalizedSamples.mul( float( adaptiveSamplingMax ) );
-		const samples = int( floor( targetSamples.add( 0.5 ) ) );
-		result.assign( clamp( samples, adaptiveSamplingMin, adaptiveSamplingMax ) );
-
-	} );
-
-	return result;
-
-} );
-
-// =============================================================================
-// Main Path Tracer Implementation (Compute Shader)
-// =============================================================================
-
-/**
- * Generates TSL nodes for the path tracer compute kernel body.
- * Must be called from within a compute Fn() scope (e.g., in ShaderBuilder).
- *
- * Previous-frame reads use texture() sampling from MRT RenderTarget textures
- * (populated by copyTextureToTexture after each dispatch).
- *
- * @param {Object} params - All uniforms, textures, and output StorageTextures
- */
-export const pathTracerMain = ( params ) => {
-
-	const {
-		// Compute pixel coordinate (vec2 with 0.5 offset for pixel center)
-		pixelCoord,
-		// Output StorageTextures
-		writeColorTex, writeNDTex, writeAlbedoTex,
-		// Frame / resolution
-		resolution, frame,
-		samplesPerPixel: numRaysPerPixel,
-		visMode,
-		cameraWorldMatrix, cameraProjectionMatrixInverse, cameraViewMatrix, cameraProjectionMatrix,
-		bvhBuffer, triangleBuffer, materialBuffer,
-		albedoMaps, normalMaps, bumpMaps,
-		metalnessMaps, roughnessMaps, emissiveMaps,
-		displacementMaps,
-		directionalLightsBuffer, numDirectionalLights,
-		areaLightsBuffer, numAreaLights,
-		pointLightsBuffer, numPointLights,
-		spotLightsBuffer, numSpotLights,
-		envTexture, environmentIntensity, envMatrix,
-		envCDFBuffer,
-		envTotalSum, envCompensationDelta, envResolution,
-		enableEnvironmentLight, useEnvMapIS,
-		groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight,
-		maxBounceCount, transmissiveBounces, maxSubsurfaceSteps,
-		showBackground, transparentBackground, backgroundIntensity,
-		fireflyThreshold, globalIlluminationIntensity,
-		enableEmissiveTriangleSampling,
-		emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
-		lightBVHBuffer, lightBVHNodeCount,
-		debugVisScale,
-		enableAccumulation, hasPreviousAccumulated,
-		prevAccumTexture, prevNormalDepthTexture, prevAlbedoTexture,
-		accumulationAlpha, cameraIsMoving,
-		useAdaptiveSampling, adaptiveSamplingTexture, adaptiveSamplingMin, adaptiveSamplingMax,
-		enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
-	} = params;
-
-	// Integer coordinates for textureStore writes
-	const uintCoord = uvec2( uint( int( pixelCoord.x ) ), uint( int( pixelCoord.y ) ) );
-
-	// UV for sampling previous-frame textures from MRT RenderTarget
-	const prevUV = pixelCoord.div( resolution );
-
-	// Screen position in NDC [-1, 1]
-	// Negate Y for NDC convention (bottom-up)
-	const screenPosition = pixelCoord.div( resolution ).mul( 2.0 ).sub( 1.0 ).toVar();
-	screenPosition.y.assign( screenPosition.y.negate() );
-
-	// Initialize pixel accumulator
-	const pixelColor = vec4( 0.0 ).toVar();
-	const pixelSamples = int( 0 ).toVar();
-
-	const baseSeed = getDecorrelatedSeed( { pixelCoord, rayIndex: int( 0 ), frame } ).toVar();
-
-	// MRT — linearDepth is ray distance (sky/miss = 1e6), the convention
-	// MotionVector + ASVGF expect downstream.
-	const worldNormal = vec3( 0.0, 0.0, 1.0 ).toVar();
-	const linearDepth = float( 1e6 ).toVar();
-
-	// Accumulate per-sample alpha for transparent background (0.0 = env, 1.0 = geometry)
-	const pixelAlpha = float( 0.0 ).toVar();
-
-	const samplesCount = int( numRaysPerPixel ).toVar();
-
-	// Adaptive sampling
-	If( frame.greaterThan( uint( 2 ) ).and( useAdaptiveSampling ), () => {
-
-		const adaptiveSamples = getRequiredSamples(
-			pixelCoord, resolution,
-			adaptiveSamplingTexture, adaptiveSamplingMin, adaptiveSamplingMax,
-		);
-		samplesCount.assign( adaptiveSamples );
-
-		// Handle converged pixels — carry forward all data from previous frame
-		If( samplesCount.equal( int( 0 ) ), () => {
-
-			If( enableAccumulation.and( hasPreviousAccumulated ), () => {
-
-				const prevSample = texture( prevAccumTexture, prevUV, 0 );
-				pixelColor.assign( prevSample );
-				pixelAlpha.assign( prevSample.w );
-
-				// Carry forward MRT data so accumulation blend preserves them
-				const prevND = texture( prevNormalDepthTexture, prevUV, 0 );
-				worldNormal.assign( prevND.xyz.mul( 2.0 ).sub( 1.0 ) );
-				linearDepth.assign( prevND.w );
-
-			} ).Else( () => {
-
-				samplesCount.assign( 1 );
-
-			} );
-
-		} );
-
-	} );
-
-	// First-hit data for MRT
-	const objectNormal = vec3( 0.0 ).toVar();
-	const objectColor = vec3( 0.0 ).toVar();
-	const objectID = float( - 1000.0 ).toVar();
-
-	// Pre-compute loop-invariant jitter scale
-	const jitterScale = vec2( 2.0 ).div( resolution ).toVar();
-
-	// Main sample loop
-	Loop( { start: int( 0 ), end: samplesCount, type: 'int', condition: '<' }, ( { i: rayIndex } ) => {
-
-		const seed = pcgHash( { state: baseSeed.add( uint( rayIndex ) ) } ).toVar();
-
-		const stratifiedJitter = getStratifiedSample(
-			pixelCoord, rayIndex, samplesCount, seed, resolution, frame,
-		).toVar();
-
-		// Debug mode 9: Visualize stratified samples
-		If( visMode.equal( int( 9 ) ), () => {
-
-			pixelColor.assign( vec4( stratifiedJitter, 1.0, 1.0 ) );
-			pixelSamples.assign( 1 );
-			Break();
-
-		} );
-
-		const jitter = stratifiedJitter.sub( 0.5 ).mul( jitterScale );
-		const jitteredScreenPosition = screenPosition.add( jitter );
-
-		const ray = Ray.wrap( generateRayFromCamera(
-			jitteredScreenPosition, seed,
-			cameraWorldMatrix, cameraProjectionMatrixInverse,
-			enableDOF, focalLength, aperture, focusDistance, sceneScale, apertureScale, anamorphicRatio,
-		) );
-
-		const sampleColor = vec4( 0.0 ).toVar();
-
-		// Debug or normal trace (mode 11 runs the full path tracer so we can sniff NaN at the end)
-		If( visMode.greaterThan( int( 0 ) ).and( visMode.notEqual( int( 11 ) ) ), () => {
-
-			sampleColor.assign( TraceDebugMode(
-				ray.origin, ray.direction,
-				bvhBuffer,
-				triangleBuffer,
-				materialBuffer,
-				envTexture, envMatrix, environmentIntensity, enableEnvironmentLight,
-				visMode, debugVisScale,
-				pixelCoord, resolution,
-				albedoMaps, normalMaps, bumpMaps,
-				metalnessMaps, roughnessMaps, emissiveMaps,
-				cameraProjectionMatrix, cameraViewMatrix,
-				frame,
-			) );
-
-		} ).Else( () => {
-
-			// Normal path tracing
-			const traceResult = TraceResult.wrap( Trace(
-				ray, seed, rayIndex,
-				bvhBuffer,
-				triangleBuffer,
-				materialBuffer,
-				albedoMaps, normalMaps, bumpMaps,
-				metalnessMaps, roughnessMaps, emissiveMaps,
-				displacementMaps,
-				directionalLightsBuffer, numDirectionalLights,
-				areaLightsBuffer, numAreaLights,
-				pointLightsBuffer, numPointLights,
-				spotLightsBuffer, numSpotLights,
-				envTexture, environmentIntensity, envMatrix,
-				envCDFBuffer,
-				envTotalSum, envCompensationDelta, envResolution,
-				enableEnvironmentLight, useEnvMapIS,
-				groundProjectionEnabled, groundProjectionRadius, groundProjectionHeight,
-				maxBounceCount, transmissiveBounces, maxSubsurfaceSteps,
-				backgroundIntensity, showBackground, transparentBackground,
-				fireflyThreshold, globalIlluminationIntensity,
-				enableEmissiveTriangleSampling,
-				emissiveTriangleBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower, emissiveBoost,
-				lightBVHBuffer, lightBVHNodeCount,
-				pixelCoord, resolution, frame,
-			) );
-
-			sampleColor.assign( traceResult.radiance );
-
-			// Accumulate first-hit data from primary rays
-			If( rayIndex.equal( int( 0 ) ), () => {
-
-				objectNormal.assign( traceResult.objectNormal );
-				objectColor.assign( traceResult.objectColor );
-				objectID.assign( traceResult.objectID );
-
-				// Set MRT data from first hit (only for geometry hits — miss rays have zero normal,
-				// and normalize(vec3(0)) = NaN which would corrupt the OIDN denoiser input)
-				If( traceResult.firstHitDistance.lessThan( 1e9 ), () => {
-
-					worldNormal.assign( normalize( traceResult.objectNormal ) );
-					linearDepth.assign( traceResult.firstHitDistance );
-
-				} );
-
-			} );
-
-		} );
-
-		pixelColor.addAssign( sampleColor );
-		pixelAlpha.addAssign( sampleColor.w );
-		pixelSamples.addAssign( 1 );
-
-	} );
-
-	// Average samples
-	If( pixelSamples.greaterThan( int( 0 ) ), () => {
-
-		pixelColor.divAssign( float( pixelSamples ) );
-		pixelAlpha.divAssign( float( pixelSamples ) );
-
-	} );
-
-	// Temporal accumulation
-	const finalColor = pixelColor.xyz.toVar();
-	const finalNormalDepth = vec4( worldNormal.mul( 0.5 ).add( 0.5 ), linearDepth ).toVar();
-	const finalAlbedo = vec3( objectColor ).toVar();
-
-	// Output alpha: accumulated per-sample alpha when transparent, otherwise 1.0
-	const outputAlpha = select( transparentBackground, pixelAlpha, float( 1.0 ) ).toVar();
-
-	If( enableAccumulation.and( cameraIsMoving.not() ).and( frame.greaterThan( uint( 0 ) ) ).and( hasPreviousAccumulated ).and( visMode.notEqual( int( 11 ) ) ), () => {
-
-		const prevAccumSample = texture( prevAccumTexture, prevUV, 0 ).toVar();
-
-		finalColor.assign( mix( prevAccumSample.xyz, pixelColor.xyz, accumulationAlpha ) );
-		finalNormalDepth.assign( mix( texture( prevNormalDepthTexture, prevUV, 0 ), finalNormalDepth, accumulationAlpha ) );
-		finalAlbedo.assign( mix( texture( prevAlbedoTexture, prevUV, 0 ).xyz, finalAlbedo, accumulationAlpha ) );
-
-		// Temporally accumulate alpha from previous frame's gColor.w
-		If( transparentBackground, () => {
-
-			outputAlpha.assign( mix( prevAccumSample.w, pixelAlpha, accumulationAlpha ) );
-
-		} );
-
-	} );
-
-	// NaN/Inf debug: red where the path tracer output isn't finite, black otherwise.
-	If( visMode.equal( int( 11 ) ), () => {
-
-		finalColor.assign( nanInfToRed( finalColor ) );
-
-	} );
-
-	// Write outputs to StorageTextures
-	textureStore( writeColorTex, uintCoord, vec4( finalColor.xyz, outputAlpha ) ).toWriteOnly();
-	textureStore( writeNDTex, uintCoord, finalNormalDepth ).toWriteOnly();
-	textureStore( writeAlbedoTex, uintCoord, vec4( finalAlbedo, 1.0 ) ).toWriteOnly();
-
-};

package/src/managers/TileManager.js

@@ -1,298 +0,0 @@
-/**
- * TileManager.js
- * Handles all tile-based rendering logic including tile bounds calculation,
- * spiral order generation, and tile bounds calculation.
- */
-
-export class TileManager {
-
-	constructor( width, height, tiles ) {
-
-		this.width = width;
-		this.height = height;
-		this.tiles = tiles;
-		this.tileIndex = 0;
-
-		// Performance caches
-		this.tileBoundsCache = new Map();
-		this.totalTilesCache = tiles * tiles;
-
-		// Tile rendering state
-		this.currentTileBounds = null;
-
-		// Generate initial spiral order
-		this.spiralOrder = this.generateSpiralOrder( tiles );
-
-	}
-
-	/**
-     * Calculate the scissor bounds for a given tile
-     * @param {number} tileIndex - The index of the tile
-     * @param {number} totalTiles - Total number of tiles per row/column
-     * @param {number} width - Render target width
-     * @param {number} height - Render target height
-     * @returns {Object} - Scissor bounds {x, y, width, height}
-     */
-	calculateTileBounds( tileIndex, totalTiles, width, height ) {
-
-		// Use cache to avoid recalculation
-		const cacheKey = `${tileIndex}-${totalTiles}-${width}-${height}`;
-		if ( this.tileBoundsCache.has( cacheKey ) ) {
-
-			return this.tileBoundsCache.get( cacheKey );
-
-		}
-
-		// Calculate tile size using ceiling division to ensure all pixels are covered
-		const tileWidth = Math.ceil( width / totalTiles );
-		const tileHeight = Math.ceil( height / totalTiles );
-
-		// Calculate tile coordinates
-		const tileX = tileIndex % totalTiles;
-		const tileY = Math.floor( tileIndex / totalTiles );
-
-		// Calculate pixel bounds
-		const x = tileX * tileWidth;
-		const y = tileY * tileHeight;
-
-		// Clamp to actual render target bounds
-		const clampedWidth = Math.min( tileWidth, width - x );
-		const clampedHeight = Math.min( tileHeight, height - y );
-
-		const bounds = {
-			x: x,
-			y: y,
-			width: clampedWidth,
-			height: clampedHeight
-		};
-
-		// Cache the result
-		this.tileBoundsCache.set( cacheKey, bounds );
-		return bounds;
-
-	}
-
-	/**
-     * Set up scissor testing for tile rendering
-     * @param {Object} renderer - The Three.js renderer
-     * @param {Object} bounds - Scissor bounds {x, y, width, height}
-     */
-
-	/**
-     * Generate spiral order for tile rendering (center-out pattern)
-     * @param {number} tiles - Number of tiles per row/column
-     * @returns {Array<number>} - Array of tile indices in spiral order
-     */
-	generateSpiralOrder( tiles ) {
-
-		const totalTiles = tiles * tiles;
-		const tilePositions = [];
-
-		// Create array of tile positions with their distances from center
-		for ( let i = 0; i < totalTiles; i ++ ) {
-
-			const x = i % tiles;
-			const y = Math.floor( i / tiles );
-
-			// Improved distance calculation for better ordering with any tile count
-			const center = ( tiles - 1 ) / 2;
-			const dx = x - center;
-			const dy = y - center;
-
-			// Use Manhattan distance as primary sort key for more predictable ordering
-			const manhattanDistance = Math.abs( dx ) + Math.abs( dy );
-
-			// Use Euclidean distance as secondary sort key for smooth transitions
-			const euclideanDistance = Math.sqrt( dx * dx + dy * dy );
-
-			// Calculate angle with better precision for spiral ordering
-			let angle = Math.atan( dy, dx );
-			// Normalize angle to 0-2π range
-			if ( angle < 0 ) angle += 2 * Math.PI;
-
-			// Add small offset based on position to ensure deterministic ordering
-			const positionOffset = ( x + y * tiles ) * 0.001;
-
-			tilePositions.push( {
-				index: i,
-				x,
-				y,
-				manhattanDistance,
-				euclideanDistance,
-				angle,
-				positionOffset
-			} );
-
-		}
-
-		// Improved sorting: Manhattan distance first, then Euclidean, then angle
-		tilePositions.sort( ( a, b ) => {
-
-			// Primary: Manhattan distance (creates more predictable rings)
-			const manhattanDiff = a.manhattanDistance - b.manhattanDistance;
-			if ( Math.abs( manhattanDiff ) > 0.01 ) {
-
-				return manhattanDiff;
-
-			}
-
-			// Secondary: Euclidean distance (smooth transitions within rings)
-			const euclideanDiff = a.euclideanDistance - b.euclideanDistance;
-			if ( Math.abs( euclideanDiff ) > 0.01 ) {
-
-				return euclideanDiff;
-
-			}
-
-			// Tertiary: Angle for spiral effect within same distance
-			const angleDiff = a.angle - b.angle;
-			if ( Math.abs( angleDiff ) > 0.01 ) {
-
-				return angleDiff;
-
-			}
-
-			// Final: Position offset for deterministic ordering
-			return a.positionOffset - b.positionOffset;
-
-		} );
-
-		return tilePositions.map( pos => pos.index );
-
-	}
-
-	/**
-     * Handle tile rendering logic for a given frame and render mode
-     * @param {Object} renderer - The Three.js renderer
-     * @param {number} renderMode - Current render mode (0 = full, 1 = tiled)
-     * @param {number} frameValue - Current frame number
-     * @returns {Object} - Tile rendering info {tileIndex, tileBounds, shouldSwapTargets, isCompleteCycle}
-     */
-	handleTileRendering( renderer, renderMode, frameValue ) {
-
-		let shouldSwapTargets = true;
-		let currentTileIndex = - 1;
-		let tileBounds = null;
-		let isCompleteCycle = true;
-
-		if ( renderMode === 1 ) {
-
-			if ( frameValue === 0 ) {
-
-				currentTileIndex = - 1;
-				isCompleteCycle = true;
-
-			} else {
-
-				const linearTileIndex = ( frameValue - 1 ) % this.totalTilesCache;
-				currentTileIndex = this.spiralOrder[ linearTileIndex ];
-				tileBounds = this.calculateTileBounds( currentTileIndex, this.tiles, this.width, this.height );
-				isCompleteCycle = ( linearTileIndex === this.totalTilesCache - 1 );
-				shouldSwapTargets = isCompleteCycle;
-
-			}
-
-		} else {
-
-			currentTileIndex = - 1;
-			isCompleteCycle = true;
-
-		}
-
-		this.tileIndex = currentTileIndex;
-
-		return {
-			tileIndex: currentTileIndex,
-			tileBounds,
-			shouldSwapTargets,
-			isCompleteCycle
-		};
-
-	}
-
-	/**
-     * Set the number of tiles and regenerate order
-     * @param {number} newTileCount - New tile count per row/column
-     */
-	setTileCount( newTileCount ) {
-
-		// Validate tile count and provide warnings
-		if ( newTileCount < 1 ) {
-
-			console.warn( 'TileManager: Tile count must be at least 1, clamping to 1' );
-			newTileCount = 1;
-
-		}
-
-		if ( newTileCount > 10 ) {
-
-			console.warn( 'TileManager: Tile count > 10 may cause performance issues' );
-
-		}
-
-		if ( newTileCount > 6 ) {
-
-			const totalTiles = newTileCount * newTileCount;
-			console.warn( `TileManager: ${newTileCount}x${newTileCount} = ${totalTiles} tiles may impact performance and memory usage` );
-
-		}
-
-
-		this.tiles = newTileCount;
-		this.totalTilesCache = newTileCount * newTileCount;
-		this.tileIndex = 0;
-		this.spiralOrder = this.generateSpiralOrder( newTileCount );
-		this.tileBoundsCache.clear(); // Clear cache when tile count changes
-
-	}
-
-	/**
-     * Update dimensions when render target size changes
-     * @param {number} width - New width
-     * @param {number} height - New height
-     */
-	setSize( width, height ) {
-
-		this.width = width;
-		this.height = height;
-		this.tileBoundsCache.clear(); // Clear cache when size changes
-
-	}
-
-	/**
-     * Calculate completion threshold for tiled rendering
-     * @param {number} maxFrames - Maximum frames to render
-     * @returns {number} - Total frames needed for completion
-     */
-	calculateCompletionThreshold( maxFrames ) {
-
-		return this.totalTilesCache * maxFrames;
-
-	}
-
-	/**
-     * Get current tile information
-     * @returns {Object} - Current tile state
-     */
-	getCurrentTileInfo() {
-
-		return {
-			tileIndex: this.tileIndex,
-			tiles: this.tiles,
-			totalTiles: this.totalTilesCache,
-			currentBounds: this.currentTileBounds
-		};
-
-	}
-
-	/**
-     * Clean up resources
-     */
-	dispose() {
-
-		this.tileBoundsCache.clear();
-		this.currentTileBounds = null;
-
-	}
-
-}