@pizzapopcorn/unijs 0.0.1

package/README.md

@@ -0,0 +1,24 @@
+# UniJS - WebGL Interop (Library)
+
+## Prerequisites
+- Your Unity WebGL build must have the [Unity plugin package](https://github.com/PizzaPopcorn/unijs) installed and implemented (instructions provided in the README of that repo).
+- If you want to customize the library you need to have [Node.js](https://nodejs.org) installed.
+
+## Installation
+IMPORTANT: You don't have to clone/fork this repository if you just want to use the library without modifying it. Use CDN in that case.
+
+For getting the latest version in your project just paste this line in the html page that will load the Unity instance:
+```javascript
+<script src="https://cdn.jsdelivr.net/npm/@pizzapopcorn/unijs/dist/unity.min.js"></script>
+```
+Now if you want to customize the library you can clone/fork this repository and follow the build steps.
+
+## Build
+Building is pretty straightforward, just do the modifications you need and then run the following command:
+```bash
+npm run build
+```
+That will create `unity.js` and `unity.min.js` files that you can manually import to your web page project.
+
+## Additional Notes
+Notice that this library is designed to be only compatible with browser since that's where Unity runs. That being said, there is no need to import the npm package in any scenario, it just exists for the sake of the CDN download.

package/dist/unity.js

@@ -0,0 +1,347 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Unity = factory());
+})(this, (function () { 'use strict';
+
+    class GameObject {
+
+        static keyGameObjects = {};
+        static #lifeCycleCallbacks = {
+            awake: {},
+            start: {},
+            enable: {},
+            disable: {},
+            destroy: {}
+        }
+
+        static GetKeyGameObject(key){
+            if(!GameObject.keyGameObjects.hasOwnProperty(key)) {
+                console.error(`GameObject with key '${key}' not found`);
+                return null;
+            }
+            return GameObject.keyGameObjects[key];
+        }
+
+        static onAwake(key, callback){
+            if(!GameObject.#lifeCycleCallbacks.awake.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.awake[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.awake[key].add(callback);
+        }
+
+        static onStart(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.start.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.start[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.start[key].add(callback);
+        }
+
+        static onEnable(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.enable.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.enable[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.enable[key].add(callback);
+        }
+
+        static onDisable(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.disable.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.disable[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.disable[key].add(callback);
+        }
+
+        static onDestroy(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.destroy.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.destroy[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.destroy[key].add(callback);
+        }
+
+        static _register(key, data) {
+            GameObject.keyGameObjects[key] = new GameObject(key, data);
+        }
+
+        static _receiveLifeCycleEvent(key, event) {
+            const gameObject = GameObject.keyGameObjects[key];
+            if(!gameObject) return;
+
+            const callbacks = GameObject.#lifeCycleCallbacks[event][key];
+            if(callbacks) {
+                for(const callback of callbacks) {
+                    callback(gameObject);
+                }
+            }
+            if(event === "destroy") {
+                gameObject.transform = null;
+                delete GameObject.keyGameObjects[key];
+            }
+        }
+
+        constructor(key, data) {
+            this.key = key;
+            this.name = data.name;
+            this.transform = data.transform;
+            this.hierarchyPath = data.hasOwnProperty("hierarchyPath") ? data.hierarchyPath : "";
+        }
+
+        SetActive(active) {
+            this?.#invokeGameObjectEvent("gameObject.setActive", active);
+        }
+
+        InvokeMethod(methodName, paramType = "", paramValue = "") {
+            const { Unity } = require('./Unity');
+            paramType = Unity.types[paramType] || paramType;
+            this?.#invokeGameObjectEvent("gameObject.invokeMethod", { methodName: methodName, parameterType: paramType, parameterValue: paramValue });
+        }
+
+        GetChild(query) {
+            const eventName = typeof query === "string" ? "gameObject.findChild" : "gameObject.getChild";
+            const childData = this?.#invokeGameObjectEvent(eventName, query);
+            if(childData !== null) {
+                const currentPath = this.hierarchyPath === "" ? this.key : this.hierarchyPath;
+                childData.hierarchyPath = currentPath + "/" + childData.name;
+                return new GameObject(this.key, childData);
+            }
+            return null;
+        }
+
+        Translate(x, y, z) {
+            this?.#invokeGameObjectEvent("transform.translate", { x: x, y: y, z: z });
+        }
+
+        Rotate(x, y, z) {
+            this?.#invokeGameObjectEvent("transform.rotate", { x: x, y: y, z: z });
+        }
+
+        SetLocalScale(x, y, z) {
+            this?.#invokeGameObjectEvent("transform.setLocalScale", { x: x, y: y, z: z });
+        }
+
+        SetLocalPosition(x, y, z) {
+            this?.#invokeGameObjectEvent("transform.setLocalPosition", { x: x, y: y, z: z });
+        }
+
+        SetText(text) {
+            this?.#invokeGameObjectEvent("text.setText", text);
+        }
+
+        Destroy() {
+            this?.#invokeGameObjectEvent("gameObject.destroy", "");
+        }
+
+        #invokeGameObjectEvent(eventName, payload) {
+            if(!this.transform) return null;
+
+            let payloadJson = payload;
+            if(typeof payload === "object") payloadJson = JSON.stringify(payload);
+            else if(typeof payload !== "string") payloadJson = payload.toString();
+            const eventPayload = { eventName: eventName, hierarchyPath: this.hierarchyPath, payloadJson: payloadJson, listenDisabled: true };
+
+            const { Unity } = require('./Unity');
+            const response = Unity.InvokeEvent(`GOEvent:${this.key}`, JSON.stringify(eventPayload));
+
+            console.log(`Invoked Event: GOEvent:${this.key}`, eventPayload);
+
+            if(response === null || !response.hasOwnProperty("ok")){
+                console.error(`Invalid JSON response from GameObject event callback: ${response}`);
+                return null;
+            }
+
+            if(response.ok) {
+                let responseObj = response.responseJson;
+                try {
+                    responseObj = JSON.parse(response.responseJson);
+                } catch {}
+                return responseObj;
+            }
+            console.error(`Error invoking GameObject event: ${eventName}`, response.error);
+            return null;
+        }
+    }
+
+    class Unity {
+        /** @type {typeof GameObject} */
+        static GameObject = GameObject;
+        static internalLogs = false;
+        static types = {
+            int: "System.Int32",
+            float: "System.Single",
+            double: "System.Double",
+            bool: "System.Boolean",
+            string: "System.String",
+            char: "System.Char",
+            byte: "System.Byte",
+            long: "System.Int64",
+            short: "System.Int16",
+            decimal: "System.Decimal",
+            object: "System.Object",
+            customClass: (className, namespace = "", assembly = "Assembly-CSharp") => {
+                const qualifiedName = namespace === "" ? className : `${namespace}.${className}`;
+                return `${qualifiedName}, ${assembly}.dll`;
+            },
+        };
+
+        static #clientEventCallback;
+        static #instanceReady = false;
+        static #onInstanceReadyListeners = new Set();
+        static #onEventListeners = {};
+
+        static LoadInstance(url, elementId) {
+            Unity.#instanceReady = false;
+            const r = new XMLHttpRequest();
+            r.open("GET", url + "/index.html", true);
+            r.onreadystatechange = function () {
+                if (r.readyState !== 4 || r.status !== 200) return;
+                document.querySelector(`#${elementId}`).innerHTML = r.responseText;
+
+                const link = document.createElement('link');
+
+                link.rel = 'stylesheet';
+                link.type = 'text/css';
+                link.href = url + "/TemplateData/style.css";
+                document.head.appendChild(link);
+
+                const indexScript = document.createElement("script");
+                indexScript.src = url + "/index.js";
+                document.body.appendChild(indexScript);
+            };
+            r.send();
+        }
+
+        static GetBuildVersion() {
+            return Unity.InvokeEvent("InstanceEvent:GetBuildVersion");
+        }
+
+        static InvokeEvent(eventName, payload = undefined) {
+            const responseJson = Unity.#invokeEventInternal(eventName, payload);
+            try {
+                const response = JSON.parse(responseJson);
+                if(response.hasOwnProperty("promiseId")){
+                    console.warn(`Event '${eventName}' returned a promise. Consider using InvokeEventAsync instead.`);
+                    Unity.onEvent(`PromiseResolvedEvent:${response.promiseId}`, payload => {
+                        delete Unity.#onEventListeners[`PromiseResolvedEvent:${response.promiseId}`];
+                    });
+                }
+                return response;
+            }
+            catch {
+                return responseJson;
+            }
+        }
+
+        static async InvokeEventAsync(eventName, payload = undefined) {
+            return new Promise(resolve => {
+                const responseJson = Unity.#invokeEventInternal(eventName, payload);
+                try {
+                    const response = JSON.parse(responseJson);
+                    if(response.hasOwnProperty("promiseId")){
+                        Unity.onEvent(`PromiseResolvedEvent:${response.promiseId}`, payload => {
+                            resolve(payload);
+                            delete Unity.#onEventListeners[`PromiseResolvedEvent:${response.promiseId}`];
+                        });
+                    }
+                    else {
+                        resolve(response);
+                    }
+                } catch {
+                    resolve(responseJson);
+                }
+            })
+        }
+
+        static async WaitForEndOfFrameAsync() {
+            return new Promise((resolve) => {
+                const eventId = crypto.randomUUID().toString();
+                const eventName = `EndOfFrameEvent:${eventId}`;
+
+                Unity.onEvent(eventName, () => {
+                    resolve();
+                    delete Unity.#onEventListeners[eventName];
+                });
+
+                Unity.InvokeEvent("InstanceEvent:WaitForEndOfFrame", eventId);
+            });
+        }
+
+        static async LoadBundleAsync(bundleUrl) {
+            await Unity.InvokeEventAsync("InstanceEvent:LoadBundle", bundleUrl);
+        }
+
+        static async InstantiatePrefabFromBundleAsync(bundleUrl, prefabName, parentKey = "") {
+            await Unity.InvokeEventAsync("InstanceEvent:InstantiatePrefabFromBundle", {
+                bundleUrl: bundleUrl,
+                prefabName: prefabName,
+                parentKey: parentKey
+            });
+        }
+
+        // Listeners -----------------------------
+
+        static onInstanceReady(callback) {
+            if(!Unity.#instanceReady) {
+                Unity.#onInstanceReadyListeners.add(callback);
+            }
+            else {
+                callback();
+            }
+        }
+
+        static onEvent(eventName, callback) {
+            if(!Unity.#onEventListeners.hasOwnProperty(eventName)) {
+                Unity.#onEventListeners[eventName] = new Set();
+            }
+            Unity.#onEventListeners[eventName].add(callback);
+        }
+
+        static offEvent(eventName, callback) {
+            if(!Unity.#onEventListeners.hasOwnProperty(eventName)) return;
+            Unity.#onEventListeners[eventName].delete(callback);
+        }
+
+        static #invokeEventInternal(eventName, payload) {
+            if(payload === undefined || payload === null) payload = "";
+            let payloadJson = payload;
+            if(typeof payload === "object") payloadJson = JSON.stringify(payload);
+            else if(typeof payload !== "string") payloadJson = payload.toString();
+            const responseJson = Unity.#clientEventCallback(eventName, payloadJson);
+            Unity.#onEventListeners[eventName]?.forEach(callback => callback(payloadJson));
+            return responseJson;
+        }
+
+        // JSLib usage -----------------------------
+
+        /**Only for unity js library use*/
+        static _instanceReady() {
+            Unity.#instanceReady = true;
+            Unity.#onInstanceReadyListeners.forEach(callback => callback());
+        }
+
+        /**Only for unity js library use*/
+        static _registerClientListener(callback) {
+            Unity.#clientEventCallback = callback;
+        }
+
+        /**Only for unity js library use*/
+        static _receiveEvent(eventName, payloadJson) {
+            let payload = payloadJson;
+            try {
+                payload = JSON.parse(payloadJson);
+            } catch {}
+
+            Unity.InvokeEvent(eventName, payload);
+        }
+
+        /**Only for unity js library use*/
+        static _logFromUnity(verbosity, message) {
+            if(verbosity === "internal" && !Unity.internalLogs) return;
+            if(verbosity === "error") console.error(`[Unity] ${message}`);
+            else if(verbosity === "warning") console.warn(`[Unity] ${message}`);
+            else console.log(`[Unity] ${message}`);
+        }
+
+    }
+
+    return Unity;
+
+}));

package/dist/unity.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Unity=t()}(this,function(){"use strict";class e{static keyGameObjects={};static#e={awake:{},start:{},enable:{},disable:{},destroy:{}};static GetKeyGameObject(t){return e.keyGameObjects.hasOwnProperty(t)?e.keyGameObjects[t]:(console.error(`GameObject with key '${t}' not found`),null)}static onAwake(t,n){e.#e.awake.hasOwnProperty(t)||(e.#e.awake[t]=new Set),e.#e.awake[t].add(n)}static onStart(t,n){e.#e.start.hasOwnProperty(t)||(e.#e.start[t]=new Set),e.#e.start[t].add(n)}static onEnable(t,n){e.#e.enable.hasOwnProperty(t)||(e.#e.enable[t]=new Set),e.#e.enable[t].add(n)}static onDisable(t,n){e.#e.disable.hasOwnProperty(t)||(e.#e.disable[t]=new Set),e.#e.disable[t].add(n)}static onDestroy(t,n){e.#e.destroy.hasOwnProperty(t)||(e.#e.destroy[t]=new Set),e.#e.destroy[t].add(n)}static _register(t,n){e.keyGameObjects[t]=new e(t,n)}static _receiveLifeCycleEvent(t,n){const s=e.keyGameObjects[t];if(!s)return;const a=e.#e[n][t];if(a)for(const e of a)e(s);"destroy"===n&&(s.transform=null,delete e.keyGameObjects[t])}constructor(e,t){this.key=e,this.name=t.name,this.transform=t.transform,this.hierarchyPath=t.hasOwnProperty("hierarchyPath")?t.hierarchyPath:""}SetActive(e){this?.#t("gameObject.setActive",e)}InvokeMethod(e,t="",n=""){const{Unity:s}=require("./Unity");t=s.types[t]||t,this?.#t("gameObject.invokeMethod",{methodName:e,parameterType:t,parameterValue:n})}GetChild(t){const n="string"==typeof t?"gameObject.findChild":"gameObject.getChild",s=this?.#t(n,t);if(null!==s){const t=""===this.hierarchyPath?this.key:this.hierarchyPath;return s.hierarchyPath=t+"/"+s.name,new e(this.key,s)}return null}Translate(e,t,n){this?.#t("transform.translate",{x:e,y:t,z:n})}Rotate(e,t,n){this?.#t("transform.rotate",{x:e,y:t,z:n})}SetLocalScale(e,t,n){this?.#t("transform.setLocalScale",{x:e,y:t,z:n})}SetLocalPosition(e,t,n){this?.#t("transform.setLocalPosition",{x:e,y:t,z:n})}SetText(e){this?.#t("text.setText",e)}Destroy(){this?.#t("gameObject.destroy","")}#t(e,t){if(!this.transform)return null;let n=t;"object"==typeof t?n=JSON.stringify(t):"string"!=typeof t&&(n=t.toString());const s={eventName:e,hierarchyPath:this.hierarchyPath,payloadJson:n,listenDisabled:!0},{Unity:a}=require("./Unity"),r=a.InvokeEvent(`GOEvent:${this.key}`,JSON.stringify(s));if(console.log(`Invoked Event: GOEvent:${this.key}`,s),null===r||!r.hasOwnProperty("ok"))return console.error(`Invalid JSON response from GameObject event callback: ${r}`),null;if(r.ok){let e=r.responseJson;try{e=JSON.parse(r.responseJson)}catch{}return e}return console.error(`Error invoking GameObject event: ${e}`,r.error),null}}class t{static GameObject=e;static internalLogs=!1;static types={int:"System.Int32",float:"System.Single",double:"System.Double",bool:"System.Boolean",string:"System.String",char:"System.Char",byte:"System.Byte",long:"System.Int64",short:"System.Int16",decimal:"System.Decimal",object:"System.Object",customClass:(e,t="",n="Assembly-CSharp")=>`${""===t?e:`${t}.${e}`}, ${n}.dll`};static#n;static#s=!1;static#a=new Set;static#r={};static LoadInstance(e,n){t.#s=!1;const s=new XMLHttpRequest;s.open("GET",e+"/index.html",!0),s.onreadystatechange=function(){if(4!==s.readyState||200!==s.status)return;document.querySelector(`#${n}`).innerHTML=s.responseText;const t=document.createElement("link");t.rel="stylesheet",t.type="text/css",t.href=e+"/TemplateData/style.css",document.head.appendChild(t);const a=document.createElement("script");a.src=e+"/index.js",document.body.appendChild(a)},s.send()}static GetBuildVersion(){return t.InvokeEvent("InstanceEvent:GetBuildVersion")}static InvokeEvent(e,n=void 0){const s=t.#o(e,n);try{const n=JSON.parse(s);return n.hasOwnProperty("promiseId")&&(console.warn(`Event '${e}' returned a promise. Consider using InvokeEventAsync instead.`),t.onEvent(`PromiseResolvedEvent:${n.promiseId}`,e=>{delete t.#r[`PromiseResolvedEvent:${n.promiseId}`]})),n}catch{return s}}static async InvokeEventAsync(e,n=void 0){return new Promise(s=>{const a=t.#o(e,n);try{const e=JSON.parse(a);e.hasOwnProperty("promiseId")?t.onEvent(`PromiseResolvedEvent:${e.promiseId}`,n=>{s(n),delete t.#r[`PromiseResolvedEvent:${e.promiseId}`]}):s(e)}catch{s(a)}})}static async WaitForEndOfFrameAsync(){return new Promise(e=>{const n=crypto.randomUUID().toString(),s=`EndOfFrameEvent:${n}`;t.onEvent(s,()=>{e(),delete t.#r[s]}),t.InvokeEvent("InstanceEvent:WaitForEndOfFrame",n)})}static async LoadBundleAsync(e){await t.InvokeEventAsync("InstanceEvent:LoadBundle",e)}static async InstantiatePrefabFromBundleAsync(e,n,s=""){await t.InvokeEventAsync("InstanceEvent:InstantiatePrefabFromBundle",{bundleUrl:e,prefabName:n,parentKey:s})}static onInstanceReady(e){t.#s?e():t.#a.add(e)}static onEvent(e,n){t.#r.hasOwnProperty(e)||(t.#r[e]=new Set),t.#r[e].add(n)}static offEvent(e,n){t.#r.hasOwnProperty(e)&&t.#r[e].delete(n)}static#o(e,n){null==n&&(n="");let s=n;"object"==typeof n?s=JSON.stringify(n):"string"!=typeof n&&(s=n.toString());const a=t.#n(e,s);return t.#r[e]?.forEach(e=>e(s)),a}static _instanceReady(){t.#s=!0,t.#a.forEach(e=>e())}static _registerClientListener(e){t.#n=e}static _receiveEvent(e,n){let s=n;try{s=JSON.parse(n)}catch{}t.InvokeEvent(e,s)}static _logFromUnity(e,n){("internal"!==e||t.internalLogs)&&("error"===e?console.error(`[Unity] ${n}`):"warning"===e?console.warn(`[Unity] ${n}`):console.log(`[Unity] ${n}`))}}return t});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@pizzapopcorn/unijs",
+  "version": "0.0.1",
+  "description": "A seamless interop layer to control Unity WebGL builds from the browser's JavaScript context.",
+  "license": "MIT",
+  "keywords": [
+    "unijs",
+    "unityjs",
+    "unity.js",
+    "unity",
+    "uni",
+    "js",
+    "javascript",
+    "interop",
+    "web",
+    "webgl"
+  ],
+  "homepage": "https://github.com/PizzaPopcorn/unijs-lib#readme",
+  "bugs": {
+    "url": "https://github.com/PizzaPopcorn/unijs-lib/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PizzaPopcorn/unijs-lib.git"
+  },
+  "author": "Andres Urrutia <urrutiac.andres@gmail.com> (https://portfolio.sharpdevmx.com)",
+  "type": "module",
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "rollup": "^4.59.0"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "dist"
+  ]
+}