@jack120/test 0.2.0

package/library/render/material.ts

@@ -0,0 +1,258 @@
+import { RpcClient } from "../rpc";
+import { Entity } from "../entity";
+import { vec4 } from "gl-matrix";
+
+export type MaterialHandle = number;
+
+export enum ShaderType {
+	URP_LIT = "Universal Render Pipeline/Lit",
+}
+
+export enum ShaderProperties {
+	/** 2D Texture */
+	BaseMap = "_BaseMap",
+	/** vec4 [0.0, 1.0] */
+	BaseColor = "_BaseColor",
+
+	/** float [0.0, 1.0] */
+	Cutoff = "_Cutoff",
+
+	/** float [0.0, 1.0] */
+	Smoothness = "_Smoothness",
+	/** float */
+	SmoothnessTextureChannel = "_SmoothnessTextureChannel",
+
+	/** float [0.0, 1.0] */
+	Metallic = "_Metallic",
+	/** 2D Texture */
+	MetallicGlossMap = "_MetallicGlossMap",
+
+	/** vec3 [0.0, 1.0] */
+	SpecColor = "_SpecColor",
+	/** 2D Texture */
+	SpecGlossMap = "_SpecGlossMap",
+
+	/** float */
+	SpecularHighlights = "_SpecularHighlights",
+	/** float */
+	EnvironmentReflections = "_EnvironmentReflections",
+
+	/** float */
+	BumpScale = "_BumpScale",
+	/** 2D Texture */
+	BumpMap = "_BumpMap",
+
+	/** float [0.005, 0.08] */
+	Parallax = "_Parallax",
+	/** 2D Texture */
+	ParallaxMap = "_ParallaxMap",
+
+	/** float [0.0, 1.0] */
+	OcclusionStrength = "_OcclusionStrength",
+	/** 2D Texture */
+	OcclusionMap = "_OcclusionMap",
+
+	/** vec3 [0.0, 1.0] */
+	EmissionColor = "_EmissionColor",
+	/** 2D Texture */
+	EmissionMap = "_EmissionMap",
+
+	/** 2D Texture */
+	DetailMask = "_DetailMask",
+	/** float [0.0, 2.0] */
+	DetailAlbedoMapScale = "_DetailAlbedoMapScale",
+	/** 2D Texture */
+	DetailAlbedoMap = "_DetailAlbedoMap",
+	/** float [0.0, 2.0] */
+	DetailNormalMapScale = "_DetailNormalMapScale",
+	/** 2D Texture */
+	DetailNormalMap = "_DetailNormalMap",
+}
+
+export class MaterialManager {
+	/**
+	 * Create a new material with the specified shader
+	 * @param shader The name of the shader to use
+	 * @returns The material handle
+	 */
+	static Create(shader: ShaderType): MaterialHandle;
+
+	/**
+	 * Create a new material and attach it to a renderable component
+	 * @param shader The name of the shader to use
+	 * @param entity The entity with the renderable component
+	 * @param submeshIndex The submesh index to attach to (default: 0)
+	 * @returns The material handle
+	 */
+	static Create(
+		shader: ShaderType,
+		entity: Entity,
+		submeshIndex?: number,
+	): MaterialHandle;
+
+	static Create(
+		shader: ShaderType = ShaderType.URP_LIT,
+		entity?: Entity,
+		submeshIndex: number = 0,
+	): MaterialHandle {
+		const matHandle = Number(
+			RpcClient.Call("Material_Create", {
+				shaderName: shader,
+				clientId: RpcClient.GetClientId(),
+			}),
+		);
+
+		if (entity !== undefined) {
+			RpcClient.Call("Renderable_SetMaterial", {
+				entityHandle: entity,
+				materialHandle: matHandle,
+				index: submeshIndex,
+			});
+		}
+
+		return matHandle;
+	}
+
+	/**
+	 * Destroy a material
+	 * @param handle The material handle to destroy
+	 * @returns boolean indicating success
+	 */
+	static Destroy(handle: MaterialHandle): boolean {
+		return Boolean(
+			RpcClient.Call("Material_Destroy", { materialHandle: handle }),
+		);
+	}
+
+	/**
+	 * Create a material instance
+	 * @param handle The material handle to create an instance from
+	 * @returns The material instance handle
+	 */
+	static CreateInstance(handle: MaterialHandle): MaterialHandle {
+		return Number(
+			RpcClient.Call("Material_CreateInstance", {
+				materialHandle: handle,
+				clientId: RpcClient.GetClientId(),
+			}),
+		);
+	}
+
+	/**
+	 * Set a float property on the material
+	 * @param handle The material handle
+	 * @param prop The property name
+	 * @param value The float value
+	 * @returns boolean indicating success
+	 */
+	static SetFloat(
+		handle: MaterialHandle,
+		prop: ShaderProperties,
+		value: number,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Material_SetFloat", {
+				materialHandle: handle,
+				propertyName: prop,
+				value,
+			}),
+		);
+	}
+
+	/**
+	 * Set a vector property on the material
+	 * @param handle The material handle
+	 * @param prop The property name
+	 * @param value vec4 value
+	 * @returns boolean indicating success
+	 */
+	static SetVector(
+		handle: MaterialHandle,
+		prop: ShaderProperties,
+		value: vec4,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Material_SetVector", {
+				materialHandle: handle,
+				propertyName: prop,
+				x: value[0],
+				y: value[1],
+				z: value[2],
+				w: value[3],
+			}),
+		);
+	}
+
+	/**
+	 * Set a color property on the material
+	 * @param handle The material handle
+	 * @param prop The property name
+	 * @param rgba vec4 color [0.0, 1.0]
+	 * @returns boolean indicating success
+	 */
+	static SetColor(
+		handle: MaterialHandle,
+		prop: ShaderProperties,
+		rgba: vec4,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Material_SetColor", {
+				materialHandle: handle,
+				propertyName: prop,
+				r: rgba[0],
+				g: rgba[1],
+				b: rgba[2],
+				a: rgba[3],
+			}),
+		);
+	}
+
+	/**
+	 * Set a texture property on the material
+	 * @param handle The material handle
+	 * @param prop The property name
+	 * @param tex The texture handle
+	 * @returns boolean indicating success
+	 */
+	static SetTexture(
+		handle: MaterialHandle,
+		prop: ShaderProperties,
+		tex: number,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Material_SetTexture", {
+				materialHandle: handle,
+				propertyName: prop,
+				textureHandle: tex,
+			}),
+		);
+	}
+
+	/**
+	 * Get a float property from the material
+	 * @param handle The material handle
+	 * @param prop The property name
+	 * @returns The float value
+	 */
+	static GetFloat(handle: MaterialHandle, prop: ShaderProperties): number {
+		return Number(
+			RpcClient.Call("Material_GetFloat", {
+				materialHandle: handle,
+				propertyName: prop,
+			}),
+		);
+	}
+
+	/**
+	 * Get a color property from the material
+	 * @param handle The material handle
+	 * @param prop The property name
+	 * @returns The color as a string
+	 */
+	static GetColor(handle: MaterialHandle, prop: ShaderProperties): string {
+		return RpcClient.Call("Material_GetColor", {
+			materialHandle: handle,
+			propertyName: prop,
+		});
+	}
+}

package/library/render/mesh.ts

@@ -0,0 +1,208 @@
+import { RpcClient } from "../rpc";
+import { Entity } from "../entity";
+import { vec2, vec3 } from "gl-matrix";
+import { base64Encode } from "../utilities/base64";
+
+export type MeshHandle = number;
+
+// NOTE: the following are not supported compared to legacy code:
+// - Filament's VertexBufferBuilder / IndexBufferBuilder (Unity meshes are atomic)
+// - Filament's Attribute, Normalized, AdvancedSkinning on a raw VB/IB
+
+// We don't expose VertexBuffer/IndexBuffer builders in Unity; instead use Mesh RPCs directly
+export class MeshManager {
+	/**
+	 * Create a new mesh
+	 * @returns The mesh handle
+	 */
+	static Create(): MeshHandle;
+	/**
+	 * Create a new mesh and attach it to a renderable component
+	 * @param entity The entity with the renderable component
+	 * @returns The mesh handle
+	 */
+	static Create(entity: Entity): MeshHandle;
+	static Create(entity?: Entity): MeshHandle {
+		const meshHandle = Number(
+			RpcClient.Call("Mesh_Create", {
+				clientId: RpcClient.GetClientId(),
+			}),
+		);
+
+		if (entity !== undefined) {
+			RpcClient.Call("Renderable_SetMesh", {
+				entityHandle: entity,
+				meshHandle: meshHandle,
+			});
+		}
+
+		return meshHandle;
+	}
+
+	/**
+	 * Destroy a mesh
+	 * @param handle The mesh handle to destroy
+	 * @returns boolean indicating success
+	 */
+	static Destroy(handle: MeshHandle): boolean {
+		return Boolean(RpcClient.Call("Mesh_Destroy", { meshHandle: handle }));
+	}
+
+	/**
+	 * Set the vertices for the mesh
+	 * @param handle The mesh handle
+	 * @param vertices Array of vertex positions
+	 * @returns boolean indicating success
+	 */
+	static SetVertices(handle: MeshHandle, vertices: vec3[]): boolean;
+	/**
+	 * Set the vertices for the mesh
+	 * @param handle The mesh handle
+	 * @param base64Vertices Array of vertex positions encoded as a base64 string
+	 * @returns boolean indicating success
+	 */
+	static SetVertices(handle: MeshHandle, base64Vertices: string): boolean;
+	static SetVertices(
+		handle: MeshHandle,
+		verticesOrBase64: vec3[] | string,
+	): boolean {
+		let base64Vertices;
+
+		if (typeof verticesOrBase64 === "string") {
+			base64Vertices = verticesOrBase64;
+		} else {
+			const buffer = new Float32Array(verticesOrBase64.length * 3);
+			for (let i = 0; i < verticesOrBase64.length; i++) {
+				const n = verticesOrBase64[i];
+				buffer[i * 3] = n[0];
+				buffer[i * 3 + 1] = n[1];
+				buffer[i * 3 + 2] = n[2];
+			}
+			base64Vertices = base64Encode(buffer.buffer);
+		}
+
+		return Boolean(
+			RpcClient.Call("Mesh_SetVertices", {
+				meshHandle: handle,
+				base64Vertices,
+			}),
+		);
+	}
+
+	/**
+	 * Set the triangles (indices) for the mesh
+	 * @param handle The mesh handle
+	 * @param indices Array of triangle indices
+	 * @returns boolean indicating success
+	 */
+	static SetTriangles(handle: MeshHandle, indices: vec3[]): boolean;
+	/**
+	 * Set the triangles (indices) for the mesh
+	 * @param handle The mesh handle
+	 * @param base64Indices Array of triangle indices encoeded as a base64 string
+	 * @returns boolean indicating success
+	 */
+	static SetTriangles(handle: MeshHandle, base64Indices: string): boolean;
+	static SetTriangles(
+		handle: MeshHandle,
+		indicesOrBase64: vec3[] | string,
+	): boolean {
+		let base64Triangles: string;
+
+		if (typeof indicesOrBase64 === "string") {
+			base64Triangles = indicesOrBase64;
+		} else {
+			const buffer = new Float32Array(indicesOrBase64.length * 3);
+			for (let i = 0; i < indicesOrBase64.length; i++) {
+				const n = indicesOrBase64[i];
+				buffer[i * 3] = n[0];
+				buffer[i * 3 + 1] = n[1];
+				buffer[i * 3 + 2] = n[2];
+			}
+			base64Triangles = base64Encode(buffer.buffer);
+		}
+
+		return Boolean(
+			RpcClient.Call("Mesh_SetTriangles", {
+				meshHandle: handle,
+				base64Triangles,
+			}),
+		);
+	}
+
+	static SetUVs(handle: MeshHandle, uvs: vec2[]): boolean;
+	static SetUVs(handle: MeshHandle, base64Uvs: string): boolean;
+	static SetUVs(handle: MeshHandle, uvsOrBase64: vec2[] | string): boolean {
+		let base64Uvs: string;
+
+		if (typeof uvsOrBase64 === "string") {
+			base64Uvs = uvsOrBase64;
+		} else {
+			const buffer = new Float32Array(uvsOrBase64.length * 2);
+			for (let i = 0; i < uvsOrBase64.length; i++) {
+				const n = uvsOrBase64[i];
+				buffer[i * 2] = n[0];
+				buffer[i * 2 + 1] = n[1];
+			}
+			base64Uvs = base64Encode(buffer.buffer);
+		}
+
+		return Boolean(
+			RpcClient.Call("Mesh_SetUVs", {
+				meshHandle: handle,
+				base64Uvs,
+			}),
+		);
+	}
+
+	static SetNormals(handle: MeshHandle, normals: vec3[]): boolean;
+	static SetNormals(handle: MeshHandle, base64Normals: string): boolean;
+	static SetNormals(
+		handle: MeshHandle,
+		normalsOrBase64: vec3[] | string,
+	): boolean {
+		let base64Normals: string;
+
+		if (typeof normalsOrBase64 === "string") {
+			base64Normals = normalsOrBase64;
+		} else {
+			const buffer = new Float32Array(normalsOrBase64.length * 3);
+			for (let i = 0; i < normalsOrBase64.length; i++) {
+				const n = normalsOrBase64[i];
+				buffer[i * 3] = n[0];
+				buffer[i * 3 + 1] = n[1];
+				buffer[i * 3 + 2] = n[2];
+			}
+			base64Normals = base64Encode(buffer.buffer);
+		}
+
+		return Boolean(
+			RpcClient.Call("Mesh_SetNormals", {
+				meshHandle: handle,
+				base64Normals,
+			}),
+		);
+	}
+
+	/**
+	 * Recalculate normals for the mesh
+	 * @param handle The mesh handle
+	 * @returns boolean indicating success
+	 */
+	static RecalcNormals(handle: MeshHandle): boolean {
+		return Boolean(
+			RpcClient.Call("Mesh_RecalculateNormals", { meshHandle: handle }),
+		);
+	}
+
+	/**
+	 * Recalculate bounds for the mesh
+	 * @param handle The mesh handle
+	 * @returns boolean indicating success
+	 */
+	static RecalcBounds(handle: MeshHandle): boolean {
+		return Boolean(
+			RpcClient.Call("Mesh_RecalculateBounds", { meshHandle: handle }),
+		);
+	}
+}

package/library/render/primitives.ts

@@ -0,0 +1,76 @@
+import { MeshManager } from "../render/mesh";
+
+export function NewCubeMesh(): number {
+	// 8 vertices for a unit cube
+	const cubeVertices = [
+		[-0.5, -0.5, -0.5], // 0: left-bottom-back
+		[0.5, -0.5, -0.5], // 1: right-bottom-back
+		[0.5, 0.5, -0.5], // 2: right-top-back
+		[-0.5, 0.5, -0.5], // 3: left-top-back
+		[-0.5, -0.5, 0.5], // 4: left-bottom-front
+		[0.5, -0.5, 0.5], // 5: right-bottom-front
+		[0.5, 0.5, 0.5], // 6: right-top-front
+		[-0.5, 0.5, 0.5], // 7: left-top-front
+	];
+
+	// 12 triangles = 36 indices for cube faces
+	const cubeIndices = [
+		// back face
+		[0, 2, 1],
+		[0, 3, 2],
+		// front face
+		[4, 5, 6],
+		[4, 6, 7],
+		// bottom face
+		[0, 1, 5],
+		[0, 5, 4],
+		// top face
+		[3, 7, 6],
+		[3, 6, 2],
+		// left face
+		[0, 4, 7],
+		[0, 7, 3],
+		// right face
+		[1, 2, 6],
+		[1, 6, 5],
+	];
+	// Create mesh and attach to renderable
+	const meshHandle = MeshManager.Create();
+	MeshManager.SetVertices(meshHandle, cubeVertices);
+	MeshManager.SetTriangles(meshHandle, cubeIndices);
+	MeshManager.RecalcNormals(meshHandle);
+	MeshManager.RecalcBounds(meshHandle);
+
+	return meshHandle;
+}
+
+export function NewQuadMesh(): number {
+	// Define 4 vertices of the quad in the X-Y plane, Z = 0
+	const quadVertices = [
+		[-0.5, -0.5, 0.0], // 0: bottom-left
+		[0.5, -0.5, 0.0], // 1: bottom-right
+		[0.5, 0.5, 0.0], // 2: top-right
+		[-0.5, 0.5, 0.0], // 3: top-left
+	];
+
+	// Y-flipped UVs: (0,0) is top-left instead of bottom-left
+	const quadUVs = [
+		[0.0, 1.0], // 0: bottom-left
+		[1.0, 1.0], // 1: bottom-right
+		[1.0, 0.0], // 2: top-right
+		[0.0, 0.0], // 3: top-left
+	];
+	const quadIndices = [
+		[0, 2, 1],
+		[0, 3, 2],
+	];
+	// Create mesh and set geometry
+	const meshHandle = MeshManager.Create();
+	MeshManager.SetVertices(meshHandle, quadVertices);
+	MeshManager.SetUVs(meshHandle, quadUVs);
+	MeshManager.SetTriangles(meshHandle, quadIndices);
+	MeshManager.RecalcNormals(meshHandle);
+	MeshManager.RecalcBounds(meshHandle);
+
+	return meshHandle;
+}

package/library/render/renderable.ts

@@ -0,0 +1,137 @@
+import { RpcClient } from "../rpc";
+import { Entity } from "../entity";
+
+// NOTE: the following are not supported compared to legacy code:
+// - Filament's RenderableBuilder.Geometry(index,type,vertices,indices,offset,count)
+// - RenderableBuilder.Material(index,materialInstance)
+// - BoundingBox(...), SetBlendOrderAt
+
+export class RenderableManager {
+	/**
+	 * Create a renderable component and attach it to the specified entity
+	 * @param entity The entity to attach the renderable component to
+	 * @returns boolean indicating success
+	 */
+	static Create(entity: Entity): boolean {
+		return Boolean(
+			RpcClient.Call("Renderable_Create", { entityHandle: entity }),
+		);
+	}
+
+	/**
+	 * Destroy the Renderable component on this entity.
+	 * @param entityHandle The entity to remove the renderable component from
+	 * @returns boolean indicating success
+	 */
+	static Destroy(entityHandle: Entity): boolean {
+		return Boolean(RpcClient.Call("Renderable_Destroy", { entityHandle }));
+	}
+
+	/**
+	 * Returns whether this entity currently has a Renderable.
+	 * @param entityHandle The entity to check
+	 * @returns boolean indicating if renderable component exists
+	 */
+	static HasComponent(entityHandle: Entity): boolean {
+		return Boolean(RpcClient.Call("Renderable_HasComponent", { entityHandle }));
+	}
+
+	/**
+	 * Set the mesh for the renderable component
+	 * @param entityHandle The entity with the renderable component
+	 * @param meshHandle The mesh handle to attach
+	 * @returns boolean indicating success
+	 */
+	static SetMesh(entityHandle: Entity, meshHandle: number): boolean {
+		if (RenderableManager.HasComponent(entityHandle)) {
+			return Boolean(
+				RpcClient.Call("Renderable_SetMesh", {
+					entityHandle,
+					meshHandle,
+				}),
+			);
+		} else return false;
+	}
+
+	/**
+	 * Set the material for the renderable component
+	 * @param entityHandle The entity with the renderable component
+	 * @param materialHandle The material handle to attach
+	 * @param index The submesh index (default: 0)
+	 * @returns boolean indicating success
+	 */
+	static SetMaterial(
+		entityHandle: Entity,
+		materialHandle: number,
+		index: number = 0,
+	): boolean {
+		return Boolean(
+			RpcClient.Call("Renderable_SetMaterial", {
+				entityHandle,
+				materialHandle,
+				index,
+			}),
+		);
+	}
+
+	/**
+	 * Set the layer mask on this Renderable (bitmask of visible layers).
+	 * @param entityHandle The entity with the renderable component
+	 * @param layerMask The layer mask
+	 * @returns boolean indicating success
+	 */
+	static SetLayerMask(entityHandle: Entity, layerMask: number): boolean {
+		return Boolean(
+			RpcClient.Call("Renderable_SetLayerMask", {
+				entityHandle,
+				layerMask,
+			}),
+		);
+	}
+
+	/**
+	 * Enable or disable receiving shadows on this Renderable.
+	 * @param entityHandle The entity with the renderable component
+	 * @param receive Whether to receive shadows
+	 * @returns boolean indicating success
+	 */
+	static SetReceiveShadows(entityHandle: Entity, receive: boolean): boolean {
+		return Boolean(
+			RpcClient.Call("Renderable_SetReceiveShadows", {
+				entityHandle,
+				receive,
+			}),
+		);
+	}
+
+	/**
+	 * Control shadow‐casting mode.
+	 *   0 = Off, 1 = On, 2 = TwoSided, 3 = ShadowsOnly
+	 * @param entityHandle The entity with the renderable component
+	 * @param shadowMode The shadow casting mode
+	 * @returns boolean indicating success
+	 */
+	static SetCastShadows(entityHandle: Entity, shadowMode: number): boolean {
+		return Boolean(
+			RpcClient.Call("Renderable_SetCastShadows", {
+				entityHandle,
+				shadowMode,
+			}),
+		);
+	}
+
+	/**
+	 * Enable or disable frustum‐culling on this Renderable.
+	 * @param entityHandle The entity with the renderable component
+	 * @param enabled Whether to enable culling
+	 * @returns boolean indicating success
+	 */
+	static SetCulling(entityHandle: Entity, enabled: boolean): boolean {
+		return Boolean(
+			RpcClient.Call("Renderable_SetCulling", {
+				entityHandle,
+				enabled,
+			}),
+		);
+	}
+}