@erik9994857/cag 2.0.4 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erik9994857/cag",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "CaG — A code library and custom language for building 3D worlds with .cagc files, .bbmodel support, and auto UV mapping",
   "main": "src/index.js",
   "bin": {

package/src/api/model-api.js

@@ -70,6 +70,7 @@ class ModelAPI {
       geometry: null,
       texture: null,
       uvMappings: null,
+      allTextures: [],
       valid: false
     };
 
@@ -83,20 +84,24 @@ class ModelAPI {
     }
 
     if (resource.texture) {
-      result.texture = this.loadTexture(resource.texture);
+      const tex = this.loadTexture(resource.texture);
+      result.texture = tex;
+      result.allTextures = [tex.dataURL];
     } else if (embeddedTextures.length > 0) {
-      result.texture = {
-        path: null,
-        width: result.geometry ? result.geometry.resolution.width : 16,
-        height: result.geometry ? result.geometry.resolution.height : 16,
-        format: "png",
-        size: 0,
-        dataURL: embeddedTextures[0].source
-      };
+      const resW = result.geometry ? result.geometry.resolution.width : 16;
+      const resH = result.geometry ? result.geometry.resolution.height : 16;
+      result.allTextures = embeddedTextures.map(function (t) { return t.source; });
+      if (embeddedTextures.length === 1) {
+        result.texture = {
+          path: null, width: resW, height: resH,
+          format: "png", size: 0, dataURL: embeddedTextures[0].source
+        };
+      } else {
+        this.remapToAtlas(result, embeddedTextures, resW, resH);
+      }
     }
 
     if (result.geometry && result.texture && result.uvMappings) {
-      result.uvMappings = this.validateAndFixUVMappings(result.uvMappings, result.texture);
       result.valid = true;
     } else if (result.geometry) {
       result.valid = true;
@@ -105,6 +110,28 @@ class ModelAPI {
     return result;
   }
 
+  remapToAtlas(result, textures, texW, texH) {
+    const numTex = textures.length;
+    const atlasW = numTex * texW;
+    const atlasH = texH;
+
+    for (let i = 0; i < result.uvMappings.length; i++) {
+      const m = result.uvMappings[i];
+      const idx = m.textureIndex || 0;
+      const texIdx = Math.min(idx, numTex - 1);
+      const offsetU = texIdx * texW;
+      m.uv = [m.uv[0] + offsetU, m.uv[1], m.uv[2] + offsetU, m.uv[3]];
+    }
+
+    result.texture = {
+      path: null, width: atlasW, height: atlasH,
+      format: "png", size: 0, dataURL: textures[0].source
+    };
+    if (result.geometry) {
+      result.geometry.resolution = { width: atlasW, height: atlasH };
+    }
+  }
+
   parseBBModel(filePath) {
     const raw = fs.readFileSync(filePath, "utf-8");
     let data;
@@ -122,10 +149,11 @@ class ModelAPI {
     };
 
     const uvMappings = [];
-
-    const useBoxUV = !!data.box_uv;
     const uvMapper = new UVMapper(geometry.resolution);
 
+    // Detect box_uv: can be at root level or in meta
+    const projectBoxUV = !!(data.box_uv || (data.meta && data.meta.box_uv));
+
     if (data.elements && Array.isArray(data.elements)) {
       for (const element of data.elements) {
         const geomElement = {
@@ -137,60 +165,44 @@ class ModelAPI {
           faces: {}
         };
 
-        const needsAutoUV = useBoxUV || (element.box_uv !== undefined && element.box_uv);
-        let autoUVs = null;
-        if (needsAutoUV) {
-          autoUVs = uvMapper.autoMap(geomElement.from, geomElement.to);
+        // Element-level box_uv overrides project-level
+        const isBoxUV = element.box_uv !== undefined ? !!element.box_uv : projectBoxUV;
+
+        // For box UV: compute face UVs from geometry + uv_offset
+        let boxUVs = null;
+        if (isBoxUV) {
+          const uvOff = element.uv_offset || [0, 0];
+          boxUVs = uvMapper.autoMap(geomElement.from, geomElement.to, uvOff);
         }
 
-        if (element.faces) {
-          const faceNames = ["north", "south", "east", "west", "up", "down"];
+        const faceNames = ["north", "south", "east", "west", "up", "down"];
+
+        if (isBoxUV) {
+          // Box UV mode: compute all face UVs from geometry
+          for (const faceName of faceNames) {
+            const texIdx = (element.faces && element.faces[faceName] && element.faces[faceName].texture !== undefined)
+              ? element.faces[faceName].texture : 0;
+            geomElement.faces[faceName] = { uv: boxUVs[faceName], texture: texIdx };
+            uvMappings.push({
+              element: geomElement.name, face: faceName,
+              uv: boxUVs[faceName], textureIndex: texIdx
+            });
+          }
+        } else if (element.faces) {
+          // Per-face UV mode: read UVs directly from bbmodel
           for (const faceName of faceNames) {
             if (element.faces[faceName]) {
               const face = element.faces[faceName];
-              let faceUV = face.uv;
-
-              if (!faceUV || !Array.isArray(faceUV) || faceUV.length < 4) {
-                faceUV = autoUVs ? autoUVs[faceName] : [0, 0, 16, 16];
-              }
-
-              geomElement.faces[faceName] = {
-                uv: faceUV,
-                texture: face.texture !== undefined ? face.texture : 0
-              };
+              const faceUV = (face.uv && Array.isArray(face.uv) && face.uv.length >= 4)
+                ? face.uv : [0, 0, 16, 16];
+              const texIdx = face.texture !== undefined ? face.texture : 0;
+              geomElement.faces[faceName] = { uv: faceUV, texture: texIdx };
               uvMappings.push({
-                element: geomElement.name,
-                face: faceName,
-                uv: faceUV,
-                textureIndex: face.texture !== undefined ? face.texture : 0
-              });
-            } else if (needsAutoUV && autoUVs) {
-              geomElement.faces[faceName] = {
-                uv: autoUVs[faceName],
-                texture: 0
-              };
-              uvMappings.push({
-                element: geomElement.name,
-                face: faceName,
-                uv: autoUVs[faceName],
-                textureIndex: 0
+                element: geomElement.name, face: faceName,
+                uv: faceUV, textureIndex: texIdx
               });
             }
           }
-        } else if (needsAutoUV && autoUVs) {
-          const faceNames = ["north", "south", "east", "west", "up", "down"];
-          for (const faceName of faceNames) {
-            geomElement.faces[faceName] = {
-              uv: autoUVs[faceName],
-              texture: 0
-            };
-            uvMappings.push({
-              element: geomElement.name,
-              face: faceName,
-              uv: autoUVs[faceName],
-              textureIndex: 0
-            });
-          }
         }
 
         geometry.elements.push(geomElement);

package/src/models/uv-mapper.js

@@ -252,18 +252,20 @@ class UVMapper {
     return result;
   }
 
-  autoMap(elementFrom, elementTo) {
-    var sizeX = Math.abs(elementTo[0] - elementFrom[0]);
-    var sizeY = Math.abs(elementTo[1] - elementFrom[1]);
-    var sizeZ = Math.abs(elementTo[2] - elementFrom[2]);
+  autoMap(elementFrom, elementTo, uvOffset) {
+    var W = Math.abs(elementTo[0] - elementFrom[0]);
+    var H = Math.abs(elementTo[1] - elementFrom[1]);
+    var D = Math.abs(elementTo[2] - elementFrom[2]);
+    var ox = uvOffset ? uvOffset[0] : 0;
+    var oy = uvOffset ? uvOffset[1] : 0;
 
     return {
-      north: [sizeZ, sizeZ, sizeZ + sizeX, sizeZ + sizeY],
-      south: [sizeZ + sizeX + sizeZ, sizeZ, sizeZ + sizeX + sizeZ + sizeX, sizeZ + sizeY],
-      east: [0, sizeZ, sizeZ, sizeZ + sizeY],
-      west: [sizeZ + sizeX, sizeZ, sizeZ + sizeX + sizeZ, sizeZ + sizeY],
-      up: [sizeZ, 0, sizeZ + sizeX, sizeZ],
-      down: [sizeZ + sizeX, 0, sizeZ + sizeX + sizeX, sizeZ]
+      east:  [ox,               D + oy,      D + ox,               D + H + oy],
+      north: [D + ox,           D + oy,      D + W + ox,           D + H + oy],
+      west:  [D + W + ox,       D + oy,      D * 2 + W + ox,       D + H + oy],
+      south: [D * 2 + W + ox,   D + oy,      D * 2 + W * 2 + ox,   D + H + oy],
+      up:    [D + W + ox,       D + oy,      D + ox,               oy],
+      down:  [D + W * 2 + ox,   oy,          D + W + ox,           D + oy]
     };
   }
 

package/src/runtime/electron-runner.js

@@ -215,6 +215,7 @@ ElectronRunner.prototype.getRendererSource = function () {
       }
       modelDataForRenderer[smName] = {
         textureDataURL: smData.textureDataURL || null,
+        allTextures: smData.allTextures || [],
         resW: smData.resolution ? smData.resolution.width : 16,
         resH: smData.resolution ? smData.resolution.height : 16,
         faceUV: faceUVMap
@@ -448,19 +449,44 @@ ElectronRunner.prototype.getRendererSource = function () {
   js.push("  this.blockTexture = gl.createTexture();");
   js.push("  gl.bindTexture(gl.TEXTURE_2D, this.blockTexture);");
   js.push("  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array([128,128,128,255]));");
+  js.push("  function uploadTex(source) {");
+  js.push("    var g = game.gl;");
+  js.push("    g.bindTexture(g.TEXTURE_2D, game.blockTexture);");
+  js.push("    g.texImage2D(g.TEXTURE_2D, 0, g.RGBA, g.RGBA, g.UNSIGNED_BYTE, source);");
+  js.push("    g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MIN_FILTER, g.NEAREST);");
+  js.push("    g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MAG_FILTER, g.NEAREST);");
+  js.push("    g.texParameteri(g.TEXTURE_2D, g.TEXTURE_WRAP_S, g.CLAMP_TO_EDGE);");
+  js.push("    g.texParameteri(g.TEXTURE_2D, g.TEXTURE_WRAP_T, g.CLAMP_TO_EDGE);");
+  js.push("  }");
   js.push("  var texKeys = Object.keys(MODELS);");
-  js.push("  if (texKeys.length > 0 && MODELS[texKeys[0]].textureDataURL) {");
-  js.push("    var texImg = new Image();");
-  js.push("    texImg.onload = function() {");
-  js.push("      var g = game.gl;");
-  js.push("      g.bindTexture(g.TEXTURE_2D, game.blockTexture);");
-  js.push("      g.texImage2D(g.TEXTURE_2D, 0, g.RGBA, g.RGBA, g.UNSIGNED_BYTE, texImg);");
-  js.push("      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MIN_FILTER, g.NEAREST);");
-  js.push("      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MAG_FILTER, g.NEAREST);");
-  js.push("      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_WRAP_S, g.CLAMP_TO_EDGE);");
-  js.push("      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_WRAP_T, g.CLAMP_TO_EDGE);");
-  js.push("    };");
-  js.push("    texImg.src = MODELS[texKeys[0]].textureDataURL;");
+  js.push("  if (texKeys.length > 0) {");
+  js.push("    var m = MODELS[texKeys[0]];");
+  js.push("    var srcs = m.allTextures && m.allTextures.length > 0 ? m.allTextures : (m.textureDataURL ? [m.textureDataURL] : []);");
+  js.push("    if (srcs.length > 1) {");
+  js.push("      var loaded = 0, imgs = [];");
+  js.push("      for (var ti = 0; ti < srcs.length; ti++) {");
+  js.push("        (function(idx) {");
+  js.push("          var img = new Image();");
+  js.push("          img.onload = function() {");
+  js.push("            imgs[idx] = img;");
+  js.push("            loaded++;");
+  js.push("            if (loaded === srcs.length) {");
+  js.push("              var tw = imgs[0].width, th = imgs[0].height;");
+  js.push("              var c = document.createElement('canvas');");
+  js.push("              c.width = tw * srcs.length; c.height = th;");
+  js.push("              var ctx = c.getContext('2d');");
+  js.push("              for (var j = 0; j < imgs.length; j++) ctx.drawImage(imgs[j], j * tw, 0);");
+  js.push("              uploadTex(c);");
+  js.push("            }");
+  js.push("          };");
+  js.push("          img.src = srcs[idx];");
+  js.push("        })(ti);");
+  js.push("      }");
+  js.push("    } else if (srcs.length === 1) {");
+  js.push("      var texImg = new Image();");
+  js.push("      texImg.onload = function() { uploadTex(texImg); };");
+  js.push("      texImg.src = srcs[0];");
+  js.push("    }");
   js.push("  }");
   js.push("");
   js.push("  gl.enable(gl.DEPTH_TEST);");
@@ -696,7 +722,8 @@ ElectronRunner.extractSettings = function (executor) {
           settings.models[mName] = {
             uvMappings: model.uvMappings || [],
             resolution: { width: texW, height: texH },
-            textureDataURL: model.texture && model.texture.dataURL ? model.texture.dataURL : null
+            textureDataURL: model.texture && model.texture.dataURL ? model.texture.dataURL : null,
+            allTextures: model.allTextures || []
           };
         }
       }