minerender 2.0.0-alpha.0 → 2.0.0-alpha.1

package/dist/esm/renderer/SceneObject.js

@@ -1,392 +1,392 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { Euler, InstancedMesh, Matrix4, Mesh, Object3D, Quaternion, Vector3 } from "three";
-import { Geometries } from "../Geometries";
-import { UVMapper } from "../UVMapper";
-import { axisToVec3 } from "../Axis";
-import { changeEvent } from "../util/util";
-import { InstanceReference } from "../instance/InstanceReference";
-import { MineRenderError } from "../error/MineRenderError";
-import { isInstancedMesh } from "../util/three";
-import { isDisposable } from "../Disposable";
-import merge from "ts-deepmerge";
-import { prefix } from "../util/log";
-const p = prefix("SceneObject");
-export class SceneObject extends Object3D {
-    constructor(options) {
-        super();
-        this.isSceneObject = true;
-        this.materialCallbacks = {};
-        this._isInstanced = false;
-        this._instanceCounter = 0;
-        this.options = merge({}, SceneObject.DEFAULT_OPTIONS, options !== null && options !== void 0 ? options : {});
-    }
-    set scene(scene) {
-        if (!!this._scene)
-            throw new MineRenderError("Scene already set");
-        this._scene = scene;
-    }
-    get scene() {
-        if (!this._scene)
-            throw new MineRenderError("Scene not set");
-        return this._scene;
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-        });
-    }
-    notifyDirty() {
-        this.dispatchEvent(changeEvent);
-    }
-    //<editor-fold desc="GROUPS">
-    createAndAddGroup(name, x = 0, y = 0, z = 0, offsetAxis, offset = 0) {
-        const group = this.createGroup(name, x, y, z, offsetAxis, offset);
-        this.add(group);
-        this.notifyDirty();
-        return group;
-    }
-    createGroup(name, x = 0, y = 0, z = 0, offsetAxis, offset = 0) {
-        const obj = new Object3D();
-        if (name) {
-            obj.name = `group:${name}`;
-        }
-        if (x > 0 || y > 0 || z > 0) {
-            obj.position.set(x, y, z);
-        }
-        if (offsetAxis) {
-            obj.translateOnAxis(axisToVec3(offsetAxis), offset);
-        }
-        return obj;
-    }
-    /**
-     * Get a group by its name
-     */
-    getGroupByName(name) {
-        return this.getObjectByName(`group:${name}`);
-    }
-    /**
-     * Toggle visibility of a group
-     * @param name name of the group
-     * @param visible set the visibility directly, if not set toggles it
-     */
-    toggleGroupVisibility(name, visible) {
-        return this.toggleObjectVisibility(this.getGroupByName(name), visible);
-    }
-    //</editor-fold>
-    //<editor-fold desc="MESHES">
-    createAndAddMesh(name, group, geometry, material, offsetAxis, offset = 0) {
-        const mesh = this.createMesh(name, geometry, material, offsetAxis, offset);
-        if (group) {
-            group.add(mesh);
-        }
-        else {
-            this.add(mesh);
-        }
-        this.notifyDirty();
-        return mesh;
-    }
-    createMesh(name, geometry, material, offsetAxis, offset = 0) {
-        const mesh = new Mesh(geometry, material);
-        if (name) {
-            mesh.name = `mesh:${name}`;
-        }
-        //TODO
-        mesh.castShadow = true;
-        mesh.receiveShadow = true;
-        if (offsetAxis) {
-            mesh.translateOnAxis(axisToVec3(offsetAxis), offset);
-        }
-        return mesh;
-    }
-    createInstancedMesh(name, geometry, material, count) {
-        const mesh = new InstancedMesh(geometry, material, count);
-        if (name) {
-            mesh.name = `mesh:${name}`;
-        }
-        return mesh;
-    }
-    /**
-     * Get a mesh by its name
-     */
-    getMeshByName(name) {
-        return this.getObjectByName(`mesh:${name}`);
-    }
-    /**
-     * Toggle visibility of a mesh
-     * @param name name of the mesh
-     * @param visible set the visibility directly, if not set toggles it
-     */
-    toggleMeshVisibility(name, visible) {
-        return this.toggleObjectVisibility(this.getMeshByName(name), visible);
-    }
-    iterateAllMeshes(cb) {
-        this.children.forEach(obj => {
-            if (obj.isMesh) {
-                cb(obj);
-            }
-            obj.children.forEach(obj1 => {
-                if (obj1.isMesh) {
-                    cb(obj1);
-                }
-            });
-        });
-    }
-    //</editor-fold>
-    //<editor-fold desc="GEOMETRIES">
-    _getBoxGeometryFromDimensions([width, height, depth], faces, originalTextureSize, actualTextureSize) {
-        const uv = UVMapper.facesToUvArray(faces, originalTextureSize, actualTextureSize);
-        return Geometries.getBox({
-            width,
-            height,
-            depth,
-            uv
-        });
-    }
-    _getBoxGeometryFromElement(element) {
-        const width = element.to[0] - element.from[0];
-        const height = element.to[1] - element.from[1];
-        const depth = element.to[2] - element.from[2];
-        const uv = element.mappedUv;
-        return Geometries.getBox({
-            width,
-            height,
-            depth,
-            uv
-        });
-    }
-    _getBoxGeometryForDimensionsAndUv(width, height, depth, uv) {
-        return Geometries.getBox({
-            width,
-            height,
-            depth,
-            uv
-        });
-    }
-    //</editor-fold>
-    //<editor-fold desc="INSTANCING">
-    get isInstanced() {
-        return this._isInstanced;
-    }
-    get instanceCounter() {
-        return this._instanceCounter;
-    }
-    constructInstanceReference(i) {
-        return new InstanceReference(this, i);
-    }
-    nextInstance() {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        const i = this._instanceCounter++;
-        this.setMatrixAt(i, new Matrix4());
-        console.debug(p, "nextInstance " + i);
-        if (i === this.options.maxInstanceCount) {
-            console.warn(p, "Max instance count reached for " + this);
-        }
-        if (this.scene) {
-            this.scene.stats.instanceCount++;
-        }
-        this.notifyDirty();
-        return this.constructInstanceReference(i);
-    }
-    //</editor-fold>
-    //<editor-fold desc="TRANSFORMATION">
-    getMatrixAt(index, matrix = new Matrix4()) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        const child = this.children[0];
-        if (child && isInstancedMesh(child)) { //TODO: figure out why child isn't set
-            child.getMatrixAt(index, matrix);
-        }
-        return matrix;
-    }
-    setMatrixAt(index, matrix) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        const child = this.children[0];
-        if (child && isInstancedMesh(child)) { //TODO: figure out why child isn't set
-            child.setMatrixAt(index, matrix);
-            child.instanceMatrix.needsUpdate = true;
-        }
-        this.notifyDirty();
-    }
-    setPositionRotationScaleAt(index, position, rotation, scale) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        const oldPosition = new Vector3();
-        const oldRotation = new Quaternion();
-        const oldScale = new Vector3();
-        const matrix = new Matrix4();
-        if (!scale || !rotation || !position) {
-            this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
-        }
-        matrix.compose(position ? position : oldPosition, rotation ? new Quaternion().setFromEuler(rotation) : oldRotation, scale ? scale : oldScale);
-        this.setMatrixAt(index, matrix);
-    }
-    setPositionAt(index, position) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        this.setPositionRotationScaleAt(index, position);
-    }
-    getPositionAt(index, vector = new Vector3()) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        const matrix = this.getMatrixAt(index);
-        vector.setFromMatrixPosition(matrix);
-        return vector;
-    }
-    setRotationAt(index, rotation) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        this.setPositionRotationScaleAt(index, undefined, rotation, undefined);
-    }
-    getRotationAt(index, euler = new Euler()) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        const matrix = this.getMatrixAt(index);
-        euler.setFromRotationMatrix(matrix);
-        return euler;
-    }
-    setScaleAt(index, scale) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        this.setPositionRotationScaleAt(index, undefined, undefined, scale);
-    }
-    getScaleAt(index, vector = new Vector3()) {
-        if (!this.isInstanced)
-            throw new MineRenderError("Object is not instanced");
-        const matrix = this.getMatrixAt(index);
-        vector.setFromMatrixScale(matrix);
-        return vector;
-    }
-    setPositionRotationScale(position, rotation, scale) {
-        if (this.isInstanced) {
-            //TODO: specific instance
-            for (let i = 0; i < this.instanceCounter; i++) {
-                this.setPositionRotationScaleAt(i, position, rotation, scale);
-            }
-        }
-        else {
-            if (position) {
-                this.position.set(position.x, position.y, position.z);
-            }
-            if (rotation) {
-                this.rotation.set(rotation.x, rotation.y, rotation.z);
-            }
-            if (scale) {
-                this.scale.set(scale.x, scale.y, scale.z);
-            }
-        }
-        this.notifyDirty();
-    }
-    setPosition(position) {
-        if (this.isInstanced) {
-            //TODO: specific instance
-            for (let i = 0; i < this.instanceCounter; i++) {
-                this.setPositionRotationScaleAt(i, position);
-            }
-        }
-        else {
-            this.position.set(position.x, position.y, position.z);
-        }
-        this.notifyDirty();
-    }
-    getPosition() {
-        if (this.isInstanced) {
-            return this.getPositionAt(0);
-        }
-        else {
-            return this.position;
-        }
-    }
-    setRotation(rotation) {
-        if (this.isInstanced) {
-            //TODO: specific instance
-            for (let i = 0; i < this.instanceCounter; i++) {
-                this.setPositionRotationScaleAt(i, undefined, rotation);
-            }
-        }
-        else {
-            this.rotation.set(rotation.x, rotation.y, rotation.z);
-        }
-        this.notifyDirty();
-    }
-    getRotation() {
-        if (this.isInstanced) {
-            return this.getRotationAt(0);
-        }
-        else {
-            return this.rotation;
-        }
-    }
-    setScale(scale) {
-        if (this.isInstanced) {
-            //TODO: specific instance
-            for (let i = 0; i < this.instanceCounter; i++) {
-                this.setPositionRotationScaleAt(i, undefined, undefined, scale);
-            }
-        }
-        else {
-            this.scale.set(scale.x, scale.y, scale.z);
-        }
-        this.notifyDirty();
-    }
-    getScale() {
-        if (this.isInstanced) {
-            return this.getScaleAt(0);
-        }
-        else {
-            return this.scale;
-        }
-    }
-    //</editor-fold>
-    toggleObjectVisibility(object, visible) {
-        if (object) {
-            if (typeof visible !== "undefined") {
-                object.visible = visible;
-            }
-            else {
-                object.visible = !object.visible;
-            }
-            return object.visible;
-        }
-        this.notifyDirty();
-        return false;
-    }
-    //<editor-fold desc="CLEANUP">
-    dispose() {
-        this.disposeAndRemoveAllChildren();
-        this.notifyDirty();
-    }
-    disposeAndRemoveAllChildren() {
-        while (this.children.length > 0) {
-            let c = this.children[0];
-            if (isDisposable(c)) {
-                c.dispose();
-            }
-            this.remove(c);
-        }
-        this.notifyDirty();
-    }
-    removeFromScene() {
-        var _a;
-        (_a = this._scene) === null || _a === void 0 ? void 0 : _a.remove(this);
-        this.notifyDirty();
-    }
-}
-SceneObject.DEFAULT_OPTIONS = merge({}, {
-    instanceMeshes: true,
-    maxInstanceCount: 50,
-    mergeMeshes: true,
-    wireframe: false
-});
-export function isSceneObject(obj) {
-    return obj.isSceneObject;
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Euler, InstancedMesh, Matrix4, Mesh, Object3D, Quaternion, Vector3 } from "three";
+import { Geometries } from "../Geometries";
+import { UVMapper } from "../UVMapper";
+import { axisToVec3 } from "../Axis";
+import { changeEvent } from "../util/util";
+import { InstanceReference } from "../instance/InstanceReference";
+import { MineRenderError } from "../error/MineRenderError";
+import { isInstancedMesh } from "../util/three";
+import { isDisposable } from "../Disposable";
+import merge from "ts-deepmerge";
+import { prefix } from "../util/log";
+const p = prefix("SceneObject");
+export class SceneObject extends Object3D {
+    constructor(options) {
+        super();
+        this.isSceneObject = true;
+        this.materialCallbacks = {};
+        this._isInstanced = false;
+        this._instanceCounter = 0;
+        this.options = merge({}, SceneObject.DEFAULT_OPTIONS, options !== null && options !== void 0 ? options : {});
+    }
+    set scene(scene) {
+        if (!!this._scene)
+            throw new MineRenderError("Scene already set");
+        this._scene = scene;
+    }
+    get scene() {
+        if (!this._scene)
+            throw new MineRenderError("Scene not set");
+        return this._scene;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    notifyDirty() {
+        this.dispatchEvent(changeEvent);
+    }
+    //<editor-fold desc="GROUPS">
+    createAndAddGroup(name, x = 0, y = 0, z = 0, offsetAxis, offset = 0) {
+        const group = this.createGroup(name, x, y, z, offsetAxis, offset);
+        this.add(group);
+        this.notifyDirty();
+        return group;
+    }
+    createGroup(name, x = 0, y = 0, z = 0, offsetAxis, offset = 0) {
+        const obj = new Object3D();
+        if (name) {
+            obj.name = `group:${name}`;
+        }
+        if (x > 0 || y > 0 || z > 0) {
+            obj.position.set(x, y, z);
+        }
+        if (offsetAxis) {
+            obj.translateOnAxis(axisToVec3(offsetAxis), offset);
+        }
+        return obj;
+    }
+    /**
+     * Get a group by its name
+     */
+    getGroupByName(name) {
+        return this.getObjectByName(`group:${name}`);
+    }
+    /**
+     * Toggle visibility of a group
+     * @param name name of the group
+     * @param visible set the visibility directly, if not set toggles it
+     */
+    toggleGroupVisibility(name, visible) {
+        return this.toggleObjectVisibility(this.getGroupByName(name), visible);
+    }
+    //</editor-fold>
+    //<editor-fold desc="MESHES">
+    createAndAddMesh(name, group, geometry, material, offsetAxis, offset = 0) {
+        const mesh = this.createMesh(name, geometry, material, offsetAxis, offset);
+        if (group) {
+            group.add(mesh);
+        }
+        else {
+            this.add(mesh);
+        }
+        this.notifyDirty();
+        return mesh;
+    }
+    createMesh(name, geometry, material, offsetAxis, offset = 0) {
+        const mesh = new Mesh(geometry, material);
+        if (name) {
+            mesh.name = `mesh:${name}`;
+        }
+        //TODO
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        if (offsetAxis) {
+            mesh.translateOnAxis(axisToVec3(offsetAxis), offset);
+        }
+        return mesh;
+    }
+    createInstancedMesh(name, geometry, material, count) {
+        const mesh = new InstancedMesh(geometry, material, count);
+        if (name) {
+            mesh.name = `mesh:${name}`;
+        }
+        return mesh;
+    }
+    /**
+     * Get a mesh by its name
+     */
+    getMeshByName(name) {
+        return this.getObjectByName(`mesh:${name}`);
+    }
+    /**
+     * Toggle visibility of a mesh
+     * @param name name of the mesh
+     * @param visible set the visibility directly, if not set toggles it
+     */
+    toggleMeshVisibility(name, visible) {
+        return this.toggleObjectVisibility(this.getMeshByName(name), visible);
+    }
+    iterateAllMeshes(cb) {
+        this.children.forEach(obj => {
+            if (obj.isMesh) {
+                cb(obj);
+            }
+            obj.children.forEach(obj1 => {
+                if (obj1.isMesh) {
+                    cb(obj1);
+                }
+            });
+        });
+    }
+    //</editor-fold>
+    //<editor-fold desc="GEOMETRIES">
+    _getBoxGeometryFromDimensions([width, height, depth], faces, originalTextureSize, actualTextureSize) {
+        const uv = UVMapper.facesToUvArray(faces, originalTextureSize, actualTextureSize);
+        return Geometries.getBox({
+            width,
+            height,
+            depth,
+            uv
+        });
+    }
+    _getBoxGeometryFromElement(element) {
+        const width = element.to[0] - element.from[0];
+        const height = element.to[1] - element.from[1];
+        const depth = element.to[2] - element.from[2];
+        const uv = element.mappedUv;
+        return Geometries.getBox({
+            width,
+            height,
+            depth,
+            uv
+        });
+    }
+    _getBoxGeometryForDimensionsAndUv(width, height, depth, uv) {
+        return Geometries.getBox({
+            width,
+            height,
+            depth,
+            uv
+        });
+    }
+    //</editor-fold>
+    //<editor-fold desc="INSTANCING">
+    get isInstanced() {
+        return this._isInstanced;
+    }
+    get instanceCounter() {
+        return this._instanceCounter;
+    }
+    constructInstanceReference(i) {
+        return new InstanceReference(this, i);
+    }
+    nextInstance() {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        const i = this._instanceCounter++;
+        this.setMatrixAt(i, new Matrix4());
+        console.debug(p, "nextInstance " + i);
+        if (i === this.options.maxInstanceCount) {
+            console.warn(p, "Max instance count reached for " + this);
+        }
+        if (this.scene) {
+            this.scene.stats.instanceCount++;
+        }
+        this.notifyDirty();
+        return this.constructInstanceReference(i);
+    }
+    //</editor-fold>
+    //<editor-fold desc="TRANSFORMATION">
+    getMatrixAt(index, matrix = new Matrix4()) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        const child = this.children[0];
+        if (child && isInstancedMesh(child)) { //TODO: figure out why child isn't set
+            child.getMatrixAt(index, matrix);
+        }
+        return matrix;
+    }
+    setMatrixAt(index, matrix) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        const child = this.children[0];
+        if (child && isInstancedMesh(child)) { //TODO: figure out why child isn't set
+            child.setMatrixAt(index, matrix);
+            child.instanceMatrix.needsUpdate = true;
+        }
+        this.notifyDirty();
+    }
+    setPositionRotationScaleAt(index, position, rotation, scale) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        const oldPosition = new Vector3();
+        const oldRotation = new Quaternion();
+        const oldScale = new Vector3();
+        const matrix = new Matrix4();
+        if (!scale || !rotation || !position) {
+            this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
+        }
+        matrix.compose(position ? position : oldPosition, rotation ? new Quaternion().setFromEuler(rotation) : oldRotation, scale ? scale : oldScale);
+        this.setMatrixAt(index, matrix);
+    }
+    setPositionAt(index, position) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        this.setPositionRotationScaleAt(index, position);
+    }
+    getPositionAt(index, vector = new Vector3()) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        const matrix = this.getMatrixAt(index);
+        vector.setFromMatrixPosition(matrix);
+        return vector;
+    }
+    setRotationAt(index, rotation) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        this.setPositionRotationScaleAt(index, undefined, rotation, undefined);
+    }
+    getRotationAt(index, euler = new Euler()) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        const matrix = this.getMatrixAt(index);
+        euler.setFromRotationMatrix(matrix);
+        return euler;
+    }
+    setScaleAt(index, scale) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        this.setPositionRotationScaleAt(index, undefined, undefined, scale);
+    }
+    getScaleAt(index, vector = new Vector3()) {
+        if (!this.isInstanced)
+            throw new MineRenderError("Object is not instanced");
+        const matrix = this.getMatrixAt(index);
+        vector.setFromMatrixScale(matrix);
+        return vector;
+    }
+    setPositionRotationScale(position, rotation, scale) {
+        if (this.isInstanced) {
+            //TODO: specific instance
+            for (let i = 0; i < this.instanceCounter; i++) {
+                this.setPositionRotationScaleAt(i, position, rotation, scale);
+            }
+        }
+        else {
+            if (position) {
+                this.position.set(position.x, position.y, position.z);
+            }
+            if (rotation) {
+                this.rotation.set(rotation.x, rotation.y, rotation.z);
+            }
+            if (scale) {
+                this.scale.set(scale.x, scale.y, scale.z);
+            }
+        }
+        this.notifyDirty();
+    }
+    setPosition(position) {
+        if (this.isInstanced) {
+            //TODO: specific instance
+            for (let i = 0; i < this.instanceCounter; i++) {
+                this.setPositionRotationScaleAt(i, position);
+            }
+        }
+        else {
+            this.position.set(position.x, position.y, position.z);
+        }
+        this.notifyDirty();
+    }
+    getPosition() {
+        if (this.isInstanced) {
+            return this.getPositionAt(0);
+        }
+        else {
+            return this.position;
+        }
+    }
+    setRotation(rotation) {
+        if (this.isInstanced) {
+            //TODO: specific instance
+            for (let i = 0; i < this.instanceCounter; i++) {
+                this.setPositionRotationScaleAt(i, undefined, rotation);
+            }
+        }
+        else {
+            this.rotation.set(rotation.x, rotation.y, rotation.z);
+        }
+        this.notifyDirty();
+    }
+    getRotation() {
+        if (this.isInstanced) {
+            return this.getRotationAt(0);
+        }
+        else {
+            return this.rotation;
+        }
+    }
+    setScale(scale) {
+        if (this.isInstanced) {
+            //TODO: specific instance
+            for (let i = 0; i < this.instanceCounter; i++) {
+                this.setPositionRotationScaleAt(i, undefined, undefined, scale);
+            }
+        }
+        else {
+            this.scale.set(scale.x, scale.y, scale.z);
+        }
+        this.notifyDirty();
+    }
+    getScale() {
+        if (this.isInstanced) {
+            return this.getScaleAt(0);
+        }
+        else {
+            return this.scale;
+        }
+    }
+    //</editor-fold>
+    toggleObjectVisibility(object, visible) {
+        if (object) {
+            if (typeof visible !== "undefined") {
+                object.visible = visible;
+            }
+            else {
+                object.visible = !object.visible;
+            }
+            return object.visible;
+        }
+        this.notifyDirty();
+        return false;
+    }
+    //<editor-fold desc="CLEANUP">
+    dispose() {
+        this.disposeAndRemoveAllChildren();
+        this.notifyDirty();
+    }
+    disposeAndRemoveAllChildren() {
+        while (this.children.length > 0) {
+            let c = this.children[0];
+            if (isDisposable(c)) {
+                c.dispose();
+            }
+            this.remove(c);
+        }
+        this.notifyDirty();
+    }
+    removeFromScene() {
+        var _a;
+        (_a = this._scene) === null || _a === void 0 ? void 0 : _a.remove(this);
+        this.notifyDirty();
+    }
+}
+SceneObject.DEFAULT_OPTIONS = merge({}, {
+    instanceMeshes: true,
+    maxInstanceCount: 50,
+    mergeMeshes: true,
+    wireframe: false
+});
+export function isSceneObject(obj) {
+    return obj.isSceneObject;
+}
 //# sourceMappingURL=SceneObject.js.map