@jack120/test 0.2.0 → 0.2.1

package/library/rpc.ts

@@ -1,81 +0,0 @@
-import { platform } from "node:os";
-
-const addon =
-	platform() === "darwin"
-		? require("./native-bindings-osx.node")
-		: require("./native-bindings-win.node");
-
-export class RpcClient {
-	static Init() {
-		addon.Rpc_RegisterCbHandler((callbackId: number, argsJson: string) => {
-			let kvJson = JSON.parse(argsJson);
-			let objJson = RpcClient.keyValueToObject(
-				kvJson["keys"],
-				kvJson["values"],
-			);
-			try {
-				RpcClient.callbackRegistry[callbackId](objJson);
-			} catch (error) {
-				console.error(`${error}`);
-			}
-		});
-	}
-
-	static RegisterCallback(callback: (...args: any[]) => any): number {
-		let callbackId: number = Number(
-			RpcClient.Call("_RPC::AllocateCallback", {
-				clientId: RpcClient.GetClientId(),
-			}),
-		);
-		RpcClient.callbackRegistry[callbackId] = callback;
-		return callbackId;
-	}
-
-	/**
-	 *
-	 * @param funcName RPC function name to call
-	 * @param args Arguments of RPC in the format: `{parameter0: value0, parameter1: value1}`
-	 * @returns The value returned from RPC function in string type
-	 */
-	static Call(funcName: string, args: object): any {
-		if (!this.initialized) {
-			this.initialized = true;
-			RpcClient.Init();
-		}
-		const processedArgs: Record<string, any> = {};
-		for (const [key, value] of Object.entries(args)) {
-			if (typeof value === "function") {
-				processedArgs[key] = RpcClient.RegisterCallback(value);
-			} else {
-				processedArgs[key] = value;
-			}
-		}
-		return JSON.parse(
-			addon.Rpc_Call(
-				funcName,
-				JSON.stringify(this.objectToKeyValue(processedArgs)),
-			),
-		).result;
-	}
-
-	static GetClientId(): number {
-		return Number(addon.Rpc_GetClientId());
-	}
-
-	static objectToKeyValue(obj: Record<string, any>) {
-		const keys = Object.keys(obj);
-		const values = keys.map((key) => obj[key]);
-		return { keys, values };
-	}
-
-	static keyValueToObject(keys: string[], values: any[]): Record<string, any> {
-		const obj: Record<string, any> = {};
-		keys.forEach((key, index) => {
-			obj[key] = values[index];
-		});
-		return obj;
-	}
-
-	static callbackRegistry: { [key: number]: (...args: any[]) => any } = {};
-	static initialized = false;
-}

package/library/utilities/base64.ts

@@ -1,63 +0,0 @@
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-// Use a lookup table to find the index.
-const lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
-for (let i = 0; i < chars.length; i++) {
-    lookup[chars.charCodeAt(i)] = i;
-}
-
-export const base64Encode = (arraybuffer: ArrayBufferLike): string => {
-    let bytes = new Uint8Array(arraybuffer),
-        i,
-        len = bytes.length,
-        base64 = '';
-
-    for (i = 0; i < len; i += 3) {
-        base64 += chars[bytes[i] >> 2];
-        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
-        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
-        base64 += chars[bytes[i + 2] & 63];
-    }
-
-    if (len % 3 === 2) {
-        base64 = base64.substring(0, base64.length - 1) + '=';
-    } else if (len % 3 === 1) {
-        base64 = base64.substring(0, base64.length - 2) + '==';
-    }
-
-    return base64;
-};
-
-export const base64Decode = (base64: string): ArrayBufferLike => {
-    let bufferLength = base64.length * 0.75,
-        len = base64.length,
-        i,
-        p = 0,
-        encoded1,
-        encoded2,
-        encoded3,
-        encoded4;
-
-    if (base64[base64.length - 1] === '=') {
-        bufferLength--;
-        if (base64[base64.length - 2] === '=') {
-            bufferLength--;
-        }
-    }
-
-    const arraybuffer = new ArrayBuffer(bufferLength),
-        bytes = new Uint8Array(arraybuffer);
-
-    for (i = 0; i < len; i += 4) {
-        encoded1 = lookup[base64.charCodeAt(i)];
-        encoded2 = lookup[base64.charCodeAt(i + 1)];
-        encoded3 = lookup[base64.charCodeAt(i + 2)];
-        encoded4 = lookup[base64.charCodeAt(i + 3)];
-
-        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
-        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
-        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
-    }
-
-    return arraybuffer;
-};

package/loader-template.ts

@@ -1,419 +0,0 @@
-import {
-	CameraManager,
-	ColliderManager,
-	Entity,
-	EntityManager,
-	GrabInteractableManager,
-	LightManager,
-	LightType,
-	MaterialManager,
-	MeshManager,
-	quat,
-	RenderableManager,
-	RigidbodyManager,
-	ShaderProperties,
-	ShaderType,
-	TextureFormat,
-	TextureManager,
-	TransformManager,
-	vec3,
-	vec4,
-} from "@adamas/index";
-
-export const LoadAsset = async () => {
-	const assetRecord = new Map<string, object>();
-
-	// <ASSET_IMPORT>
-
-	const projectFile = (await import("./project.adamas.json")).default;
-
-	// type Properties = Exclude<(typeof scene.properties)[number][number], string>;
-	// type Transforms = Exclude<(typeof scene.transforms)[number][number], string>;
-	// type Renderables = Exclude<
-	// 	(typeof scene.renderables)[number][number],
-	// 	string
-	// >;
-	// type Lights = Exclude<(typeof scene.lights)[number][number], string>;
-	// type Cameras = Exclude<(typeof scene.cameras)[number][number], string>;
-	// type Colliders = Exclude<(typeof scene.colliders)[number][number], string>;
-	// type Rigidbodies = Exclude<
-	// 	(typeof scene.rigidbodies)[number][number],
-	// 	string
-	// >;
-	// type Grabbles = Exclude<(typeof scene.grabbles)[number][number], string>;
-
-	type Properties = {
-		componentType: string;
-		name: string;
-	};
-	type Transforms = {
-		componentType: string;
-		parent: string;
-		children: string[];
-		localScale: {
-			x: number;
-			y: number;
-			z: number;
-		};
-		localRotation: {
-			isEuler: boolean;
-			_x: number;
-			_y: number;
-			_z: number;
-			_order: string;
-		};
-		localPosition: {
-			x: number;
-			y: number;
-			z: number;
-		};
-	};
-	type Renderables = {
-		componentType: string;
-		layerMask: number;
-		receiveShadows: boolean;
-		castShadows: number;
-		culling: boolean;
-		mesh: string;
-		material: string;
-	};
-	type Lights = {
-		componentType: string;
-		color: {
-			x: number;
-			y: number;
-			z: number;
-		};
-		cullingMask: number;
-		intensity: number;
-		range: number;
-		shadows: number;
-		lightType: number;
-		spotAngle: number;
-		isSpotAngleDegree: boolean;
-	};
-	type Cameras = {
-		componentType: string;
-		cullingMask: number;
-		projectionType: number;
-		projectionFov: number;
-		projectionAspectRatio: number;
-		projectionNear: number;
-		projectionFar: number;
-		renderTexture: string;
-		orthoLeft: number;
-		orthoRight: number;
-		orthoBottom: number;
-		orthoTop: number;
-		orthoNear: number;
-		orthoFar: number;
-	};
-	type Colliders = {
-		componentType: string;
-		colliders: (
-			| {
-					isTrigger: boolean;
-					colliderType: string;
-					center: {
-						x: number;
-						y: number;
-						z: number;
-					};
-					size: {
-						x: number;
-						y: number;
-						z: number;
-					};
-					radius?: undefined;
-					height?: undefined;
-			  }
-			| {
-					isTrigger: boolean;
-					colliderType: string;
-					center: {
-						x: number;
-						y: number;
-						z: number;
-					};
-					radius: number;
-					size?: undefined;
-					height?: undefined;
-			  }
-			| {
-					isTrigger: boolean;
-					colliderType: string;
-					center: {
-						x: number;
-						y: number;
-						z: number;
-					};
-					height: number;
-					radius: number;
-					size?: undefined;
-			  }
-		)[];
-	};
-	type Rigidbodies = {
-		componentType: string;
-		angularDamping: number;
-		isKinematic: boolean;
-		linearDamping: number;
-		mass: number;
-		useGravity: boolean;
-	};
-	type Grabbles = {
-		componentType: string;
-		throwOnDetach: boolean;
-		trackPosition: boolean;
-		trackRotation: boolean;
-		trackScale: boolean;
-		attachEntity: string;
-	};
-
-	const scene = projectFile.scene;
-	const properties = new Map(scene.properties as [string, Properties][]);
-	const transforms = new Map(scene.transforms as [string, Transforms][]);
-	const renderables = new Map(scene.renderables as [string, Renderables][]);
-	const lights = new Map(scene.lights as [string, Lights][]);
-	const cameras = new Map(scene.cameras as [string, Cameras][]);
-	const colliders = new Map(scene.colliders as [string, Colliders][]);
-	const rigidbodies = new Map(scene.rigidbodies as [string, Rigidbodies][]);
-	const grabbles = new Map(scene.grabbles as [string, Grabbles][]);
-
-	const entityMap = new Map<string, Entity>();
-	for (const entity of scene.entities) {
-		const property = properties.get(entity)!;
-		const entityId = EntityManager.Create(property.name);
-		entityMap.set(entity, entityId);
-	}
-
-	for (const entity of scene.entities) {
-		const currEntity = entityMap.get(entity)!;
-
-		const transform = transforms.get(entity);
-		if (transform) {
-			if (transform.parent != "root") {
-				TransformManager.SetParent(
-					currEntity,
-					entityMap.get(transform.parent)!,
-				);
-			}
-
-			TransformManager.SetLocalPosition(
-				currEntity,
-				vec3.fromValues(
-					transform.localPosition.x,
-					transform.localPosition.y,
-					transform.localPosition.z,
-				),
-			);
-			TransformManager.SetLocalScale(
-				currEntity,
-				vec3.fromValues(
-					transform.localScale.x,
-					transform.localScale.y,
-					transform.localScale.z,
-				),
-			);
-			TransformManager.SetLocalRotation(
-				currEntity,
-				quat.fromEuler(
-					[0, 0, 0, 0],
-					transform.localRotation._x,
-					transform.localRotation._y,
-					transform.localRotation._z,
-				),
-			);
-		}
-
-		const renderable = renderables.get(entity);
-		if (renderable && renderable.mesh && renderable.material) {
-			RenderableManager.Create(currEntity);
-
-			const meshAsset = assetRecord.get(
-				renderable.mesh,
-			) as typeof import(".mesh").default;
-
-			if (meshAsset) {
-				const mesh = MeshManager.Create();
-				MeshManager.SetVertices(mesh, meshAsset.base64Vertices);
-				MeshManager.SetTriangles(mesh, meshAsset.base64Indices);
-
-				if (meshAsset.base64Uvs) MeshManager.SetUVs(mesh, meshAsset.base64Uvs);
-				if (meshAsset.base64Normals)
-					MeshManager.SetNormals(mesh, meshAsset.base64Normals);
-				RenderableManager.SetMesh(currEntity, mesh);
-
-				RenderableManager.SetCulling(currEntity, renderable.culling);
-			}
-
-			const materialAsset = assetRecord.get(
-				renderable.material,
-			) as typeof import(".mat").default;
-
-			if (materialAsset) {
-				const matHandle = MaterialManager.Create(ShaderType.URP_LIT);
-				MaterialManager.SetColor(
-					matHandle,
-					ShaderProperties.BaseColor,
-					vec4.fromValues(
-						materialAsset.baseColor.x,
-						materialAsset.baseColor.y,
-						materialAsset.baseColor.z,
-						materialAsset.baseColor.w,
-					),
-				);
-
-				if (materialAsset.baseMap) {
-					const texHandle = TextureManager.Create2D(1, 1, TextureFormat.RGBA32);
-					const texAsset = assetRecord.get(
-						materialAsset.baseMap,
-					)! as typeof import(".tex").default;
-
-					TextureManager.LoadImageBase64(texHandle, texAsset.base64Image);
-					MaterialManager.SetTexture(
-						matHandle,
-						ShaderProperties.BaseMap,
-						texHandle,
-					);
-				}
-
-				if (materialAsset.detailNormalMap) {
-				}
-
-				MaterialManager.SetColor(
-					matHandle,
-					ShaderProperties.EmissionColor,
-					vec4.fromValues(
-						materialAsset.emissionColor.x,
-						materialAsset.emissionColor.y,
-						materialAsset.emissionColor.z,
-						1,
-					),
-				);
-				if (materialAsset.emissionMap) {
-				}
-
-				RenderableManager.SetMaterial(currEntity, matHandle);
-			}
-		}
-
-		const light = lights.get(entity);
-		if (light) {
-			LightManager.Create(currEntity, light.lightType);
-			LightManager.SetColor(
-				currEntity,
-				vec3.fromValues(light.color.x, light.color.y, light.color.z),
-			);
-			LightManager.SetCullingMask(currEntity, light.cullingMask);
-			LightManager.SetIntensity(currEntity, light.intensity);
-			LightManager.SetRange(currEntity, light.range);
-			LightManager.SetShadows(currEntity, light.shadows);
-
-			if (light.lightType == LightType.Spot)
-				LightManager.SetSpotAngle(currEntity, light.spotAngle);
-		}
-
-		const camera = cameras.get(entity);
-		if (camera) {
-			CameraManager.Create(currEntity);
-			CameraManager.SetCullingMask(currEntity, camera.cullingMask);
-
-			if (camera.projectionType == 0) {
-				CameraManager.SetProjection(
-					currEntity,
-					0,
-					camera.projectionFov,
-					camera.projectionAspectRatio,
-					camera.projectionNear,
-					camera.projectionFar,
-				);
-			} else {
-				CameraManager.SetOrthographic(
-					currEntity,
-					camera.orthoLeft,
-					camera.orthoRight,
-					camera.orthoBottom,
-					camera.orthoTop,
-					camera.orthoNear,
-					camera.orthoFar,
-				);
-			}
-		}
-
-		const collider = colliders.get(entity);
-		if (collider) {
-			collider.colliders.forEach((c) => {
-				switch (c.colliderType) {
-					case "Box": {
-						const handle = ColliderManager.CreateBox(currEntity);
-						ColliderManager.SetBoxColliderCenter(
-							handle,
-							vec3.fromValues(c.center.x, c.center.y, c.center.z),
-						);
-						ColliderManager.SetBoxColliderSize(
-							handle,
-							vec3.fromValues(c.size!.x, c.size!.y, c.size!.z),
-						);
-						break;
-					}
-					case "Sphere": {
-						const handle = ColliderManager.CreateSphere(currEntity);
-						ColliderManager.SetSphereColliderCenter(
-							handle,
-							vec3.fromValues(c.center.x, c.center.y, c.center.z),
-						);
-						ColliderManager.SetSphereColliderRadius(handle, c.radius!);
-						break;
-					}
-					case "Capsule": {
-						const handle = ColliderManager.CreateCapsule(currEntity);
-						ColliderManager.SetCapsuleColliderCenter(
-							handle,
-							vec3.fromValues(c.center.x, c.center.y, c.center.z),
-						);
-						ColliderManager.SetCapsuleColliderRadius(handle, c.radius!);
-						ColliderManager.SetCapsuleColliderHeight(handle, c.height!);
-						break;
-					}
-				}
-			});
-		}
-
-		const rigidbody = rigidbodies.get(entity);
-		if (rigidbody) {
-			RigidbodyManager.Create(currEntity);
-			RigidbodyManager.SetAngularDamping(currEntity, rigidbody.angularDamping);
-			RigidbodyManager.SetIsKinematic(currEntity, rigidbody.isKinematic);
-			RigidbodyManager.SetLinearDamping(currEntity, rigidbody.linearDamping);
-			RigidbodyManager.SetMass(currEntity, rigidbody.mass);
-			RigidbodyManager.SetUseGravity(currEntity, rigidbody.useGravity);
-		}
-
-		const grabble = grabbles.get(entity);
-		if (grabble) {
-			GrabInteractableManager.Create(currEntity);
-
-			GrabInteractableManager.SetThrowOnDetach(
-				currEntity,
-				grabble.throwOnDetach,
-			);
-			GrabInteractableManager.SetTrackPosition(
-				currEntity,
-				grabble.trackPosition,
-			);
-			GrabInteractableManager.SetTrackRotation(
-				currEntity,
-				grabble.trackRotation,
-			);
-			GrabInteractableManager.SetTrackScale(currEntity, grabble.trackScale);
-
-			if (grabble.attachEntity) {
-				GrabInteractableManager.SetAttachEntity(
-					currEntity,
-					entityMap.get(grabble.attachEntity)!,
-				);
-			}
-		}
-	}
-};

package/native.cc

@@ -1,111 +0,0 @@
-#include <napi.h>
-#include <RpcClient.h>
-
-struct TsfnContext
-{
-    TsfnContext(Napi::Env env): deferred(Napi::Promise::Deferred::New(env)) {}
-
-    // Native Promise returned to JavaScript
-    Napi::Promise::Deferred deferred;
-
-    Napi::ThreadSafeFunction tsfn;
-
-    static void Destroy(Napi::Env env, void* finalizeData, TsfnContext* context)
-    {
-        // Resolve the Promise previously returned to JS via the CreateTSFN method.
-        context->deferred.Resolve(Napi::Boolean::New(env, true));
-        delete context;
-    }
-};
-
-Napi::Number RpcGetClientId(const Napi::CallbackInfo& info)
-{
-    Napi::Env env = info.Env();
-    return Napi::Number::New(env, RpcClient::Get().GetClientId());
-}
-
-Napi::Value RpcCall(const Napi::CallbackInfo& info)
-{
-    Napi::Env env = info.Env();
-    if (info.Length() != 2)
-    {
-        Napi::TypeError::New(env, "Wrong number of arguments")
-            .ThrowAsJavaScriptException();
-        return env.Null();
-    }
-
-    if (!info[0].IsString() || !info[1].IsString())
-    {
-        Napi::TypeError::New(env, "Wrong arguments")
-            .ThrowAsJavaScriptException();
-        return env.Null();
-    }
-
-    std::string functionName = info[0].As<Napi::String>().Utf8Value();
-    std::string jsonArgs = info[1].As<Napi::String>().Utf8Value();
-
-    std::string resultStr = RpcClient::Get().Call(functionName, jsonArgs);
-    return Napi::String::New(env, resultStr);
-}
-
-Napi::Value RpcRegisterCbHandler(const Napi::CallbackInfo& info)
-{
-    Napi::Env env = info.Env();
-    if (info.Length() != 1)
-    {
-        Napi::TypeError::New(env, "Wrong number of arguments")
-            .ThrowAsJavaScriptException();
-        return env.Null();
-    }
-
-    if (!info[0].IsFunction())
-    {
-        Napi::TypeError::New(env, "Wrong arguments")
-            .ThrowAsJavaScriptException();
-        return env.Null();
-    }
-
-    TsfnContext* context = new TsfnContext(env);
-
-    context->tsfn = Napi::ThreadSafeFunction::New(
-        env,                           // Environment
-        info[0].As<Napi::Function>(),  // JS function from caller
-        "TSFN",                        // Resource name
-        0,                             // Max queue size (0 = unlimited).
-        1,                             // Initial thread count
-        context,                       // Context,
-        TsfnContext::Destroy,          // Finalizer
-        (void*)nullptr                 // Finalizer data
-    );
-
-    RpcClient::Get().RegisterCallbackHandler([=] (int callbackId, const std::string& jsonArgs)
-    {
-        napi_status status = context->tsfn.BlockingCall(context,
-            [=](Napi::Env env, Napi::Function jsCallback, TsfnContext* ctx) {
-                jsCallback.Call({
-                    Napi::Number::New(env, callbackId),
-                    Napi::String::New(env, jsonArgs)
-                });
-            }
-        );
-
-        if (status != napi_ok) {
-            Napi::Error::Fatal("ThreadEntry",
-                "Napi::ThreadSafeNapi::Function.BlockingCall() failed"
-            );
-        }
-    });
-
-    return context->deferred.Promise();
-}
-
-static Napi::Object Init(Napi::Env env, Napi::Object exports) {
-    RpcClient::Get(6969, true);
-
-    exports.Set(Napi::String::New(env, "Rpc_Call"), Napi::Function::New(env, RpcCall));
-    exports.Set(Napi::String::New(env, "Rpc_RegisterCbHandler"), Napi::Function::New(env, RpcRegisterCbHandler));
-    exports.Set(Napi::String::New(env, "Rpc_GetClientId"), Napi::Function::New(env, RpcGetClientId));
-    return exports;
-}
-
-NODE_API_MODULE(hello, Init)