feat(web): extend scene render audio and unit authoring

web/protocol/animation-render-commands.ts

@@ -29,4 +29,16 @@ export const animationRenderCommands = Object.freeze({
   setWorldProperties(dataId: string, properties: AnimationCommand<"setWorldProperties">["properties"]): AnimationCommand<"setWorldProperties"> {
     return { type: "setWorldProperties", dataId, properties };
   },
+  setSceneProperties(dataId: string, properties: AnimationCommand<"setSceneProperties">["properties"]): AnimationCommand<"setSceneProperties"> {
+    return { type: "setSceneProperties", dataId, properties: { ...properties } };
+  },
+  setSceneRenderSettings(dataId: string, properties: AnimationCommand<"setSceneRenderSettings">["properties"]): AnimationCommand<"setSceneRenderSettings"> {
+    return { type: "setSceneRenderSettings", dataId, properties: { ...properties } };
+  },
+  setSceneAudioSettings(dataId: string, properties: AnimationCommand<"setSceneAudioSettings">["properties"]): AnimationCommand<"setSceneAudioSettings"> {
+    return { type: "setSceneAudioSettings", dataId, properties: { ...properties } };
+  },
+  setSceneUnitSettings(dataId: string, properties: AnimationCommand<"setSceneUnitSettings">["properties"]): AnimationCommand<"setSceneUnitSettings"> {
+    return { type: "setSceneUnitSettings", dataId, properties: { ...properties } };
+  },
 } satisfies Record<string, (...args: never[]) => WebEngineEditCommand>);

web/protocol/scene-ir.ts

@@ -531,6 +531,31 @@ export interface SceneIR {
     tint?: number;
     whiteBalanceStatus?: "AVAILABLE" | "BLOCKED";
   };
+  renderSettings?: {
+    resolutionX: number;
+    resolutionY: number;
+    resolutionPercentage: number;
+    frameStart: number;
+    frameEnd: number;
+    outputPath: string;
+  };
+  audioSettings?: {
+    volume: number;
+    speedOfSound: number;
+    dopplerFactor: number;
+    distanceModel: number;
+    muted: boolean;
+    sync: boolean;
+  };
+  unitSettings?: {
+    system: number;
+    scaleLength: number;
+    rotationSystem: number;
+    lengthUnit: number;
+    massUnit: number;
+    timeUnit: number;
+    temperatureUnit: number;
+  };
   compositorGraph?: CompositorGraphIR;
   compositorStatus?: "AVAILABLE" | "BLOCKED";
   sequencerTimeline?: SequencerTimelineIR;
@@ -1524,6 +1549,20 @@ export function parseSceneSnapshotIR(value: unknown): SceneSnapshotIR {
       for (const field of ["temperature", "tint"] as const) if (scene.colorManagement[field] !== undefined) requireNumber(scene.colorManagement[field], `scenes[${index}].colorManagement.${field}`);
       if (scene.colorManagement.whiteBalanceStatus !== undefined && !["AVAILABLE", "BLOCKED"].includes(scene.colorManagement.whiteBalanceStatus as string)) throw new Error(`scenes[${index}].colorManagement.whiteBalanceStatus is invalid`);
     }
+    if (scene.renderSettings !== undefined) {
+      if (!isRecord(scene.renderSettings)) throw new Error(`SceneIR.scenes[${index}].renderSettings must be an object`);
+      for (const field of ["resolutionX", "resolutionY", "resolutionPercentage", "frameStart", "frameEnd"] as const) requireNumber(scene.renderSettings[field], `scenes[${index}].renderSettings.${field}`);
+      requireString(scene.renderSettings.outputPath, `scenes[${index}].renderSettings.outputPath`);
+    }
+    if (scene.audioSettings !== undefined) {
+      if (!isRecord(scene.audioSettings)) throw new Error(`SceneIR.scenes[${index}].audioSettings must be an object`);
+      for (const field of ["volume", "speedOfSound", "dopplerFactor", "distanceModel"] as const) requireNumber(scene.audioSettings[field], `scenes[${index}].audioSettings.${field}`);
+      for (const field of ["muted", "sync"] as const) requireBoolean(scene.audioSettings[field], `scenes[${index}].audioSettings.${field}`);
+    }
+    if (scene.unitSettings !== undefined) {
+      if (!isRecord(scene.unitSettings)) throw new Error(`SceneIR.scenes[${index}].unitSettings must be an object`);
+      for (const field of ["system", "scaleLength", "rotationSystem", "lengthUnit", "massUnit", "timeUnit", "temperatureUnit"] as const) requireNumber(scene.unitSettings[field], `scenes[${index}].unitSettings.${field}`);
+    }
     if (scene.compositorStatus !== undefined && !["AVAILABLE", "BLOCKED"].includes(scene.compositorStatus as string)) {
       throw new Error(`scenes[${index}].compositorStatus is invalid`);
     }

web/protocol/web-engine-capabilities.ts

@@ -79,6 +79,10 @@ export const WEB_ENGINE_COMMAND_CAPABILITIES = {
   setLightProperties: { family: "RENDER", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
   setCameraProperties: { family: "RENDER", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
   setWorldProperties: { family: "RENDER", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
+  setSceneProperties: { family: "CORE_SCENE_GRAPH", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
+  setSceneRenderSettings: { family: "CORE_SCENE_GRAPH", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
+  setSceneAudioSettings: { family: "CORE_SCENE_GRAPH", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
+  setSceneUnitSettings: { family: "CORE_SCENE_GRAPH", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
   setMetaballElements: { family: "GEOMETRY", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
   sculptStroke: { family: "SCULPT", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },
   setSculptMeshAttributes: { family: "SCULPT", route: "MAIN_AUTHORITATIVE", implementation: "SOURCE_BACKED" },

web/protocol/web-engine.ts

@@ -143,6 +143,10 @@ export type WebEngineEditCommand =
   | { type: "setLightProperties"; dataId: string; properties: { color?: [number, number, number]; energy?: number; exposure?: number; temperature?: number; useTemperature?: boolean; castsShadow?: boolean; radius?: number; spotAngle?: number; spotBlend?: number; areaSize?: number; areaSizeY?: number; areaSpread?: number; sunAngle?: number } }
   | { type: "setCameraProperties"; dataId: string; properties: { projection?: "PERSPECTIVE" | "ORTHOGRAPHIC"; lensMm?: number; sensorWidthMm?: number; sensorHeightMm?: number; sensorFit?: 0 | 1 | 2; shift?: [number, number]; near?: number; far?: number; orthoScale?: number; depthOfField?: { enabled?: boolean; focusDistance?: number; apertureFStop?: number; apertureBlades?: number; apertureRotation?: number; apertureRatio?: number } } }
   | { type: "setWorldProperties"; dataId: string; properties: { color?: [number, number, number]; exposure?: number; mist?: { enabled?: boolean; type?: "QUADRATIC" | "LINEAR" | "INVERSE_QUADRATIC"; start?: number; depth?: number; intensity?: number; height?: number } } }
+  | { type: "setSceneProperties"; dataId: string; properties: { renderEngine?: string; viewTransform?: string; look?: string; exposure?: number; gamma?: number } }
+  | { type: "setSceneRenderSettings"; dataId: string; properties: { resolutionX?: number; resolutionY?: number; resolutionPercentage?: number; frameStart?: number; frameEnd?: number; outputPath?: string } }
+  | { type: "setSceneAudioSettings"; dataId: string; properties: { volume?: number; speedOfSound?: number; dopplerFactor?: number; distanceModel?: number; muted?: boolean; sync?: boolean } }
+  | { type: "setSceneUnitSettings"; dataId: string; properties: { system?: number; scaleLength?: number; rotationSystem?: number; lengthUnit?: number; massUnit?: number; timeUnit?: number; temperatureUnit?: number } }
   | { type: "setMetaballElements"; dataId: string; elements: Array<{ type: number; position: [number, number, number]; radius: number; scale: [number, number, number] }> }
   | { type: "sculptStroke"; stroke: SculptStrokeIR }
   | { type: "setSculptMeshAttributes"; attributes: SculptMeshAttributesIR }

web/protocol/workbench-command-groups.ts

@@ -4,7 +4,7 @@ export const WORKBENCH_COMMAND_GROUPS = Object.freeze({
   OBJECT: ["createPrimitive", "duplicateObject", "deleteObject", "setObjectTransform", "setParent", "createCollection", "moveObjectToCollection", "renameId", "applyObjectTransform", "setObjectOrigin"],
   MESH: ["meshEdit", "translateMeshVertices", "createUVMap", "setActiveUVMap", "unwrapUV", "setVertexColors", "setVertexWeights"],
   ANIMATION: ["setFrame", "insertObjectKeyframe", "deleteObjectKeyframe", "setFCurveInterpolation", "setConstraint", "setNLAStack"],
-  RENDER: ["setCameraProperties", "setLightProperties", "setWorldProperties"],
+  RENDER: ["setCameraProperties", "setLightProperties", "setWorldProperties", "setSceneProperties", "setSceneRenderSettings", "setSceneAudioSettings", "setSceneUnitSettings"],
   IO: ["importImage", "importVFont", "setMaterialImageNode"],
 } as const satisfies Record<string, readonly WebEngineCommandType[]>);