Provides API for custom render scene channnels

Sources/CShaderTypes/ShaderTypes.h

@@ -55,6 +55,7 @@ typedef struct{
 
 typedef struct{
     simd_float4 attenuation;
+    // Emission direction from the spot light into the scene.
     simd_float3 direction;
     simd_float3 position;
     simd_float3 color;
@@ -66,6 +67,7 @@ typedef struct{
 typedef struct{
     simd_float3 position;
     simd_float3 color;
+    // LTC polygon/front normal used to choose rectangle winding in the area-light shader.
     simd_float3 forward;
     simd_float3 right;
     simd_float3 up;
@@ -299,6 +301,7 @@ typedef enum RenderTargets{
 typedef struct{
     simd_float4 baseColor;
     simd_int4 hasTexture; //x=hasbasecolor,y=hasroughmap, z=hasmetalmap
+    simd_int4 textureChannels; //x=roughness channel, y=metallic channel; 0=r,1=g,2=b,3=a
     simd_float4 edgeTint;
     simd_float3 emmissive;
     float roughness;

Sources/DemoGame/AppDelegate.swift

@@ -147,6 +147,12 @@
             demoState.onLoadTiledScene = { [weak self] sceneID, url, completion in
                 self?.gameScene.loadTileScene(sceneID: sceneID, url: url, completion: completion)
             }
+            demoState.onLoadSceneAuthoredFile = { [weak self] path, completion in
+                self?.gameScene.loadSceneAuthoredFile(path: path, completion: completion)
+            }
+            demoState.onLoadSceneAuthoredURL = { [weak self] url, completion in
+                self?.gameScene.loadSceneAuthoredURL(url: url, completion: completion)
+            }
             demoState.onBatchingChanged = { [weak self] enabled in
                 self?.gameScene.setBatching(enabled)
             }

Sources/DemoGame/DemoHUD.swift

@@ -208,6 +208,11 @@
                     Spacer(minLength: 0)
                 }
 
+                Toggle("Scene Authored", isOn: $state.localSceneAuthoredEnabled)
+                    .toggleStyle(.checkbox)
+                    .padding(.leading, 100)
+                    .disabled(state.isLoading)
+
                 Divider()
 
                 sectionLabel("CONTROLS")
@@ -539,6 +544,9 @@
                     if success {
                         state.selectedPostFXPreset = .neutral
                         state.applySelectedPostFXPreset()
+                        if state.localSceneAuthoredEnabled {
+                            state.onLoadSceneAuthoredFile?(path) { _ in }
+                        }
                     }
                     finishLocalImport(url: url, accessing: accessing, success: success, streamingEnabled: false)
                 }
@@ -558,6 +566,9 @@
                     if success {
                         state.selectedPostFXPreset = .neutral
                         state.applySelectedPostFXPreset()
+                        if state.localSceneAuthoredEnabled {
+                            state.onLoadSceneAuthoredURL?(url) { _ in }
+                        }
                     }
                     finishLocalImport(url: url, accessing: accessing, success: success, streamingEnabled: success)
                 }

Sources/DemoGame/DemoState.swift

@@ -103,6 +103,8 @@
             remoteScenes.first { $0.id == selectedRemoteSceneID }
         }
 
+        var localSceneAuthoredEnabled: Bool = false
+
         // MARK: - Features
 
         var batchingEnabled: Bool = false {
@@ -229,6 +231,8 @@
 
         var onLoadFile: ((String, @escaping @Sendable (Bool) -> Void) -> Void)?
         var onLoadTiledScene: ((String, URL, @escaping @Sendable (Bool) -> Void) -> Void)?
+        var onLoadSceneAuthoredFile: ((String, @escaping @Sendable (Bool) -> Void) -> Void)?
+        var onLoadSceneAuthoredURL: ((URL, @escaping @Sendable (Bool) -> Void) -> Void)?
         var onBatchingChanged: ((Bool) -> Void)?
         var onStreamingChanged: ((Bool, Double, Double) -> Void)?
         var onLodDebugChanged: ((Bool) -> Void)?

Sources/DemoGame/GameScene.swift

@@ -71,6 +71,8 @@
             let light = createEntity()
             setEntityName(entityId: light, name: "Directional Light")
             createDirLight(entityId: light)
+
+            setDirectionalLight(.active(light))
             setCamera(.active(gameCamera))
 
             setRendering(.environment(.ibl(true)))
@@ -84,14 +86,21 @@
     extension GameScene {
         /// Loads a USDZ file as an always-resident asset, replacing whatever was previously loaded.
         /// The previously loaded entity is destroyed; the scene camera and light are preserved.
-        func loadFile(path: String, completion: @escaping @Sendable (Bool) -> Void) {
+        func loadFile(
+            path: String,
+            completion: @escaping @Sendable (Bool) -> Void
+        ) {
             prepareForMeshLoad { [weak self] in
                 guard let self else { return }
 
                 let entity = createEntity()
                 setEntityName(entityId: entity, name: path)
 
-                setEntityMeshAsync(entityId: entity, filename: path, withExtension: "untold") { [weak self] success in
+                setEntityMeshAsync(
+                    entityId: entity,
+                    filename: path,
+                    withExtension: "untold"
+                ) { [weak self] success in
                     guard let self else { return }
                     loadedEntity = success ? entity : nil
                     loadedContent = success ? .mesh(entity) : .none
@@ -106,7 +115,11 @@
         }
 
         /// Loads a tiled scene from a local or remote manifest URL.
-        func loadTileScene(sceneID: String, url: URL, completion: @escaping @Sendable (Bool) -> Void) {
+        func loadTileScene(
+            sceneID: String,
+            url: URL,
+            completion: @escaping @Sendable (Bool) -> Void
+        ) {
             // Destroy any previously loaded tiled scene before registering a new one.
             if case let .tiledScene(oldRoot) = loadedContent {
                 destroyEntity(entityId: oldRoot)
@@ -132,6 +145,14 @@
             }
         }
 
+        func loadSceneAuthoredFile(path: String, completion: @escaping @Sendable (Bool) -> Void) {
+            loadSceneAuthored(filename: path, withExtension: "untold", completion: completion)
+        }
+
+        func loadSceneAuthoredURL(url: URL, completion: @escaping @Sendable (Bool) -> Void) {
+            loadSceneAuthored(url: url, completion: completion)
+        }
+
         private func prepareForMeshLoad(completion: @escaping () -> Void) {
             clearSceneBatches()
             setGeometryStreaming(.enabled(false))

Sources/Sandbox/GameScene.swift

@@ -27,19 +27,26 @@
             // Uncomment to render a simple mesh.
             /*
              let entity = createEntity()
-             setEntityMeshAsync(entityId: entity, filename: "/path/to/mesh", withExtension: "untold") { success in
-
+             setEntityMeshAsync(entityId: entity, filename: "/path/to/file", withExtension: "untold") { success in
                  setEntityName(entityId: entity, name: "redplayer")
-
-                 //load animation
-                 setEntityAnimations(entityId: entity, filename: "/path/to/animation", withExtension: "untold", name: "running")
-
-                 changeAnimation(entityId: entity, name: "running")
-
-                 setSceneReady(true)
-
+                 if success {
+                     loadSceneAuthored(filename: "/path/to/file", withExtension: "untold")
+                 }
+                 setSceneReady(success)
              }
-              */
+             */
+            /*
+             let sceneRoot = createEntity()
+             setEntityStreamScene(
+                   entityId: sceneRoot,
+                   url: URL(fileURLWithPath: "/path/to/local/json")
+               ) { success in
+                   if success {
+                       loadSceneAuthored(url: URL(fileURLWithPath: "/path/to/local/json"))
+                   }
+                   setSceneReady(success)
+               }
+             */
 
             // Uncomment to render a streamed scene
             /*
@@ -62,12 +69,12 @@
             let camera = createEntity()
             setEntityName(entityId: camera, name: "Main Camera")
             createGameCamera(entityId: camera)
-            CameraSystem.shared.activeCamera = camera
+            setCamera(.active(camera))
             setOrbitOffset(entityId: camera, uTargetOffset: Constants.orbitTargetOffset)
 
-            let light = createEntity()
-            setEntityName(entityId: light, name: "Directional Light")
-            createDirLight(entityId: light)
+//            let light = createEntity()
+//            setEntityName(entityId: light, name: "Directional Light")
+            // createDirLight(entityId: light)
         }
 
         func update(deltaTime _: Float) {

Sources/UntoldEngine/AssetFormat/UntoldBinaryCodable.swift

@@ -331,6 +331,158 @@ extension UntoldTextureRefRecordV1: UntoldBinaryEncodable, UntoldBinaryDecodable
     }
 }
 
+extension UntoldLightRecordV1: UntoldBinaryEncodable, UntoldBinaryDecodable {
+    public func encode(to writer: UntoldBinaryWriter) {
+        writer.writeUInt32LE(entityId)
+        writer.writeUInt32LE(nameOffset)
+        writer.writeUInt32LE(lightType.rawValue)
+        writer.writeUInt32LE(flags)
+        writer.writeFloat32LE(color.x)
+        writer.writeFloat32LE(color.y)
+        writer.writeFloat32LE(color.z)
+        writer.writeFloat32LE(intensity)
+        writer.writeFloat32LE(position.x)
+        writer.writeFloat32LE(position.y)
+        writer.writeFloat32LE(position.z)
+        writer.writeFloat32LE(radius)
+        writer.writeFloat32LE(direction.x)
+        writer.writeFloat32LE(direction.y)
+        writer.writeFloat32LE(direction.z)
+        writer.writeFloat32LE(falloff)
+        writer.writeFloat32LE(right.x)
+        writer.writeFloat32LE(right.y)
+        writer.writeFloat32LE(right.z)
+        writer.writeFloat32LE(innerCone)
+        writer.writeFloat32LE(up.x)
+        writer.writeFloat32LE(up.y)
+        writer.writeFloat32LE(up.z)
+        writer.writeFloat32LE(outerCone)
+        writer.writeFloat32LE(areaSize.x)
+        writer.writeFloat32LE(areaSize.y)
+        writer.writeFloat32LE(sourcePower)
+        writer.writeFloat32LE(sourceExposure)
+        writer.writeMatrix4x4LE(localTransform)
+    }
+
+    public static func decode(from reader: UntoldBinaryReader) throws -> UntoldLightRecordV1 {
+        let entityId = try reader.readUInt32LE()
+        let nameOffset = try reader.readUInt32LE()
+        let lightTypeRaw = try reader.readUInt32LE()
+        guard let lightType = UntoldLightType(rawValue: lightTypeRaw) else {
+            throw UntoldValidationError.unsupportedEnumValue
+        }
+
+        return try UntoldLightRecordV1(
+            entityId: entityId,
+            nameOffset: nameOffset,
+            lightType: lightType,
+            flags: reader.readUInt32LE(),
+            color: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            intensity: reader.readFloat32LE(),
+            position: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            radius: reader.readFloat32LE(),
+            direction: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            falloff: reader.readFloat32LE(),
+            right: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            innerCone: reader.readFloat32LE(),
+            up: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            outerCone: reader.readFloat32LE(),
+            areaSize: SIMD2<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            sourcePower: reader.readFloat32LE(),
+            sourceExposure: reader.readFloat32LE(),
+            localTransform: reader.readMatrix4x4LE()
+        )
+    }
+}
+
+extension UntoldCameraRecordV1: UntoldBinaryEncodable, UntoldBinaryDecodable {
+    public func encode(to writer: UntoldBinaryWriter) {
+        writer.writeUInt32LE(entityId)
+        writer.writeUInt32LE(nameOffset)
+        writer.writeUInt32LE(flags)
+        writer.writeUInt32LE(reserved0)
+        writer.writeFloat32LE(position.x)
+        writer.writeFloat32LE(position.y)
+        writer.writeFloat32LE(position.z)
+        writer.writeFloat32LE(fovYDegrees)
+        writer.writeFloat32LE(forward.x)
+        writer.writeFloat32LE(forward.y)
+        writer.writeFloat32LE(forward.z)
+        writer.writeFloat32LE(nearClip)
+        writer.writeFloat32LE(up.x)
+        writer.writeFloat32LE(up.y)
+        writer.writeFloat32LE(up.z)
+        writer.writeFloat32LE(farClip)
+        writer.writeFloat32LE(right.x)
+        writer.writeFloat32LE(right.y)
+        writer.writeFloat32LE(right.z)
+        writer.writeFloat32LE(aspectRatio)
+        writer.writeMatrix4x4LE(localTransform)
+    }
+
+    public static func decode(from reader: UntoldBinaryReader) throws -> UntoldCameraRecordV1 {
+        let entityId = try reader.readUInt32LE()
+        let nameOffset = try reader.readUInt32LE()
+        let flags = try reader.readUInt32LE()
+        let reserved0 = try reader.readUInt32LE()
+        var record = try UntoldCameraRecordV1(
+            entityId: entityId,
+            nameOffset: nameOffset,
+            flags: flags,
+            position: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            fovYDegrees: reader.readFloat32LE(),
+            forward: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            nearClip: reader.readFloat32LE(),
+            up: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            farClip: reader.readFloat32LE(),
+            right: SIMD3<Float>(
+                reader.readFloat32LE(),
+                reader.readFloat32LE(),
+                reader.readFloat32LE()
+            ),
+            aspectRatio: reader.readFloat32LE(),
+            localTransform: reader.readMatrix4x4LE()
+        )
+        record.reserved0 = reserved0
+        return record
+    }
+}
+
 extension UntoldSkeletonRecordV1: UntoldBinaryEncodable, UntoldBinaryDecodable {
     public func encode(to writer: UntoldBinaryWriter) {
         writer.writeUInt32LE(entityId)