@jack120/test 0.2.0

package/library/render/renderer.ts

@@ -0,0 +1,124 @@
+import { MaterialManager } from "../render/material";
+import { TextureManager } from "../render/texture";
+import { SceneManager } from "../render/scene";
+
+export class RendererManager {
+	// ------------------------------------------------------------
+	// Camera / XR
+	// ------------------------------------------------------------
+
+	/**
+	 * Filament: Renderer::getDefaultCameraEntity()
+	 * Unity RPC not yet implemented; please register a CameraManager method.
+	 * @returns The default camera entity handle
+	 */
+	static GetDefaultCameraEntity(): number {
+		console.warn("GetDefaultCameraEntity(): Unity RPC not available");
+		return -1;
+	}
+
+	/**
+	 * Filament: Renderer::getXRCameras()
+	 * Unity RPC not yet implemented.
+	 * @returns Array of XR camera entity handles
+	 */
+	static GetXRCameras(): number[] {
+		console.warn("GetXRCameras(): Unity RPC not available");
+		return [];
+	}
+
+	// ------------------------------------------------------------
+	// Material / Skybox / Indirect Light
+	// ------------------------------------------------------------
+
+	/**
+	 * Destroy a material instance (mimics Filament::Renderer::destroyMaterialInstance)
+	 * @param instanceHandle The material instance handle to destroy
+	 * @returns boolean indicating success
+	 */
+	static DestroyMaterialInstance(instanceHandle: number): boolean {
+		return MaterialManager.Destroy(instanceHandle);
+	}
+
+	/**
+	 * Destroy a render-target (in Unity, render textures)
+	 * @param rtHandle The render target handle to destroy
+	 * @returns boolean indicating success
+	 */
+	static DestroyRenderTarget(rtHandle: number): boolean {
+		return TextureManager.Destroy(rtHandle);
+	}
+
+	/**
+	 * Destroy a skybox (in Unity, just a material)
+	 * @param skyboxMatHandle The skybox material handle to destroy
+	 * @returns boolean indicating success
+	 */
+	static DestroySkybox(skyboxMatHandle: number): boolean {
+		return MaterialManager.Destroy(skyboxMatHandle);
+	}
+
+	/**
+	 * Destroy an indirect light (no direct Unity equivalent)
+	 * @param ilHandle The indirect light handle to destroy
+	 * @returns boolean indicating success
+	 */
+	static DestroyIndirectLight(ilHandle: number): boolean {
+		console.warn("DestroyIndirectLight(): no Unity RPC equivalent");
+		return false;
+	}
+
+	// ------------------------------------------------------------
+	// Scene-level convenience
+	// ------------------------------------------------------------
+
+	/**
+	 * Wraps Scene_SetSkybox
+	 * @param sceneHandle The scene handle
+	 * @param skyboxMatHandle The skybox material handle
+	 * @returns boolean indicating success
+	 */
+	static SetSkybox(sceneHandle: number, skyboxMatHandle: number): boolean {
+		return SceneManager.SetSkybox(sceneHandle, skyboxMatHandle);
+	}
+
+	/**
+	 * Wraps Scene_SetAmbientLight
+	 * @param sceneHandle The scene handle
+	 * @param r Red component (0-1)
+	 * @param g Green component (0-1)
+	 * @param b Blue component (0-1)
+	 * @param intensity The ambient light intensity
+	 * @returns boolean indicating success
+	 */
+	static SetAmbientLight(
+		sceneHandle: number,
+		r: number,
+		g: number,
+		b: number,
+		intensity: number,
+	): boolean {
+		return SceneManager.SetAmbientLight(sceneHandle, r, g, b, intensity);
+	}
+
+	/**
+	 * Wraps Scene_SetFog
+	 * @param sceneHandle The scene handle
+	 * @param enabled Whether fog is enabled
+	 * @param mode The fog mode
+	 * @param density The fog density
+	 * @param start The fog start distance
+	 * @param end The fog end distance
+	 * @returns boolean indicating success
+	 */
+	static SetFog(
+		sceneHandle: number,
+		enabled: boolean,
+		mode: number,
+		density: number,
+		start: number,
+		end: number,
+	): boolean {
+		return SceneManager.SetFog(sceneHandle, enabled, mode, density, start, end);
+	}
+}

package/library/render/scene.ts

@@ -0,0 +1,89 @@
+import { RpcClient } from "../rpc";
+
+export type SceneHandle = number;
+
+// NOTE: the following are not supported compared to legacy code:
+// - A dedicated "SkyboxBuilder" or multiple‐camera viewports (Unity handles those internally)
+
+// includes skybox as well
+export class SceneManager {
+	/**
+	 * Get the default scene handle
+	 * @returns The default scene handle
+	 */
+	static GetDefault(): SceneHandle {
+		return Number(RpcClient.Call("Scene_GetDefault", {}));
+	}
+
+	/**
+	 * Set the skybox for the scene
+	 * @param sceneHandle The scene handle
+	 * @param skyboxHandle The skybox material handle
+	 * @returns boolean indicating success
+	 */
+	static SetSkybox(sceneHandle: SceneHandle, skyboxHandle: number): boolean {
+		return Boolean(
+			RpcClient.Call("Scene_SetSkybox", {
+				sceneHandle,
+				skyboxHandle,
+			}),
+		);
+	}
+
+	/**
+	 * Set the ambient light for the scene
+	 * @param sceneHandle The scene handle
+	 * @param r Red component (0-1)
+	 * @param g Green component (0-1)
+	 * @param b Blue component (0-1)
+	 * @param intensity The ambient light intensity
+	 * @returns boolean indicating success
+	 */
+	static SetAmbientLight(
+		sceneHandle: SceneHandle,
+		r: number,
+		g: number,
+		b: number,
+		intensity: number,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Scene_SetAmbientLight", {
+				sceneHandle,
+				r,
+				g,
+				b,
+				intensity,
+			}),
+		);
+	}
+
+	/**
+	 * Set the fog parameters for the scene
+	 * @param sceneHandle The scene handle
+	 * @param enabled Whether fog is enabled
+	 * @param mode The fog mode
+	 * @param density The fog density
+	 * @param start The fog start distance
+	 * @param end The fog end distance
+	 * @returns boolean indicating success
+	 */
+	static SetFog(
+		sceneHandle: SceneHandle,
+		enabled: boolean,
+		mode: number,
+		density: number,
+		start: number,
+		end: number,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Scene_SetFog", {
+				sceneHandle,
+				enabled,
+				mode,
+				density,
+				start,
+				end,
+			}),
+		);
+	}
+}

package/library/render/texture.ts

@@ -0,0 +1,247 @@
+import { RpcClient } from "../rpc";
+import { base64Encode } from "../utilities/base64";
+import { MaterialHandle } from "./material";
+
+export type TextureHandle = number;
+
+// NOTE: the following are not supported compared to legacy code:
+// - Filament's TextureBuilder, Swizzle, GenerateMipmaps, PixelBufferDescriptor
+
+export enum TextureFormat {
+	//
+	// Summary:
+	//     Alpha-only texture format, 8 bit integer.
+	Alpha8 = 1,
+	//
+	// Summary:
+	//     A 16 bits/pixel texture format. Texture stores color with an alpha channel.
+	ARGB4444 = 2,
+	//
+	// Summary:
+	//     Three channel (RGB) texture format, 8-bits unsigned integer per channel.
+	RGB24 = 3,
+	//
+	// Summary:
+	//     Four channel (RGBA) texture format, 8-bits unsigned integer per channel.
+	RGBA32 = 4,
+	//
+	// Summary:
+	//     Color with alpha texture format, 8-bits per channel.
+	ARGB32 = 5,
+	//
+	// Summary:
+	//     A 16 bit color texture format.
+	RGB565 = 7,
+	//
+	// Summary:
+	//     Single channel (R) texture format, 16-bits unsigned integer.
+	R16 = 9,
+	//
+	// Summary:
+	//     Compressed color texture format.
+	DXT1 = 10,
+	//
+	// Summary:
+	//     Compressed color with alpha channel texture format.
+	DXT5 = 12,
+}
+
+export class TextureManager {
+	/**
+	 * Create a 2D texture
+	 * @param width The texture width
+	 * @param height The texture height
+	 * @param format The texture format
+	 * @returns The texture handle
+	 */
+	static Create2D(
+		width: number,
+		height: number,
+		format: TextureFormat,
+	): TextureHandle {
+		return Number(
+			RpcClient.Call("Texture_Create2D", {
+				width,
+				height,
+				format,
+				clientId: RpcClient.GetClientId(),
+			}),
+		);
+	}
+
+	/**
+	 * Create a 2D texture and attach it to a material
+	 * @param width The texture width
+	 * @param height The texture height
+	 * @param format The texture format
+	 * @param materialHandle The material handle to attach to
+	 * @param propertyName The material property name
+	 * @returns The texture handle
+	 */
+	static Create2DForMaterial(
+		width: number,
+		height: number,
+		format: TextureFormat,
+		materialHandle: MaterialHandle,
+		propertyName: string,
+	): TextureHandle {
+		const textureHandle = Number(
+			RpcClient.Call("Texture_Create2D", {
+				width,
+				height,
+				format,
+				clientId: RpcClient.GetClientId(),
+			}),
+		);
+		RpcClient.Call("Material_SetTexture", {
+			materialHandle: materialHandle,
+			propertyName: propertyName,
+			textureHandle: textureHandle,
+		});
+		return textureHandle;
+	}
+
+	/**
+	 * Create a render texture
+	 * @param width The texture width
+	 * @param height The texture height
+	 * @param depth The texture depth
+	 * @param format The texture format
+	 * @returns The texture handle
+	 */
+	static CreateRenderTexture(
+		width: number,
+		height: number,
+		depth: number,
+		format: TextureFormat,
+	): TextureHandle {
+		return Number(
+			RpcClient.Call("Texture_CreateRenderTexture", {
+				width,
+				height,
+				depth,
+				format,
+				clientId: RpcClient.GetClientId(),
+			}),
+		);
+	}
+
+	/**
+	 * Destroy a texture
+	 * @param handle The texture handle to destroy
+	 * @returns boolean indicating success
+	 */
+	static Destroy(handle: TextureHandle): boolean {
+		return Boolean(
+			RpcClient.Call("Texture_Destroy", { textureHandle: handle }),
+		);
+	}
+
+	/**
+	 * Set raw RGBA iamge for the texture
+	 * @param handle The texture handle
+	 * @param rgbaDataJson RGBA values
+	 * @param width The texture width
+	 * @param height The texture height
+	 * @returns boolean indicating success
+	 */
+	static LoadRawTextureData(
+		handle: TextureHandle,
+		base64Rgba: ArrayBufferLike,
+		width: number,
+		height: number,
+	): boolean {
+		const base64String = base64Encode(base64Rgba);
+		return Boolean(
+			RpcClient.Call("Texture_LoadRawTextureData", {
+				textureHandle: handle,
+				base64Rgba: base64String,
+				width,
+				height,
+			}),
+		);
+	}
+
+	/**
+	 * Loads PNG/JPG image byte array into a texture.
+	 * @param handle The texture handle
+	 * @param imageDataJson JSON string with comma-separated RGBA values
+	 * @returns boolean indicating success
+	 */
+	static LoadImage(handle: TextureHandle, image: ArrayBufferLike): boolean {
+		const base64Image = base64Encode(image);
+
+		return Boolean(
+			RpcClient.Call("Texture_LoadImage", {
+				textureHandle: handle,
+				base64Image,
+			}),
+		);
+	}
+
+	/**
+	 * Loads PNG/JPG image byte array into a texture.
+	 * @param handle The texture handle
+	 * @param imageDataJson JSON string with comma-separated RGBA values
+	 * @returns boolean indicating success
+	 */
+	static LoadImageBase64(handle: TextureHandle, base64Image: string): boolean {
+		return Boolean(
+			RpcClient.Call("Texture_LoadImage", {
+				textureHandle: handle,
+				base64Image,
+			}),
+		);
+	}
+
+	/**
+	 * Set the filter mode for the texture
+	 * @param handle The texture handle
+	 * @param mode The filter mode
+	 * @returns boolean indicating success
+	 */
+	static SetFilterMode(
+		handle: TextureHandle,
+		mode: TextureFilterMode,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Texture_SetFilterMode", {
+				textureHandle: handle,
+				filterMode: mode,
+			}),
+		);
+	}
+
+	/**
+	 * Set the wrap mode for the texture
+	 * @param handle The texture handle
+	 * @param wrapMode The wrap mode
+	 * @returns boolean indicating success
+	 */
+	static SetWrapMode(
+		handle: TextureHandle,
+		wrapMode: TextureWrapMode,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Texture_SetWrapMode", {
+				textureHandle: handle,
+				wrapMode,
+			}),
+		);
+	}
+}
+
+export enum TextureFilterMode {
+	NEAREST = 0,
+	LINEAR = 1,
+	NEAREST_MIPMAP_NEAREST = 2,
+	LINEAR_MIPMAP_NEAREST = 3,
+	NEAREST_MIPMAP_LINEAR = 4,
+	LINEAR_MIPMAP_LINEAR = 5,
+}
+
+export enum TextureWrapMode {
+	CLAMP_TO_EDGE = 0,
+	REPEAT = 1,
+	MIRRORED_REPEAT = 2,
+}

package/library/render/transform.ts

@@ -0,0 +1,259 @@
+import { RpcClient } from "../rpc";
+import { Entity } from "../entity";
+import { mat4, quat, vec3 } from "gl-matrix";
+
+/**
+ * Wrapper for Unity Transform RPCs.
+ * Provides strongly-typed parameters and returns.
+ */
+export class TransformManager {
+	/**
+	 * Checks if the entity has a Transform component.
+	 * @param entity The entity to check
+	 * @returns boolean indicating if transform component exists
+	 */
+	static HasComponent(entity: Entity): boolean {
+		return Boolean(
+			RpcClient.Call("Transform_HasComponent", { entityHandle: entity }),
+		);
+	}
+
+	/**
+	 * Sets the world transform given a 16-element row-major matrix.
+	 * Transposes to column-major and flips Z-axis for Unity.
+	 * TODO: double check if this is correct, what are we using internally?
+	 * Use the coords provided by gl matrix or unity.
+	 * @param entity The entity with the transform component
+	 * @param srcMatrix The source transformation matrix
+	 * @returns boolean indicating success
+	 */
+	static SetTransform(entity: Entity, srcMatrix: mat4): boolean {
+		const colMaj: number[] = new Array(16);
+		for (let row = 0; row < 4; row++) {
+			for (let col = 0; col < 4; col++) {
+				let val = srcMatrix[row * 4 + col];
+				if (col === 2) val = -val; // flip Z-axis
+				colMaj[col * 4 + row] = val;
+			}
+		}
+		const matrixJson = colMaj.join(",");
+		return Boolean(
+			RpcClient.Call("Transform_SetTransform", {
+				entityHandle: entity,
+				matrixJson,
+			}),
+		);
+	}
+
+	/**
+	 * Retrieves the world transform matrix (column-major).
+	 * @param entity The entity with the transform component
+	 * @returns The transformation matrix
+	 */
+	static GetTransform(entity: Entity): mat4 {
+		const result = RpcClient.Call("Transform_GetTransform", {
+			entityHandle: entity,
+		}) as string;
+		const nums = result.split(",").map((j) => parseFloat(j));
+
+		if (nums.length !== 16) {
+			throw new Error(`Invalid transform data (${nums.length} elements)`);
+		}
+		return mat4.fromValues(
+			nums[0],
+			nums[1],
+			nums[2],
+			nums[3],
+			nums[4],
+			nums[5],
+			nums[6],
+			nums[7],
+			nums[8],
+			nums[9],
+			nums[10],
+			nums[11],
+			nums[12],
+			nums[13],
+			nums[14],
+			nums[15],
+		);
+	}
+
+	/**
+	 * Sets this entity's parent transform.
+	 * @param entity The entity with the transform component
+	 * @param parent The parent entity
+	 * @returns boolean indicating success
+	 */
+	static SetParent(entity: Entity, parent: Entity): boolean {
+		return Boolean(
+			RpcClient.Call("Transform_SetParent", {
+				entityHandle: entity,
+				parentHandle: parent,
+			}),
+		);
+	}
+
+	/**
+	 * Gets the parent entity handle, or -1 if none.
+	 * @param entity The entity with the transform component
+	 * @returns The parent entity handle
+	 */
+	static GetParent(entity: Entity): Entity {
+		return Number(
+			RpcClient.Call("Transform_GetParent", { entityHandle: entity }),
+		);
+	}
+
+	/**
+	 * Sets world position vector.
+	 * @param entity The entity with the transform component
+	 * @param pos The position vector
+	 * @returns boolean indicating success
+	 */
+	static SetWorldPosition(entity: Entity, pos: vec3): boolean {
+		return Boolean(
+			RpcClient.Call("Transform_SetWorldPosition", {
+				entityHandle: entity,
+				x: pos[0],
+				y: pos[1],
+				z: pos[2],
+			}),
+		);
+	}
+
+	/**
+	 * Sets local position vector.
+	 * @param entity The entity with the transform component
+	 * @param pos The position vector
+	 * @returns boolean indicating success
+	 */
+	static SetLocalPosition(entity: Entity, pos: vec3): boolean {
+		return Boolean(
+			RpcClient.Call("Transform_SetLocalPosition", {
+				entityHandle: entity,
+				x: pos[0],
+				y: pos[1],
+				z: pos[2],
+			}),
+		);
+	}
+
+	/**
+	 * Gets world position vector.
+	 * @param entity The entity with the transform component
+	 * @returns The position vector
+	 */
+	static GetWorldPosition(entity: Entity): vec3 {
+		const data = RpcClient.Call("Transform_GetWorldPosition", {
+			entityHandle: entity,
+		}) as string;
+		const [x, y, z] = data.split(",").map((j) => parseFloat(j));
+		return vec3.fromValues(x, y, z);
+	}
+
+	/**
+	 * Gets local position vector.
+	 * @param entity The entity with the transform component
+	 * @returns The position vector
+	 */
+	static GetLocalPosition(entity: Entity): vec3 {
+		const data = RpcClient.Call("Transform_GetLocalPosition", {
+			entityHandle: entity,
+		}) as string;
+		const [x, y, z] = data.split(",").map((j) => parseFloat(j));
+		return vec3.fromValues(x, y, z);
+	}
+
+	/**
+	 * Sets world rotation quaternion.
+	 * @param entity The entity with the transform component
+	 * @param quat The rotation quaternion [x, y, z, w]
+	 * @returns boolean indicating success
+	 */
+	static SetWorldRotation(entity: Entity, quat: quat): boolean {
+		return Boolean(
+			RpcClient.Call("Transform_SetWorldRotation", {
+				entityHandle: entity,
+				x: quat[0],
+				y: quat[1],
+				z: quat[2],
+				w: quat[3],
+			}),
+		);
+	}
+
+	/**
+	 * Sets local rotation quaternion.
+	 * @param entity The entity with the transform component
+	 * @param quat The rotation quaternion [x, y, z, w]
+	 * @returns boolean indicating success
+	 */
+	static SetLocalRotation(entity: Entity, quat: quat): boolean {
+		return Boolean(
+			RpcClient.Call("Transform_SetLocalRotation", {
+				entityHandle: entity,
+				x: quat[0],
+				y: quat[1],
+				z: quat[2],
+				w: quat[3],
+			}),
+		);
+	}
+
+	/**
+	 * Gets local rotation quaternion.
+	 * @param entity The entity with the transform component
+	 * @returns The rotation quaternion
+	 */
+	static GetWorldRotation(entity: Entity): quat {
+		const data = RpcClient.Call("Transform_GetWorldRotation", {
+			entityHandle: entity,
+		}) as string;
+		const [x, y, z, w] = data.split(",").map((j) => parseFloat(j));
+		return quat.fromValues(x, y, z, w);
+	}
+
+	/**
+	 * Gets local rotation quaternion.
+	 * @param entity The entity with the transform component
+	 * @returns The rotation quaternion
+	 */
+	static GetLocalRotation(entity: Entity): quat {
+		const data = RpcClient.Call("Transform_GetLocalRotation", {
+			entityHandle: entity,
+		}) as string;
+		const [x, y, z, w] = data.split(",").map((j) => parseFloat(j));
+		return quat.fromValues(x, y, z, w);
+	}
+
+	/**
+	 * Sets local scale vector.
+	 * @param entity The entity with the transform component
+	 * @param scale The scale vector
+	 * @returns boolean indicating success
+	 */
+	static SetLocalScale(entity: Entity, scale: vec3): boolean {
+		return Boolean(
+			RpcClient.Call("Transform_SetLocalScale", {
+				entityHandle: entity,
+				x: scale[0],
+				y: scale[1],
+				z: scale[2],
+			}),
+		);
+	}
+
+	/**
+	 * Gets local scale vector.
+	 * @param entity The entity with the transform component
+	 * @returns The position vector
+	 */
+	static GetLocalScale(entity: Entity): vec3 {
+		const data = RpcClient.Call("Transform_GetLocalScale", {
+			entityHandle: entity,
+		}) as string;
+		const [x, y, z] = data.split(",").map((j) => parseFloat(j));
+		return vec3.fromValues(x, y, z);
+	}
+}