@reactvision/react-viro 2.54.0 → 2.55.0

package/dist/components/Studio/domain/materialConfig.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * Studio material_config parsing and Viro material definition building.
+ * Ported from studio-go/domain/materialConfig.ts — no zod dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materialConfigNeedsTimeUniform = materialConfigNeedsTimeUniform;
+exports.materialConfigNeedsViewportUniforms = materialConfigNeedsViewportUniforms;
+exports.studioMaterialName = studioMaterialName;
+exports.parseMaterialConfig = parseMaterialConfig;
+exports.buildViroMaterialDefinition = buildViroMaterialDefinition;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const TEXTURE_KEYS = [
+    "diffuseTexture",
+    "normalTexture",
+    "roughnessTexture",
+    "metalnessTexture",
+    "ambientOcclusionTexture",
+    "specularTexture",
+];
+function textureToViro(uri) {
+    if (uri == null || uri === "")
+        return undefined;
+    return { uri };
+}
+function collectShaderModifierStrings(config) {
+    const mods = config.shaderModifiers;
+    if (!mods)
+        return [];
+    const strings = [];
+    for (const stage of Object.values(mods)) {
+        if (typeof stage === "string") {
+            strings.push(stage);
+        }
+        else if (stage && typeof stage === "object") {
+            const s = stage;
+            if (typeof s.uniforms === "string")
+                strings.push(s.uniforms);
+            if (typeof s.body === "string")
+                strings.push(s.body);
+        }
+    }
+    return strings;
+}
+const TIME_WORD_RE = /\btime\b/i;
+const CAMERA_TEXTURE_RE = /\bcamera_texture\b/;
+const RF_VIEWPORT_RE = /\b_rf_vpw\b|\b_rf_vph\b/;
+function materialConfigNeedsTimeUniform(config) {
+    if (config.materialUniforms?.some((u) => u.name === "time"))
+        return true;
+    return collectShaderModifierStrings(config).some((s) => TIME_WORD_RE.test(s));
+}
+/**
+ * True if the shader uses _rf_vpw/_rf_vph viewport uniforms.
+ * These must be pushed via ViroMaterials.updateShaderUniform on mount and orientation change.
+ */
+function materialConfigNeedsViewportUniforms(config) {
+    return collectShaderModifierStrings(config).some((s) => RF_VIEWPORT_RE.test(s));
+}
+/**
+ * Prepends GLSL uniform declarations that the body references but the uniforms block omits.
+ * Required when shaders are authored for remote delivery without explicit sampler declarations.
+ */
+function injectMissingGlslDeclarations(uniforms, body) {
+    let result = uniforms;
+    if (CAMERA_TEXTURE_RE.test(body) && !CAMERA_TEXTURE_RE.test(result)) {
+        result =
+            "uniform sampler2D camera_texture;\nuniform highp mat4 camera_image_transform;\n" +
+                result;
+    }
+    if (RF_VIEWPORT_RE.test(body) && !/\b_rf_vpw\b/.test(result)) {
+        result = "uniform highp float _rf_vpw;\nuniform highp float _rf_vph;\n" + result;
+    }
+    return result;
+}
+/**
+ * iOS only applies `ViroMaterials.updateShaderUniform` to uniforms registered
+ * via `materialUniforms`. If a shader references `time` or viewport uniforms in
+ * GLSL only, we add the runtime binding here.
+ */
+function mergeMaterialUniformsForViro(config) {
+    const list = config.materialUniforms
+        ? config.materialUniforms.map((u) => ({ name: u.name, type: u.type, value: u.value }))
+        : [];
+    if (materialConfigNeedsTimeUniform(config) && !list.some((u) => u.name === "time")) {
+        list.push({ name: "time", type: "float", value: 0 });
+    }
+    if (materialConfigNeedsViewportUniforms(config)) {
+        if (!list.some((u) => u.name === "_rf_vpw"))
+            list.push({ name: "_rf_vpw", type: "float", value: 0 });
+        if (!list.some((u) => u.name === "_rf_vph"))
+            list.push({ name: "_rf_vph", type: "float", value: 0 });
+    }
+    return list.length > 0 ? list : undefined;
+}
+/**
+ * Studio stores modifiers as `{ uniforms, body }`; Viro works best with a single
+ * GLSL string per stage. Stages with advanced fields are kept as structured objects.
+ * Camera texture usage is detected from GLSL and auto-flagged so the Viro native
+ * layer binds the camera feed even when the DB JSON omits `requiresCameraTexture`.
+ */
+function normalizeShaderModifiersForViro(mods) {
+    const out = {};
+    for (const [key, stage] of Object.entries(mods)) {
+        if (typeof stage === "string") {
+            out[key] = stage;
+            continue;
+        }
+        if (stage && typeof stage === "object") {
+            const s = stage;
+            const uniforms = typeof s.uniforms === "string" ? s.uniforms : "";
+            const body = typeof s.body === "string" ? s.body : "";
+            // Detect camera texture usage in GLSL even when the flag is absent from DB JSON.
+            const usesCameraTexture = CAMERA_TEXTURE_RE.test(body) || CAMERA_TEXTURE_RE.test(uniforms);
+            const hasAdvanced = s.varyings != null ||
+                s.requiresSceneDepth === true ||
+                s.requiresCameraTexture === true ||
+                usesCameraTexture ||
+                s.priority != null;
+            if (hasAdvanced) {
+                if (usesCameraTexture && s.requiresCameraTexture !== true) {
+                    // Auto-fix: flag the stage and inject any missing GLSL declarations so the
+                    // native Viro layer binds camera_texture and the shader compiles cleanly.
+                    out[key] = {
+                        ...s,
+                        requiresCameraTexture: true,
+                        uniforms: injectMissingGlslDeclarations(uniforms, body),
+                    };
+                }
+                else {
+                    out[key] = stage;
+                }
+                continue;
+            }
+            const merged = [uniforms.trim(), body.trim()].filter(Boolean).join("\n");
+            out[key] = merged.length > 0 ? merged : stage;
+        }
+    }
+    return out;
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+function studioMaterialName(assetId) {
+    return `studio_${assetId}`;
+}
+/**
+ * Parses `scene_assets.material_config` JSON. Returns null if missing or invalid.
+ */
+function parseMaterialConfig(raw) {
+    if (raw == null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    try {
+        const config = {
+            lightingModel: (["Constant", "Lambert", "Blinn", "Phong", "PBR"].includes(r.lightingModel)
+                ? r.lightingModel
+                : "PBR"),
+        };
+        if (typeof r.presetName === "string")
+            config.presetName = r.presetName;
+        if (typeof r.diffuseColor === "string")
+            config.diffuseColor = r.diffuseColor;
+        if (typeof r.roughness === "number")
+            config.roughness = r.roughness;
+        if (typeof r.metalness === "number")
+            config.metalness = r.metalness;
+        if (typeof r.shininess === "number")
+            config.shininess = r.shininess;
+        if (typeof r.alpha === "number")
+            config.alpha = r.alpha;
+        if (typeof r.blendMode === "string")
+            config.blendMode = r.blendMode;
+        if (r.bloomThreshold != null && typeof r.bloomThreshold === "number")
+            config.bloomThreshold = r.bloomThreshold;
+        if (["Clamp", "Repeat", "Mirror"].includes(r.wrapS))
+            config.wrapS = r.wrapS;
+        if (["Clamp", "Repeat", "Mirror"].includes(r.wrapT))
+            config.wrapT = r.wrapT;
+        if (typeof r.transparencyMode === "string")
+            config.transparencyMode = r.transparencyMode;
+        if (typeof r.cullMode === "string")
+            config.cullMode = r.cullMode;
+        for (const key of TEXTURE_KEYS) {
+            const v = r[key];
+            if (typeof v === "string" || v === null)
+                config[key] = v;
+        }
+        if (r.shaderModifiers && typeof r.shaderModifiers === "object" && !Array.isArray(r.shaderModifiers)) {
+            config.shaderModifiers = r.shaderModifiers;
+        }
+        if (Array.isArray(r.materialUniforms)) {
+            config.materialUniforms = r.materialUniforms.filter((u) => u && typeof u.name === "string" && typeof u.type === "string");
+        }
+        return config;
+    }
+    catch (e) {
+        console.warn("[material_config] Failed to parse material_config", e);
+        return null;
+    }
+}
+/**
+ * Maps a validated Studio material_config to Viro's `createMaterials` definition shape.
+ */
+function buildViroMaterialDefinition(config) {
+    const out = { lightingModel: config.lightingModel };
+    if (config.diffuseColor !== undefined)
+        out.diffuseColor = config.diffuseColor;
+    if (config.roughness !== undefined)
+        out.roughness = config.roughness;
+    if (config.metalness !== undefined)
+        out.metalness = config.metalness;
+    if (config.shininess !== undefined)
+        out.shininess = config.shininess;
+    if (config.alpha !== undefined)
+        out.alpha = config.alpha;
+    if (config.blendMode !== undefined)
+        out.blendMode = config.blendMode;
+    if (config.bloomThreshold != undefined)
+        out.bloomThreshold = config.bloomThreshold;
+    if (config.wrapS !== undefined)
+        out.wrapS = config.wrapS;
+    if (config.wrapT !== undefined)
+        out.wrapT = config.wrapT;
+    if (config.transparencyMode !== undefined)
+        out.transparencyMode = config.transparencyMode;
+    if (config.cullMode !== undefined)
+        out.cullMode = config.cullMode;
+    for (const key of TEXTURE_KEYS) {
+        const mapped = textureToViro(config[key]);
+        if (mapped !== undefined)
+            out[key] = mapped;
+    }
+    if (config.shaderModifiers !== undefined) {
+        out.shaderModifiers = normalizeShaderModifiersForViro(config.shaderModifiers);
+    }
+    const mergedUniforms = mergeMaterialUniformsForViro(config);
+    if (mergedUniforms !== undefined)
+        out.materialUniforms = mergedUniforms;
+    return out;
+}

package/dist/components/Studio/domain/physicsConfig.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Studio physics_config and physics_world_config parsing and Viro prop building.
+ * Ported from studio-go/domain/physicsConfig.ts — no zod dependency.
+ */
+type Vec3 = [number, number, number];
+type ForceEntry = {
+    value: Vec3;
+    position?: Vec3;
+};
+type PhysicsShape = {
+    type: "Box";
+    params: [number, number, number];
+} | {
+    type: "Sphere";
+    params: [number];
+} | {
+    type: "Compound";
+    children: Array<{
+        type: "Box" | "Sphere";
+        params: number[];
+        position: Vec3;
+        rotation?: Vec3;
+    }>;
+};
+export type PhysicsBodyConfig = {
+    enabled: boolean;
+    type: "Dynamic" | "Kinematic" | "Static";
+    mass: number;
+    shape?: PhysicsShape;
+    restitution?: number;
+    friction?: number;
+    useGravity?: boolean;
+    viroTag?: string;
+    force?: ForceEntry | ForceEntry[];
+    torque?: Vec3 | Vec3[];
+    velocity?: Vec3;
+};
+export type PhysicsWorldConfig = {
+    enabled: boolean;
+    gravity: Vec3;
+    drawBounds: boolean;
+};
+export type BuildViroPhysicsBodyOptions = {
+    /** Forces Dynamic body to Kinematic with mass 0 while dragging. */
+    kinematicDragOverride?: boolean;
+};
+/**
+ * Parses `scene.physics_world_config` JSON. Returns null if missing or invalid.
+ */
+export declare function parsePhysicsWorldConfig(raw: unknown): PhysicsWorldConfig | null;
+/**
+ * Parses `asset.physics_config` JSON. Returns null if missing or invalid.
+ */
+export declare function parsePhysicsBodyConfig(raw: unknown): PhysicsBodyConfig | null;
+/** Viro `ViroARScene` physicsWorld prop. */
+export declare function buildViroPhysicsWorld(config: PhysicsWorldConfig): {
+    gravity: Vec3;
+    drawBounds?: boolean;
+};
+/** Maps validated Studio physics_config to Viro `physicsBody` prop. */
+export declare function buildViroPhysicsBody(config: PhysicsBodyConfig, options?: BuildViroPhysicsBodyOptions): Record<string, unknown>;
+/**
+ * Draggable Dynamic bodies need kinematic override during drag so the simulation
+ * doesn't fight the gesture.
+ */
+export declare function shouldUseKinematicPhysicsDrag(asset: {
+    is_draggable: boolean;
+}, config: PhysicsBodyConfig | null): boolean;
+export {};

package/dist/components/Studio/domain/physicsConfig.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Studio physics_config and physics_world_config parsing and Viro prop building.
+ * Ported from studio-go/domain/physicsConfig.ts — no zod dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePhysicsWorldConfig = parsePhysicsWorldConfig;
+exports.parsePhysicsBodyConfig = parsePhysicsBodyConfig;
+exports.buildViroPhysicsWorld = buildViroPhysicsWorld;
+exports.buildViroPhysicsBody = buildViroPhysicsBody;
+exports.shouldUseKinematicPhysicsDrag = shouldUseKinematicPhysicsDrag;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function isVec3(v) {
+    return Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === "number");
+}
+function parseShape(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const r = raw;
+    if (r.type === "Box" && Array.isArray(r.params) && r.params.length === 3) {
+        return { type: "Box", params: r.params };
+    }
+    if (r.type === "Sphere" && Array.isArray(r.params) && r.params.length >= 1) {
+        return { type: "Sphere", params: [r.params[0]] };
+    }
+    if (r.type === "Compound" && Array.isArray(r.children)) {
+        const children = r.children.filter((c) => {
+            if (!c || typeof c !== "object")
+                return false;
+            const ch = c;
+            return (ch.type === "Box" || ch.type === "Sphere") && Array.isArray(ch.params) && isVec3(ch.position);
+        });
+        if (children.length > 0)
+            return { type: "Compound", children };
+    }
+    return undefined;
+}
+function mapShapeToViro(shape) {
+    if (shape.type === "Box")
+        return { type: "Box", params: [...shape.params] };
+    if (shape.type === "Sphere")
+        return { type: "Sphere", params: [...shape.params] };
+    return {
+        type: "Compound",
+        params: [],
+        children: shape.children.map((c) => {
+            const base = { type: c.type, params: [...c.params], position: [...c.position] };
+            if (c.rotation)
+                base.rotation = [...c.rotation];
+            return base;
+        }),
+    };
+}
+function normalizeTorque(torque) {
+    if (Array.isArray(torque[0])) {
+        return torque.reduce((acc, t) => [acc[0] + t[0], acc[1] + t[1], acc[2] + t[2]], [0, 0, 0]);
+    }
+    return [...torque];
+}
+function normalizeForce(force) {
+    const arr = Array.isArray(force) ? force : [force];
+    return arr.map((f) => ({
+        value: [...f.value],
+        position: f.position != null ? [...f.position] : undefined,
+    }));
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Parses `scene.physics_world_config` JSON. Returns null if missing or invalid.
+ */
+function parsePhysicsWorldConfig(raw) {
+    if (raw == null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    try {
+        return {
+            enabled: typeof r.enabled === "boolean" ? r.enabled : false,
+            gravity: isVec3(r.gravity) ? r.gravity : [0, -9.8, 0],
+            drawBounds: typeof r.drawBounds === "boolean" ? r.drawBounds : false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parses `asset.physics_config` JSON. Returns null if missing or invalid.
+ */
+function parsePhysicsBodyConfig(raw) {
+    if (raw == null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    try {
+        const type = (["Dynamic", "Kinematic", "Static"].includes(r.type)
+            ? r.type
+            : undefined);
+        if (!type)
+            return null;
+        const mass = typeof r.mass === "number" ? r.mass : 0;
+        const config = {
+            enabled: typeof r.enabled === "boolean" ? r.enabled : true,
+            type,
+            mass,
+        };
+        const shape = parseShape(r.shape);
+        if (shape)
+            config.shape = shape;
+        if (typeof r.restitution === "number")
+            config.restitution = r.restitution;
+        if (typeof r.friction === "number")
+            config.friction = r.friction;
+        if (typeof r.useGravity === "boolean")
+            config.useGravity = r.useGravity;
+        if (typeof r.viroTag === "string")
+            config.viroTag = r.viroTag;
+        if (isVec3(r.velocity))
+            config.velocity = r.velocity;
+        if (r.torque != null)
+            config.torque = r.torque;
+        if (r.force != null)
+            config.force = r.force;
+        return config;
+    }
+    catch {
+        return null;
+    }
+}
+/** Viro `ViroARScene` physicsWorld prop. */
+function buildViroPhysicsWorld(config) {
+    return {
+        gravity: [...config.gravity],
+        ...(config.drawBounds ? { drawBounds: true } : {}),
+    };
+}
+/** Maps validated Studio physics_config to Viro `physicsBody` prop. */
+function buildViroPhysicsBody(config, options) {
+    const kinematicDrag = options?.kinematicDragOverride === true && config.type === "Dynamic" && config.enabled;
+    const type = kinematicDrag ? "Kinematic" : config.type;
+    const mass = kinematicDrag ? 0 : config.mass;
+    const shape = mapShapeToViro(config.shape ?? { type: "Box", params: [1, 1, 1] });
+    const body = { type, mass, shape, enabled: config.enabled };
+    if (config.restitution !== undefined)
+        body.restitution = config.restitution;
+    if (config.friction !== undefined)
+        body.friction = config.friction;
+    if (config.useGravity !== undefined)
+        body.useGravity = kinematicDrag ? false : config.useGravity;
+    if (config.velocity !== undefined)
+        body.velocity = [...config.velocity];
+    if (config.torque !== undefined)
+        body.torque = normalizeTorque(config.torque);
+    if (config.force !== undefined)
+        body.force = normalizeForce(config.force);
+    return body;
+}
+/**
+ * Draggable Dynamic bodies need kinematic override during drag so the simulation
+ * doesn't fight the gesture.
+ */
+function shouldUseKinematicPhysicsDrag(asset, config) {
+    return (asset.is_draggable === true &&
+        config != null &&
+        config.enabled === true &&
+        config.type === "Dynamic");
+}

package/dist/components/Studio/domain/sceneNavigationHandler.d.ts

@@ -0,0 +1,12 @@
+import { StudioAnimation, StudioSceneFunction } from "../types";
+type SceneNavigator = any;
+/**
+ * Single dispatcher for all scene function types.
+ * Used by onClick, onCollision, and on_load_function triggers.
+ */
+export declare function executeFunctionWithRelations(fn: StudioSceneFunction, sceneNavigator: SceneNavigator | undefined, animations: StudioAnimation[], onAnimationTrigger?: (targetAssetId: string, animationKey: string) => void, depth?: number, onSceneChange?: (sceneId: string, sceneName: string) => void): void;
+/**
+ * Executes the scene's on_load_function if set.
+ */
+export declare function executeOnLoadFunction(functionId: string, functions: StudioSceneFunction[], sceneNavigator: SceneNavigator | undefined, animations: StudioAnimation[], onAnimationTrigger?: (targetAssetId: string, animationKey: string) => void, onSceneChange?: (sceneId: string, sceneName: string) => void): void;
+export {};

package/dist/components/Studio/domain/sceneNavigationHandler.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFunctionWithRelations = executeFunctionWithRelations;
+exports.executeOnLoadFunction = executeOnLoadFunction;
+const react_native_1 = require("react-native");
+const ViroPlatform_1 = require("../../Utilities/ViroPlatform");
+const VRTStudioModule_1 = require("../VRTStudioModule");
+const ANIMATION_CHAIN_MAX_DEPTH = 10;
+/**
+ * Resolves a scene function by ID from a flat list.
+ */
+function resolveById(id, fns) {
+    return fns.find((f) => f.id === id);
+}
+/**
+ * Looks up target_asset_id for an ANIMATION-type scene function.
+ * The inline scene_animation only has the animation UUID — we resolve it
+ * from the top-level animations array.
+ */
+function resolveAnimationTargetAssetId(animationId, animations) {
+    return animations.find((a) => a.id === animationId)?.target_asset_id;
+}
+/**
+ * Single dispatcher for all scene function types.
+ * Used by onClick, onCollision, and on_load_function triggers.
+ */
+function executeFunctionWithRelations(fn, sceneNavigator, animations, onAnimationTrigger, depth = 0, onSceneChange) {
+    if (depth > ANIMATION_CHAIN_MAX_DEPTH) {
+        console.warn(`[Studio] Max animation chain depth (${ANIMATION_CHAIN_MAX_DEPTH}) exceeded for function ${fn.id}.`);
+        return;
+    }
+    if (fn.function_type === "NAVIGATION") {
+        const nav = fn.scene_navigation;
+        if (!nav?.navigate_to || !sceneNavigator)
+            return;
+        void navigateToScene(sceneNavigator, nav.navigate_to, animations, onSceneChange);
+    }
+    else if (fn.function_type === "ALERT") {
+        const alrt = fn.scene_alert;
+        if (!alrt)
+            return;
+        if (ViroPlatform_1.isQuest) {
+            // Alert.alert shows a 2D panel dialog — invisible in the VR compositor.
+            // Log it so it's not silently swallowed; in-scene VR alert UI is a TODO.
+            console.warn(`[Studio] Alert (Quest — not shown in VR): "${alrt.alert_title}" — ${alrt.alert_message}`);
+            return;
+        }
+        react_native_1.Alert.alert(alrt.alert_title ?? "Alert", alrt.alert_message ?? "", [
+            { text: "OK", style: "default" },
+        ]);
+    }
+    else if (fn.function_type === "ANIMATION") {
+        const anim = fn.scene_animation;
+        if (!anim || !onAnimationTrigger)
+            return;
+        const animLookupId = fn.animation ?? anim.id;
+        const targetAssetId = resolveAnimationTargetAssetId(animLookupId, animations);
+        if (!targetAssetId) {
+            console.warn(`[Studio] ANIMATION function ${fn.id}: could not resolve target_asset_id for animation ${anim.id}`);
+            return;
+        }
+        onAnimationTrigger(targetAssetId, anim.animation_key);
+    }
+}
+/**
+ * Executes the scene's on_load_function if set.
+ */
+function executeOnLoadFunction(functionId, functions, sceneNavigator, animations, onAnimationTrigger, onSceneChange) {
+    const fn = resolveById(functionId, functions);
+    if (!fn) {
+        console.warn(`[Studio] on_load_function ${functionId} not found.`);
+        return;
+    }
+    executeFunctionWithRelations(fn, sceneNavigator, animations, onAnimationTrigger, 0, onSceneChange);
+}
+/**
+ * Navigates to a new AR scene by fetching its data via rvGetScene and
+ * pushing it onto the ViroARSceneNavigator stack.
+ *
+ * The sceneNavigator object exposes rvGetScene as a method — no separate
+ * API client needed here.
+ */
+async function navigateToScene(sceneNavigator, targetSceneId, currentAnimations, onSceneChange) {
+    if (!sceneNavigator) {
+        console.error("[Studio] SceneNavigator not available for navigation");
+        react_native_1.Alert.alert("Navigation Error", "Unable to navigate to scene");
+        return;
+    }
+    console.log(`[Studio] Navigating to scene: ${targetSceneId}`);
+    try {
+        const result = await VRTStudioModule_1.VRTStudioModule.rvGetScene(targetSceneId);
+        if (!result?.success) {
+            throw new Error(result?.error ?? "rvGetScene failed");
+        }
+        const sceneData = JSON.parse(result.data);
+        // Lazy import to avoid circular dependency
+        const { StudioARScene } = require("../StudioARScene");
+        sceneNavigator.push({
+            scene: StudioARScene,
+            passProps: {
+                sceneData,
+                onSceneChange,
+            },
+        });
+        onSceneChange?.(targetSceneId, sceneData.scene.name ?? targetSceneId);
+        console.log(`[Studio] Navigated to scene: ${sceneData.scene.name}`);
+    }
+    catch (error) {
+        console.error("[Studio] Error navigating to scene:", error);
+        react_native_1.Alert.alert("Navigation Error", "Failed to load scene");
+    }
+}

package/dist/components/Studio/domain/studioMaterials.d.ts

@@ -0,0 +1,6 @@
+import { StudioAsset } from "../types";
+/**
+ * Registers Viro materials for scene assets that have a valid `material_config`.
+ * Call synchronously after fetching assets and before rendering AR nodes.
+ */
+export declare function registerStudioMaterialsForAssets(assets: StudioAsset[]): void;

package/dist/components/Studio/domain/studioMaterials.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStudioMaterialsForAssets = registerStudioMaterialsForAssets;
+const ViroMaterials_1 = require("../../Material/ViroMaterials");
+const materialConfig_1 = require("./materialConfig");
+/**
+ * Registers Viro materials for scene assets that have a valid `material_config`.
+ * Call synchronously after fetching assets and before rendering AR nodes.
+ */
+function registerStudioMaterialsForAssets(assets) {
+    const materials = {};
+    for (const asset of assets) {
+        if (asset.asset_type_name !== "3D-MODEL")
+            continue;
+        if (asset.material_config == null)
+            continue;
+        const config = (0, materialConfig_1.parseMaterialConfig)(asset.material_config);
+        if (!config)
+            continue;
+        materials[(0, materialConfig_1.studioMaterialName)(asset.id)] = (0, materialConfig_1.buildViroMaterialDefinition)(config);
+    }
+    if (Object.keys(materials).length === 0)
+        return;
+    try {
+        ViroMaterials_1.ViroMaterials.createMaterials(materials);
+    }
+    catch (err) {
+        console.error("[studioMaterials] ViroMaterials.createMaterials failed", err);
+    }
+}

package/dist/components/Studio/domain/triggerImageRegistry.d.ts

@@ -0,0 +1,13 @@
+import { StudioAsset } from "../types";
+/**
+ * Registers trigger image targets with ViroReact for image recognition.
+ * One target per asset with trigger_image_url.
+ * Must be called before rendering ViroARImageMarker components.
+ *
+ * @returns Map from trigger_image_url → target name for lookup in ViroARImageMarker
+ */
+export declare function registerTriggerImageTargets(assets: StudioAsset[]): Map<string, string>;
+/**
+ * Cleans up trigger image targets when the scene unmounts.
+ */
+export declare function cleanupTriggerImageTargets(targetNames: string[]): void;