@auraindustry/aurajs 0.0.7 → 0.1.0

package/templates/create/3d/scenes/gameplay.scene.js

@@ -0,0 +1,292 @@
+import {
+  axisFromKeys,
+  createInteractionPromptState,
+  createGoalZone,
+  createProximityTrigger3D,
+  createTriggerTracker,
+  distanceSquared3D,
+  isGoalReached,
+  respawnAtCheckpoint,
+  setAvatarInput3D,
+  spawnCharacterAvatar3D,
+  stepVolumeTriggers3D,
+  stepMovingPlatform3D,
+  tickCharacterAvatar3D,
+  updateInteractionPromptState,
+  updateCheckpointProgress,
+} from '../src/starter-utils/index.js';
+import {
+  GOAL_ZONE,
+  HUD_TARGET_PICKUPS,
+  WORLD_LIMIT,
+} from '../content/gameplay/course.js';
+import { bindPlayerAvatarVisual, drawPlatformerActors, loadPlayerAvatarVisual } from '../prefabs/player.prefab.js';
+import { drawPlatformerCourse, syncPlatformerCharacterObstacles } from '../prefabs/world.prefab.js';
+import { createPlatformerMaterials } from '../src/runtime/materials.js';
+import { advancePickupState, createPlatformerRunState } from '../src/runtime/state.js';
+
+function createPlatformerSessionSeed() {
+  return {
+    runsStarted: 0,
+    bestScore: 0,
+    lastOutcome: 'idle',
+    lastSceneId: 'gameplay',
+  };
+}
+
+function ensurePlatformerSession(context, appState) {
+  if (typeof context.ensureSessionState === 'function') {
+    return context.ensureSessionState('platformer', createPlatformerSessionSeed());
+  }
+  if (!appState.session || typeof appState.session !== 'object' || Array.isArray(appState.session)) {
+    appState.session = {};
+  }
+  if (!appState.session.platformer || typeof appState.session.platformer !== 'object' || Array.isArray(appState.session.platformer)) {
+    appState.session.platformer = createPlatformerSessionSeed();
+  }
+  return appState.session.platformer;
+}
+
+function createPlatformerUiStateSeed() {
+  return {
+    showControlsHint: true,
+  };
+}
+
+function ensurePlatformerUiState(context, appState) {
+  if (typeof context.ensureUiState === 'function') {
+    return context.ensureUiState('platformerHud', createPlatformerUiStateSeed());
+  }
+  if (!appState.ui || typeof appState.ui !== 'object' || Array.isArray(appState.ui)) {
+    appState.ui = {};
+  }
+  if (!appState.ui.platformerHud || typeof appState.ui.platformerHud !== 'object' || Array.isArray(appState.ui.platformerHud)) {
+    appState.ui.platformerHud = createPlatformerUiStateSeed();
+  }
+  return appState.ui.platformerHud;
+}
+
+export function createGameplayScene(context = {}) {
+  const appState = context.appState || {};
+  const platformerSession = ensurePlatformerSession(context, appState);
+  const platformerUiState = ensurePlatformerUiState(context, appState);
+  const projectTitle = context.projectTitle || 'AuraJS Game';
+  const goalZone = createGoalZone(GOAL_ZONE);
+  const promptState = createInteractionPromptState();
+  const triggerTracker = createTriggerTracker({
+    subjectId: 'player',
+    dimension: '3d',
+  });
+  let boxMesh = null;
+  let materials = null;
+  let playerVisual = null;
+  let sceneState = createPlatformerRunState();
+
+  function syncSessionState() {
+    platformerSession.lastSceneId = 'gameplay';
+    platformerSession.bestScore = Math.max(Number(platformerSession.bestScore || 0), sceneState.score);
+    platformerSession.lastScore = sceneState.score;
+    platformerSession.lastOutcome = sceneState.levelComplete ? 'level-complete' : 'running';
+  }
+
+  function isPauseOpen() {
+    const shellState = context.getScreenShellState?.();
+    return Array.isArray(shellState?.modals) && shellState.modals.some((entry) => entry.screenId === 'pause');
+  }
+
+  function syncHud() {
+    context.setHudScreen?.('hud', {
+      score: sceneState.score,
+      levelComplete: sceneState.levelComplete,
+      promptText: promptState.promptText || '',
+      paused: isPauseOpen(),
+      showControlsHint: platformerUiState.showControlsHint !== false,
+    });
+  }
+
+  function buildPromptTriggers() {
+    const nextCheckpointIndex = Math.min(
+      sceneState.checkpointSystem.activeIndex + 1,
+      sceneState.checkpointSystem.checkpoints.length - 1,
+    );
+    const nextCheckpoint = sceneState.checkpointSystem.checkpoints[nextCheckpointIndex] || null;
+    const triggers = [];
+
+    if (nextCheckpoint && nextCheckpointIndex > sceneState.checkpointSystem.activeIndex) {
+      triggers.push(createProximityTrigger3D(
+        `checkpoint-${nextCheckpointIndex}`,
+        nextCheckpoint.x,
+        nextCheckpoint.y,
+        nextCheckpoint.z,
+        nextCheckpoint.radius + 0.35,
+        {
+          role: 'checkpoint',
+          priority: 2,
+          promptText: 'Checkpoint nearby',
+        },
+      ));
+    }
+
+    if (sceneState.score >= HUD_TARGET_PICKUPS) {
+      triggers.push(createProximityTrigger3D('goal-zone', GOAL_ZONE.x, GOAL_ZONE.y, GOAL_ZONE.z, GOAL_ZONE.radius + 0.4, {
+        role: 'objective',
+        priority: 5,
+        promptText: 'Goal ready. Reach the finish.',
+      }));
+    } else {
+      triggers.push(createProximityTrigger3D('pickup-shard', sceneState.pickup.x, sceneState.pickup.y, sceneState.pickup.z, 1.1, {
+        role: 'objective',
+        priority: 4,
+        promptText: 'Collect the relic shard',
+      }));
+    }
+
+    return triggers;
+  }
+
+  function updatePromptState() {
+    const triggerStep = stepVolumeTriggers3D(triggerTracker, sceneState.player.position, buildPromptTriggers());
+    updateInteractionPromptState(promptState, triggerStep, {
+      interactPressed: false,
+    });
+  }
+
+  function syncPauseModal() {
+    if (!aura.input.isKeyPressed('escape')) return false;
+
+    const shellState = context.getScreenShellState?.();
+    const topModal = shellState?.modals?.[shellState.modals.length - 1] || null;
+    if (topModal) {
+      context.popModalScreen?.({
+        resumeReason: 'resume',
+      });
+      return true;
+    }
+
+    const pauseData = {
+      score: sceneState.score,
+      levelComplete: sceneState.levelComplete,
+    };
+    context.pushModalScreen?.('pause', pauseData);
+    return true;
+  }
+
+  function resetRun() {
+    sceneState = createPlatformerRunState(sceneState?.player ?? null);
+    if (!playerVisual) return;
+    bindPlayerAvatarVisual(sceneState.player, playerVisual);
+    syncPlatformerCharacterObstacles(sceneState.movingPlatform);
+    spawnCharacterAvatar3D(aura, sceneState.player, { position: sceneState.player.position });
+    updatePromptState();
+    platformerSession.runsStarted += 1;
+    syncSessionState();
+    syncHud();
+  }
+
+  function updateMovement(dt) {
+    const moveX = axisFromKeys(aura.input, ['arrowleft', 'a'], ['arrowright', 'd']);
+    const moveZ = axisFromKeys(aura.input, ['arrowup', 'w'], ['arrowdown', 's']);
+    const jumpedThisFrame = aura.input.isKeyPressed('space');
+    const runningThisFrame = aura.input.isKeyDown('shift') || aura.input.isKeyDown('shiftleft') || aura.input.isKeyDown('shiftright');
+    if (platformerUiState.showControlsHint && (moveX !== 0 || moveZ !== 0 || jumpedThisFrame || runningThisFrame)) {
+      platformerUiState.showControlsHint = false;
+    }
+    setAvatarInput3D(sceneState.player, {
+      moveX,
+      moveZ,
+      jump: jumpedThisFrame,
+      run: runningThisFrame,
+    });
+    tickCharacterAvatar3D(aura, sceneState.player, dt);
+    sceneState.player.position.x = Math.max(-WORLD_LIMIT, Math.min(WORLD_LIMIT, sceneState.player.position.x));
+    sceneState.player.position.z = Math.max(-WORLD_LIMIT, Math.min(WORLD_LIMIT, sceneState.player.position.z));
+    spawnCharacterAvatar3D(aura, sceneState.player, { position: sceneState.player.position });
+  }
+
+  function updateProgress() {
+    if (sceneState.player.position.y < -10) {
+      if (!respawnAtCheckpoint(sceneState.checkpointSystem, sceneState.player)) {
+        resetRun();
+        return false;
+      }
+      spawnCharacterAvatar3D(aura, sceneState.player, { position: sceneState.player.position });
+    }
+
+    if (distanceSquared3D(sceneState.player, sceneState.pickup) <= 0.8) {
+      advancePickupState(sceneState);
+    }
+
+    updateCheckpointProgress(sceneState.checkpointSystem, sceneState.player);
+    if (sceneState.score >= HUD_TARGET_PICKUPS && isGoalReached(goalZone, sceneState.player)) {
+      sceneState.levelComplete = true;
+      syncSessionState();
+    }
+    return true;
+  }
+
+  return {
+    setup() {
+      boxMesh = aura.mesh.createBox();
+      materials = createPlatformerMaterials();
+      playerVisual = loadPlayerAvatarVisual();
+
+      aura.light.ambient({ r: 1, g: 1, b: 1 }, 0.22);
+      aura.light.directional({ x: 0.6, y: -1.0, z: -0.4 }, { r: 1, g: 1, b: 1 }, 1.0);
+      aura.camera3d.perspective(62, 0.1, 140);
+
+      resetRun();
+      syncHud();
+      console.log(`${projectTitle} started (3D platformer template)`);
+    },
+    update(dt) {
+      if (syncPauseModal()) {
+        syncHud();
+        return;
+      }
+      if (isPauseOpen()) {
+        syncHud();
+        return;
+      }
+
+      sceneState.elapsed += dt;
+      stepMovingPlatform3D(sceneState.movingPlatform, dt);
+      syncPlatformerCharacterObstacles(sceneState.movingPlatform);
+
+      if (sceneState.levelComplete) {
+        if (aura.input.isKeyPressed('enter')) {
+          resetRun();
+        }
+        syncHud();
+        return;
+      }
+
+      updateMovement(dt);
+      if (!updateProgress()) return;
+      updatePromptState();
+      syncSessionState();
+      syncHud();
+    },
+    onResume() {
+      syncHud();
+    },
+    onExit() {
+      context.clearHudScreen?.();
+    },
+    draw() {
+      aura.draw3d.clear3d({ r: 0.06, g: 0.08, b: 0.12 });
+      drawPlatformerCourse({
+        mesh: boxMesh,
+        floorMaterial: materials.floor,
+        platformMaterial: materials.platform,
+        movingPlatform: sceneState.movingPlatform,
+      });
+      drawPlatformerActors({
+        mesh: boxMesh,
+        materials,
+        state: sceneState,
+        goalZone,
+      });
+      aura.scene3d.submitRenderBindings();
+    },
+  };
+}

package/templates/create/3d/src/main.js

@@ -1,306 +1,17 @@
-// {{PROJECT_TITLE}} — AuraJS 3D platformer starter
+// {{PROJECT_TITLE}} - AuraJS 3D platformer starter
 
-import { activeCheckpoint, axisFromKeys, clamp, createCheckpointSystem, createGoalZone, createMovingPlatform3D, distanceSquared3D, isGoalReached, respawnAtCheckpoint, stepVerticalMotion, stepMovingPlatform3D, tryJump, updateCheckpointProgress } from './starter-utils/index.js';
+import { createApp } from './runtime/app.js';
 
-const PLAYER_HALF = { x: 0.45, y: 0.55, z: 0.45 };
-const MOVE_SPEED = 5.3;
-const JUMP_SPEED = 8.2;
-const GRAVITY = 20.0;
-const WORLD_LIMIT = 9.0;
-
-const STATIC_PLATFORMS = [
-  { x: -3.2, y: 1.2, z: -2.4, sx: 3.0, sy: 0.5, sz: 2.2 },
-  { x: 1.4, y: 2.4, z: -0.8, sx: 2.8, sy: 0.5, sz: 2.0 },
-  { x: 4.4, y: 3.8, z: -3.0, sx: 3.4, sy: 0.5, sz: 2.0 },
-];
-const CHECKPOINTS = [
-  { x: 0, y: 1.1, z: 5.5, radius: 1.4 },
-  { x: -3.2, y: 2.0, z: -2.4, radius: 1.25 },
-  { x: 1.4, y: 3.2, z: -0.8, radius: 1.25 },
-  { x: 4.4, y: 4.6, z: -3.0, radius: 1.3 },
-];
-
-let boxMesh;
-let floorMat;
-let platformMat;
-let playerMat;
-let pickupMat;
-let checkpointMat;
-let goalMat;
-
-let player = { x: 0, y: 1.1, z: 5.5, vy: 0, onGround: false };
-let pickup = { x: 4.4, y: 4.6, z: -3.0 };
-let score = 0;
-let elapsed = 0;
-let levelComplete = false;
-let checkpointSystem = createCheckpointSystem({ checkpoints: CHECKPOINTS });
-let movingPlatform = createMovingPlatform3D({
-  from: { x: -0.2, y: 1.8, z: 2.2 },
-  to: { x: 3.1, y: 3.0, z: 0.8 },
-  size: { x: 2.4, y: 0.4, z: 2.0 },
-  periodSeconds: 3.2,
-});
-const goalZone = createGoalZone({ x: 4.4, y: 4.8, z: -3.0, radius: 1.15 });
-
-function hasMethod(obj, method) {
-  return Boolean(obj) && typeof obj[method] === 'function';
-}
-
-function failWithReason(reasonCode, message) {
-  throw new Error(`[3d-platformer-template] ${message} [reason:${reasonCode}]`);
-}
-
-function assertRuntimeCapabilities() {
-  const missing = [];
-  if (!hasMethod(aura.mesh, 'createBox')) missing.push('aura.mesh.createBox');
-  if (!hasMethod(aura.material, 'create')) missing.push('aura.material.create');
-  if (!hasMethod(aura.light, 'ambient')) missing.push('aura.light.ambient');
-  if (!hasMethod(aura.light, 'directional')) missing.push('aura.light.directional');
-  if (!hasMethod(aura.camera3d, 'perspective')) missing.push('aura.camera3d.perspective');
-  if (!hasMethod(aura.camera3d, 'setPosition')) missing.push('aura.camera3d.setPosition');
-  if (!hasMethod(aura.camera3d, 'lookAt')) missing.push('aura.camera3d.lookAt');
-  if (!hasMethod(aura.input, 'isKeyDown')) missing.push('aura.input.isKeyDown');
-  if (!hasMethod(aura.input, 'isKeyPressed')) missing.push('aura.input.isKeyPressed');
-  if (!hasMethod(aura.draw3d, 'clear3d')) missing.push('aura.draw3d.clear3d');
-  if (!hasMethod(aura.draw3d, 'drawMesh')) missing.push('aura.draw3d.drawMesh');
-  if (!hasMethod(aura.draw2d, 'text')) missing.push('aura.draw2d.text');
-  if (!hasMethod(aura.draw2d, 'measureText')) missing.push('aura.draw2d.measureText');
-  if (typeof aura.rgb !== 'function') missing.push('aura.rgb');
-  if (!aura.Color || !aura.Color.WHITE) missing.push('aura.Color.WHITE');
-
-  if (missing.length > 0) {
-    failWithReason('missing_runtime_api', `runtime missing required APIs: ${missing.join(', ')}`);
-  }
-
-  const small = aura.draw2d.measureText('Probe', { size: 8 });
-  const large = aura.draw2d.measureText('Probe', { size: 24 });
-  if (!Number.isFinite(Number(small?.width)) || !Number.isFinite(Number(large?.width)) || Number(large.width) <= Number(small.width)) {
-    failWithReason(
-      'placeholder_runtime_behavior',
-      'draw2d.measureText appears to be placeholder behavior (size does not affect width).',
-    );
-  }
-}
-
-function resetRun() {
-  player = { x: 0, y: 1.1, z: 5.5, vy: 0, onGround: false };
-  pickup = { x: 4.4, y: 4.6, z: -3.0 };
-  score = 0;
-  elapsed = 0;
-  levelComplete = false;
-  checkpointSystem = createCheckpointSystem({ checkpoints: CHECKPOINTS });
-  movingPlatform = createMovingPlatform3D({
-    from: { x: -0.2, y: 1.8, z: 2.2 },
-    to: { x: 3.1, y: 3.0, z: 0.8 },
-    size: { x: 2.4, y: 0.4, z: 2.0 },
-    periodSeconds: 3.2,
-  });
-}
-
-function findSupportTop(x, z) {
-  let top = 0;
-
-  const includePlatform = (platform) => {
-    const hx = platform.sx * 0.5;
-    const hz = platform.sz * 0.5;
-    if (Math.abs(x - platform.x) > hx || Math.abs(z - platform.z) > hz) return;
-    top = Math.max(top, platform.y + (platform.sy * 0.5));
-  };
-
-  for (const platform of STATIC_PLATFORMS) {
-    includePlatform(platform);
-  }
-
-  includePlatform({
-    x: movingPlatform.position.x,
-    y: movingPlatform.position.y,
-    z: movingPlatform.position.z,
-    sx: movingPlatform.size.x,
-    sy: movingPlatform.size.y,
-    sz: movingPlatform.size.z,
-  });
-
-  return top;
-}
-
-function collectPickup() {
-  if (levelComplete) return;
-  if (distanceSquared3D(player, pickup) > 0.8) return;
-
-  score += 1;
-  if (score % 3 === 0) {
-    pickup = { x: 0, y: 3.0, z: -4.0 };
-  } else if (score % 2 === 0) {
-    pickup = { x: -3.2, y: 2.0, z: -2.4 };
-  } else {
-    pickup = { x: 1.4, y: 3.2, z: -0.8 };
-  }
-}
+const app = createApp();
 
 aura.setup = function () {
-  assertRuntimeCapabilities();
-  boxMesh = aura.mesh.createBox();
-
-  floorMat = aura.material.create({
-    color: { r: 0.18, g: 0.28, b: 0.2, a: 1.0 },
-    metallic: 0.05,
-    roughness: 0.95,
-  });
-
-  platformMat = aura.material.create({
-    color: { r: 0.42, g: 0.56, b: 0.78, a: 1.0 },
-    metallic: 0.1,
-    roughness: 0.6,
-  });
-
-  playerMat = aura.material.create({
-    color: { r: 0.98, g: 0.52, b: 0.26, a: 1.0 },
-    metallic: 0.25,
-    roughness: 0.35,
-  });
-
-  pickupMat = aura.material.create({
-    color: { r: 0.95, g: 0.9, b: 0.3, a: 1.0 },
-    metallic: 0.65,
-    roughness: 0.25,
-  });
-
-  checkpointMat = aura.material.create({
-    color: { r: 0.36, g: 0.9, b: 1.0, a: 1.0 },
-    metallic: 0.45,
-    roughness: 0.28,
-  });
-
-  goalMat = aura.material.create({
-    color: { r: 0.5, g: 1.0, b: 0.64, a: 1.0 },
-    metallic: 0.35,
-    roughness: 0.35,
-  });
-
-  aura.light.ambient({ r: 1, g: 1, b: 1 }, 0.22);
-  aura.light.directional({ x: 0.6, y: -1.0, z: -0.4 }, { r: 1, g: 1, b: 1 }, 1.0);
-  aura.camera3d.perspective(62, 0.1, 140);
-
-  resetRun();
-  console.log('{{PROJECT_TITLE}} started (3D platformer template)');
+  app.setup();
 };
 
 aura.update = function (dt) {
-  elapsed += dt;
-  stepMovingPlatform3D(movingPlatform, dt);
-
-  if (levelComplete) {
-    if (aura.input.isKeyPressed('enter')) resetRun();
-    return;
-  }
-
-  const moveX = axisFromKeys(aura.input, ['arrowleft', 'a'], ['arrowright', 'd']);
-  const moveZ = axisFromKeys(aura.input, ['arrowup', 'w'], ['arrowdown', 's']);
-
-  player.x += moveX * MOVE_SPEED * dt;
-  player.z += moveZ * MOVE_SPEED * dt;
-  player.x = clamp(player.x, -WORLD_LIMIT, WORLD_LIMIT);
-  player.z = clamp(player.z, -WORLD_LIMIT, WORLD_LIMIT);
-
-  if (aura.input.isKeyPressed('space')) {
-    tryJump(player, JUMP_SPEED);
-  }
-
-  const supportTop = findSupportTop(player.x, player.z);
-  const floorY = supportTop + PLAYER_HALF.y;
-  stepVerticalMotion(player, dt, GRAVITY, floorY);
-
-  if (player.y < -10) {
-    if (!respawnAtCheckpoint(checkpointSystem, player)) {
-      resetRun();
-    }
-  }
-
-  collectPickup();
-  updateCheckpointProgress(checkpointSystem, player);
-  if (score >= 3 && isGoalReached(goalZone, player)) {
-    levelComplete = true;
-  }
-
-  aura.camera3d.setPosition(player.x + 7.4, player.y + 6.0, player.z + 8.8);
-  aura.camera3d.lookAt(player.x, player.y + 0.2, player.z);
+  app.update(dt);
 };
 
 aura.draw = function () {
-  aura.draw3d.clear3d({ r: 0.06, g: 0.08, b: 0.12 });
-
-  aura.draw3d.drawMesh(boxMesh, floorMat, {
-    position: { x: 0, y: -0.5, z: 0 },
-    rotation: { x: 0, y: 0, z: 0 },
-    scale: { x: 24, y: 1, z: 24 },
-  });
-
-  for (const platform of STATIC_PLATFORMS) {
-    aura.draw3d.drawMesh(boxMesh, platformMat, {
-      position: { x: platform.x, y: platform.y, z: platform.z },
-      rotation: { x: 0, y: 0, z: 0 },
-      scale: { x: platform.sx, y: platform.sy, z: platform.sz },
-    });
-  }
-
-  aura.draw3d.drawMesh(boxMesh, platformMat, {
-    position: { x: movingPlatform.position.x, y: movingPlatform.position.y, z: movingPlatform.position.z },
-    rotation: { x: 0, y: 0, z: 0 },
-    scale: { x: movingPlatform.size.x, y: movingPlatform.size.y, z: movingPlatform.size.z },
-  });
-
-  aura.draw3d.drawMesh(boxMesh, playerMat, {
-    position: { x: player.x, y: player.y, z: player.z },
-    rotation: { x: 0, y: elapsed * 1.2, z: 0 },
-    scale: { x: PLAYER_HALF.x * 2, y: PLAYER_HALF.y * 2, z: PLAYER_HALF.z * 2 },
-  });
-
-  aura.draw3d.drawMesh(boxMesh, pickupMat, {
-    position: { x: pickup.x, y: pickup.y + (Math.sin(elapsed * 2.5) * 0.2), z: pickup.z },
-    rotation: { x: elapsed * 0.4, y: elapsed * 1.5, z: elapsed * 0.3 },
-    scale: { x: 0.55, y: 0.55, z: 0.55 },
-  });
-
-  const checkpoint = activeCheckpoint(checkpointSystem);
-  if (checkpoint) {
-    aura.draw3d.drawMesh(boxMesh, checkpointMat, {
-      position: { x: checkpoint.x, y: checkpoint.y - 0.4, z: checkpoint.z },
-      rotation: { x: 0, y: elapsed * 0.7, z: 0 },
-      scale: { x: 0.45, y: 0.45, z: 0.45 },
-    });
-  }
-
-  aura.draw3d.drawMesh(boxMesh, goalMat, {
-    position: { x: goalZone.x, y: goalZone.y, z: goalZone.z },
-    rotation: { x: 0, y: elapsed * 0.9, z: 0 },
-    scale: { x: goalZone.radius * 1.2, y: goalZone.radius * 1.2, z: goalZone.radius * 1.2 },
-  });
-
-  aura.draw2d.text('Move: Arrows/WASD  Jump: Space', 12, 12, {
-    color: aura.Color.WHITE,
-    size: 14,
-    align: 'left',
-  });
-  aura.draw2d.text(`Pickups ${score}/3`, 12, 34, {
-    color: aura.Color.WHITE,
-    size: 14,
-    align: 'left',
-  });
-  aura.draw2d.text('Reach checkpoints. Goal unlocks at 3 pickups.', 12, 56, {
-    color: aura.Color.WHITE,
-    size: 13,
-    align: 'left',
-  });
-  if (levelComplete) {
-    aura.draw2d.text('GOAL REACHED', 12, 84, {
-      color: aura.rgb(0.5, 1.0, 0.64),
-      size: 24,
-      align: 'left',
-    });
-    aura.draw2d.text('Press Enter to restart', 12, 112, {
-      color: aura.Color.WHITE,
-      size: 16,
-      align: 'left',
-    });
-  }
+  app.draw();
 };

package/templates/create/3d/src/runtime/app.js

@@ -0,0 +1,49 @@
+import { createSceneRegistry } from './scene-registry.js';
+import { createProjectInspector } from './project-inspector.js';
+import { assertRuntimeCapabilities } from './capabilities.js';
+
+export function createApp() {
+  const sceneRegistry = createSceneRegistry({
+    projectTitle: '{{PROJECT_TITLE}}',
+  });
+  const projectInspector = createProjectInspector();
+  let activeSceneId = sceneRegistry.defaultSceneId || Object.keys(sceneRegistry.scenes)[0] || null;
+
+  const activeScene = () => (activeSceneId ? sceneRegistry.scenes[activeSceneId] || null : null);
+
+  return {
+    get activeSceneId() {
+      return activeSceneId;
+    },
+    get sceneRegistry() {
+      return sceneRegistry;
+    },
+    get projectInspectorEnabled() {
+      return projectInspector.enabled;
+    },
+    getProjectInspectorState() {
+      return projectInspector.snapshot({ activeSceneId });
+    },
+    setup() {
+      assertRuntimeCapabilities();
+      activeScene()?.setup?.();
+    },
+    update(dt) {
+      projectInspector.syncInput(globalThis.aura?.input || null);
+      activeScene()?.update?.(dt);
+    },
+    draw() {
+      activeScene()?.draw?.();
+      projectInspector.draw({ activeSceneId });
+    },
+    toggleProjectInspector(nextEnabled) {
+      return projectInspector.toggle(nextEnabled);
+    },
+    swapScene(nextSceneId) {
+      if (!sceneRegistry.scenes[nextSceneId]) {
+        throw new Error(`Unknown scene "${nextSceneId}".`);
+      }
+      activeSceneId = nextSceneId;
+    },
+  };
+}