emeraldengine 2.2.1 → 3.0.0

package/src/Serializer.js

@@ -0,0 +1,131 @@
+/**
+ * @class Serializer
+ * @description Saves/loads a scene to/from plain JSON. Because components hold
+ * live GL/physics handles that can't be serialized generically, reconstruction
+ * goes through registered factories keyed by a `prefabType`. Each object's
+ * transform, layer, opacity and an optional `serialize()` payload are captured.
+ *
+ * @example
+ * Serializer.register("coin", (data) => makeCoin(data.value));
+ * coin.prefabType = "coin";
+ * coin.serialize = () => ({ value: 5 });
+ *
+ * const json = Serializer.toJSON(scene);          // save
+ * Serializer.fromJSON(json, new Scene());          // load
+ */
+class Serializer {
+  /**
+   * @method register
+   * @description Registers a factory that rebuilds an object from its data.
+   * @param {string} type - The prefabType
+   * @param {(data:any, entry:any) => Object} factory - Returns a GameObject
+   */
+  static register(type, factory) {
+    Serializer.factories.set(type, factory);
+  }
+
+  /**
+   * @method serializeObject
+   * @description Captures a single object's serializable state.
+   */
+  static serializeObject(obj) {
+    const t = obj.transform;
+    return {
+      type: obj.prefabType || null,
+      name: obj.name,
+      layer: obj.layer || 0,
+      opacity: typeof obj.opacity === "number" ? obj.opacity : 1,
+      screenSpace: !!obj.screenSpace,
+      transform: t
+        ? {
+            position: { x: t.position.x, y: t.position.y, z: t.position.z },
+            rotation: t.rotation,
+            scale: { x: t.scale.x, y: t.scale.y },
+          }
+        : null,
+      data:
+        typeof obj.serialize === "function"
+          ? obj.serialize()
+          : obj.data || null,
+    };
+  }
+
+  /**
+   * @method serializeScene
+   * @description Returns a plain object describing the scene.
+   */
+  static serializeScene(scene) {
+    return { objects: scene.objects.map((o) => Serializer.serializeObject(o)) };
+  }
+
+  /**
+   * @method applyState
+   * @description Applies a serialized entry's transform/layer/opacity to an object.
+   */
+  static applyState(obj, entry) {
+    if (entry.transform && obj.transform) {
+      const t = entry.transform;
+      obj.transform.position.x = t.position.x;
+      obj.transform.position.y = t.position.y;
+      obj.transform.position.z = t.position.z;
+      obj.transform.rotation = t.rotation;
+      obj.transform.scale.x = t.scale.x;
+      obj.transform.scale.y = t.scale.y;
+    }
+    if (typeof entry.layer === "number") obj.layer = entry.layer;
+    if (typeof entry.opacity === "number") obj.opacity = entry.opacity;
+    if (entry.screenSpace && typeof obj.setScreenSpace === "function") {
+      obj.setScreenSpace(true);
+    }
+    if (entry.name) obj.name = entry.name;
+  }
+
+  /**
+   * @method deserializeObject
+   * @description Rebuilds an object from an entry via its registered factory.
+   * @returns {Object|null}
+   */
+  static deserializeObject(entry) {
+    const factory = Serializer.factories.get(entry.type);
+    if (!factory) {
+      console.warn(`[Serializer] > No factory for type "${entry.type}"`);
+      return null;
+    }
+    const obj = factory(entry.data, entry);
+    if (obj) Serializer.applyState(obj, entry);
+    return obj;
+  }
+
+  /**
+   * @method deserializeScene
+   * @description Rebuilds objects into the given scene.
+   * @returns {Scene} - The populated scene
+   */
+  static deserializeScene(json, scene) {
+    for (const entry of json.objects || []) {
+      const obj = Serializer.deserializeObject(entry);
+      if (obj) scene.add(obj);
+    }
+    return scene;
+  }
+
+  /**
+   * @method toJSON
+   * @description Serializes a scene to a JSON string.
+   */
+  static toJSON(scene) {
+    return JSON.stringify(Serializer.serializeScene(scene));
+  }
+
+  /**
+   * @method fromJSON
+   * @description Loads a scene from a JSON string into the given scene.
+   */
+  static fromJSON(str, scene) {
+    return Serializer.deserializeScene(JSON.parse(str), scene);
+  }
+}
+
+Serializer.factories = new Map();
+
+export default Serializer;

package/src/Shaders.js

@@ -1,165 +1,150 @@
-const STANDARD_VERTEX_SHADER = `
-  attribute vec4 aVertexPosition;
-  attribute vec2 aTextureCoord;
-  
-  // Instance matrix (each row as a separate attribute)
-  attribute vec4 aInstanceMatrix0;
-  attribute vec4 aInstanceMatrix1;
-  attribute vec4 aInstanceMatrix2;
-  attribute vec4 aInstanceMatrix3;
-  
-  // Per-instance texture coordinates (one for each vertex of the quad)
-  attribute vec2 aInstanceTexCoord0;
-  attribute vec2 aInstanceTexCoord1;
-  attribute vec2 aInstanceTexCoord2;
-  attribute vec2 aInstanceTexCoord3;
-  
-  uniform mat4 uModelViewMatrix;
-  uniform mat4 uInstancedModelViewMatrix;
-  uniform mat4 uProjectionMatrix;
-  uniform bool useInstances;
-
-  varying highp vec2 vTexCoord;
-  varying vec2 vFragPos;
-  
-  void main() {
-    // Construct the instance matrix
-    mat4 instanceMatrix = mat4(
-      aInstanceMatrix0,
-      aInstanceMatrix1,
-      aInstanceMatrix2,
-      aInstanceMatrix3
-    );
-    
-    // Apply the instance-specific transform, then the global transforms
-    if(useInstances) {
-        gl_Position = uProjectionMatrix * uInstancedModelViewMatrix * instanceMatrix * aVertexPosition;
-        vFragPos = (uInstancedModelViewMatrix * instanceMatrix * aVertexPosition).xy;
-        
-        // Use per-instance texture coordinates based on vertex index
-        // Vertex order: top-right, top-left, bottom-right, bottom-left
-        int vertexIndex = int(aVertexPosition.x > 0.0 ? (aVertexPosition.y > 0.0 ? 0 : 2) : (aVertexPosition.y > 0.0 ? 1 : 3));
-        
-        if(vertexIndex == 0) {
-            vTexCoord = aInstanceTexCoord0;
-        } else if(vertexIndex == 1) {
-            vTexCoord = aInstanceTexCoord1;
-        } else if(vertexIndex == 2) {
-            vTexCoord = aInstanceTexCoord2;
-        } else {
-            vTexCoord = aInstanceTexCoord3;
-        }
-    } else {
-        gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition;
-        vFragPos = (uModelViewMatrix * aVertexPosition).xy;
-        vTexCoord = aTextureCoord;
-    }
-  }
-`;
-
-const STANDARD_FRAGMENT_SHADER = `
-    #ifdef GL_ES
-    precision highp float;
-    #endif
-    uniform bool useTexture;
-    uniform vec4 uColor;
-    uniform sampler2D uSampler;
-    uniform float uOpacity; // Global opacity multiplier per GameObject
-
-    uniform vec2 uLightPosition[4]; // Support up to 4 lights
-    uniform vec3 uLightColor[4];    // RGB colors for each light
-    uniform float uLightIntensity[4]; // Intensity of each light
-    uniform float uLightRadius[4];  // Radius of each light
-    uniform int uActiveLights;      // Number of active lights
-    
-    // Directional lights
-    uniform vec2 uDirLightPosition[4]; // Position of directional lights
-    uniform vec2 uDirLightDirection[4]; // Direction of directional lights
-    uniform vec3 uDirLightColor[4];    // RGB colors for each directional light
-    uniform float uDirLightIntensity[4]; // Intensity of each directional light
-    uniform float uDirLightWidth[4];   // Width of each directional light beam
-    uniform int uActiveDirLights;      // Number of active directional lights
-    
-    uniform vec3 uAmbientLightValues; // Ambient light values
-    uniform bool uUseLighting;      // Whether to apply lighting to this object
-
-    varying vec2 vTexCoord;
-    varying vec2 vFragPos;
-
-    void main() {
-        vec4 ambientLight = vec4(uAmbientLightValues.xyz, 1.0); // Move ambient light here
-        
-        vec4 texColor;
-        if (useTexture) {
-            texColor = texture2D(uSampler, vTexCoord);
-            // Discard only fully or nearly fully transparent texels to keep soft edges
-            if (texColor.a < 0.01) discard;
-            // Apply color tint to texture
-            texColor *= uColor;
-        } else {
-            texColor = uColor;
-        }
-        
-        // Start with ambient light
-        vec3 lighting = ambientLight.rgb;
-        
-        // Calculate contribution from each point light
-        for(int i = 0; i < 4; i++) {
-            if(i >= uActiveLights) break;
-            
-            float distance = length(uLightPosition[i] - vFragPos);
-            
-            // Check if fragment is within light radius
-            if(distance < uLightRadius[i]) {
-                // Calculate attenuation (falloff)
-                float attenuation = 1.0 - distance / uLightRadius[i];
-                
-                // Add this light's contribution
-                lighting += uLightColor[i] * attenuation * uLightIntensity[i];
-            }
-        }
-        
-        // Calculate contribution from each directional light
-        for(int i = 0; i < 4; i++) {
-            if(i >= uActiveDirLights) break;
-            
-            vec2 lightPos = uDirLightPosition[i];
-            vec2 lightDir = normalize(uDirLightDirection[i]);
-            vec2 toFrag = vFragPos - lightPos;
-            
-            // Check if fragment is in front of the light
-            float projection = dot(toFrag, lightDir);
-            if(projection < 0.0) continue;
-            
-            // Calculate perpendicular distance from light beam center
-            float perpDistance = abs(dot(toFrag, vec2(-lightDir.y, lightDir.x)));
-            
-            // Check if fragment is within light beam width
-            if(perpDistance > uDirLightWidth[i] * 0.5) continue;
-            
-            // Simplified lighting without shadows for now
-            float widthFactor = 1.0 - (perpDistance / (uDirLightWidth[i] * 0.5));
-            
-            // Optional: Add distance attenuation
-            float distance = length(toFrag);
-            float maxDistance = 1000.0; // Maximum effective distance
-            float distanceFactor = max(0.0, 1.0 - (distance / maxDistance));
-            
-            // Add this directional light's contribution
-            lighting += uDirLightColor[i] * uDirLightIntensity[i] * widthFactor * distanceFactor;
-        }
-        
-        // Apply lighting to texture color only if lighting is enabled
-        vec4 outColor;
-        if (uUseLighting) {
-            outColor = vec4(texColor.rgb * lighting, texColor.a);
-        } else {
-            outColor = texColor;
-        }
-        // Apply global opacity multiplier
-        outColor.a *= clamp(uOpacity, 0.0, 1.0);
-        gl_FragColor = outColor;
-    }
-`;
-
-export { STANDARD_VERTEX_SHADER, STANDARD_FRAGMENT_SHADER };
+const STANDARD_VERTEX_SHADER = `
+  attribute vec4 aVertexPosition;
+  attribute vec2 aTextureCoord;
+  
+  attribute vec4 aInstanceMatrix0;
+  attribute vec4 aInstanceMatrix1;
+  attribute vec4 aInstanceMatrix2;
+  attribute vec4 aInstanceMatrix3;
+  
+  attribute vec2 aInstanceTexCoord0;
+  attribute vec2 aInstanceTexCoord1;
+  attribute vec2 aInstanceTexCoord2;
+  attribute vec2 aInstanceTexCoord3;
+
+  attribute vec4 aInstanceColor;
+
+  uniform mat4 uModelViewMatrix;
+  uniform mat4 uInstancedModelViewMatrix;
+  uniform mat4 uProjectionMatrix;
+  uniform bool useInstances;
+
+  varying highp vec2 vTexCoord;
+  varying vec2 vFragPos;
+  varying vec4 vInstanceColor;
+
+  void main() {
+    mat4 instanceMatrix = mat4(
+      aInstanceMatrix0,
+      aInstanceMatrix1,
+      aInstanceMatrix2,
+      aInstanceMatrix3
+    );
+    
+    if(useInstances) {
+        gl_Position = uProjectionMatrix * uInstancedModelViewMatrix * instanceMatrix * aVertexPosition;
+        vFragPos = (uInstancedModelViewMatrix * instanceMatrix * aVertexPosition).xy;
+        vInstanceColor = aInstanceColor;
+
+        int vertexIndex = int(aVertexPosition.x > 0.0 ? (aVertexPosition.y > 0.0 ? 0 : 2) : (aVertexPosition.y > 0.0 ? 1 : 3));
+        
+        if(vertexIndex == 0) {
+            vTexCoord = aInstanceTexCoord0;
+        } else if(vertexIndex == 1) {
+            vTexCoord = aInstanceTexCoord1;
+        } else if(vertexIndex == 2) {
+            vTexCoord = aInstanceTexCoord2;
+        } else {
+            vTexCoord = aInstanceTexCoord3;
+        }
+    } else {
+        gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition;
+        vFragPos = (uModelViewMatrix * aVertexPosition).xy;
+        vTexCoord = aTextureCoord;
+        vInstanceColor = vec4(1.0);
+    }
+  }
+`;
+
+const STANDARD_FRAGMENT_SHADER = `
+    #ifdef GL_ES
+    precision highp float;
+    #endif
+    uniform bool useTexture;
+    uniform vec4 uColor;
+    uniform sampler2D uSampler;
+    uniform float uOpacity;
+
+    uniform vec2 uLightPosition[4];
+    uniform vec3 uLightColor[4];
+    uniform float uLightIntensity[4];
+    uniform float uLightRadius[4];
+    uniform int uActiveLights;
+    
+    uniform vec2 uDirLightPosition[4];
+    uniform vec2 uDirLightDirection[4];
+    uniform vec3 uDirLightColor[4];
+    uniform float uDirLightIntensity[4];
+    uniform float uDirLightWidth[4];
+    uniform int uActiveDirLights;
+    
+    uniform vec3 uAmbientLightValues;
+    uniform bool uUseLighting;
+
+    varying vec2 vTexCoord;
+    varying vec2 vFragPos;
+    varying vec4 vInstanceColor;
+
+    void main() {
+        vec4 ambientLight = vec4(uAmbientLightValues.xyz, 1.0);
+
+        vec4 texColor;
+        if (useTexture) {
+            texColor = texture2D(uSampler, vTexCoord);
+            if (texColor.a < 0.01) discard;
+            texColor *= uColor;
+        } else {
+            texColor = uColor;
+        }
+
+        texColor *= vInstanceColor;
+        
+        vec3 lighting = ambientLight.rgb;
+        
+        for(int i = 0; i < 4; i++) {
+            if(i >= uActiveLights) break;
+            
+            float distance = length(uLightPosition[i] - vFragPos);
+            
+            if(distance < uLightRadius[i]) {
+                float attenuation = 1.0 - distance / uLightRadius[i];
+                
+                lighting += uLightColor[i] * attenuation * uLightIntensity[i];
+            }
+        }
+        
+        for(int i = 0; i < 4; i++) {
+            if(i >= uActiveDirLights) break;
+            
+            vec2 lightPos = uDirLightPosition[i];
+            vec2 lightDir = normalize(uDirLightDirection[i]);
+            vec2 toFrag = vFragPos - lightPos;
+            
+            float projection = dot(toFrag, lightDir);
+            if(projection < 0.0) continue;
+            
+            float perpDistance = abs(dot(toFrag, vec2(-lightDir.y, lightDir.x)));
+            
+            if(perpDistance > uDirLightWidth[i] * 0.5) continue;
+            
+            float widthFactor = 1.0 - (perpDistance / (uDirLightWidth[i] * 0.5));
+            
+            float distance = length(toFrag);
+            float maxDistance = 1000.0;
+            float distanceFactor = max(0.0, 1.0 - (distance / maxDistance));
+            
+            lighting += uDirLightColor[i] * uDirLightIntensity[i] * widthFactor * distanceFactor;
+        }
+        
+        vec4 outColor;
+        if (uUseLighting) {
+            outColor = vec4(texColor.rgb * lighting, texColor.a);
+        } else {
+            outColor = texColor;
+        }
+        outColor.a *= clamp(uOpacity, 0.0, 1.0);
+        gl_FragColor = outColor;
+    }
+`;
+
+export { STANDARD_VERTEX_SHADER, STANDARD_FRAGMENT_SHADER };