@hology/core 0.0.250 → 0.0.252

package/dist/rendering/webgpu-runtime-bridge.js

@@ -0,0 +1,4 @@
+let e=null,n=null;export function configureWebGpuRuntimeBindings(n){e=n}export async function ensureWebGpuRuntimeBindings(){null==e&&(n??(n=import("@hology/webgpu-renderer").then(e=>{configureWebGpuRuntimeBindings({createComputeKernel:(n,i)=>new e.ComputeKernel(n,i),buildParticleLightingShaderHeader:e.buildParticleLightingShaderHeader})}).catch(e=>{throw n=null,e})),await n)}export function createWebGpuComputeKernel(n,i){if(null==e)throw new Error("WebGPU runtime bindings are unavailable. Initialize the WebGPU rendering backend first.");return e.createComputeKernel(n,i)}export function buildWebGpuParticleLightingShaderHeader(n=!0,i){if(null==e)throw new Error("WebGPU runtime bindings are unavailable. Initialize the WebGPU rendering backend first.");return e.buildParticleLightingShaderHeader(n,i)}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/rendering.d.ts

@@ -18,7 +18,9 @@ import type { VfxBackendPreference } from './effects/vfx/gpu-sprite-compiler.js'
 export type { UpscalingOptions } from "./rendering/upscaling-pass.js";
 export type { AntiAliasingMode, ExperimentalWebGpuPostProcessingOptions, ExperimentalWebGpuRenderGraphExtension } from './rendering/webgpu-experimental-backend.js';
 export type { GTAOOptions, GTAOQuality, MotionBlurOptions, MotionBlurOverride, MotionBlurOverrideHandle, VolumetricFogOptions, VolumetricFogQuality } from './rendering/webgpu-experimental-backend.js';
-export type RenderingBackend = 'webgl' | 'webgpu-experimental';
+/** Renderer requested by a view. `webgpu-experimental` is a deprecated alias. */
+export type RenderingBackend = 'webgl' | 'webgpu' | 'webgpu-experimental';
+export type ActiveRenderingBackend = 'webgl' | 'webgpu';
 export interface DirectionalShadowOptions {
     enabled: boolean;
     mapSize: number;
@@ -101,6 +103,7 @@ export type RenderingViewOptions = {
         enabled?: boolean;
     };
     shadows?: {
+        enabled?: boolean;
         autoUpdate?: boolean;
         /**
          * Array of update intervals (ms) for each CSM cascade. The first value is for the closest shadow, the next for the next cascade, etc.
@@ -115,27 +118,36 @@ export type RenderingViewOptions = {
 export declare class RenderingView {
     container: HTMLElement;
     readonly options: RenderingViewOptions;
+    private static readonly webGpuBackendPool;
     private static activeView;
-    private static sharedExperimentalWebGpuBackend;
-    private static sharedExperimentalWebGpuBackendPromise;
     private static experimentalWebGpuPresentationView;
-    private _activeBackend;
+    private backendHandle;
+    private webGlBackend;
     private experimentalWebGpuBackend;
+    private experimentalWebGpuBackendPoolKey;
     private experimentalWebGpuFailed;
+    private webGpuRuntimeErrorReported;
     private experimentalWebGpuCapabilityReported;
     private experimentalWebGpuDynamicBatchingEnabled;
+    private ambientOcclusionSettings;
     private experimentalWebGpuSelectedObjectInstances;
+    private outlinesEnabled;
+    private selectedOutlineObjects;
     private experimentalStaticDrawSetRegistrations;
     private experimentalWebGpuRenderGraphExtensions;
     private worldEnvironment;
-    get activeBackend(): RenderingBackend;
-    get requestedBackend(): RenderingBackend;
+    get activeBackend(): ActiveRenderingBackend | null;
+    get canvas(): HTMLCanvasElement | null;
+    get initialized(): boolean;
+    get requestedBackend(): ActiveRenderingBackend;
     get vfxBackendPreference(): VfxBackendPreference;
     get webgpuVfxInstancesPerTemplate(): number;
     get webgpuVfxTemplateMemoryBudgetBytes(): number;
     get webgpuVfxWorldMemoryBudgetBytes(): number;
     /** @deprecated Retained for source compatibility; GPU VFX no longer performs timed eviction. */
     get webgpuVfxColdTemplateSeconds(): number;
+    get webGpuDevice(): GPUDevice | null;
+    /** @deprecated Use webGpuDevice. */
     get experimentalWebGpuDevice(): GPUDevice | null;
     /**
      * Snapshots a materialized static root after the experimental renderer has
@@ -143,14 +155,18 @@ export declare class RenderingView {
      * so WebGL fallback continues to render the normal Three.js objects.
      */
     registerExperimentalStaticDrawSet(root: THREE.Object3D, label: string, allowUnsortedLateDraws?: boolean): () => void;
-    /** Registers a view-local extension executed by the shared WebGPU backend. */
+    /** @deprecated Use registerWebGpuRenderGraphExtension. */
     registerExperimentalWebGpuRenderGraphExtension(extension: ExperimentalWebGpuRenderGraphExtension): () => void;
     private isIntersecting;
     private needsPausedRender;
     private wakePausedRenderer;
     camera: THREE.Camera;
     windowVisible: boolean;
+    /** @deprecated WebGL-specific escape hatch. Use webGlRenderer and backend-neutral RenderingView APIs. */
     renderer: WebGLRenderer;
+    /** Returns the WebGL renderer only when the active backend is WebGL. */
+    get webGlRenderer(): WebGLRenderer | null;
+    registerWebGpuRenderGraphExtension(extension: ExperimentalWebGpuRenderGraphExtension): () => void;
     rendererDepth: WebGLRenderer;
     private composer;
     private bloomComposer;
@@ -193,8 +209,8 @@ export declare class RenderingView {
     private volumetricFogPass;
     private postProcessEffectId;
     private postProcessEffects;
-    private readonly postProcessEffectResolution;
-    private readonly postProcessEffectUniformState;
+    private postProcessEffectResolution;
+    private postProcessEffectUniformState;
     private fquadCopySceneColor;
     private fquadCopySceneDepth;
     private occlusionClusters;
@@ -212,6 +228,7 @@ export declare class RenderingView {
      * additively combined. Normals as well could simply be overwritten for SSR.
      */
     private fquadBlendAO;
+    private createAoblendQuad;
     setPaused(value: boolean): void;
     resolutionScale: number;
     maxPixelRatio: number;
@@ -270,6 +287,8 @@ export declare class RenderingView {
     private outlineEffect;
     private gRenderTarget;
     private phasedRenderPass;
+    private webGlInitialized;
+    private setupWebGlPipeline;
     constructor(container: HTMLElement, options?: RenderingViewOptions);
     addCluster(cluster: Cluster): void;
     /**
@@ -286,6 +305,11 @@ export declare class RenderingView {
     setMotionBlurOptions(options: MotionBlurOptions): void;
     setDirectionalShadowOptions(options: DirectionalShadowOptions): void;
     setGTAOOptions(options: GTAOOptions): void;
+    configureAmbientOcclusion(enabled: boolean, blendIntensity?: number, options?: Record<string, unknown>): void;
+    invalidateShadows(): void;
+    initTexture(texture: Texture): void;
+    setBaseToneMapping(mapping: THREE.ToneMapping, exposure: number): void;
+    get supportsWebGlDepthTexture(): boolean;
     setAntiAliasingMode(mode: AntiAliasingMode): void;
     setGTAOQuality(quality: GTAOQuality): void;
     setVolumetricFogOptions(options: VolumetricFogOptions): void;
@@ -330,7 +354,8 @@ export declare class RenderingView {
     private syncWebGpuPassStatsDom;
     private updateWebGpuPassStats;
     private getActiveRendererCanvas;
-    private disableExperimentalWebGpu;
+    private requireInitializedBackend;
+    private fallbackToWebGlForUnavailableWebGpu;
     private activateExperimentalStaticDrawSets;
     private disposeExperimentalStaticDrawSets;
     private applyEnvMap;
@@ -405,6 +430,12 @@ export declare class RenderingView {
     private unapplyGBufferMaterials;
     private applyGBufferShadowUniformUpdater;
     initTextures(scene?: THREE.Scene): void;
+    /**
+     * Initializes scene textures without monopolizing the host event loop.
+     * Intended for loading boundaries where native hosts must continue pumping
+     * their window and presenting a loading UI while uploads are prepared.
+     */
+    initTexturesAsync(scene?: THREE.Scene): Promise<void>;
     private _initiatedMaterialTextures;
     private _initiatedTextures;
     private _initMaterialTextures;
@@ -412,15 +443,15 @@ export declare class RenderingView {
     private compileInProgress;
     compileAsync(scene?: Object3D): Promise<void>;
     private compileExperimentalWebGpu;
-    private static acquireSharedExperimentalWebGpuBackend;
+    private acquireWebGpuBackend;
+    private releaseExperimentalWebGpuBackend;
     private applyExperimentalWebGpuViewState;
+    private syncWebGpuOutlineState;
     private depthMaterialCachedMaterials;
     private applyDepthMaterial;
     private unapplyDepthMaterial;
     private renderScene;
-    private pmremGenerator?;
-    private pmremGeneratorResults;
-    getEnvTexture(texture: Texture): THREE.Texture;
+    getEnvTexture(texture: Texture): Texture;
     private applyPostProcessSettings;
     private updatePostProcessEffectUniforms;
     private insetHeight;
@@ -439,8 +470,6 @@ export declare class RenderingView {
     private bloomStoredMaterials;
     private bloomHidden;
     private hasBloom;
-    private darkenNonBloomed;
-    private restoreMaterial;
     private initSceneColorUniform;
     private initDepthUniform;
     private initNormalUniform;