@xtctwins/tctwins-core 1.0.33 → 1.0.34

package/dist/tctwins-core.es.js

@@ -7339,8 +7339,8 @@ const utils = {
 
 const scenesRenderInfo = {}; // Used for throttling FPS for each Scene
 const sceneIDMap = new Map$1(); // Ensures unique scene IDs
-const taskQueue = new Queue(); // Task queue, which is pumped on each frame; tasks are pushed to it with calls to xeokit.schedule
-const tickEvent = {sceneId: null, time: null, startTime: null, prevTime: null, deltaTime: null};
+const taskQueue = new Queue(); // Task queue, which is pumped on each frame; tasks are pushed to it with calls to tctwins.schedule
+const tickEvent = { sceneId: null, time: null, startTime: null, prevTime: null, deltaTime: null };
 const taskBudget = 10; // Millisecs we're allowed to spend on tasks in each frame
 const fpsSamples = [];
 const numFPSSamples = 30;
@@ -7349,119 +7349,121 @@ let lastTime = 0;
 let elapsedTime;
 let totalFPS = 0;
 
-
 /**
  * @private
  */
 function Core() {
-
-    /**
+	/**
      Semantic version number. The value for this is set by an expression that's concatenated to
-     the end of the built binary by the xeokit build script.
+     the end of the built binary by the tctwins build script.
      @property version
-     @namespace xeokit
+     @namespace tctwins
      @type {String}
      */
-    this.version = "1.0.0";
+	this.version = "1.0.0";
 
-    /**
+	/**
      Existing {@link Scene}s , mapped to their IDs
      @property scenes
-     @namespace xeokit
+     @namespace tctwins
      @type {Scene}
      */
-    this.scenes = {};
+	this.scenes = {};
 
-    this._superTypes = {}; // For each component type, a list of its supertypes, ordered upwards in the hierarchy.
+	this._superTypes = {}; // For each component type, a list of its supertypes, ordered upwards in the hierarchy.
 
-    /**
-     * Registers a scene on xeokit.
-     * This is called within the xeokit.Scene constructor.
-     * @private
-     */
-    this._addScene = function (scene) {
-        if (scene.id) { // User-supplied ID
-            if (core.scenes[scene.id]) {
-                console.error(`[ERROR] Scene ${utils.inQuotes(scene.id)} already exists`);
-                return;
-            }
-        } else { // Auto-generated ID
-            scene.id = sceneIDMap.addItem({});
-        }
-        core.scenes[scene.id] = scene;
-        const ticksPerOcclusionTest = scene.ticksPerOcclusionTest;
-        const ticksPerRender = scene.ticksPerRender;
-        scenesRenderInfo[scene.id] = {
-            ticksPerOcclusionTest: ticksPerOcclusionTest,
-            ticksPerRender: ticksPerRender,
-            renderCountdown: ticksPerRender
-        };
-        stats.components.scenes++;
-        scene.once("destroyed", () => { // Unregister destroyed scenes
-            sceneIDMap.removeItem(scene.id);
-            delete core.scenes[scene.id];
-            delete scenesRenderInfo[scene.id];
-            stats.components.scenes--;
-        });
-    };
+	/**
+	 * Registers a scene on tctwins.
+	 * This is called within the tctwins.Scene constructor.
+	 * @private
+	 */
+	this._addScene = function (scene) {
+		if (scene.id) {
+			// User-supplied ID
+			if (core.scenes[scene.id]) {
+				console.error(`[ERROR] Scene ${utils.inQuotes(scene.id)} already exists`);
+				return;
+			}
+		} else {
+			// Auto-generated ID
+			scene.id = sceneIDMap.addItem({});
+		}
+		core.scenes[scene.id] = scene;
+		const ticksPerOcclusionTest = scene.ticksPerOcclusionTest;
+		const ticksPerRender = scene.ticksPerRender;
+		scenesRenderInfo[scene.id] = {
+			ticksPerOcclusionTest: ticksPerOcclusionTest,
+			ticksPerRender: ticksPerRender,
+			renderCountdown: ticksPerRender
+		};
+		stats.components.scenes++;
+		scene.once("destroyed", () => {
+			// Unregister destroyed scenes
+			sceneIDMap.removeItem(scene.id);
+			delete core.scenes[scene.id];
+			delete scenesRenderInfo[scene.id];
+			stats.components.scenes--;
+		});
+	};
 
-    /**
-     * @private
-     */
-    this.clear = function () {
-        let scene;
-        for (const id in core.scenes) {
-            if (core.scenes.hasOwnProperty(id)) {
-                scene = core.scenes[id];
-                // Only clear the default Scene
-                // but destroy all the others
-                if (id === "default.scene") {
-                    scene.clear();
-                } else {
-                    scene.destroy();
-                    delete core.scenes[scene.id];
-                }
-            }
-        }
-    };
+	/**
+	 * @private
+	 */
+	this.clear = function () {
+		let scene;
+		for (const id in core.scenes) {
+			if (core.scenes.hasOwnProperty(id)) {
+				scene = core.scenes[id];
+				// Only clear the default Scene
+				// but destroy all the others
+				if (id === "default.scene") {
+					scene.clear();
+				} else {
+					scene.destroy();
+					delete core.scenes[scene.id];
+				}
+			}
+		}
+	};
 
-    /**
-     * Schedule a task to run at the next frame.
-     *
-     * Internally, this pushes the task to a FIFO queue. Within each frame interval, xeokit processes the queue
-     * for a certain period of time, popping tasks and running them. After each frame interval, tasks that did not
-     * get a chance to run during the task are left in the queue to be run next time.
-     *
-     * @param {Function} callback Callback that runs the task.
-     * @param {Object} [scope] Scope for the callback.
-     */
-    this.scheduleTask = function (callback, scope = null) {
-        taskQueue.push(callback);
-        taskQueue.push(scope);
-    };
+	/**
+	 * Schedule a task to run at the next frame.
+	 *
+	 * Internally, this pushes the task to a FIFO queue. Within each frame interval, tctwins processes the queue
+	 * for a certain period of time, popping tasks and running them. After each frame interval, tasks that did not
+	 * get a chance to run during the task are left in the queue to be run next time.
+	 *
+	 * @param {Function} callback Callback that runs the task.
+	 * @param {Object} [scope] Scope for the callback.
+	 */
+	this.scheduleTask = function (callback, scope = null) {
+		taskQueue.push(callback);
+		taskQueue.push(scope);
+	};
 
-    this.runTasks = function (until = -1) { // Pops and processes tasks in the queue, until the given number of milliseconds has elapsed.
-        let time = (new Date()).getTime();
-        let callback;
-        let scope;
-        let tasksRun = 0;
-        while (taskQueue.length > 0 && (until < 0 || time < until)) {
-            callback = taskQueue.shift();
-            scope = taskQueue.shift();
-            if (scope) {
-                callback.call(scope);
-            } else {
-                callback();
-            }
-            time = (new Date()).getTime();
-            tasksRun++;
-        }
-        return tasksRun;
-    };
+	this.runTasks = function (until = -1) {
+		// Pops and processes tasks in the queue, until the given number of milliseconds has elapsed.
+		let time = new Date().getTime();
+		let callback;
+		let scope;
+		let tasksRun = 0;
+		while (taskQueue.length > 0 && (until < 0 || time < until)) {
+			callback = taskQueue.shift();
+			scope = taskQueue.shift();
+			if (scope) {
+				callback.call(scope);
+			} else {
+				callback();
+			}
+			time = new Date().getTime();
+			tasksRun++;
+		}
+		return tasksRun;
+	};
 
-    this.getNumTasks = function () {
-        return taskQueue.length;
-    };
+	this.getNumTasks = function () {
+		return taskQueue.length;
+	};
 }
 
 /**
@@ -7471,132 +7473,137 @@ function Core() {
 const core = new Core();
 
 const frame = function () {
-    let time = Date.now();
-    elapsedTime = time - lastTime;
-    if (lastTime > 0 && elapsedTime > 0) { // Log FPS stats
-        var newFPS = 1000 / elapsedTime; // Moving average of FPS
-        totalFPS += newFPS;
-        fpsSamples.push(newFPS);
-        if (fpsSamples.length >= numFPSSamples) {
-            totalFPS -= fpsSamples.shift();
-        }
-        stats.frame.fps = Math.round(totalFPS / fpsSamples.length);
-    }
-    for (let id in core.scenes) {
-        core.scenes[id].compile();
-    }
-    runTasks(time);
-    lastTime = time;
+	let time = Date.now();
+	elapsedTime = time - lastTime;
+	if (lastTime > 0 && elapsedTime > 0) {
+		// Log FPS stats
+		var newFPS = 1000 / elapsedTime; // Moving average of FPS
+		totalFPS += newFPS;
+		fpsSamples.push(newFPS);
+		if (fpsSamples.length >= numFPSSamples) {
+			totalFPS -= fpsSamples.shift();
+		}
+		stats.frame.fps = Math.round(totalFPS / fpsSamples.length);
+	}
+	for (let id in core.scenes) {
+		core.scenes[id].compile();
+	}
+	runTasks(time);
+	lastTime = time;
 };
 
 class WorkerInterval {
-    worker = null;
+	worker = null;
 
-    constructor(callback, interval) {
-        const blob = new Blob([`setInterval(() => postMessage(0), ${interval});`]);
-        const workerScript = URL.createObjectURL(blob);
-        this.worker = new Worker(workerScript);
-        this.worker.onmessage = callback;
-    }
+	constructor(callback, interval) {
+		const blob = new Blob([`setInterval(() => postMessage(0), ${interval});`]);
+		const workerScript = URL.createObjectURL(blob);
+		this.worker = new Worker(workerScript);
+		this.worker.onmessage = callback;
+	}
 
-    stop() {
-        this.worker.terminate();
-    }
+	stop() {
+		this.worker.terminate();
+	}
 }
 
 new WorkerInterval(frame, 100);
 
 const renderFrame = function () {
-    let time = Date.now();
-    elapsedTime = time - lastTime;
-    if (lastTime > 0 && elapsedTime > 0) { // Log FPS stats
-        var newFPS = 1000 / elapsedTime; // Moving average of FPS
-        totalFPS += newFPS;
-        fpsSamples.push(newFPS);
-        if (fpsSamples.length >= numFPSSamples) {
-            totalFPS -= fpsSamples.shift();
-        }
-        stats.frame.fps = Math.round(totalFPS / fpsSamples.length);
-    }
-    runTasks(time);
-    fireTickEvents(time);
-    renderScenes();
-    (window.requestPostAnimationFrame !== undefined) ? window.requestPostAnimationFrame(frame) : requestAnimationFrame(renderFrame);
+	let time = Date.now();
+	elapsedTime = time - lastTime;
+	if (lastTime > 0 && elapsedTime > 0) {
+		// Log FPS stats
+		var newFPS = 1000 / elapsedTime; // Moving average of FPS
+		totalFPS += newFPS;
+		fpsSamples.push(newFPS);
+		if (fpsSamples.length >= numFPSSamples) {
+			totalFPS -= fpsSamples.shift();
+		}
+		stats.frame.fps = Math.round(totalFPS / fpsSamples.length);
+	}
+	runTasks(time);
+	fireTickEvents(time);
+	renderScenes();
+	window.requestPostAnimationFrame !== undefined
+		? window.requestPostAnimationFrame(frame)
+		: requestAnimationFrame(renderFrame);
 };
 
 renderFrame();
 
-function runTasks(time) { // Process as many enqueued tasks as we can within the per-frame task budget
-    const tasksRun = core.runTasks(time + taskBudget);
-    const tasksScheduled = core.getNumTasks();
-    stats.frame.tasksRun = tasksRun;
-    stats.frame.tasksScheduled = tasksScheduled;
-    stats.frame.tasksBudget = taskBudget;
+function runTasks(time) {
+	// Process as many enqueued tasks as we can within the per-frame task budget
+	const tasksRun = core.runTasks(time + taskBudget);
+	const tasksScheduled = core.getNumTasks();
+	stats.frame.tasksRun = tasksRun;
+	stats.frame.tasksScheduled = tasksScheduled;
+	stats.frame.tasksBudget = taskBudget;
 }
 
-function fireTickEvents(time) { // Fire tick event on each Scene
-    tickEvent.time = time;
-    for (var id in core.scenes) {
-        if (core.scenes.hasOwnProperty(id)) {
-            var scene = core.scenes[id];
-            tickEvent.sceneId = id;
-            tickEvent.startTime = scene.startTime;
-            tickEvent.deltaTime = tickEvent.prevTime != null ? tickEvent.time - tickEvent.prevTime : 0;
-            /**
-             * Fired on each game loop iteration.
-             *
-             * @event tick
-             * @param {String} sceneID The ID of this Scene.
-             * @param {Number} startTime The time in seconds since 1970 that this Scene was instantiated.
-             * @param {Number} time The time in seconds since 1970 of this "tick" event.
-             * @param {Number} prevTime The time of the previous "tick" event from this Scene.
-             * @param {Number} deltaTime The time in seconds since the previous "tick" event from this Scene.
-             */
-            scene.fire("tick", tickEvent, true);
-        }
-    }
-    tickEvent.prevTime = time;
+function fireTickEvents(time) {
+	// Fire tick event on each Scene
+	tickEvent.time = time;
+	for (var id in core.scenes) {
+		if (core.scenes.hasOwnProperty(id)) {
+			var scene = core.scenes[id];
+			tickEvent.sceneId = id;
+			tickEvent.startTime = scene.startTime;
+			tickEvent.deltaTime = tickEvent.prevTime != null ? tickEvent.time - tickEvent.prevTime : 0;
+			/**
+			 * Fired on each game loop iteration.
+			 *
+			 * @event tick
+			 * @param {String} sceneID The ID of this Scene.
+			 * @param {Number} startTime The time in seconds since 1970 that this Scene was instantiated.
+			 * @param {Number} time The time in seconds since 1970 of this "tick" event.
+			 * @param {Number} prevTime The time of the previous "tick" event from this Scene.
+			 * @param {Number} deltaTime The time in seconds since the previous "tick" event from this Scene.
+			 */
+			scene.fire("tick", tickEvent, true);
+		}
+	}
+	tickEvent.prevTime = time;
 }
 
 function renderScenes() {
-    const scenes = core.scenes;
-    const forceRender = false;
-    let scene;
-    let renderInfo;
-    let ticksPerOcclusionTest;
-    let ticksPerRender;
-    let id;
-    for (id in scenes) {
-        if (scenes.hasOwnProperty(id)) {
-
-            scene = scenes[id];
-            renderInfo = scenesRenderInfo[id];
-
-            if (!renderInfo) {
-                renderInfo = scenesRenderInfo[id] = {}; // FIXME
-            }
+	const scenes = core.scenes;
+	const forceRender = false;
+	let scene;
+	let renderInfo;
+	let ticksPerOcclusionTest;
+	let ticksPerRender;
+	let id;
+	for (id in scenes) {
+		if (scenes.hasOwnProperty(id)) {
+			scene = scenes[id];
+			renderInfo = scenesRenderInfo[id];
+
+			if (!renderInfo) {
+				renderInfo = scenesRenderInfo[id] = {}; // FIXME
+			}
 
-            ticksPerOcclusionTest = scene.ticksPerOcclusionTest;
-            if (renderInfo.ticksPerOcclusionTest !== ticksPerOcclusionTest) {
-                renderInfo.ticksPerOcclusionTest = ticksPerOcclusionTest;
-                renderInfo.renderCountdown = ticksPerOcclusionTest;
-            }
-            if (--scene.occlusionTestCountdown <= 0) {
-                scene.doOcclusionTest();
-                scene.occlusionTestCountdown = ticksPerOcclusionTest;
-            }
+			ticksPerOcclusionTest = scene.ticksPerOcclusionTest;
+			if (renderInfo.ticksPerOcclusionTest !== ticksPerOcclusionTest) {
+				renderInfo.ticksPerOcclusionTest = ticksPerOcclusionTest;
+				renderInfo.renderCountdown = ticksPerOcclusionTest;
+			}
+			if (--scene.occlusionTestCountdown <= 0) {
+				scene.doOcclusionTest();
+				scene.occlusionTestCountdown = ticksPerOcclusionTest;
+			}
 
-            ticksPerRender = scene.ticksPerRender;
-            if (renderInfo.ticksPerRender !== ticksPerRender) {
-                renderInfo.ticksPerRender = ticksPerRender;
-                renderInfo.renderCountdown = ticksPerRender;
-            }
-            if (--renderInfo.renderCountdown === 0) {
-                scene.render(forceRender);
-                renderInfo.renderCountdown = ticksPerRender;
-            }
-        }
-    }
+			ticksPerRender = scene.ticksPerRender;
+			if (renderInfo.ticksPerRender !== ticksPerRender) {
+				renderInfo.ticksPerRender = ticksPerRender;
+				renderInfo.renderCountdown = ticksPerRender;
+			}
+			if (--renderInfo.renderCountdown === 0) {
+				scene.render(forceRender);
+				renderInfo.renderCountdown = ticksPerRender;
+			}
+		}
+	}
 }
 
 /**
@@ -18401,7 +18408,7 @@ class SAOOcclusionRenderer {
     }
 }
 
-const blurStdDev = 4;
+const blurStdDev = 10;
 const blurDepthCutoff = 0.01;
 const KERNEL_RADIUS = 16;
 
@@ -18416,49 +18423,45 @@ const tempVec2a$1 = new Float32Array(2);
  * @private
  */
 class SAODepthLimitedBlurRenderer {
+	constructor(scene) {
+		this._scene = scene;
 
-    constructor(scene) {
+		// The program
 
-        this._scene = scene;
+		this._program = null;
+		this._programError = false;
 
-        // The program
+		// Variable locations
 
-        this._program = null;
-        this._programError = false;
+		this._aPosition = null;
+		this._aUV = null;
 
-        // Variable locations
+		this._uDepthTexture = "uDepthTexture";
+		this._uOcclusionTexture = "uOcclusionTexture";
 
-        this._aPosition = null;
-        this._aUV = null;
+		this._uViewport = null;
+		this._uCameraNear = null;
+		this._uCameraFar = null;
+		this._uCameraProjectionMatrix = null;
+		this._uCameraInverseProjectionMatrix = null;
 
-        this._uDepthTexture = "uDepthTexture";
-        this._uOcclusionTexture = "uOcclusionTexture";
+		// VBOs
 
-        this._uViewport = null;
-        this._uCameraNear = null;
-        this._uCameraFar = null;
-        this._uCameraProjectionMatrix = null;
-        this._uCameraInverseProjectionMatrix = null;
+		this._uvBuf = null;
+		this._positionsBuf = null;
+		this._indicesBuf = null;
 
-        // VBOs
-
-        this._uvBuf = null;
-        this._positionsBuf = null;
-        this._indicesBuf = null;
-
-        this.init();
-    }
-
-    init() {
-
-        // Create program & VBOs, locate attributes and uniforms
+		this.init();
+	}
 
-        const gl = this._scene.canvas.gl;
+	init() {
+		// Create program & VBOs, locate attributes and uniforms
 
-        this._program = new Program(gl, {
+		const gl = this._scene.canvas.gl;
 
-            vertex: [
-                `#version 300 es
+		this._program = new Program(gl, {
+			vertex: [
+				`#version 300 es
                 precision highp float;
                 precision highp int;
                     
@@ -18471,10 +18474,11 @@ class SAODepthLimitedBlurRenderer {
                     vUV = aUV;
                     vInvSize = 1.0 / uViewport;
                     gl_Position = vec4(aPosition, 1.0);
-                }`],
+                }`
+			],
 
-            fragment: [
-                `#version 300 es
+			fragment: [
+				`#version 300 es
                 precision highp float;
                 precision highp int;
                     
@@ -18588,135 +18592,137 @@ class SAODepthLimitedBlurRenderer {
 
                     outColor = packFloatToRGBA(occlusionSum / weightSum);
                 }`
-            ]
-        });
+			]
+		});
 
-        if (this._program.errors) {
-            console.error(this._program.errors.join("\n"));
-            this._programError = true;
-            return;
-        }
+		if (this._program.errors) {
+			console.error(this._program.errors.join("\n"));
+			this._programError = true;
+			return;
+		}
 
-        const uv = new Float32Array([1, 1, 0, 1, 0, 0, 1, 0]);
-        const positions = new Float32Array([1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0]);
+		const uv = new Float32Array([1, 1, 0, 1, 0, 0, 1, 0]);
+		const positions = new Float32Array([1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0]);
 
-        // Mitigation: if Uint8Array is used, the geometry is corrupted on OSX when using Chrome with data-textures
-        const indices = new Uint32Array([0, 1, 2, 0, 2, 3]);
+		// Mitigation: if Uint8Array is used, the geometry is corrupted on OSX when using Chrome with data-textures
+		const indices = new Uint32Array([0, 1, 2, 0, 2, 3]);
 
-        this._positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, positions, positions.length, 3, gl.STATIC_DRAW);
-        this._uvBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, uv, uv.length, 2, gl.STATIC_DRAW);
-        this._indicesBuf = new ArrayBuf(gl, gl.ELEMENT_ARRAY_BUFFER, indices, indices.length, 1, gl.STATIC_DRAW);
+		this._positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, positions, positions.length, 3, gl.STATIC_DRAW);
+		this._uvBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, uv, uv.length, 2, gl.STATIC_DRAW);
+		this._indicesBuf = new ArrayBuf(gl, gl.ELEMENT_ARRAY_BUFFER, indices, indices.length, 1, gl.STATIC_DRAW);
 
-        this._program.bind();
+		this._program.bind();
 
-        this._uViewport = this._program.getLocation("uViewport");
+		this._uViewport = this._program.getLocation("uViewport");
 
-        this._uCameraNear = this._program.getLocation("uCameraNear");
-        this._uCameraFar = this._program.getLocation("uCameraFar");
-
-        this._uDepthCutoff = this._program.getLocation("uDepthCutoff");
+		this._uCameraNear = this._program.getLocation("uCameraNear");
+		this._uCameraFar = this._program.getLocation("uCameraFar");
 
-        this._uSampleOffsets = gl.getUniformLocation(this._program.handle, "uSampleOffsets");
-        this._uSampleWeights = gl.getUniformLocation(this._program.handle, "uSampleWeights");
+		this._uDepthCutoff = this._program.getLocation("uDepthCutoff");
 
-        this._aPosition = this._program.getAttribute("aPosition");
-        this._aUV = this._program.getAttribute("aUV");
-    }
+		this._uSampleOffsets = gl.getUniformLocation(this._program.handle, "uSampleOffsets");
+		this._uSampleWeights = gl.getUniformLocation(this._program.handle, "uSampleWeights");
 
-    render(depthRenderBuffer, occlusionRenderBuffer, direction) {
+		this._aPosition = this._program.getAttribute("aPosition");
+		this._aUV = this._program.getAttribute("aUV");
+	}
 
-        if (this._programError) {
-            return;
-        }
+	render(depthRenderBuffer, occlusionRenderBuffer, direction) {
+		if (this._programError) {
+			return;
+		}
 
-        if (!this._getInverseProjectMat) { // HACK: scene.camera not defined until render time
-            this._getInverseProjectMat = (() => {
-                let projMatDirty = true;
-                this._scene.camera.on("projMatrix", function () {
-                    projMatDirty = true;
-                });
-                const inverseProjectMat = math.mat4();
-                return () => {
-                    if (projMatDirty) {
-                        math.inverseMat4(scene.camera.projMatrix, inverseProjectMat);
-                    }
-                    return inverseProjectMat;
-                }
-            })();
-        }
+		if (!this._getInverseProjectMat) {
+			// HACK: scene.camera not defined until render time
+			this._getInverseProjectMat = (() => {
+				let projMatDirty = true;
+				this._scene.camera.on("projMatrix", function () {
+					projMatDirty = true;
+				});
+				const inverseProjectMat = math.mat4();
+				return () => {
+					if (projMatDirty) {
+						math.inverseMat4(scene.camera.projMatrix, inverseProjectMat);
+					}
+					return inverseProjectMat;
+				};
+			})();
+		}
 
-        const gl = this._scene.canvas.gl;
-        const program = this._program;
-        const scene = this._scene;
-        const viewportWidth = gl.drawingBufferWidth;
-        const viewportHeight = gl.drawingBufferHeight;
-        const projectState = scene.camera.project._state;
-        const near = projectState.near;
-        const far = projectState.far;
+		const gl = this._scene.canvas.gl;
+		const program = this._program;
+		const scene = this._scene;
+		const viewportWidth = gl.drawingBufferWidth;
+		const viewportHeight = gl.drawingBufferHeight;
+		const projectState = scene.camera.project._state;
+		const near = projectState.near;
+		const far = projectState.far;
 
-        gl.viewport(0, 0, viewportWidth, viewportHeight);
-        gl.clearColor(0, 0, 0, 1);
-        gl.enable(gl.DEPTH_TEST);
-        gl.disable(gl.BLEND);
-        gl.frontFace(gl.CCW);
-        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+		gl.viewport(0, 0, viewportWidth, viewportHeight);
+		gl.clearColor(0, 0, 0, 1);
+		gl.enable(gl.DEPTH_TEST);
+		gl.disable(gl.BLEND);
+		gl.frontFace(gl.CCW);
+		gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
-        program.bind();
+		program.bind();
 
-        tempVec2a$1[0] = viewportWidth;
-        tempVec2a$1[1] = viewportHeight;
+		tempVec2a$1[0] = viewportWidth;
+		tempVec2a$1[1] = viewportHeight;
 
-        gl.uniform2fv(this._uViewport, tempVec2a$1);
-        gl.uniform1f(this._uCameraNear, near);
-        gl.uniform1f(this._uCameraFar, far);
+		gl.uniform2fv(this._uViewport, tempVec2a$1);
+		gl.uniform1f(this._uCameraNear, near);
+		gl.uniform1f(this._uCameraFar, far);
 
-        gl.uniform1f(this._uDepthCutoff, blurDepthCutoff);
+		gl.uniform1f(this._uDepthCutoff, blurDepthCutoff);
 
-        if (direction === 0) {// Horizontal
-            gl.uniform2fv(this._uSampleOffsets, sampleOffsetsHor);
-        } else { // Vertical
-            gl.uniform2fv(this._uSampleOffsets, sampleOffsetsVert);
-        }
+		if (direction === 0) {
+			// Horizontal
+			gl.uniform2fv(this._uSampleOffsets, sampleOffsetsHor);
+		} else {
+			// Vertical
+			gl.uniform2fv(this._uSampleOffsets, sampleOffsetsVert);
+		}
 
-        gl.uniform1fv(this._uSampleWeights, sampleWeights);
+		gl.uniform1fv(this._uSampleWeights, sampleWeights);
 
-        const depthTexture = depthRenderBuffer.getDepthTexture();
-        const occlusionTexture = occlusionRenderBuffer.getTexture();
+		const depthTexture = depthRenderBuffer.getDepthTexture();
+		const occlusionTexture = occlusionRenderBuffer.getTexture();
 
-        program.bindTexture(this._uDepthTexture, depthTexture, 0); // TODO: use FrameCtx.textureUnit
-        program.bindTexture(this._uOcclusionTexture, occlusionTexture, 1);
+		program.bindTexture(this._uDepthTexture, depthTexture, 0); // TODO: use FrameCtx.textureUnit
+		program.bindTexture(this._uOcclusionTexture, occlusionTexture, 1);
 
-        this._aUV.bindArrayBuffer(this._uvBuf);
-        this._aPosition.bindArrayBuffer(this._positionsBuf);
-        this._indicesBuf.bind();
+		this._aUV.bindArrayBuffer(this._uvBuf);
+		this._aPosition.bindArrayBuffer(this._positionsBuf);
+		this._indicesBuf.bind();
 
-        gl.drawElements(gl.TRIANGLES, this._indicesBuf.numItems, this._indicesBuf.itemType, 0);
-    }
+		gl.drawElements(gl.TRIANGLES, this._indicesBuf.numItems, this._indicesBuf.itemType, 0);
+	}
 
-    destroy() {
-        this._program.destroy();
-    }
+	destroy() {
+		this._program.destroy();
+	}
 }
 
 function createSampleWeights(kernelRadius, stdDev) {
-    const weights = [];
-    for (let i = 0; i <= kernelRadius; i++) {
-        weights.push(gaussian(i, stdDev));
-    }
-    return weights; // TODO: Optimize
+	const weights = [];
+	for (let i = 0; i <= kernelRadius; i++) {
+		weights.push(gaussian(i, stdDev));
+	}
+	return weights; // TODO: Optimize
 }
 
 function gaussian(x, stdDev) {
-    return Math.exp(-(x * x) / (2.0 * (stdDev * stdDev))) / (Math.sqrt(2.0 * Math.PI) * stdDev);
+	return Math.exp(-(x * x) / (2.0 * (stdDev * stdDev))) / (Math.sqrt(2.0 * Math.PI) * stdDev);
 }
 
 function createSampleOffsets(kernelRadius, uvIncrement) {
-    const offsets = [];
-    for (let i = 0; i <= kernelRadius; i++) {
-        offsets.push(uvIncrement[0] * i);
-        offsets.push(uvIncrement[1] * i);
-    }
-    return offsets;
+	const offsets = [];
+	for (let i = 0; i <= kernelRadius; i++) {
+		offsets.push(uvIncrement[0] * i);
+		offsets.push(uvIncrement[1] * i);
+	}
+	return offsets;
 }
 
 /**
@@ -30283,7 +30289,8 @@ class Scene extends Component {
 			contextAttr: cfg.contextAttr || {},
 			backgroundColor: cfg.backgroundColor,
 			backgroundColorFromAmbientLight: cfg.backgroundColorFromAmbientLight,
-			premultipliedAlpha: cfg.premultipliedAlpha
+			premultipliedAlpha: cfg.premultipliedAlpha,
+			resolutionScale: cfg.resolutionScale
 		});
 
 		this.canvas.on("boundary", () => {
@@ -30291,7 +30298,7 @@ class Scene extends Component {
 		});
 
 		this.canvas.on("webglContextFailed", () => {
-			alert("xeokit failed to find WebGL!");
+			alert("tctwins failed to find WebGL!");
 		});
 
 		this._renderer = new Renderer$1(this, {
@@ -108662,7 +108669,8 @@ class Viewer {
 			dtxEnabled: !!cfg.dtxEnabled,
 			edgesEnabled: cfg.edgesEnabled,
 			numCachedSectionPlanes: cfg.numCachedSectionPlanes,
-			lodEnabled: !!cfg.lodEnabled
+			lodEnabled: !!cfg.lodEnabled,
+			resolutionScale: cfg.resolutionScale
 		});
 
 		/**
@@ -134695,18 +134703,18 @@ class XTCLoaderPlugin extends Plugin {
 	// }
 }
 
-function getBaseDirectory(filePath) {
-	const pathArray = filePath.split("/");
-	pathArray.pop(); // Remove the file name or the last segment of the path
-	return pathArray.join("/") + "/";
-}
 function createInlineWorker() {
 	const workerCode = `
         self.importScripts('https://cdnjs.cloudflare.com/ajax/libs/pako/1.0.11/pako.min.js');
         
         function inflateMetadata(deflatedData) {
-            return JSON.parse(self.pako.inflate(deflatedData, { to: "string" }));
-        }
+			try {
+				return JSON.parse(self.pako.inflate(deflatedData, { to: "string" }));
+			} catch (error) {
+				console.error("Error inflating metadata:", error);
+				throw error;
+			}        
+		}
         
         self.onmessage = function (e) {
             console.log("start worker:");
@@ -134721,6 +134729,11 @@ function createInlineWorker() {
 	const blob = new Blob([workerCode], { type: "application/javascript" });
 	const workerUrl = URL.createObjectURL(blob);
 	return new Worker(workerUrl);
+}
+function getBaseDirectory(filePath) {
+	const pathArray = filePath.split("/");
+	pathArray.pop(); // Remove the file name or the last segment of the path
+	return pathArray.join("/") + "/";
 }
 
 /*