@aura3d/engine 1.0.0

package/dist/engine/index.js

@@ -0,0 +1,136 @@
+export { A3D_APP_WORKFLOW_PRESETS, createA3DApp, resolveA3DAppQualityPreset } from "../apps/index.js";
+export { Engine } from "../core/index.js";
+export { Renderer, createExternalParityEnvironmentPipeline, listExternalParityEnvironmentTargets } from "../rendering/index.js";
+export { GLTFLoader, createAssetCompatibilityReport, inspectGLTFAsset, loadRenderableAsset, summarizeExternalParityGLTFCorpus } from "../assets/index.js";
+export { loadProductAsset } from "../product-studio/index.js";
+export { createAnimationLabWorkflow, createAssetViewerWorkflow, createComparisonWorkflow, createInteractiveSceneWorkflow, createMaterialStudioWorkflow, createProductConfiguratorWorkflow, createSceneShowcaseWorkflow } from "../workflows/index.js";
+export { A3DRenderer, A3DScene, A3DAppLifecycle } from "./advanced-runtime/index.js";
+export * from "./agent-api/index.js";
+export * from "./devtools/AuraDiagnosticsOverlay.js";
+export * from "./devtools/AuraAssetPanel.js";
+export * from "./devtools/AuraPerformancePanel.js";
+export * from "./testing/screenshot.js";
+export * from "./testing/routeHealth.js";
+import { markAuraLazySystemLoaded, markAuraLazySystemRequested } from "./agent-api/index.js";
+import { createAnimationLabWorkflow, createAssetViewerWorkflow, createComparisonWorkflow, createInteractiveSceneWorkflow, createMaterialStudioWorkflow, createProductConfiguratorWorkflow, createSceneShowcaseWorkflow } from "../workflows/index.js";
+import { createExternalParityEnvironmentPipeline } from "../rendering/index.js";
+import { createAssetCompatibilityReport, inspectGLTFAsset, loadRenderableAsset } from "../assets/index.js";
+export const workflows = {
+    assetViewer: createAssetViewerWorkflow,
+    productConfigurator: createProductConfiguratorWorkflow,
+    materialStudio: createMaterialStudioWorkflow,
+    sceneShowcase: createSceneShowcaseWorkflow,
+    interactiveScene: createInteractiveSceneWorkflow,
+    animationLab: createAnimationLabWorkflow,
+    comparison: createComparisonWorkflow
+};
+export function createEnvironment(options) {
+    return createExternalParityEnvironmentPipeline(options);
+}
+export async function loadAsset(urlOrAsset, options = {}) {
+    return await loadRenderableAsset(urlOrAsset, options);
+}
+export async function loadProductAssetLazy(options) {
+    markAuraLazySystemRequested("product-gltf-loader", "loadProductAssetLazy");
+    const started = Date.now();
+    const productStudio = await import("../product-studio/index.js");
+    markAuraLazySystemLoaded("product-gltf-loader", Date.now() - started);
+    return productStudio.loadProductAsset(options);
+}
+export async function createPostProcessComposerLazy(options) {
+    markAuraLazySystemRequested("postprocess", "createPostProcessComposerLazy");
+    const started = Date.now();
+    const rendering = await import("../rendering/index.js");
+    markAuraLazySystemLoaded("postprocess", Date.now() - started);
+    return new rendering.PostProcessComposer(options);
+}
+export function createMaterialVariantController(variants, initialVariant = variants[0]) {
+    if (variants.length === 0)
+        throw new Error("createMaterialVariantController requires at least one variant.");
+    if (!variants.includes(initialVariant))
+        throw new Error(`Unknown initial material variant: ${initialVariant}`);
+    let current = initialVariant;
+    return {
+        get current() {
+            return current;
+        },
+        variants,
+        setVariant(variant) {
+            if (!variants.includes(variant))
+                throw new Error(`Unknown material variant: ${variant}`);
+            current = variant;
+            return current;
+        },
+        snapshot() {
+            return { current, variants };
+        }
+    };
+}
+export function captureScreenshot(target) {
+    const canvas = isA3DApp(target) ? findCanvasFromRenderer(target.renderer) : target;
+    if (!canvas)
+        throw new Error("captureScreenshot requires a canvas-backed A3D app or canvas.");
+    if ("toDataURL" in canvas && typeof canvas.toDataURL === "function") {
+        return {
+            mimeType: "image/png",
+            dataUrl: canvas.toDataURL("image/png"),
+            width: canvas.width,
+            height: canvas.height
+        };
+    }
+    throw new Error("captureScreenshot currently requires an HTMLCanvasElement. OffscreenCanvas capture should use convertToBlob in application code.");
+}
+export function inspectAsset(asset, resources) {
+    return inspectGLTFAsset(asset, resources);
+}
+export function createCompatibilityReport(manifest) {
+    return createAssetCompatibilityReport(manifest);
+}
+export function createAssetDiagnostics(asset) {
+    const gltf = asset.gltf;
+    return {
+        kind: asset.kind,
+        ...(asset.url ? { url: asset.url } : {}),
+        warnings: asset.warnings,
+        unsupportedFeatures: gltf?.loaderDiagnostics.unsupportedExtensions ?? [],
+        textureCount: gltf?.textures.length ?? 0,
+        animationCount: gltf?.animations.length ?? 0,
+        skinCount: gltf?.skins.length ?? 0,
+        morphTargetMeshCount: gltf?.meshes.filter((mesh) => mesh.morphTargets.length > 0).length ?? 0
+    };
+}
+export function createRenderDiagnostics(diagnostics) {
+    return {
+        drawCalls: diagnostics?.drawCalls ?? 0,
+        buffers: diagnostics?.buffers ?? 0,
+        shaders: diagnostics?.shaders ?? 0,
+        textureCount: diagnostics?.textures,
+        warnings: diagnostics ? [] : ["No render diagnostics have been recorded yet."]
+    };
+}
+export function createDiagnosticsPanel(initial = {}) {
+    let render = createRenderDiagnostics(initial.render);
+    let asset = initial.asset;
+    return {
+        kind: "a3d-diagnostics-panel",
+        update(next) {
+            if (next.render)
+                render = createRenderDiagnostics(next.render);
+            if (next.asset)
+                asset = next.asset;
+        },
+        snapshot() {
+            return {
+                render,
+                ...(asset ? { asset } : {})
+            };
+        }
+    };
+}
+function isA3DApp(value) {
+    return "diagnostics" in value && typeof value.diagnostics === "function";
+}
+function findCanvasFromRenderer(renderer) {
+    return renderer?.canvas;
+}
+//# sourceMappingURL=index.js.map

package/dist/engine/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/engine/src/index.ts"],"names":[],"mappings":"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"}

package/dist/engine/production-runtime/index.d.ts

@@ -0,0 +1,492 @@
+import { ProductionRuntimeRenderer, summarizeProductionProductionProof, type ProductionEnvironmentLightingResources, type ProductionPbrHdrPipeline, type ProductionToneMappingOperator, type ProductionRenderProof, type ContactShadowPassDiagnostics, type ProductionRuntimeRendererBackendPreference, type ProductionRuntimeRendererBackendSelection, type ProductionRuntimeRendererOptions } from "@aura3d/rendering";
+import { createProductionGLTFRenderMetadata, loadProductionGLTFRenderPipeline, type GLTFSceneAnimationApplyResult, type GLTFSceneAnimationRuntime, type GLTFSceneAnimationRuntimeSnapshot, type ProductionGLTFRenderMetadata, type ProductionGLTFRenderPipeline } from "@aura3d/assets";
+import { AnimationAction, AnimationMixer, type AnimationClip, type AnimationEvent, type AnimationMixerSnapshot, type AnimationTarget } from "@aura3d/animation";
+import { PhysicsWorld, type CollisionEvent, type ConstraintType, type PhysicsSnapshot, type RigidBody, type RigidBodyType, type Vec3 } from "@aura3d/physics";
+import type { CameraFrameBounds, CameraLike, CollectedLight, EnvironmentLightingOptions, RenderItem, RenderSource, RendererPostProcessOptions, RendererShadowOptions } from "@aura3d/rendering";
+import type { GLTFMaterialRenderStateOverride, GLTFRendererInputOptions } from "@aura3d/assets";
+export * as productionRendering from "@aura3d/rendering";
+export * as productionWorkflows from "@aura3d/workflows";
+export declare const productionAssets: {
+    createProductionGLTFRenderMetadata: typeof createProductionGLTFRenderMetadata;
+    loadProductionGLTFRenderPipeline: typeof loadProductionGLTFRenderPipeline;
+};
+export declare const AURA3D_ENGINE_PRODUCTION_PRODUCT_SURFACE = "a3d-renderer-production-runtime-sdk";
+export declare const A3D_THREEJS_EXAMPLE_PARITY_TARGETS: {
+    readonly keyframes: "webgl_animation_keyframes";
+    readonly skinningBlending: "webgl_animation_skinning_blending";
+    readonly additiveBlending: "webgl_animation_skinning_additive_blending";
+    readonly skinningIk: "webgl_animation_skinning_ik";
+    readonly skinningMorph: "webgl_animation_skinning_morph";
+    readonly multipleAnimations: "webgl_animation_multiple";
+    readonly walkCycle: "webgl_animation_walk";
+    readonly decals: "webgl_decals";
+    readonly parallaxBarrier: "webgl_effects_parallaxbarrier";
+    readonly stereo: "webgl_effects_stereo";
+};
+export interface A3DRendererOptions extends ProductionRuntimeRendererOptions {
+    readonly backend?: ProductionRuntimeRendererBackendPreference;
+}
+export interface A3DRenderResult {
+    readonly proof: ProductionRenderProof;
+    readonly summary: ReturnType<typeof summarizeProductionProductionProof>;
+}
+export interface A3DFrameRenderResult {
+    readonly backend: "webgl2" | "webgpu";
+    readonly diagnostics: ReturnType<ProductionRuntimeRenderer["getDiagnostics"]>;
+    readonly features: ReturnType<ProductionRuntimeRenderer["getFeatures"]>;
+    readonly timing?: NonNullable<ReturnType<ProductionRuntimeRenderer["renderInteractiveFrame"]>["timing"]>;
+}
+export interface A3DRenderOptions {
+    readonly scene: A3DGltfScene;
+    readonly environment?: A3DHdrEnvironment;
+    readonly environmentLighting?: EnvironmentLightingOptions;
+    readonly renderItems?: Iterable<RenderItem>;
+    readonly collectedLights?: Iterable<CollectedLight>;
+    readonly shadow?: RendererShadowOptions | boolean;
+    readonly camera?: CameraLike;
+    readonly viewport?: A3DViewport;
+    readonly postprocess?: RendererPostProcessOptions | boolean;
+}
+export declare class A3DRenderer {
+    private readonly renderer;
+    private readonly viewport;
+    readonly backend: "webgl2" | "webgpu";
+    readonly backendSelection: ProductionRuntimeRendererBackendSelection;
+    private constructor();
+    static create(options: A3DRendererOptions): Promise<A3DRenderer>;
+    captureProof(input: A3DRenderOptions): A3DRenderResult;
+    render(input: A3DRenderOptions): A3DRenderResult;
+    renderInteractiveFrame(input: A3DRenderOptions): A3DFrameRenderResult;
+    renderFrame(input: A3DRenderOptions): A3DFrameRenderResult;
+    captureProofAsync(input: A3DRenderOptions): Promise<A3DRenderResult>;
+    renderAsync(input: A3DRenderOptions): Promise<A3DRenderResult>;
+    renderInteractiveFrameAsync(input: A3DRenderOptions): Promise<A3DFrameRenderResult>;
+    renderFrameAsync(input: A3DRenderOptions): Promise<A3DFrameRenderResult>;
+    getDiagnostics(): import("@aura3d/rendering").RenderDeviceDiagnostics;
+    dispose(): void;
+    private defaultViewport;
+    private metadataForRender;
+}
+export interface A3DViewport {
+    readonly width: number;
+    readonly height: number;
+}
+export type A3DVec3 = readonly [number, number, number];
+export interface A3DDirectionalLightOptions {
+    readonly name?: string;
+    readonly direction?: A3DVec3;
+    readonly color?: A3DVec3;
+    readonly intensity?: number;
+    readonly castsShadow?: boolean;
+}
+export interface A3DStudioLightingOptions {
+    readonly preset?: "product" | "inspection" | "softbox";
+    readonly intensityScale?: number;
+    readonly shadows?: boolean;
+}
+export interface A3DGroundedStageOptions {
+    readonly labelPrefix?: string;
+    readonly floorColor?: readonly [number, number, number, number];
+    readonly backdropColor?: readonly [number, number, number, number];
+    readonly floorRoughness?: number;
+    readonly backdropRoughness?: number;
+    readonly floorMetallic?: number;
+    readonly contactShadows?: boolean;
+    readonly background?: boolean;
+    readonly shadowLightDirection?: A3DVec3;
+}
+export interface A3DGroundedStageSettings {
+    readonly backgroundBlur?: number;
+    readonly backgroundVisible?: boolean;
+}
+export interface A3DGroundedStageDiagnostics {
+    readonly labelPrefix: string;
+    readonly floorY: number;
+    readonly floorItemCount: number;
+    readonly backgroundItemCount: number;
+    readonly contactShadow?: ContactShadowPassDiagnostics;
+}
+export interface A3DGroundedStage {
+    readonly groundingItems: readonly RenderItem[];
+    readonly backgroundItems: readonly RenderItem[];
+    readonly floorY: number;
+    readonly diagnostics: A3DGroundedStageDiagnostics;
+    update(settings?: A3DGroundedStageSettings): void;
+    renderItems(options?: {
+        readonly shadows?: boolean;
+        readonly backgroundVisible?: boolean;
+    }): readonly RenderItem[];
+    dispose(): void;
+}
+export interface A3DCameraFrameOptions {
+    readonly bounds: CameraFrameBounds;
+    readonly viewport: A3DViewport;
+    readonly preset?: "product-hero" | "asset-inspection" | "material-inspection";
+    readonly target?: A3DVec3;
+    readonly yawRadians?: number;
+    readonly pitchRadians?: number;
+    readonly zoom?: number;
+    readonly paddingRatio?: number;
+}
+export interface A3DCameraFrame {
+    readonly camera: CameraLike;
+    readonly diagnostics: A3DProductViewerCameraDiagnostics;
+}
+export interface A3DProductionSceneOptions {
+    readonly scene: A3DGltfScene;
+    readonly environment?: A3DHdrEnvironment;
+    readonly viewport: A3DViewport;
+    readonly stage?: A3DGroundedStage;
+    readonly backgroundVisible?: boolean;
+    readonly extraRenderItems?: Iterable<RenderItem>;
+    readonly lights?: readonly CollectedLight[];
+    readonly camera?: CameraLike;
+    readonly cameraFrame?: A3DCameraFrameOptions;
+    readonly shadows?: RendererShadowOptions | boolean;
+    readonly postprocess?: RendererPostProcessOptions | boolean;
+    readonly environmentLighting?: EnvironmentLightingOptions;
+}
+export declare function createDirectionalLight(options?: A3DDirectionalLightOptions): CollectedLight;
+export declare function createStudioLighting(options?: A3DStudioLightingOptions): readonly CollectedLight[];
+export declare function createGroundedStage(bounds: CameraFrameBounds, options?: A3DGroundedStageOptions): A3DGroundedStage;
+export declare function createCameraFrame(options: A3DCameraFrameOptions): A3DCameraFrame;
+export declare function createProductionRenderOptions(options: A3DProductionSceneOptions): A3DRenderOptions;
+export type A3DExampleParityTargetId = keyof typeof A3D_THREEJS_EXAMPLE_PARITY_TARGETS;
+export interface A3DImportedAnimationRuntime {
+    readonly scene: A3DGltfScene;
+    readonly runtime: GLTFSceneAnimationRuntime;
+    applyClip(name: string, time: number): GLTFSceneAnimationApplyResult;
+    blendClips(samples: readonly {
+        readonly clipName: string;
+        readonly time: number;
+        readonly weight?: number;
+        readonly additive?: boolean;
+    }[]): GLTFSceneAnimationApplyResult;
+    solveTwoBoneIK(options: Parameters<GLTFSceneAnimationRuntime["solveImportedSkeletonTwoBoneIK"]>[0]): ReturnType<GLTFSceneAnimationRuntime["solveImportedSkeletonTwoBoneIK"]>;
+    snapshot(): GLTFSceneAnimationRuntimeSnapshot;
+}
+export declare function createImportedAnimationRuntime(scene: A3DGltfScene): A3DImportedAnimationRuntime;
+export interface A3DAnimationActionOptions {
+    readonly weight?: number;
+    readonly timeScale?: number;
+    readonly loop?: "once" | "repeat" | "pingpong";
+    readonly layer?: string;
+    readonly additive?: boolean;
+    readonly mask?: readonly string[];
+}
+export interface A3DAnimationControllerOptions {
+    readonly target?: AnimationTarget;
+    readonly clips?: readonly AnimationClip[];
+    readonly applyRootMotion?: boolean;
+    readonly rootMotionTrack?: string;
+    readonly rootMotionScale?: number;
+}
+export interface A3DAnimationControllerSnapshot {
+    readonly mixer: AnimationMixerSnapshot;
+    readonly registeredClips: readonly string[];
+    readonly updateCount: number;
+    readonly crossFadeCount: number;
+    readonly lastEventCount: number;
+    readonly parityTargets: typeof A3D_THREEJS_EXAMPLE_PARITY_TARGETS;
+    readonly capabilities: {
+        readonly keyframes: true;
+        readonly crossFade: true;
+        readonly additiveLayers: boolean;
+        readonly layerMasks: boolean;
+        readonly rootMotion: boolean;
+        readonly importedGltfAnimationRuntime: true;
+        readonly importedSkinningPaletteRefresh: true;
+        readonly importedMorphWeightAnimation: true;
+    };
+}
+export interface A3DAnimationController {
+    readonly mixer: AnimationMixer;
+    registerClip(clip: AnimationClip): AnimationClip;
+    play(clip: string | AnimationClip, options?: A3DAnimationActionOptions): AnimationAction;
+    crossFade(from: string | AnimationAction, to: string | AnimationAction | AnimationClip, duration: number): void;
+    update(deltaSeconds: number): readonly AnimationEvent[];
+    snapshot(): A3DAnimationControllerSnapshot;
+    dispose(): void;
+}
+export declare function createAnimationController(options?: A3DAnimationControllerOptions): A3DAnimationController;
+export interface A3DPhysicsSceneOptions {
+    readonly gravity?: Vec3;
+    readonly fixedDelta?: number;
+    readonly solverIterations?: number;
+    readonly enableSleeping?: boolean;
+}
+export interface A3DPhysicsBodyOptions {
+    readonly type?: RigidBodyType;
+    readonly position?: A3DVec3;
+    readonly velocity?: A3DVec3;
+    readonly mass?: number;
+    readonly restitution?: number;
+    readonly friction?: number;
+    readonly shape?: {
+        readonly kind: "box" | "sphere" | "capsule";
+        readonly halfExtents?: A3DVec3;
+        readonly radius?: number;
+        readonly halfHeight?: number;
+    };
+    readonly sensor?: boolean;
+}
+export interface A3DPhysicsConstraintOptions {
+    readonly type: ConstraintType;
+    readonly bodyA: RigidBody;
+    readonly bodyB: RigidBody;
+    readonly localAnchorA?: A3DVec3;
+    readonly localAnchorB?: A3DVec3;
+    readonly restLength?: number;
+    readonly stiffness?: number;
+    readonly axis?: A3DVec3;
+}
+export interface A3DPhysicsStepOptions {
+    readonly dt?: number;
+    readonly steps?: number;
+}
+export interface A3DPhysicsSceneSnapshot {
+    readonly world: PhysicsSnapshot;
+    readonly parityTargets: Pick<typeof A3D_THREEJS_EXAMPLE_PARITY_TARGETS, "walkCycle">;
+    readonly capabilities: {
+        readonly dynamicRigidBodies: true;
+        readonly staticColliders: true;
+        readonly constraints: true;
+        readonly contacts: true;
+        readonly raycast: true;
+        readonly sphereCast: true;
+    };
+}
+export interface A3DPhysicsScene {
+    readonly world: PhysicsWorld;
+    createBody(options?: A3DPhysicsBodyOptions): RigidBody;
+    createGroundPlane(constant?: number): RigidBody;
+    addConstraint(options: A3DPhysicsConstraintOptions): ReturnType<PhysicsWorld["createConstraint"]>;
+    step(options?: number | A3DPhysicsStepOptions): readonly CollisionEvent[];
+    raycast(origin: A3DVec3, direction: A3DVec3, maxDistance?: number): ReturnType<PhysicsWorld["raycast"]>;
+    sphereCast(origin: A3DVec3, radius: number, direction: A3DVec3, maxDistance?: number): ReturnType<PhysicsWorld["sphereCast"]>;
+    snapshot(): A3DPhysicsSceneSnapshot;
+}
+export declare function createPhysicsScene(options?: A3DPhysicsSceneOptions): A3DPhysicsScene;
+export interface A3DGltfSceneOptions {
+    readonly url: string;
+    readonly assetId?: string;
+    readonly assetName?: string;
+    readonly materialVariant?: string;
+    readonly materialRenderStateOverrides?: readonly GLTFMaterialRenderStateOverride[];
+    readonly sceneIndex?: number;
+    readonly sceneName?: string;
+    readonly viewport?: A3DViewport;
+    readonly rendererInput?: GLTFRendererInputOptions;
+}
+export interface A3DGltfRendererInputOptions {
+    readonly viewport: A3DViewport;
+    readonly environment?: A3DHdrEnvironment;
+    readonly environmentLighting?: EnvironmentLightingOptions;
+    readonly renderItems?: Iterable<RenderItem>;
+    readonly collectedLights?: Iterable<CollectedLight>;
+    readonly shadow?: RendererShadowOptions | boolean;
+    readonly postprocess?: RendererPostProcessOptions | boolean;
+}
+export declare class A3DGltfScene {
+    private readonly pipeline;
+    constructor(pipeline: ProductionGLTFRenderPipeline);
+    get asset(): import("@aura3d/assets").GLTFAsset;
+    get resources(): import("@aura3d/assets").GLTFRenderResources;
+    get metadata(): ProductionGLTFRenderMetadata;
+    createRendererInput(options: A3DGltfRendererInputOptions): {
+        readonly source: RenderSource;
+        readonly camera: CameraLike;
+        readonly bounds: CameraFrameBounds;
+    };
+    dispose(): void;
+}
+export declare function loadGltfScene(input: string | A3DGltfSceneOptions): Promise<A3DGltfScene>;
+export interface A3DHdrEnvironmentOptions {
+    readonly url: string;
+    readonly id?: string;
+    readonly label?: string;
+    readonly data?: ArrayBuffer | Uint8Array;
+    readonly intensity?: number;
+    readonly backgroundIntensity?: number;
+    readonly rotation?: number;
+    readonly toneMapping?: {
+        readonly operator?: ProductionToneMappingOperator;
+        readonly exposure?: number;
+        readonly whitePoint?: number;
+    };
+}
+export declare class A3DHdrEnvironment {
+    readonly id: string;
+    readonly label: string;
+    readonly url: string;
+    readonly pipeline: ProductionPbrHdrPipeline;
+    readonly lighting: ProductionEnvironmentLightingResources;
+    constructor(options: {
+        readonly id: string;
+        readonly label: string;
+        readonly url: string;
+        readonly pipeline: ProductionPbrHdrPipeline;
+        readonly lighting: ProductionEnvironmentLightingResources;
+    });
+    get environmentLighting(): EnvironmentLightingOptions;
+    dispose(): void;
+}
+export declare function loadHdrEnvironment(input: string | A3DHdrEnvironmentOptions): Promise<A3DHdrEnvironment>;
+export interface A3DOrbitControlsOptions {
+    readonly enabled?: boolean;
+    readonly enablePan?: boolean;
+    readonly enableZoom?: boolean;
+    readonly enableRotate?: boolean;
+    readonly target?: readonly [number, number, number];
+    readonly position?: readonly [number, number, number];
+}
+export interface A3DOrbitControlsSnapshot {
+    readonly target: readonly [number, number, number];
+    readonly position: readonly [number, number, number];
+    readonly rotation: readonly [number, number];
+    readonly zoom: number;
+    readonly enabled: boolean;
+}
+export interface A3DOrbitControls {
+    rotate(deltaX: number, deltaY: number): A3DOrbitControlsSnapshot;
+    pan(deltaX: number, deltaY: number): A3DOrbitControlsSnapshot;
+    dolly(scale: number): A3DOrbitControlsSnapshot;
+    reset(): A3DOrbitControlsSnapshot;
+    snapshot(): A3DOrbitControlsSnapshot;
+}
+export declare function createOrbitControls(options?: A3DOrbitControlsOptions): A3DOrbitControls;
+export interface A3DNavigationControlsOptions {
+    readonly enabled?: boolean;
+    readonly locked?: boolean;
+    readonly position?: readonly [number, number, number];
+    readonly rotation?: readonly [number, number, number];
+    readonly movementSpeed?: number;
+}
+export interface A3DNavigationControlsSnapshot {
+    readonly position: readonly [number, number, number];
+    readonly rotation: readonly [number, number, number];
+    readonly movementSpeed: number;
+    readonly enabled: boolean;
+    readonly locked: boolean;
+}
+export interface A3DFirstPersonControls {
+    moveForward(distance: number): A3DNavigationControlsSnapshot;
+    strafe(distance: number): A3DNavigationControlsSnapshot;
+    look(deltaX: number, deltaY: number): A3DNavigationControlsSnapshot;
+    reset(): A3DNavigationControlsSnapshot;
+    snapshot(): A3DNavigationControlsSnapshot;
+}
+export interface A3DMapControls extends A3DOrbitControls {
+    truck(deltaX: number, deltaZ: number): A3DOrbitControlsSnapshot;
+}
+export interface A3DTrackballControls extends A3DOrbitControls {
+    roll(delta: number): A3DOrbitControlsSnapshot;
+}
+export interface A3DPointerLockControls {
+    lock(): A3DNavigationControlsSnapshot;
+    unlock(): A3DNavigationControlsSnapshot;
+    look(deltaX: number, deltaY: number): A3DNavigationControlsSnapshot;
+    reset(): A3DNavigationControlsSnapshot;
+    snapshot(): A3DNavigationControlsSnapshot;
+}
+export declare function createFirstPersonControls(options?: A3DNavigationControlsOptions): A3DFirstPersonControls;
+export declare function createMapControls(options?: A3DOrbitControlsOptions): A3DMapControls;
+export declare function createTrackballControls(options?: A3DOrbitControlsOptions): A3DTrackballControls;
+export declare function createPointerLockControls(options?: A3DNavigationControlsOptions): A3DPointerLockControls;
+export interface A3DProductViewerOptions {
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    readonly asset: A3DGltfScene;
+    readonly environment: A3DHdrEnvironment;
+    readonly backend?: "webgl2" | "webgpu";
+    readonly width?: number;
+    readonly height?: number;
+    readonly camera?: {
+        readonly preset?: "product-hero" | "asset-inspection" | "material-inspection";
+        readonly orbit?: boolean;
+    };
+    readonly lighting?: {
+        readonly ibl?: boolean;
+        readonly shadows?: boolean;
+    };
+    readonly postprocess?: {
+        readonly toneMapping?: "aces" | "filmic" | "linear" | "reinhard";
+        readonly exposure?: number;
+        readonly bloom?: boolean;
+        readonly ssao?: boolean;
+        readonly fxaa?: boolean;
+        readonly colorGrade?: boolean;
+    };
+}
+export interface A3DProductViewerSettings {
+    readonly exposure: number;
+    readonly iblIntensity: number;
+    readonly specularIntensity: number;
+    readonly environmentRotation: number;
+    readonly backgroundVisible: boolean;
+    readonly backgroundBlur: number;
+    readonly shadows: boolean;
+    readonly toneMapping: "aces" | "filmic" | "linear" | "reinhard";
+    readonly bloom: boolean;
+    readonly ssao: boolean;
+    readonly fxaa: boolean;
+    readonly colorGrade: boolean;
+}
+export interface A3DProductViewerCameraDiagnostics {
+    readonly preset: "product-hero" | "asset-inspection" | "material-inspection";
+    readonly yawRadians: number;
+    readonly pitchRadians: number;
+    readonly paddingRatio: number;
+    readonly cameraPosition: readonly [number, number, number];
+    readonly targetOffset: readonly [number, number, number];
+    readonly zoom: number;
+}
+export interface A3DProductViewerStageDiagnostics {
+    readonly enabled: boolean;
+    readonly itemCount: number;
+    readonly floorY: number;
+    readonly directionalShadowMap: boolean;
+    readonly softFiltering: "pcf-16" | "off";
+    readonly depthAwareAmbientOcclusion: boolean;
+    readonly contactShadow: ContactShadowPassDiagnostics;
+}
+export interface A3DProductViewerBackgroundDiagnostics {
+    readonly enabled: boolean;
+    readonly itemCount: number;
+    readonly mode: "visible-hdr-studio-skybox";
+    readonly blur: number;
+    readonly environmentRotation: number;
+}
+export interface A3DProductViewer {
+    readonly renderer: A3DRenderer;
+    readonly asset: A3DGltfScene;
+    readonly environment: A3DHdrEnvironment;
+    readonly controls: A3DOrbitControls;
+    render(): A3DRenderResult;
+    renderAsync(): Promise<A3DRenderResult>;
+    setSettings(settings: Partial<A3DProductViewerSettings>): A3DProductViewerSettings;
+    setEnvironment(environment: A3DHdrEnvironment): A3DHdrEnvironment;
+    getSettings(): A3DProductViewerSettings;
+    captureScreenshot(type?: "image/png" | "image/jpeg", quality?: number): string | undefined;
+    diagnostics(): {
+        readonly asset: ProductionGLTFRenderMetadata;
+        readonly environment: {
+            readonly id: string;
+            readonly url: string;
+            readonly realRadianceHdr: boolean;
+            readonly specularPrefilter: boolean;
+            readonly cubemapPMREM: boolean;
+            readonly cubemapPMREMShaderSampling: "webgl2-sampler-cube";
+            readonly cubemapFaceSize: number;
+            readonly cubemapMipCount: number;
+            readonly brdfLut: boolean;
+        };
+        readonly controls: A3DOrbitControlsSnapshot;
+        readonly settings: A3DProductViewerSettings;
+        readonly camera?: A3DProductViewerCameraDiagnostics;
+        readonly stage: A3DProductViewerStageDiagnostics;
+        readonly background: A3DProductViewerBackgroundDiagnostics;
+    };
+    dispose(): void;
+}
+export declare function createProductViewer(options: A3DProductViewerOptions): Promise<A3DProductViewer>;
+//# sourceMappingURL=index.d.ts.map