@heliguy-xyz/splat-viewer 1.0.0-rc.7 → 1.0.0-rc.9

package/dist/web-component/splat-viewer.js

@@ -105357,6 +105357,7 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	                transform,
 	                metadata,
 	                loadStartTime,
+	                visible: true,
 	            };
 	            if (blobUrl !== undefined) {
 	                modelInfo.blobUrl = blobUrl;
@@ -105560,6 +105561,54 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        model.transform = transform;
 	        model.metadata.transform = transform;
 	    }
+	    /**
+	     * Set visibility for a specific model by ID
+	     * @param modelId ID of the model
+	     * @param visible True to show, false to hide
+	     */
+	    setModelVisible(modelId, visible) {
+	        const model = this.models.get(modelId);
+	        if (!model) {
+	            throw new Error(`Model with ID "${modelId}" not found`);
+	        }
+	        // Apply visibility to underlying entity
+	        if (model.entity) {
+	            model.entity.enabled = visible;
+	        }
+	        model.visible = visible;
+	        // Emit model-visibility-changed event
+	        if (this._eventEmitter) {
+	            this._eventEmitter('model-visibility-changed', {
+	                modelId: model.id,
+	                name: model.name,
+	                visible,
+	            });
+	        }
+	    }
+	    /**
+	     * Set visibility for all models matching a given name
+	     * @param name Model name to match (case-sensitive)
+	     * @param visible True to show, false to hide
+	     */
+	    setModelsVisibleByName(name, visible) {
+	        for (const model of this.models.values()) {
+	            if (model.name === name) {
+	                // Apply visibility to entity
+	                if (model.entity) {
+	                    model.entity.enabled = visible;
+	                }
+	                model.visible = visible;
+	                // Emit model-visibility-changed event for each affected model
+	                if (this._eventEmitter) {
+	                    this._eventEmitter('model-visibility-changed', {
+	                        modelId: model.id,
+	                        name: model.name,
+	                        visible,
+	                    });
+	                }
+	            }
+	        }
+	    }
 	}
 
 	// Core type definitions for the Web Component
@@ -139995,6 +140044,9 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        this._sceneConfigManager = null;
 	        // Event system
 	        this._eventListeners = new Map();
+	        // Splat rendering configuration (mirrors key SuperSplat options)
+	        this._splatCenterSize = null;
+	        this._sphericalHarmonicsBands = null;
 	        this.canvas = options.canvas || null;
 	        this.enableStats = options.enableStats || false;
 	        this.autoFocus = options.autoFocus !== false;
@@ -140122,6 +140174,8 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	                    // This ensures the loading spinner stays visible until the model is actually rendered
 	                    return await new Promise(resolve => {
 	                        this.app.once('frameupdate', () => {
+	                            // Apply any pending splat rendering configuration
+	                            this._applySplatRenderingConfigToEntity(result.entity);
 	                            if (this.autoFocus) {
 	                                this.focus(result.entity);
 	                                setTimeout(() => {
@@ -140212,6 +140266,8 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	                // This ensures the loading spinner stays visible until the model is actually rendered
 	                return await new Promise(resolve => {
 	                    this.app.once('frameupdate', () => {
+	                        // Apply any pending splat rendering configuration
+	                        this._applySplatRenderingConfigToEntity(entity);
 	                        if (this.autoFocus) {
 	                            this.focus(entity);
 	                            setTimeout(() => {
@@ -140345,7 +140401,12 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        if (!this._modelManager) {
 	            throw new Error('SplatViewerCore.addModel: ModelManager not initialized');
 	        }
-	        return await this._modelManager.addModel(source, options);
+	        const info = await this._modelManager.addModel(source, options);
+	        // Apply any pending splat rendering configuration to the new model entity
+	        if (info?.entity) {
+	            this._applySplatRenderingConfigToEntity(info.entity);
+	        }
+	        return info;
 	    }
 	    /**
 	     * Remove a specific model from the scene
@@ -140407,6 +140468,194 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        }
 	        return this._modelManager.getSceneStats();
 	    }
+	    /**
+	     * Set fly camera base movement speed (convenience over setFlyCameraConfig)
+	     * @param speed Units per second (must be > 0)
+	     */
+	    setFlyCameraSpeed(speed) {
+	        if (speed <= 0 || !isFinite(speed)) {
+	            console.warn('SplatViewerCore.setFlyCameraSpeed: speed must be > 0');
+	            return;
+	        }
+	        this.setFlyCameraConfig({ moveSpeed: speed });
+	    }
+	    /**
+	     * Get current fly camera base movement speed
+	     * @returns Speed in units per second, or null if fly camera not initialized
+	     */
+	    getFlyCameraSpeed() {
+	        const cfg = this.getFlyCameraConfig();
+	        return cfg ? cfg.moveSpeed : null;
+	    }
+	    /**
+	     * Set visibility for a specific model by ID
+	     * @param modelId ID of the model
+	     * @param visible True to show, false to hide
+	     */
+	    setModelVisible(modelId, visible) {
+	        if (!this._modelManager) {
+	            throw new Error('SplatViewerCore.setModelVisible: ModelManager not initialized');
+	        }
+	        this._modelManager.setModelVisible(modelId, visible);
+	    }
+	    /**
+	     * Set visibility for all models matching a given name
+	     * @param name Model name to match (case-sensitive)
+	     * @param visible True to show, false to hide
+	     */
+	    setModelsVisibleByName(name, visible) {
+	        if (!this._modelManager) {
+	            throw new Error('SplatViewerCore.setModelsVisibleByName: ModelManager not initialized');
+	        }
+	        this._modelManager.setModelsVisibleByName(name, visible);
+	    }
+	    // ==========================================
+	    // Splat Rendering Configuration
+	    // ==========================================
+	    /**
+	     * Set rendered centers size for all splat models.
+	     * This maps onto underlying gsplat / renderer properties when available.
+	     * @param size Positive size value (implementation-specific units)
+	     */
+	    setSplatCenterSize(size) {
+	        if (!isFinite(size) || size <= 0) {
+	            console.warn('SplatViewerCore.setSplatCenterSize: size must be > 0');
+	            return;
+	        }
+	        const previousSize = this._splatCenterSize;
+	        this._splatCenterSize = size;
+	        this._forEachSplatEntity(entity => {
+	            this._applySplatRenderingConfigToEntity(entity);
+	        });
+	        // Emit event for UI integrations
+	        this.emit({
+	            type: 'splat-center-size-changed',
+	            detail: {
+	                size,
+	                previousSize: previousSize ?? size,
+	            },
+	        });
+	    }
+	    /**
+	     * Get current centers size value last set via API.
+	     * Returns null if not configured yet.
+	     */
+	    getSplatCenterSize() {
+	        return this._splatCenterSize;
+	    }
+	    /**
+	     * Set spherical harmonics bands for all splat models.
+	     * @param bands Integer band count (0-3)
+	     */
+	    setSphericalHarmonicsBands(bands) {
+	        if (!isFinite(bands)) {
+	            console.warn('SplatViewerCore.setSphericalHarmonicsBands: bands must be a finite number');
+	            return;
+	        }
+	        const clamped = Math.max(0, Math.min(3, Math.round(bands)));
+	        const previousBands = this._sphericalHarmonicsBands;
+	        this._sphericalHarmonicsBands = clamped;
+	        this._forEachSplatEntity(entity => {
+	            this._applySplatRenderingConfigToEntity(entity);
+	        });
+	        // Emit event for UI integrations
+	        this.emit({
+	            type: 'spherical-harmonics-bands-changed',
+	            detail: {
+	                bands: clamped,
+	                previousBands: previousBands ?? clamped,
+	            },
+	        });
+	    }
+	    /**
+	     * Get current spherical harmonics bands setting last configured via API.
+	     * Returns null if not configured yet.
+	     */
+	    getSphericalHarmonicsBands() {
+	        return this._sphericalHarmonicsBands;
+	    }
+	    // Apply stored rendering configuration to a specific splat entity
+	    _applySplatRenderingConfigToEntity(entity) {
+	        const anyEntity = entity;
+	        const comp = anyEntity.gsplat;
+	        if (!comp)
+	            return;
+	        // Centers size – try several known/likely property names
+	        if (this._splatCenterSize != null) {
+	            const size = this._splatCenterSize;
+	            if ('centerSize' in comp)
+	                comp.centerSize = size;
+	            if ('centersSize' in comp)
+	                comp.centersSize = size;
+	            if ('pointSize' in comp)
+	                comp.pointSize = size;
+	            if (comp.settings) {
+	                if ('centerSize' in comp.settings)
+	                    comp.settings.centerSize = size;
+	                if ('centersSize' in comp.settings)
+	                    comp.settings.centersSize = size;
+	                if ('pointSize' in comp.settings)
+	                    comp.settings.pointSize = size;
+	            }
+	            if (comp.instance) {
+	                if ('centerSize' in comp.instance)
+	                    comp.instance.centerSize = size;
+	                if ('centersSize' in comp.instance)
+	                    comp.instance.centersSize = size;
+	                if ('pointSize' in comp.instance)
+	                    comp.instance.pointSize = size;
+	                if (comp.instance.renderOptions) {
+	                    const ro = comp.instance.renderOptions;
+	                    if ('centerSize' in ro)
+	                        ro.centerSize = size;
+	                    if ('centersSize' in ro)
+	                        ro.centersSize = size;
+	                    if ('pointSize' in ro)
+	                        ro.pointSize = size;
+	                }
+	            }
+	        }
+	        // Spherical harmonics bands – prefer integer band count properties
+	        if (this._sphericalHarmonicsBands != null) {
+	            const bands = this._sphericalHarmonicsBands;
+	            if ('shBands' in comp)
+	                comp.shBands = bands;
+	            if ('shBandCount' in comp)
+	                comp.shBandCount = bands;
+	            if ('sphericalHarmonicsBands' in comp)
+	                comp.sphericalHarmonicsBands = bands;
+	            if (comp.settings) {
+	                if ('shBands' in comp.settings)
+	                    comp.settings.shBands = bands;
+	                if ('shBandCount' in comp.settings)
+	                    comp.settings.shBandCount = bands;
+	                if ('sphericalHarmonicsBands' in comp.settings)
+	                    comp.settings.sphericalHarmonicsBands = bands;
+	            }
+	            if (comp.instance) {
+	                if ('shBands' in comp.instance)
+	                    comp.instance.shBands = bands;
+	                if ('shBandCount' in comp.instance)
+	                    comp.instance.shBandCount = bands;
+	                if ('sphericalHarmonicsBands' in comp.instance)
+	                    comp.instance.sphericalHarmonicsBands = bands;
+	            }
+	        }
+	    }
+	    // Helper: iterate over all splat entities managed by this core
+	    _forEachSplatEntity(fn) {
+	        if (this.entities.splat) {
+	            fn(this.entities.splat);
+	        }
+	        if (this._modelManager) {
+	            const models = this._modelManager.getModels();
+	            for (const m of models) {
+	                if (m.entity) {
+	                    fn(m.entity);
+	                }
+	            }
+	        }
+	    }
 	    // ==========================================
 	    // Transform System API
 	    // ==========================================
@@ -141688,6 +141937,13 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        this._core.on('background-color-changed', (event) => {
 	            this.dispatchEvent(createCustomEvent('background-color-changed', event.detail));
 	        });
+	        // Splat rendering configuration events
+	        this._core.on('splat-center-size-changed', (event) => {
+	            this.dispatchEvent(createCustomEvent('splat-center-size-changed', event.detail));
+	        });
+	        this._core.on('spherical-harmonics-bands-changed', (event) => {
+	            this.dispatchEvent(createCustomEvent('spherical-harmonics-bands-changed', event.detail));
+	        });
 	        // Multi-model management events
 	        this._core.on('model-added', (event) => {
 	            this.dispatchEvent(createCustomEvent('model-added', event.detail));
@@ -141899,6 +142155,28 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        }
 	        return this._core.getSceneStats();
 	    }
+	    /**
+	     * Set visibility for a specific model by ID
+	     * @param modelId ID of the model
+	     * @param visible True to show, false to hide
+	     */
+	    setModelVisible(modelId, visible) {
+	        if (!this._core) {
+	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
+	        }
+	        this._core.setModelVisible(modelId, visible);
+	    }
+	    /**
+	     * Set visibility for all models matching a given name
+	     * @param name Model name to match (case-sensitive)
+	     * @param visible True to show, false to hide
+	     */
+	    setModelsVisibleByName(name, visible) {
+	        if (!this._core) {
+	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
+	        }
+	        this._core.setModelsVisibleByName(name, visible);
+	    }
 	    // ==========================================
 	    // Camera Mode / Fly Camera API
 	    // ==========================================
@@ -141953,6 +142231,26 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        }
 	        await this._core.animateCameraFOV(targetFOV, duration);
 	    }
+	    /**
+	     * Set fly camera base movement speed (convenience over setFlyCameraConfig)
+	     * @param speed Units per second (must be > 0)
+	     */
+	    setFlyCameraSpeed(speed) {
+	        if (!this._core) {
+	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
+	        }
+	        this._core.setFlyCameraSpeed(speed);
+	    }
+	    /**
+	     * Get current fly camera base movement speed
+	     * @returns Speed in units per second, or null if fly camera not initialized
+	     */
+	    getFlyCameraSpeed() {
+	        if (!this._core) {
+	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
+	        }
+	        return this._core.getFlyCameraSpeed();
+	    }
 	    setBackgroundColor(color) {
 	        if (!this._core) {
 	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
@@ -141971,6 +142269,44 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        }
 	        await this._core.animateBackgroundColor(targetColor, duration);
 	    }
+	    /**
+	     * Set rendered centers size for all splat models
+	     * @param size Positive size value (implementation-specific units)
+	     */
+	    setSplatCenterSize(size) {
+	        if (!this._core) {
+	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
+	        }
+	        this._core.setSplatCenterSize(size);
+	    }
+	    /**
+	     * Get current centers size value last set via API
+	     */
+	    getSplatCenterSize() {
+	        if (!this._core) {
+	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
+	        }
+	        return this._core.getSplatCenterSize();
+	    }
+	    /**
+	     * Set spherical harmonics bands for all splat models
+	     * @param bands Integer band count (0-3)
+	     */
+	    setSphericalHarmonicsBands(bands) {
+	        if (!this._core) {
+	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
+	        }
+	        this._core.setSphericalHarmonicsBands(bands);
+	    }
+	    /**
+	     * Get current spherical harmonics bands setting last configured via API
+	     */
+	    getSphericalHarmonicsBands() {
+	        if (!this._core) {
+	            throw new Error('SplatViewerElement: Core not initialized. Call connectedCallback first.');
+	        }
+	        return this._core.getSphericalHarmonicsBands();
+	    }
 	    // ==========================================
 	    // Transform System API
 	    // ==========================================