@reactvision/react-viro 2.54.0 → 2.55.0

package/components/Studio/domain/sceneNavigationHandler.ts

@@ -0,0 +1,150 @@
+import { Alert } from "react-native";
+import { isQuest } from "../../Utilities/ViroPlatform";
+import { StudioAnimation, StudioSceneFunction, StudioSceneResponse } from "../types";
+import { VRTStudioModule } from "../VRTStudioModule";
+
+type SceneNavigator = any; // ViroARSceneNavigator navigator object passed to AR scenes
+
+const ANIMATION_CHAIN_MAX_DEPTH = 10;
+
+/**
+ * Resolves a scene function by ID from a flat list.
+ */
+function resolveById(
+  id: string,
+  fns: StudioSceneFunction[]
+): StudioSceneFunction | undefined {
+  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: string,
+  animations: StudioAnimation[]
+): string | undefined {
+  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.
+ */
+export function executeFunctionWithRelations(
+  fn: StudioSceneFunction,
+  sceneNavigator: SceneNavigator | undefined,
+  animations: StudioAnimation[],
+  onAnimationTrigger?: (targetAssetId: string, animationKey: string) => void,
+  depth = 0,
+  onSceneChange?: (sceneId: string, sceneName: string) => void,
+): void {
+  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 (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;
+    }
+    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.
+ */
+export function executeOnLoadFunction(
+  functionId: string,
+  functions: StudioSceneFunction[],
+  sceneNavigator: SceneNavigator | undefined,
+  animations: StudioAnimation[],
+  onAnimationTrigger?: (targetAssetId: string, animationKey: string) => void,
+  onSceneChange?: (sceneId: string, sceneName: string) => void,
+): void {
+  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: SceneNavigator,
+  targetSceneId: string,
+  currentAnimations: StudioAnimation[],
+  onSceneChange?: (sceneId: string, sceneName: string) => void,
+): Promise<void> {
+  if (!sceneNavigator) {
+    console.error("[Studio] SceneNavigator not available for navigation");
+    Alert.alert("Navigation Error", "Unable to navigate to scene");
+    return;
+  }
+
+  console.log(`[Studio] Navigating to scene: ${targetSceneId}`);
+
+  try {
+    const result = await VRTStudioModule.rvGetScene(targetSceneId);
+    if (!result?.success) {
+      throw new Error(result?.error ?? "rvGetScene failed");
+    }
+
+    const sceneData: StudioSceneResponse = 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);
+    Alert.alert("Navigation Error", "Failed to load scene");
+  }
+}

package/components/Studio/domain/studioMaterials.ts

@@ -0,0 +1,33 @@
+import { ViroMaterials } from "../../Material/ViroMaterials";
+import { StudioAsset } from "../types";
+import {
+  buildViroMaterialDefinition,
+  parseMaterialConfig,
+  studioMaterialName,
+} from "./materialConfig";
+
+/**
+ * Registers Viro materials for scene assets that have a valid `material_config`.
+ * Call synchronously after fetching assets and before rendering AR nodes.
+ */
+export function registerStudioMaterialsForAssets(assets: StudioAsset[]): void {
+  const materials: Record<string, ReturnType<typeof buildViroMaterialDefinition>> = {};
+
+  for (const asset of assets) {
+    if (asset.asset_type_name !== "3D-MODEL") continue;
+    if (asset.material_config == null) continue;
+
+    const config = parseMaterialConfig(asset.material_config);
+    if (!config) continue;
+
+    materials[studioMaterialName(asset.id)] = buildViroMaterialDefinition(config);
+  }
+
+  if (Object.keys(materials).length === 0) return;
+
+  try {
+    ViroMaterials.createMaterials(materials as any);
+  } catch (err) {
+    console.error("[studioMaterials] ViroMaterials.createMaterials failed", err);
+  }
+}

package/components/Studio/domain/triggerImageRegistry.ts

@@ -0,0 +1,64 @@
+import { ViroARTrackingTargets } from "../../AR/ViroARTrackingTargets";
+import { StudioAsset } from "../types";
+
+const DEFAULT_PHYSICAL_WIDTH = 0.2; // meters
+const DEFAULT_ORIENTATION = "Up" as const;
+
+/**
+ * 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 function registerTriggerImageTargets(
+  assets: StudioAsset[]
+): Map<string, string> {
+  const assetsWithTrigger = assets.filter(
+    (a): a is StudioAsset & { trigger_image_url: string } =>
+      !!a.trigger_image_url
+  );
+
+  if (assetsWithTrigger.length === 0) {
+    return new Map();
+  }
+
+  const urlToTargetName = new Map<string, string>();
+  const targets: Record<
+    string,
+    {
+      source: { uri: string };
+      orientation: string;
+      physicalWidth: number;
+      type: string;
+    }
+  > = {};
+
+  assetsWithTrigger.forEach((asset, index) => {
+    const targetName = `studio-trigger-${index}`;
+    urlToTargetName.set(asset.trigger_image_url, targetName);
+    targets[targetName] = {
+      source: { uri: asset.trigger_image_url },
+      orientation: asset.trigger_image_orientation ?? DEFAULT_ORIENTATION,
+      physicalWidth:
+        asset.trigger_image_physical_width_m ?? DEFAULT_PHYSICAL_WIDTH,
+      type: "Image",
+    };
+  });
+
+  ViroARTrackingTargets.createTargets(targets);
+  return urlToTargetName;
+}
+
+/**
+ * Cleans up trigger image targets when the scene unmounts.
+ */
+export function cleanupTriggerImageTargets(targetNames: string[]): void {
+  targetNames.forEach((name) => {
+    try {
+      ViroARTrackingTargets.deleteTarget(name);
+    } catch (error) {
+      console.warn(`[Studio] Failed to delete trigger target "${name}":`, error);
+    }
+  });
+}

package/components/Studio/domain/useStudioShaderTimeUniforms.ts

@@ -0,0 +1,51 @@
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { ViroMaterials } from "../../Material/ViroMaterials";
+import { StudioAsset } from "../types";
+import {
+  materialConfigNeedsTimeUniform,
+  parseMaterialConfig,
+  studioMaterialName,
+} from "./materialConfig";
+
+/** ~60fps — matches Viro starter kit / shader docs. */
+const TIME_TICK_MS = 16;
+
+function computeTimeUniformPayload(assets: StudioAsset[]): { key: string; names: string[] } {
+  const names: string[] = [];
+  for (const asset of assets) {
+    if (asset.asset_type_name !== "3D-MODEL") continue;
+    if (asset.material_config == null) continue;
+    const config = parseMaterialConfig(asset.material_config);
+    if (!config || !materialConfigNeedsTimeUniform(config)) continue;
+    names.push(studioMaterialName(asset.id));
+  }
+  names.sort();
+  return { key: names.join("|"), names };
+}
+
+/**
+ * Drives the `time` shader uniform for materials that use animated presets.
+ * Uses `setInterval(16)` and `Date.now() % 1000000` like working Viro starter kits.
+ */
+export function useStudioShaderTimeUniforms(assets: StudioAsset[]): void {
+  const payload = useMemo(() => computeTimeUniformPayload(assets), [assets]);
+
+  const payloadRef = useRef(payload);
+  payloadRef.current = payload;
+
+  const applyTimeUniforms = useCallback(() => {
+    const { names } = payloadRef.current;
+    if (names.length === 0) return;
+    const time = Date.now() % 1_000_000;
+    for (const name of names) {
+      ViroMaterials.updateShaderUniform(name, "time", "float", time);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (payload.names.length === 0) return;
+    const id = setInterval(applyTimeUniforms, TIME_TICK_MS);
+    applyTimeUniforms();
+    return () => clearInterval(id);
+  }, [payload.key, applyTimeUniforms]);
+}

package/components/Studio/domain/useStudioShaderViewportUniforms.ts

@@ -0,0 +1,52 @@
+import { useCallback, useEffect, useMemo } from "react";
+import { Dimensions, PixelRatio } from "react-native";
+import { ViroMaterials } from "../../Material/ViroMaterials";
+import { StudioAsset } from "../types";
+import {
+  materialConfigNeedsViewportUniforms,
+  parseMaterialConfig,
+  studioMaterialName,
+} from "./materialConfig";
+
+function computeViewportPayload(assets: StudioAsset[]): {
+  key: string;
+  names: string[];
+} {
+  const names: string[] = [];
+  for (const asset of assets) {
+    if (asset.asset_type_name !== "3D-MODEL") continue;
+    if (asset.material_config == null) continue;
+    const config = parseMaterialConfig(asset.material_config);
+    if (!config || !materialConfigNeedsViewportUniforms(config)) continue;
+    names.push(studioMaterialName(asset.id));
+  }
+  names.sort();
+  return { key: names.join("|"), names };
+}
+
+/**
+ * Pushes _rf_vpw / _rf_vph (physical pixel dimensions) to materials that sample the camera
+ * feed via gl_FragCoord. Called on mount and whenever the screen dimensions change.
+ */
+export function useStudioShaderViewportUniforms(assets: StudioAsset[]): void {
+  const payload = useMemo(() => computeViewportPayload(assets), [assets]);
+
+  const pushViewport = useCallback(() => {
+    if (payload.names.length === 0) return;
+    const { width, height } = Dimensions.get("screen");
+    const pr = PixelRatio.get();
+    const pw = width * pr;
+    const ph = height * pr;
+    for (const name of payload.names) {
+      ViroMaterials.updateShaderUniform(name, "_rf_vpw", "float", pw);
+      ViroMaterials.updateShaderUniform(name, "_rf_vph", "float", ph);
+    }
+  }, [payload]);
+
+  useEffect(() => {
+    if (payload.names.length === 0) return;
+    pushViewport();
+    const sub = Dimensions.addEventListener("change", pushViewport);
+    return () => sub.remove();
+  }, [payload.key, pushViewport]);
+}

package/components/Studio/domain/viroNodeFactory.tsx

@@ -0,0 +1,323 @@
+import * as React from "react";
+import { Platform } from "react-native";
+import { Viro3DObject } from "../../Viro3DObject";
+import { ViroImage } from "../../ViroImage";
+import { ViroText } from "../../ViroText";
+import { ViroVideo } from "../../ViroVideo";
+import { StudioAnimation, StudioAsset, StudioSceneMeta, ViroAnimationProp } from "../types";
+import { executeFunctionWithRelations } from "./sceneNavigationHandler";
+import { parseMaterialConfig, studioMaterialName } from "./materialConfig";
+import { DragConfiguration } from "./dragConfiguration";
+import { buildViroPhysicsBody, parsePhysicsBodyConfig } from "./physicsConfig";
+
+type SceneNavigator = any;
+
+export type NodeConfig = {
+  position: [number, number, number];
+  rotation: [number, number, number];
+  scale: [number, number, number];
+  dragType?: "FixedDistance" | "FixedDistanceOrigin" | "FixedToWorld" | "FixedToPlane";
+  dragPlane?: { planePoint: [number, number, number]; planeNormal: [number, number, number]; maxDistance: number };
+  physicsBody?: Record<string, unknown>;
+  viroTag?: string;
+  onClick?: () => void;
+  animation?: ViroAnimationProp;
+};
+
+/**
+ * Derives the transform config for an asset.
+ * Clamps Z to -2 for non-trigger assets to guarantee visibility.
+ */
+export function createNodeConfig(
+  asset: StudioAsset,
+  sceneNavigator: SceneNavigator | undefined,
+  animations: StudioAnimation[],
+  scene: StudioSceneMeta | null,
+  onAnimationTrigger?: (targetAssetId: string, animKey: string) => void,
+  animationStates?: Record<string, ViroAnimationProp>,
+  onSceneChange?: (sceneId: string, sceneName: string) => void
+): NodeConfig {
+  const hasTriggerImage = !!asset.trigger_image_url;
+
+  let posZ = asset.position_z ?? -2;
+  if (!hasTriggerImage && posZ > -0.5) {
+    console.warn(
+      `[Studio/NodeFactory] Asset "${asset.name}" Z=${posZ} too close, clamping to -2`
+    );
+    posZ = -2;
+  }
+
+  const position: [number, number, number] = [
+    asset.position_x ?? 0,
+    asset.position_y ?? 0,
+    posZ,
+  ];
+
+  // Apply trigger image orientation offset to rotation Z
+  let rotationZ = asset.rotation_z ?? 0;
+  if (hasTriggerImage && asset.trigger_image_orientation) {
+    const offsets: Record<string, number> = {
+      Left: -90,
+      Right: 90,
+      Down: 180,
+      Up: 0,
+    };
+    rotationZ += offsets[asset.trigger_image_orientation] ?? 0;
+  }
+
+  const rotation: [number, number, number] = [
+    asset.rotation_x ?? 0,
+    asset.rotation_y ?? 0,
+    rotationZ,
+  ];
+
+  let scaleValue = asset.scale ?? 1;
+  if (scaleValue < 0.01) scaleValue = 0.1;
+  if (scaleValue > 10) scaleValue = 2;
+  const scale: [number, number, number] = [scaleValue, scaleValue, scaleValue];
+
+  const dragType = DragConfiguration.getDragType(asset, scene);
+
+  let dragPlane: NodeConfig["dragPlane"];
+  if (dragType === "FixedToPlane") {
+    dragPlane = DragConfiguration.getDragPlane(
+      scene?.plane_direction ?? "Horizontal",
+      position,
+    );
+  }
+
+  const parsedPhysics = parsePhysicsBodyConfig(asset.physics_config);
+  const physicsBody = parsedPhysics ? buildViroPhysicsBody(parsedPhysics) : undefined;
+  const viroTag = parsedPhysics ? asset.id : undefined;
+
+  const onClick = createOnClickHandler(
+    asset,
+    sceneNavigator,
+    animations,
+    onAnimationTrigger,
+    onSceneChange
+  );
+
+  const animation = animationStates?.[asset.id];
+
+  return { position, rotation, scale, dragType, dragPlane, physicsBody, viroTag, onClick, animation };
+}
+
+function createOnClickHandler(
+  asset: StudioAsset,
+  sceneNavigator: SceneNavigator | undefined,
+  animations: StudioAnimation[],
+  onAnimationTrigger?: (targetAssetId: string, animKey: string) => void,
+  onSceneChange?: (sceneId: string, sceneName: string) => void
+): (() => void) | undefined {
+  const fn = asset.scene_function;
+  if (!fn) return undefined;
+
+  if (fn.function_type === "NAVIGATION" && !fn.scene_navigation?.navigate_to) {
+    console.warn(`[Studio] Asset "${asset.name}" has NAVIGATION but no target scene`);
+    return undefined;
+  }
+  if (fn.function_type === "ALERT" && !fn.scene_alert) {
+    console.warn(`[Studio] Asset "${asset.name}" has ALERT but no alert data`);
+    return undefined;
+  }
+  if (fn.function_type === "ANIMATION" && !fn.scene_animation) {
+    console.warn(`[Studio] Asset "${asset.name}" has ANIMATION but no animation data`);
+    return undefined;
+  }
+
+  return () =>
+    executeFunctionWithRelations(fn, sceneNavigator, animations, onAnimationTrigger, 0, onSceneChange);
+}
+
+/** Resolves asset type from asset_type_name. */
+function resolveType(
+  asset: StudioAsset
+): "3D-MODEL" | "TEXT" | "IMAGE" | "VIDEO" | null {
+  return asset.asset_type_name ?? null;
+}
+
+/** Infers 3D model format from file extension. */
+function inferModelType(url: string): "GLB" | "GLTF" | "OBJ" | "VRX" {
+  const ext = url.toLowerCase().split(".").pop();
+  if (ext === "gltf") return "GLTF";
+  if (ext === "obj") return "OBJ";
+  if (ext === "vrx") return "VRX";
+  return "GLB";
+}
+
+function create3DObject(
+  asset: StudioAsset,
+  config: NodeConfig,
+  onAssetLoaded?: (id: string) => void,
+  onCollision?: (viroTag: string, collidedPoint: [number, number, number], collidedNormal: [number, number, number]) => void
+): React.ReactElement | null {
+  if (!asset.file_url) {
+    console.warn(`[Studio] 3D model "${asset.name}" has no file_url`);
+    return null;
+  }
+
+  const modelType = inferModelType(asset.file_url);
+
+  // Android: slightly reduce scale for stability
+  const scale =
+    Platform.OS === "android"
+      ? ([
+          config.scale[0] * 0.8,
+          config.scale[1] * 0.8,
+          config.scale[2] * 0.8,
+        ] as [number, number, number])
+      : config.scale;
+
+  const hasMaterialConfig = parseMaterialConfig(asset.material_config) !== null;
+  const shaderOverrides = hasMaterialConfig ? [studioMaterialName(asset.id)] : undefined;
+
+  return (
+    <Viro3DObject
+      key={asset.id}
+      source={{ uri: asset.file_url }}
+      position={config.position}
+      rotation={config.rotation}
+      scale={scale}
+      type={modelType}
+      dragType={config.dragType}
+      dragPlane={config.dragPlane}
+      animation={config.animation as any}
+      onClick={config.onClick}
+      renderingOrder={Platform.OS === "android" ? 1 : 0}
+      onLoadEnd={() => onAssetLoaded?.(asset.id)}
+      onError={(e) =>
+        console.error(`[Studio] 3D model "${asset.name}" error:`, e)
+      }
+      // Viro derives native canDrag from `onDrag != undefined`; without this prop
+      // the drag recognizer is never attached, even when dragType is set.
+      {...(config.dragType ? { onDrag: () => {} } : {})}
+      {...(shaderOverrides ? { shaderOverrides } : {})}
+      {...(config.physicsBody ? { physicsBody: config.physicsBody as any, viroTag: config.viroTag } : {})}
+      {...(onCollision ? { onCollision: onCollision as any } : {})}
+    />
+  );
+}
+
+function createImage(
+  asset: StudioAsset,
+  config: NodeConfig,
+  onAssetLoaded?: (id: string) => void
+): React.ReactElement | null {
+  if (!asset.file_url) {
+    console.warn(`[Studio] Image "${asset.name}" has no file_url`);
+    return null;
+  }
+
+  return (
+    <ViroImage
+      key={asset.id}
+      source={{ uri: asset.file_url }}
+      position={config.position}
+      rotation={config.rotation}
+      scale={config.scale}
+      dragType={config.dragType}
+      animation={config.animation as any}
+      onClick={config.onClick}
+      onLoadEnd={() => onAssetLoaded?.(asset.id)}
+      onError={(e) =>
+        console.error(`[Studio] Image "${asset.name}" error:`, e)
+      }
+      {...(config.dragType ? { onDrag: () => {} } : {})}
+    />
+  );
+}
+
+function createText(
+  asset: StudioAsset,
+  config: NodeConfig
+): React.ReactElement {
+  return (
+    <ViroText
+      key={asset.id}
+      text={asset.name ?? ""}
+      position={config.position}
+      rotation={config.rotation}
+      scale={config.scale}
+      dragType={config.dragType}
+      animation={config.animation as any}
+      onClick={config.onClick}
+      style={{
+        fontFamily: "Arial",
+        fontSize: 20,
+        color: "#FFFFFF",
+        textAlign: "center",
+      }}
+      {...(config.dragType ? { onDrag: () => {} } : {})}
+    />
+  );
+}
+
+function createVideo(
+  asset: StudioAsset,
+  config: NodeConfig
+): React.ReactElement | null {
+  if (!asset.file_url) {
+    console.warn(`[Studio] Video "${asset.name}" has no file_url`);
+    return null;
+  }
+
+  return (
+    <ViroVideo
+      key={asset.id}
+      source={{ uri: asset.file_url }}
+      position={config.position}
+      rotation={config.rotation}
+      scale={config.scale}
+      dragType={config.dragType}
+      animation={config.animation as any}
+      onClick={config.onClick}
+      loop={true}
+      muted={false}
+      onError={(e) =>
+        console.error(`[Studio] Video "${asset.name}" error:`, e)
+      }
+      {...(config.dragType ? { onDrag: () => {} } : {})}
+    />
+  );
+}
+
+/**
+ * Creates the appropriate Viro component for a StudioAsset.
+ */
+export function createNode(
+  asset: StudioAsset,
+  sceneNavigator: SceneNavigator | undefined,
+  animations: StudioAnimation[],
+  scene: StudioSceneMeta | null,
+  onAnimationTrigger?: (targetAssetId: string, animKey: string) => void,
+  animationStates?: Record<string, ViroAnimationProp>,
+  onAssetLoaded?: (id: string) => void,
+  onCollision?: (viroTag: string, collidedPoint: [number, number, number], collidedNormal: [number, number, number]) => void,
+  onSceneChange?: (sceneId: string, sceneName: string) => void
+): React.ReactElement | null {
+  const type = resolveType(asset);
+  const config = createNodeConfig(
+    asset,
+    sceneNavigator,
+    animations,
+    scene,
+    onAnimationTrigger,
+    animationStates,
+    onSceneChange
+  );
+
+  switch (type) {
+    case "3D-MODEL":
+      return create3DObject(asset, config, onAssetLoaded, onCollision);
+    case "IMAGE":
+      return createImage(asset, config, onAssetLoaded);
+    case "TEXT":
+      return createText(asset, config);
+    case "VIDEO":
+      return createVideo(asset, config);
+    default:
+      console.warn(`[Studio] Unknown asset type "${type}" for "${asset.name}"`);
+      return null;
+  }
+}

package/components/Studio/index.ts

@@ -0,0 +1,18 @@
+export { StudioARScene } from "./StudioARScene";
+export { StudioSceneNavigator } from "./StudioSceneNavigator";
+export type {
+  StudioAnimation,
+  StudioAsset,
+  StudioCollisionBinding,
+  StudioProjectApiResponse,
+  StudioProjectAsset,
+  StudioProjectMeta,
+  StudioProjectOpeningScene,
+  StudioProjectOverview,
+  StudioProjectSceneSummary,
+  StudioSceneCreatedBy,
+  StudioSceneFunction,
+  StudioSceneMeta,
+  StudioSceneResponse,
+  ViroAnimationProp,
+} from "./types";