@jack120/test 0.2.0 → 0.2.1

package/library/render/material.ts

@@ -1,258 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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,
-			}),
-		);
-	}
-}