@bldrs-ai/conway 0.17.852 → 0.17.882

package/compiled/src/rendering/threejs/scene_object.js

@@ -0,0 +1,623 @@
+import { Group, BatchedMesh, Matrix4, BufferGeometry, BufferAttribute, InterleavedBufferAttribute, InterleavedBuffer, MeshPhysicalMaterial, FrontSide, DoubleSide, LinearSRGBColorSpace, Vector4, Vector3, } from 'three';
+import { SceneListenerOptions } from '../../core/scene';
+import { defaultCanonicalMaterial } from '../../core/canonical_material';
+import Logger from '../../logging/logger';
+import { BlendMode } from '../../../dependencies/conway-geom';
+const COMPONENT_TRANSLATION_THRESHOLD = 1024;
+const identity = new Matrix4();
+const eventListenerOptions = new SceneListenerOptions(true, false, true);
+/**
+ * A three proxy for a conway scene of a model.
+ */
+export default class SceneObject extends Group {
+    /**
+     * Does this have instances that aren't spaces?
+     */
+    get hasNonSpaces() {
+        return this.sink_.hasNonSpaces;
+    }
+    /**
+     * Should the spaces of this object be shown?
+     *
+     * @return {boolean} Whether spaces are shown.
+     */
+    get showSpaces() {
+        return this.sink_.showSpaces;
+    }
+    /**
+     * Should spaces of this object be shown?
+     *
+     * @param value The value to set (default is false)
+     */
+    set showSpaces(value) {
+        this.sink_.showSpaces = value;
+    }
+    /**
+     * Should non-space elements of this be hidden.
+     *
+     * @return {boolean} True if non-spaces are hidden.
+     */
+    get hideNonSpaces() {
+        return this.sink_.hideNonSpaces;
+    }
+    /**
+     * Should non-space elements of this be hidden.
+     *
+     * @param value The value to set (default is false)
+     */
+    set hideNonSpaces(value) {
+        this.sink_.hideNonSpaces = value;
+    }
+    /**
+     * Get the reference point for this in absolute space.
+     *
+     * Note that this should be used like an RTC reference to
+     * calculate relative transforms in a high bit space or using fixed
+     * point to produce an eye relative transform matrix.
+     *
+     * @return {Vector3} The reference point.
+     */
+    get referencePoint() {
+        return this.sink_.referencePoint;
+    }
+    /**
+     * Construct this from a conway scene.
+     *
+     * @param target The target scene to use.
+     * @param cork Should this start corked/not creating geometry batches (defaults to true),
+     * call uncork to create geometry on a corked sink.
+     */
+    constructor(target, cork = true) {
+        super();
+        this.target = target;
+        this.sink_ = new SceneEventSink(this, target, cork);
+        target.addSceneListener(this.sink_, eventListenerOptions);
+    }
+    /**
+     * Uncork the scene to batch add the geometry
+     */
+    uncork() {
+        this.sink_.uncork();
+    }
+    /**
+     * Dispose this and remove its scene elements
+     */
+    dispose() {
+        this.target.removeSceneListener(this.sink_);
+    }
+}
+const normalizeMat = new Matrix4(1, 0, 0, 0, // First column
+0, 0, -1, 0, // Second column
+0, 1, 0, 0, // Third column
+0, 0, 0, 1);
+const invertNormalizeMat = normalizeMat.clone().transpose();
+/**
+ * Sink for receiving events from a target scene
+ */
+class SceneEventSink {
+    /**
+     * Reconcile space visibility.
+     */
+    reconcileSpaces() {
+        const onlySpaces = this.nonSpaceCount_ === 0;
+        for (const [node, instance] of this.instances_.entries()) {
+            const batch = instance.batch;
+            const batched = instance.batched;
+            if (batch === void 0 ||
+                batched === void 0 ||
+                batched.geometryID === void 0 ||
+                instance.instanceID === void 0) {
+                continue;
+            }
+            const batchMesh = batch.mesh;
+            const isVisible = (!node.isSpace && !this.hideNonSpaces_) ||
+                (node.isSpace && (onlySpaces || this.showSpaces_));
+            batchMesh.setVisibleAt(instance.instanceID, isVisible);
+        }
+    }
+    /**
+     * Does this have instances that aren't spaces?
+     */
+    get hasNonSpaces() {
+        return this.nonSpaceCount_ > 0;
+    }
+    /**
+     * Should the spaces of this object be shown?
+     *
+     * @return {boolean} Whether spaces are shown.
+     */
+    get showSpaces() {
+        return this.showSpaces_;
+    }
+    /**
+     * Should spaces of this object be shown?
+     *
+     * @param value The value to set (default is false)
+     */
+    set showSpaces(value) {
+        if (this.showSpaces_ !== value) {
+            this.showSpaces_ = value;
+            this.reconcileSpaces();
+        }
+    }
+    /**
+     * Should non-space elements of this be hidden.
+     *
+     * @return {boolean} True if non-spaces are hidden.
+     */
+    get hideNonSpaces() {
+        return this.hideNonSpaces_;
+    }
+    /**
+     * Should non-space elements of this be hidden.
+     *
+     * @param value The value to set (default is false)
+     */
+    set hideNonSpaces(value) {
+        if (this.hideNonSpaces_ !== value) {
+            this.hideNonSpaces_ = value;
+            this.reconcileSpaces();
+        }
+    }
+    /**
+     * Get the reference point for this in absolute space.
+     *
+     * Note that this should be used like an RTC reference to
+     * calculate relative transforms in a high bit space or using fixed
+     * point to produce an eye relative transform matrix.
+     *
+     * @return {Vector3} The reference point.
+     */
+    get referencePoint() {
+        const firstAbsolutePoint = this.firstAbsolutePoint_;
+        if (firstAbsolutePoint === void 0) {
+            return new Vector3(0, 0, 0);
+        }
+        return new Vector3(firstAbsolutePoint.x, firstAbsolutePoint.y, firstAbsolutePoint.z);
+    }
+    /**
+     * Construct this with the group items will be attached to.
+     *
+     * @param group The group this will be attached to.
+     * @param scene The scene this comes from.
+     * @param cork_ Should this start corked (defaults to true), meaning
+     * geometry wont be added to batches. To add geometry to batches on a
+     * corkerd scene object, call "uncork".
+     */
+    constructor(group, scene, cork_ = true) {
+        this.group = group;
+        this.scene = scene;
+        this.cork_ = cork_;
+        this.materialMap_ = new Map();
+        this.instances_ = new Map();
+        this.meshes_ = new Map();
+        this.nonSpaceCount_ = 0;
+        this.showSpaces_ = false;
+        this.hideNonSpaces_ = false;
+    }
+    /**
+     * Uncork this event handler, processing all geometry into batches at once.
+     *
+     * Use this during initial non-progressive load to speed up batching.
+     *
+     * During progressive load, the cork_ parameter of the constructor should be
+     * set to "false" and this doesn't need to be called (although, calling it is
+     * idempotent).
+     */
+    uncork() {
+        if (!this.cork_) {
+            return;
+        }
+        this.cork_ = false;
+        const onlySpaces = this.nonSpaceCount_ === 0;
+        for (const batch of this.materialMap_.values()) {
+            const batchMesh = new BatchedMesh(batch.instanceCount, batch.vertexCount, batch.indexCount, batch.threeMaterial);
+            this.group.add(batchMesh);
+            if (batch.material.blend === BlendMode.OPAQUE && batch.material.baseColor[3] === 1) {
+                batchMesh.castShadow = true;
+            }
+            batchMesh.receiveShadow = true;
+            batch.mesh = batchMesh;
+            for (const batchGeometry of batch.geometryMap.values()) {
+                try {
+                    batchGeometry.geometryID = batchMesh.addGeometry(batchGeometry.meshItem.geometry);
+                }
+                catch (e) {
+                    Logger.error(`Error adding geometry item: ${e?.message}`);
+                }
+            }
+        }
+        for (const [node, instance] of this.instances_.entries()) {
+            const batch = instance.batch;
+            const batched = instance.batched;
+            if (batch === void 0 || batched === void 0 || batched.geometryID === void 0) {
+                continue;
+            }
+            const batchMesh = batch.mesh;
+            instance.instanceID = batchMesh.addInstance(batched.geometryID);
+            const isVisible = (!node.isSpace && !this.hideNonSpaces_) ||
+                (node.isSpace && (onlySpaces || this.showSpaces_));
+            batchMesh.setVisibleAt(instance.instanceID, isVisible);
+            batchMesh.setMatrixAt(instance.instanceID, instance.transform);
+        }
+    }
+    /**
+     * Get the mesh cache item for a particular mesh buffer.
+     *
+     * @param from The mesh buffer to get the cached item for.
+     * @return {MeshCacheItem} The cached items.
+     */
+    getMeshItem(from) {
+        let cacheItem = this.meshes_.get(from);
+        /** Get a cached buffer item for this */
+        if (cacheItem === void 0) {
+            const geometry = new BufferGeometry();
+            const conwayGeometry = this.scene.conwayGeometry;
+            const fromGeometry = from.geometry;
+            const readFirstPoint = from.geometry.getPoint(0);
+            const maxAbsComponent = Math.max(Math.abs(readFirstPoint.x), Math.abs(readFirstPoint.y), Math.abs(readFirstPoint.z));
+            let reificationOffset;
+            let reificationOffsetMatrix;
+            // If the first point is far from the origin, reify the geometry
+            if (maxAbsComponent > COMPONENT_TRANSLATION_THRESHOLD) {
+                reificationOffset = readFirstPoint;
+                fromGeometry.reify(reificationOffset);
+                reificationOffsetMatrix =
+                    new Matrix4().makeTranslation(readFirstPoint.x, readFirstPoint.y, readFirstPoint.z);
+            }
+            const vertexBuffer = conwayGeometry.floatHeapSlice(fromGeometry.GetVertexData(), fromGeometry.GetVertexDataSize());
+            const interleavedBuffer = new InterleavedBuffer(vertexBuffer, 6);
+            geometry.setIndex(new BufferAttribute(conwayGeometry.uint32HeapSlice(fromGeometry.GetIndexData(), fromGeometry.GetIndexDataSize()), 1));
+            geometry.setAttribute('position', new InterleavedBufferAttribute(interleavedBuffer, 3, 0));
+            geometry.setAttribute('normal', new InterleavedBufferAttribute(interleavedBuffer, 3, 3, true));
+            cacheItem = new MeshCacheItem(from, geometry, reificationOffset, reificationOffsetMatrix);
+            this.meshes_.set(from, cacheItem);
+        }
+        return cacheItem;
+    }
+    /**
+     * Callback when a transform is added (not used)
+     *
+     * @param node
+     */
+    onTransformAdded(node) {
+    }
+    /**
+     * Callback when a transform is uupdated (not used)
+     *
+     * @param node
+     */
+    onTransformUpdated(node) {
+    }
+    /**
+     * Callback when a transform is removed (not used)
+     *
+     * @param node
+     */
+    onTransformRemoved(node) {
+    }
+    /**
+     * Callback when geometry is added, with its matching
+     * transform node (if the geometry is not top level)
+     *
+     * @param node
+     * @param transform
+     */
+    onGeometryAdded(node, transform) {
+        // Note we pass this through because adding and updating are
+        // idempotent and this handled multiple added cases for the same
+        // node.
+        this.onGeometryUpdated(node, transform, true);
+    }
+    /**
+     * Callback when geometry is updated, or its matching
+     * transform node is updated (if the geometry is not top level)
+     *
+     * @param node
+     * @param transform
+     * @param isAdded
+     */
+    onGeometryUpdated(node, transform, isAdded = false) {
+        if (isAdded && !node.isSpace) {
+            if ((this.nonSpaceCount_++) === 0 && !this.cork_) {
+                this.reconcileSpaces();
+            }
+        }
+        const model = node.model;
+        const mesh = model.getMeshFromGeometryNode(node);
+        const materialFromNode = model.getMaterialFromGeometryNode(node);
+        const material = materialFromNode ?? defaultCanonicalMaterial;
+        const transformTuple = transform?.absoluteTransform;
+        let transformMatrix = transformTuple !== void 0 ?
+            new Matrix4(...transformTuple)
+                .transpose()
+                .premultiply(invertNormalizeMat) :
+            invertNormalizeMat.clone();
+        if (this.firstAbsolutePoint_ === void 0 && mesh !== void 0) {
+            const hasVertices = mesh.geometry.getVertexCount() > 0;
+            if (hasVertices) {
+                const readFirstPoint = mesh.geometry.getPoint(0);
+                const firstPointThree = new Vector4(readFirstPoint.x, readFirstPoint.y, readFirstPoint.z, 1);
+                if (transformMatrix !== void 0) {
+                    firstPointThree.applyMatrix4(transformMatrix);
+                }
+                this.firstAbsolutePoint_ = firstPointThree;
+                this.positionNormalization_ =
+                    new Matrix4().makeTranslation(-firstPointThree.x, -firstPointThree.y, -firstPointThree.z);
+            }
+        }
+        if (this.positionNormalization_ !== void 0) {
+            if (transformMatrix === void 0) {
+                transformMatrix = this.positionNormalization_.clone();
+            }
+            else {
+                transformMatrix.premultiply(this.positionNormalization_);
+            }
+        }
+        const instances = this.instances_;
+        let instance = instances.get(node);
+        if (instance === void 0) {
+            instance = new GeometryInstance(node, transformMatrix ?? identity.clone(), void 0, void 0);
+            instances.set(node, instance);
+        }
+        else {
+            instance.transform = transformMatrix ?? identity.clone();
+        }
+        const instanceMaterial = instance.material;
+        const instanceMesh = instance.mesh;
+        instance.material = material;
+        instance.mesh = mesh;
+        const batches = this.materialMap_;
+        if (instanceMaterial !== material) {
+            if (instanceMaterial !== void 0) {
+                const batch = instance.batch;
+                if (batch !== void 0 && instanceMesh !== void 0) {
+                    const geometryItem = instance.batched;
+                    if (geometryItem !== void 0) {
+                        instance.batched = void 0;
+                        const instanceID = instance.instanceID;
+                        const batchMesh = batch.mesh;
+                        if (batchMesh !== void 0 && instanceID !== void 0) {
+                            batchMesh.deleteInstance(instanceID);
+                            if ((--geometryItem.instances) === 0) {
+                                geometryItem.meshItem.batches.delete(batch);
+                                if (geometryItem.geometryID !== void 0) {
+                                    batchMesh.deleteGeometry(geometryItem.geometryID);
+                                }
+                                batch.geometryMap.delete(instanceMesh);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (instanceMesh !== mesh) {
+            const geometryItem = instance.batched;
+            const batch = instance.batch;
+            if (geometryItem !== void 0 && batch !== void 0 && instanceMesh !== void 0) {
+                instance.batched = void 0;
+                const instanceID = instance.instanceID;
+                const batchMesh = batch.mesh;
+                if (batchMesh !== void 0 && instanceID !== void 0) {
+                    batchMesh.deleteInstance(instanceID);
+                    if ((--geometryItem.instances) === 0) {
+                        geometryItem.meshItem.batches.delete(batch);
+                        // For there to be an instance id, the geometry ID must have been set
+                        batchMesh.deleteGeometry(geometryItem.geometryID);
+                        batch.geometryMap.delete(instanceMesh);
+                    }
+                }
+            }
+            if (mesh !== void 0) {
+                instance.geometry = this.getMeshItem(mesh);
+                const reificationOffsetMatrix = instance.geometry.reificationOffsetMatrix;
+                if (reificationOffsetMatrix !== void 0) {
+                    transformMatrix =
+                        transformTuple !== void 0 ?
+                            new Matrix4(...transformTuple)
+                                .transpose()
+                                .premultiply(invertNormalizeMat) :
+                            invertNormalizeMat.clone();
+                    if (this.positionNormalization_ !== void 0) {
+                        transformMatrix.premultiply(this.positionNormalization_);
+                    }
+                    transformMatrix.multiply(reificationOffsetMatrix);
+                    instance.transform = transformMatrix;
+                }
+            }
+            else {
+                instance.geometry = void 0;
+            }
+        }
+        if (mesh !== void 0 &&
+            (instanceMaterial !== material || instanceMesh !== mesh)) {
+            let batch = batches.get(material);
+            if (batch === void 0) {
+                console.log('batch created');
+                const threeMaterial = new MeshPhysicalMaterial();
+                threeMaterial.metalness = material.metalness ?? threeMaterial.metalness;
+                threeMaterial.roughness = material.roughness ?? threeMaterial.roughness;
+                const ior = material.ior;
+                const baseColor = material.baseColor;
+                const materialAlpha = baseColor[3];
+                threeMaterial.side = material.doubleSided ? DoubleSide : FrontSide;
+                if (material.blend !== BlendMode.OPAQUE && materialAlpha < 1.0) {
+                    threeMaterial.transparent = true;
+                    threeMaterial.opacity = materialAlpha;
+                    threeMaterial.premultipliedAlpha = true;
+                    threeMaterial.depthWrite = false;
+                    threeMaterial.side = DoubleSide;
+                }
+                if (ior !== void 0) {
+                    threeMaterial.ior = ior;
+                    const IOR_OF_AIR_AT_STP = 1.000273;
+                    // Assuming reflectivity of index
+                    const reflectivityRoot = (IOR_OF_AIR_AT_STP - ior) / (IOR_OF_AIR_AT_STP + ior);
+                    threeMaterial.reflectivity = reflectivityRoot * reflectivityRoot;
+                }
+                const specular = material.specular;
+                if (specular !== void 0) {
+                    threeMaterial.specularColor.setRGB(specular[0], specular[1], specular[2], LinearSRGBColorSpace);
+                }
+                threeMaterial.color.setRGB(baseColor[0] / baseColor[3], baseColor[1] / baseColor[3], baseColor[2] / baseColor[3], LinearSRGBColorSpace);
+                batch = new MaterialMeshBatch(material, threeMaterial);
+                batches.set(material, batch);
+            }
+            instance.batch = batch;
+            const instanceGeometry = instance.geometry;
+            if (instanceGeometry !== void 0) {
+                let batchMesh = batch.mesh;
+                let batchGeometry = instance.batched ?? batch.geometryMap.get(mesh);
+                const vertexCount = (mesh.geometry.GetVertexDataSize() / 6) | 0;
+                const indexCount = (mesh.geometry.GetIndexDataSize()) | 0;
+                if (this.cork_) {
+                    if (batchGeometry === void 0) {
+                        batchGeometry = new BatchGeometry(mesh, instanceGeometry);
+                        batch.vertexCount += vertexCount;
+                        batch.indexCount += indexCount;
+                        batch.geometryMap.set(mesh, batchGeometry);
+                    }
+                    ++batch.instanceCount;
+                    instance.batched = batchGeometry;
+                    return;
+                }
+                if (batchMesh === void 0) {
+                    batchMesh =
+                        new BatchedMesh(1, vertexCount, indexCount, batch.threeMaterial);
+                    if (batch.material.baseColor[3] < 1) {
+                        batchMesh.castShadow = false;
+                    }
+                    else {
+                        batchMesh.castShadow = true;
+                    }
+                    batchMesh.receiveShadow = true;
+                    this.group.add(batchMesh);
+                    batch.mesh = batchMesh;
+                    batch.vertexCount = vertexCount;
+                    batch.indexCount = indexCount;
+                    const geometryID = batchMesh.addGeometry(instanceGeometry.geometry);
+                    batchGeometry = new BatchGeometry(mesh, instanceGeometry, geometryID);
+                    instance.batched = batchGeometry;
+                    batch.geometryMap.set(mesh, batchGeometry);
+                }
+                else {
+                    batchGeometry = batch.geometryMap.get(mesh);
+                    if (batchGeometry === void 0) {
+                        const newIndexSize = batch.indexCount +
+                            indexCount;
+                        const newVertexSize = batch.vertexCount +
+                            vertexCount;
+                        batch.indexCount = newIndexSize;
+                        batch.vertexCount = newVertexSize;
+                        batchMesh.setGeometrySize(newVertexSize, newIndexSize);
+                        const geometryID = batchMesh.addGeometry(instanceGeometry.geometry);
+                        batchGeometry = new BatchGeometry(mesh, instanceGeometry, geometryID);
+                        instance.batched = batchGeometry;
+                        batch.geometryMap.set(mesh, batchGeometry);
+                    }
+                }
+                if (batchMesh.instanceCount === batchMesh.maxInstanceCount) {
+                    const GROWTH_RATE = 4;
+                    batchMesh.setInstanceCount(batchMesh.maxInstanceCount * GROWTH_RATE);
+                }
+                ++batch.instanceCount;
+                // Geometry id must exist if the batch is uncorked.
+                const instanceID = batchMesh.addInstance(batchGeometry.geometryID);
+                const onlySpaces = this.nonSpaceCount_ === 0;
+                const isVisible = (!node.isSpace && !this.hideNonSpaces_) ||
+                    (node.isSpace && (onlySpaces || this.showSpaces_));
+                batchMesh.setVisibleAt(instanceID, isVisible);
+                instance.instanceID = instanceID;
+            }
+        }
+        if (this.cork_) {
+            return;
+        }
+        if (instance.instanceID !== void 0) {
+            instance.batch?.mesh?.setMatrixAt(instance.instanceID, instance.transform);
+        }
+    }
+    /**
+     * Callback when a geometry node is removed.
+     *
+     * @param node
+     */
+    onGeometryRemoved(node) {
+        // TODO - CS
+    }
+}
+/**
+ * A mesh geometry for a particular material
+ */
+class BatchGeometry {
+    /**
+     *
+     * @param mesh
+     * @param meshItem
+     * @param geometryID
+     */
+    constructor(mesh, meshItem, geometryID) {
+        this.mesh = mesh;
+        this.meshItem = meshItem;
+        this.geometryID = geometryID;
+        /**
+         * The number of instances
+         */
+        this.instances = 0;
+    }
+}
+/**
+ * Batch mesh for a particular material.
+ */
+class MaterialMeshBatch {
+    /**
+     *
+     * @param material The material this corresponds to.
+     * @param threeMaterial
+     */
+    constructor(material, threeMaterial) {
+        this.material = material;
+        this.threeMaterial = threeMaterial;
+        this.geometryMap = new Map();
+        this.vertexCount = 0;
+        this.indexCount = 0;
+        this.instanceCount = 0;
+    }
+}
+/**
+ * Cache item for buffer geometry for a mesh
+ */
+class MeshCacheItem {
+    /**
+     *
+     * @param mesh The mesh for this cache item.
+     * @param geometry The geometry for this cache item
+     * @param reificationOffset The reification offset for this cache item.
+     * @param reificationOffsetMatrix The reification offset matrix for this cache item.
+     */
+    constructor(mesh, geometry, reificationOffset, reificationOffsetMatrix) {
+        this.mesh = mesh;
+        this.geometry = geometry;
+        this.reificationOffset = reificationOffset;
+        this.reificationOffsetMatrix = reificationOffsetMatrix;
+        this.batches = new Set();
+    }
+}
+/**
+ * Index data for a geometry node.
+ */
+class GeometryInstance {
+    /**
+     *
+     * @param node
+     * @param transform
+     * @param mesh
+     * @param material
+     */
+    constructor(node, transform, mesh, material) {
+        this.node = node;
+        this.transform = transform;
+        this.mesh = mesh;
+        this.material = material;
+    }
+}