@erik9994857/cag 1.0.0

package/src/models/bbmodel-parser.js

@@ -0,0 +1,320 @@
+const fs = require("fs");
+const path = require("path");
+
+class BBModelParser {
+  constructor() {
+    this.supportedFormatVersions = ["4.0", "4.5", "4.6", "4.7", "4.8", "4.9", "4.10"];
+    this.faceNames = ["north", "south", "east", "west", "up", "down"];
+  }
+
+  parse(filePath) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error("BBModel file not found: " + filePath);
+    }
+
+    var raw = fs.readFileSync(filePath, "utf-8");
+    var data;
+
+    try {
+      data = JSON.parse(raw);
+    } catch (e) {
+      throw new Error("Invalid BBModel JSON: " + filePath);
+    }
+
+    var result = {
+      filePath: filePath,
+      fileName: path.basename(filePath, ".bbmodel"),
+      formatVersion: this.extractFormatVersion(data),
+      name: data.name || path.basename(filePath, ".bbmodel"),
+      resolution: this.extractResolution(data),
+      elements: this.extractElements(data),
+      textures: this.extractTextures(data),
+      outliner: this.extractOutliner(data),
+      animations: this.extractAnimations(data),
+      uvMappings: [],
+      valid: false
+    };
+
+    result.uvMappings = this.extractAllUVMappings(result.elements);
+    result.valid = this.validate(result);
+
+    return result;
+  }
+
+  extractFormatVersion(data) {
+    if (data.meta && data.meta.format_version) {
+      return data.meta.format_version;
+    }
+
+    return "unknown";
+  }
+
+  extractResolution(data) {
+    if (data.resolution) {
+      return {
+        width: data.resolution.width || 16,
+        height: data.resolution.height || 16
+      };
+    }
+
+    return { width: 16, height: 16 };
+  }
+
+  extractElements(data) {
+    if (!data.elements || !Array.isArray(data.elements)) {
+      return [];
+    }
+
+    var elements = [];
+
+    for (var i = 0; i < data.elements.length; i++) {
+      var el = data.elements[i];
+
+      var element = {
+        name: el.name || "element_" + i,
+        type: el.type || "cube",
+        from: el.from || [0, 0, 0],
+        to: el.to || [1, 1, 1],
+        rotation: el.rotation || [0, 0, 0],
+        origin: el.origin || [0, 0, 0],
+        inflate: el.inflate || 0,
+        visibility: el.visibility !== undefined ? el.visibility : true,
+        faces: this.extractFaces(el),
+        uuid: el.uuid || null
+      };
+
+      elements.push(element);
+    }
+
+    return elements;
+  }
+
+  extractFaces(element) {
+    var faces = {};
+
+    if (!element.faces) {
+      for (var i = 0; i < this.faceNames.length; i++) {
+        faces[this.faceNames[i]] = {
+          uv: [0, 0, 16, 16],
+          texture: 0,
+          rotation: 0
+        };
+      }
+      return faces;
+    }
+
+    for (var j = 0; j < this.faceNames.length; j++) {
+      var faceName = this.faceNames[j];
+
+      if (element.faces[faceName]) {
+        var face = element.faces[faceName];
+        faces[faceName] = {
+          uv: face.uv || [0, 0, 16, 16],
+          texture: face.texture !== undefined ? face.texture : 0,
+          rotation: face.rotation || 0,
+          tint: face.tint || -1
+        };
+      } else {
+        faces[faceName] = {
+          uv: [0, 0, 16, 16],
+          texture: 0,
+          rotation: 0
+        };
+      }
+    }
+
+    return faces;
+  }
+
+  extractTextures(data) {
+    if (!data.textures || !Array.isArray(data.textures)) {
+      return [];
+    }
+
+    var textures = [];
+
+    for (var i = 0; i < data.textures.length; i++) {
+      var tex = data.textures[i];
+
+      textures.push({
+        id: tex.id !== undefined ? tex.id : i,
+        name: tex.name || "texture_" + i,
+        folder: tex.folder || "",
+        namespace: tex.namespace || "",
+        source: tex.source || null,
+        width: tex.width || 0,
+        height: tex.height || 0,
+        uvWidth: tex.uv_width || 16,
+        uvHeight: tex.uv_height || 16
+      });
+    }
+
+    return textures;
+  }
+
+  extractOutliner(data) {
+    if (!data.outliner || !Array.isArray(data.outliner)) {
+      return [];
+    }
+
+    return this.parseOutlinerNodes(data.outliner);
+  }
+
+  parseOutlinerNodes(nodes) {
+    var result = [];
+
+    for (var i = 0; i < nodes.length; i++) {
+      var node = nodes[i];
+
+      if (typeof node === "string") {
+        result.push({
+          type: "element_ref",
+          uuid: node
+        });
+      } else if (typeof node === "object" && node !== null) {
+        var bone = {
+          type: "group",
+          name: node.name || "group_" + i,
+          origin: node.origin || [0, 0, 0],
+          rotation: node.rotation || [0, 0, 0],
+          visibility: node.visibility !== undefined ? node.visibility : true,
+          uuid: node.uuid || null,
+          children: []
+        };
+
+        if (node.children && Array.isArray(node.children)) {
+          bone.children = this.parseOutlinerNodes(node.children);
+        }
+
+        result.push(bone);
+      }
+    }
+
+    return result;
+  }
+
+  extractAnimations(data) {
+    if (!data.animations || !Array.isArray(data.animations)) {
+      return [];
+    }
+
+    var animations = [];
+
+    for (var i = 0; i < data.animations.length; i++) {
+      var anim = data.animations[i];
+
+      animations.push({
+        name: anim.name || "animation_" + i,
+        loop: anim.loop || "once",
+        length: anim.length || 0,
+        snapping: anim.snapping || 24
+      });
+    }
+
+    return animations;
+  }
+
+  extractAllUVMappings(elements) {
+    var mappings = [];
+
+    for (var i = 0; i < elements.length; i++) {
+      var element = elements[i];
+      var faceKeys = Object.keys(element.faces);
+
+      for (var j = 0; j < faceKeys.length; j++) {
+        var faceName = faceKeys[j];
+        var face = element.faces[faceName];
+
+        mappings.push({
+          element: element.name,
+          elementIndex: i,
+          face: faceName,
+          uv: face.uv.slice(),
+          textureIndex: face.texture,
+          rotation: face.rotation || 0,
+          supported: true
+        });
+      }
+    }
+
+    return mappings;
+  }
+
+  validate(result) {
+    if (!result.elements || result.elements.length === 0) {
+      return false;
+    }
+
+    for (var i = 0; i < result.elements.length; i++) {
+      var el = result.elements[i];
+
+      if (!el.from || el.from.length !== 3) {
+        return false;
+      }
+
+      if (!el.to || el.to.length !== 3) {
+        return false;
+      }
+    }
+
+    for (var j = 0; j < result.uvMappings.length; j++) {
+      var mapping = result.uvMappings[j];
+
+      if (!mapping.uv || mapping.uv.length !== 4) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  getElementByName(parsedModel, name) {
+    for (var i = 0; i < parsedModel.elements.length; i++) {
+      if (parsedModel.elements[i].name === name) {
+        return parsedModel.elements[i];
+      }
+    }
+
+    return null;
+  }
+
+  getUVMappingsForElement(parsedModel, elementName) {
+    var result = [];
+
+    for (var i = 0; i < parsedModel.uvMappings.length; i++) {
+      if (parsedModel.uvMappings[i].element === elementName) {
+        result.push(parsedModel.uvMappings[i]);
+      }
+    }
+
+    return result;
+  }
+
+  calculateBounds(parsedModel) {
+    if (parsedModel.elements.length === 0) {
+      return { min: [0, 0, 0], max: [0, 0, 0], size: [0, 0, 0] };
+    }
+
+    var min = [Infinity, Infinity, Infinity];
+    var max = [-Infinity, -Infinity, -Infinity];
+
+    for (var i = 0; i < parsedModel.elements.length; i++) {
+      var el = parsedModel.elements[i];
+
+      for (var a = 0; a < 3; a++) {
+        if (el.from[a] < min[a]) min[a] = el.from[a];
+        if (el.to[a] < min[a]) min[a] = el.to[a];
+        if (el.from[a] > max[a]) max[a] = el.from[a];
+        if (el.to[a] > max[a]) max[a] = el.to[a];
+      }
+    }
+
+    return {
+      min: min,
+      max: max,
+      size: [max[0] - min[0], max[1] - min[1], max[2] - min[2]]
+    };
+  }
+}
+
+module.exports = BBModelParser;

package/src/models/uv-mapper.js

@@ -0,0 +1,315 @@
+class UVMapper {
+  constructor(resolution) {
+    this.resolution = resolution || { width: 16, height: 16 };
+    this.mappings = [];
+    this.fixLog = [];
+  }
+
+  setResolution(width, height) {
+    this.resolution = { width: width, height: height };
+    return this;
+  }
+
+  getResolution() {
+    return this.resolution;
+  }
+
+  mapFace(elementName, faceName, uv, textureIndex) {
+    var mapping = {
+      element: elementName,
+      face: faceName,
+      uv: uv ? uv.slice() : [0, 0, this.resolution.width, this.resolution.height],
+      textureIndex: textureIndex !== undefined ? textureIndex : 0,
+      normalized: false,
+      fixed: false,
+      supported: true
+    };
+
+    this.mappings.push(mapping);
+    return mapping;
+  }
+
+  mapElement(element) {
+    var result = [];
+    var faceNames = ["north", "south", "east", "west", "up", "down"];
+
+    for (var i = 0; i < faceNames.length; i++) {
+      var faceName = faceNames[i];
+
+      if (element.faces && element.faces[faceName]) {
+        var face = element.faces[faceName];
+        var mapping = this.mapFace(
+          element.name || "unnamed",
+          faceName,
+          face.uv,
+          face.texture
+        );
+        result.push(mapping);
+      }
+    }
+
+    return result;
+  }
+
+  mapAllElements(elements) {
+    var allMappings = [];
+
+    for (var i = 0; i < elements.length; i++) {
+      var elementMappings = this.mapElement(elements[i]);
+      allMappings = allMappings.concat(elementMappings);
+    }
+
+    return allMappings;
+  }
+
+  normalize(mapping) {
+    if (!mapping || !mapping.uv) {
+      return mapping;
+    }
+
+    var normalized = {
+      element: mapping.element,
+      face: mapping.face,
+      uv: [
+        mapping.uv[0] / this.resolution.width,
+        mapping.uv[1] / this.resolution.height,
+        mapping.uv[2] / this.resolution.width,
+        mapping.uv[3] / this.resolution.height
+      ],
+      textureIndex: mapping.textureIndex,
+      normalized: true,
+      fixed: mapping.fixed,
+      supported: mapping.supported
+    };
+
+    return normalized;
+  }
+
+  normalizeAll(mappings) {
+    var result = [];
+
+    for (var i = 0; i < mappings.length; i++) {
+      result.push(this.normalize(mappings[i]));
+    }
+
+    return result;
+  }
+
+  denormalize(mapping) {
+    if (!mapping || !mapping.uv || !mapping.normalized) {
+      return mapping;
+    }
+
+    var denormalized = {
+      element: mapping.element,
+      face: mapping.face,
+      uv: [
+        mapping.uv[0] * this.resolution.width,
+        mapping.uv[1] * this.resolution.height,
+        mapping.uv[2] * this.resolution.width,
+        mapping.uv[3] * this.resolution.height
+      ],
+      textureIndex: mapping.textureIndex,
+      normalized: false,
+      fixed: mapping.fixed,
+      supported: mapping.supported
+    };
+
+    return denormalized;
+  }
+
+  validate(mapping, textureWidth, textureHeight) {
+    if (!mapping || !mapping.uv) {
+      return { valid: false, issues: ["Missing UV data"] };
+    }
+
+    var issues = [];
+    var uv = mapping.uv;
+    var tw = textureWidth || this.resolution.width;
+    var th = textureHeight || this.resolution.height;
+
+    if (uv.length !== 4) {
+      issues.push("UV array must have exactly 4 values");
+    }
+
+    if (uv[0] < 0) issues.push("UV x1 is negative: " + uv[0]);
+    if (uv[1] < 0) issues.push("UV y1 is negative: " + uv[1]);
+    if (uv[2] < 0) issues.push("UV x2 is negative: " + uv[2]);
+    if (uv[3] < 0) issues.push("UV y2 is negative: " + uv[3]);
+
+    if (uv[0] > tw) issues.push("UV x1 exceeds texture width: " + uv[0] + " > " + tw);
+    if (uv[1] > th) issues.push("UV y1 exceeds texture height: " + uv[1] + " > " + th);
+    if (uv[2] > tw) issues.push("UV x2 exceeds texture width: " + uv[2] + " > " + tw);
+    if (uv[3] > th) issues.push("UV y2 exceeds texture height: " + uv[3] + " > " + th);
+
+    if (uv[0] === uv[2]) issues.push("UV has zero width");
+    if (uv[1] === uv[3]) issues.push("UV has zero height");
+
+    return {
+      valid: issues.length === 0,
+      issues: issues
+    };
+  }
+
+  validateAll(mappings, textureWidth, textureHeight) {
+    var results = [];
+    var allValid = true;
+
+    for (var i = 0; i < mappings.length; i++) {
+      var result = this.validate(mappings[i], textureWidth, textureHeight);
+      results.push({
+        mapping: mappings[i],
+        valid: result.valid,
+        issues: result.issues
+      });
+      if (!result.valid) {
+        allValid = false;
+      }
+    }
+
+    return {
+      allValid: allValid,
+      results: results,
+      totalMappings: mappings.length,
+      invalidCount: results.filter(function (r) { return !r.valid; }).length
+    };
+  }
+
+  fix(mapping, textureWidth, textureHeight) {
+    if (!mapping || !mapping.uv) {
+      return mapping;
+    }
+
+    var tw = textureWidth || this.resolution.width;
+    var th = textureHeight || this.resolution.height;
+    var uv = mapping.uv.slice();
+    var wasFixed = false;
+
+    for (var i = 0; i < 4; i++) {
+      if (uv[i] < 0) {
+        uv[i] = 0;
+        wasFixed = true;
+      }
+    }
+
+    if (uv[0] > tw) { uv[0] = tw; wasFixed = true; }
+    if (uv[2] > tw) { uv[2] = tw; wasFixed = true; }
+    if (uv[1] > th) { uv[1] = th; wasFixed = true; }
+    if (uv[3] > th) { uv[3] = th; wasFixed = true; }
+
+    if (uv[0] > uv[2]) {
+      var temp = uv[0];
+      uv[0] = uv[2];
+      uv[2] = temp;
+      wasFixed = true;
+    }
+
+    if (uv[1] > uv[3]) {
+      var temp2 = uv[1];
+      uv[1] = uv[3];
+      uv[3] = temp2;
+      wasFixed = true;
+    }
+
+    if (uv[0] === uv[2]) {
+      uv[2] = Math.min(uv[0] + 1, tw);
+      wasFixed = true;
+    }
+
+    if (uv[1] === uv[3]) {
+      uv[3] = Math.min(uv[1] + 1, th);
+      wasFixed = true;
+    }
+
+    if (wasFixed) {
+      this.fixLog.push({
+        element: mapping.element,
+        face: mapping.face,
+        originalUV: mapping.uv.slice(),
+        fixedUV: uv.slice(),
+        timestamp: Date.now()
+      });
+    }
+
+    var fixed = {};
+    for (var key in mapping) {
+      fixed[key] = mapping[key];
+    }
+    fixed.uv = uv;
+    fixed.fixed = wasFixed;
+    fixed.supported = true;
+
+    return fixed;
+  }
+
+  fixAll(mappings, textureWidth, textureHeight) {
+    var result = [];
+
+    for (var i = 0; i < mappings.length; i++) {
+      result.push(this.fix(mappings[i], textureWidth, textureHeight));
+    }
+
+    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]);
+
+    return {
+      north: [sizeZ, sizeY + sizeZ, sizeZ + sizeX, sizeY + sizeZ + sizeY],
+      south: [sizeZ + sizeX + sizeZ, sizeY + sizeZ, sizeZ + sizeX + sizeZ + sizeX, sizeY + sizeZ + sizeY],
+      east: [0, sizeY + sizeZ, sizeZ, sizeY + sizeZ + sizeY],
+      west: [sizeZ + sizeX, sizeY + sizeZ, sizeZ + sizeX + sizeZ, sizeY + sizeZ + sizeY],
+      up: [sizeZ, 0, sizeZ + sizeX, sizeZ],
+      down: [sizeZ + sizeX, 0, sizeZ + sizeX + sizeX, sizeZ]
+    };
+  }
+
+  calculateTextureSize(elements) {
+    var maxU = 0;
+    var maxV = 0;
+
+    for (var i = 0; i < elements.length; i++) {
+      var el = elements[i];
+      var faceKeys = Object.keys(el.faces || {});
+
+      for (var j = 0; j < faceKeys.length; j++) {
+        var face = el.faces[faceKeys[j]];
+        if (face.uv) {
+          if (face.uv[2] > maxU) maxU = face.uv[2];
+          if (face.uv[3] > maxV) maxV = face.uv[3];
+        }
+      }
+    }
+
+    var width = 1;
+    while (width < maxU) width *= 2;
+
+    var height = 1;
+    while (height < maxV) height *= 2;
+
+    return { width: width, height: height };
+  }
+
+  getFixLog() {
+    return this.fixLog;
+  }
+
+  clearFixLog() {
+    this.fixLog = [];
+    return this;
+  }
+
+  getMappings() {
+    return this.mappings;
+  }
+
+  clearMappings() {
+    this.mappings = [];
+    return this;
+  }
+}
+
+module.exports = UVMapper;