Converted tooling to C.

CMakeLists.txt

@@ -131,16 +131,16 @@ elseif(TARGET_TYPE STREQUAL game)
       GAME_VERSION=1.0
     )
 
-    # set(DIR_CHARS "${ASSETS_SOURCE_DIR}/poker/characters")
+    set(DIR_CHARS "${ASSETS_SOURCE_DIR}/poker/characters")
-    # tool_vn_character(vn_penny
+    tool_vn_character(vn_penny
-    #   ${DIR_CHARS}/penny/character.xml poker/characters/penny/sprite
+      ${DIR_CHARS}/penny/character.xml poker/characters/penny/sprite
-    # )
+    )
-    # tool_vn_character(vn_sammy
+    tool_vn_character(vn_sammy
-    #   ${DIR_CHARS}/sammy/character.xml poker/characters/sammy/sprite
+      ${DIR_CHARS}/sammy/character.xml poker/characters/sammy/sprite
-    # )
+    )
     tool_assets(
-      # vn_penny
+      vn_penny
-      # vn_sammy
+      vn_sammy
 
       shader_textured
       font_opensans

tools/display/CMakeLists.txt

@@ -14,6 +14,7 @@ target_sources(texture_generation
   PRIVATE
     texture_generation.c
     ../utils/file.c
+    ../utils/image.c
 )
 target_include_directories(${PROJECT_NAME}
   PUBLIC

tools/display/texture_generation.c

@@ -9,15 +9,6 @@
 #include "../utils/file.h"
 #include "../utils/image.h"
 
-#ifndef  STB_IMAGE_IMPLEMENTATION
-  #define STB_IMAGE_IMPLEMENTATION
-  #include <stb_image.h>
-#endif
-#ifndef  STB_IMAGE_RESIZE_IMPLEMENTATION
-  #define STB_IMAGE_RESIZE_IMPLEMENTATION
-  #include <stb_image_resize.h>
-#endif
-
 #define RESIZE_VARIANT_COUNT 4
 int RESIZE_SCALES[RESIZE_VARIANT_COUNT] = { 1, 2, 3, 4 };
 
@@ -27,7 +18,6 @@ int main(int argc, char *argv[]) {
   char xml[2048];
   char *in;
   char *out;
-  char pathSep;
   int w, h, channels, rw, rh, i, scale;
   stbi_uc *dataOriginal;
   stbi_uc *dataResized;
@@ -38,13 +28,20 @@ int main(int argc, char *argv[]) {
   }
 
   // Set up strings
-  pathSep = FILE_PATH_SEP;
   in = argv[1];
   out = argv[2];
   
   // Normalize slashes
   fileNormalizeSlashes(in);
   fileNormalizeSlashes(out);
+  
+  // Check the output doesn't already exist
+  sprintf(path, "%s.xml", out);
+  file = fopen(path, "rb");
+  if(file != NULL) {
+    fclose(file);
+    return 0;
+  }
 
   // Read in original texture
   file = fopen(in, "rb");
@@ -77,7 +74,6 @@ int main(int argc, char *argv[]) {
     stbir_resize_uint8(dataOriginal, w, h, 0, dataResized, rw, rh, 0, channels);
 
     // Determine output path
-    path[0] = '\0';
     sprintf(path, "%s_%i.texture", out, scale);
 
     // Open output file
@@ -111,7 +107,6 @@ int main(int argc, char *argv[]) {
   sprintf(xml, "%s\n</texture>", xml);
   
   // Determine XML path
-  path[0] = '\0';
   sprintf(path, "%s.xml", out);
 
   // Write XML

tools/utils/args.js

@@ -1,12 +0,0 @@
-const args = process.argv.splice(2).reduce((x,y) => {
-  const bits = y.split('=');
-  const name = bits[0].replace('--', '');
-  const val = bits[1];
-
-  x[name] = val;
-  return x;
-}, {});
-
-module.exports = {
-  args
-};

tools/utils/common.h

@@ -10,4 +10,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
-#include <stdbool.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include <stb_image.h>
+#include <stb_image_resize.h>
+#include <stb_image_write.h>

tools/utils/file.c

@@ -55,4 +55,67 @@ void assetReadString(FILE *file, char *buffer) {
   length = ftell(file);// Get our current position (the end)
   fseek(file, 0, SEEK_SET);// Reset the seek 
   fread(buffer, 1, length, file);// Read all the bytes
+}
+
+void fileGetDirectory(char *file, char* buffer) {
+  char *c, *p;
+  int32_t i;
+  p = strrchr(file, FILE_PATH_SEP);
+  c = file;
+  i = 0;
+  do {
+    buffer[i++] = *c;
+  } while(++c < p);
+  buffer[i] = '\0';
+}
+
+bool fileListChildren(
+  char *directory,
+  char *buffer,
+  int32_t *count,
+  uint8_t *types,
+  char **children
+) {
+  #if defined(_MSC_VER)
+    WIN32_FIND_DATA fdFile;
+    HANDLE hFind = NULL;
+    char sPath[2048];
+    int32_t i;
+
+    // Append wildcard
+    sprintf(sPath, "%s\\*.*", directory);
+
+    // Scan first
+    if((hFind = FindFirstFile(sPath, &fdFile)) == INVALID_HANDLE_VALUE) {
+      printf("Path not found: [%s]\n", directory);
+      return false;
+    }
+
+    // Iterate
+    i = 0;
+    do {
+      if(
+        strcmp(fdFile.cFileName, ".") == 0 ||
+        strcmp(fdFile.cFileName, "..") == 0
+      ) continue;
+
+      // Get Full path.
+      sprintf(sPath, "%s\\%s", directory, fdFile.cFileName);
+
+      //Is the entity a File or Folder?
+      if(fdFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+        types[i] = FILE_CHILD_TYPE_DIR;
+      } else {
+        types[i] = FILE_CHILD_TYPE_FILE;
+      }
+
+      children[i] = buffer + (i * FILE_CHILD_NAME_MAX);
+      strcpy(children[i], fdFile.cFileName);
+      i++;
+    } while(FindNextFile(hFind, &fdFile));
+
+    *count = i;
+    return true;
+  #else
+  #endif
 }

tools/utils/file.h

@@ -8,8 +8,14 @@
 #pragma once
 #include "common.h"
 
+#define FILE_CHILD_TYPE_DIR 0x00
+#define FILE_CHILD_TYPE_FILE 0x01
+#define FILE_CHILD_NAME_MAX 512
+#define FILE_CHILD_COUNT_MAX 64
+
 #if defined(_MSC_VER)
   #include <direct.h>
+  #include <windows.h>
   #define getcwd _getcwd
   #define FILE_PATH_SEP '\\'
 #elif defined(__GNUC__)
@@ -21,4 +27,14 @@ void fileNormalizeSlashes(char *string);
 
 void fileMkdirp(char *path);
 
-void assetReadString(FILE *file, char *buffer);
+void assetReadString(FILE *file, char *buffer);
+
+void fileGetDirectory(char *file, char* buffer);
+
+bool fileListChildren(
+  char *directory,
+  char *buffer,
+  int32_t *count,
+  uint8_t *types,
+  char **children
+);

tools/utils/file.js

@@ -1,19 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-
-const mkdirp = dir => {
-  const resolved = path.resolve(dir);
-  const resolvedDir = path.dirname(resolved);
-  const bits = resolvedDir.split(path.sep);
-  let running = '';
-
-  bits.forEach(bit => {
-    running += bit;
-    if(!fs.existsSync(running)) fs.mkdirSync(running);
-    running += path.sep;
-  });
-}
-
-module.exports = {
-  mkdirp
-}

tools/utils/image.c

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "image.h"
+
+#ifndef  STB_IMAGE_IMPLEMENTATION
+  #define STB_IMAGE_IMPLEMENTATION
+  #include <stb_image.h>
+#endif
+
+#ifndef  STB_IMAGE_RESIZE_IMPLEMENTATION
+  #define STB_IMAGE_RESIZE_IMPLEMENTATION
+  #include <stb_image_resize.h>
+#endif
+
+#ifndef  STB_IMAGE_WRITE_IMPLEMENTATION
+  #define STB_IMAGE_WRITE_IMPLEMENTATION
+  #include <stb_image_write.h>
+#endif
+
+void imageCopy(
+  uint8_t *source, int32_t sourceWidth, int32_t sourceHeight,
+  uint8_t *dest, int32_t destWidth, int32_t destHeight,
+  int32_t cropX, int32_t cropY, int32_t cropWidth, int32_t cropHeight,
+  int32_t pasteX, int32_t pasteY,
+  int32_t channels
+) {
+  int32_t x, y, c;
+  int32_t absX, absY;
+  int32_t sourceIndex, targetIndex;
+
+  if(cropX == -1) cropX = 0;
+  if(cropY == -1) cropY = 0;
+  if(cropWidth == -1) cropWidth = sourceWidth;
+  if(cropHeight == -1) cropHeight = sourceHeight;
+  if(pasteX == -1) pasteX = 0;
+  if(pasteY == -1) pasteY = 0;
+
+  for(x = cropX; x < cropX + cropWidth; x++) {
+    for(y = cropY; y < cropY + cropHeight; y++) {
+      absX = x - cropX + pasteX;
+      absY = y - cropY + pasteY;
+      if(absX >= destWidth || absY >= destHeight || absX < 0 || absY < 0)continue;
+      targetIndex = absY * destWidth + absX;
+      sourceIndex = y * sourceWidth + x;
+      for(c = 0; c < channels; c++) {
+        dest[(targetIndex*channels) + c] = source[(sourceIndex*channels) + c];
+      }
+    }
+  }
+}

tools/utils/image.h

@@ -6,3 +6,13 @@
  */
 
 #pragma once
+#include "common.h"
+#include "file.h"
+
+void imageCopy(
+  uint8_t *source, int32_t sourceWidth, int32_t sourceHeight,
+  uint8_t *dest, int32_t destWidth, int32_t destHeight,
+  int32_t cropX, int32_t cropY, int32_t cropWidth, int32_t cropHeight,
+  int32_t pasteX, int32_t pasteY,
+  int32_t channels
+);

tools/utils/image.js

@@ -1,103 +0,0 @@
-const { PNG } = require("pngjs");
-const path = require('path');
-const fs = require('fs');
-
-/**
- * Loads an image into memory.
- * @param image Image to load
- * @returns A promise that resolves to the loaded image.
- */
-const imageLoad = (image) => new Promise(resolve => {
-  fs.createReadStream(image)
-    .pipe(new PNG({ filterType: 4 }))
-    .on("parsed", function () {
-      // Normalize
-      const pixels = [];
-      for(let y = 0; y < this.height; y++) {
-        for(let x = 0; x < this.width; x++) {
-          const idx = (this.width * y + x) << 2;
-          const r = this.data[idx];
-          const g = this.data[idx + 1];
-          const b = this.data[idx + 2];
-          const a = this.data[idx + 3];
-
-          pixels.push({ r, g, b, a });
-        }
-      }
-      resolve({ pixels, width: this.width, height: this.height });
-    })
-  ;
-});
-
-/**
- * Writes an image to an output file.
- * @param image Image to write.
- * @param file File to write to.
- * @returns A promise that, when resolved, has saved the image.
- */
-const imageWrite = (image, file) => new Promise(resolve => {
-  const png = new PNG({ width: image.width, height: image.height });
-  png.width = image.width;
-  png.height = image.height;
-  
-  for(let y = 0; y < image.height; y++) {
-    for(let x = 0; x < image.width; x++) {
-      const i = (image.width * y + x);
-      const idx = i << 2;
-
-      const pixel = image.pixels[i];
-      png.data[idx] = pixel.r;
-      png.data[idx + 1] = pixel.g;
-      png.data[idx + 2] = pixel.b;
-      png.data[idx + 3] = pixel.a;
-    }
-  }
-
-  png.pack().pipe(fs.createWriteStream(file))
-    .on('close', () => resolve(true))
-  ;
-});
-
-/**
- * Creates a blank image
- * @param width Width of the image.
- * @param height Height of the image.
- * @param fill Optional pixel to fill with, defaults to 0,0,0,0
- * @returns The newly created image.
- */
-const imageCreate = (width, height, pixel) => {
-  if(!pixel || !pixel.r) pixel = { r:0, g:0, b:0, a:0 };
-  const pixels = [];
-  for(let i = 0; i < width * height; i++) pixels.push({ ...pixel });
-  return { pixels, width, height };
-}
-
-/**
- * Copies an area of a source image into a target image.
- * @param target Target image to copy into.
- * @param source Source image to copy from.
- * @param tx Target X position to copy into
- * @param ty Target Y position to copy into
- * @param sub Optional source area to use, defined as { x, y, width, height }.
- */
-const imageCopy = (target, source, tx, ty, sub) => {
-  if(!sub) sub = { x: 0, y: 0, width: source.width, height: source.height };
-
-  for(let x = sub.x; x < sub.x+sub.width; x++) {
-    for(let y = sub.y; y < sub.y+sub.height; y++) {
-      let absX = x - sub.x + tx;
-      let absY = y - sub.y + ty;
-      if(absX > target.width || absY > target.height) continue;
-      let ti = absY * target.width + absX;
-      let si = y * source.width + x;
-      target.pixels[ti] = { ...source.pixels[si] };
-    }
-  }
-}
-
-module.exports = {
-  imageWrite,
-  imageCreate,
-  imageLoad,
-  imageCopy
-}

tools/utils/xml.c

@@ -7,88 +7,204 @@
 
 #include "xml.h"
 
-void xmlParseElement(xmlnode_t *node, char *string) {
+int32_t xmlLoadChild(xml_t *xml, char *data, int32_t i) {
   char c;
-  int32_t i, j;
+  int32_t level = 0;
-  uint8_t state;
+  uint8_t doing = XML_DOING_NOTHING;
+  bool insideTag = false;
+  char* buffer = malloc(sizeof(char) * XML_TEXT_BUFFER_MAX);
+  int32_t bufferLength = 0;
 
-  node->attributeCount = 0;
+  xml->value = NULL;
+  xml->attributeCount = 0;
 
-  i = 0;
+  xml->children = malloc(sizeof(xml_t) * XML_CHILD_COUNT_MAX);
-  state = XML_STATE_NOTHING;
+  xml->childrenCount = 0;
-  while(c = string[i++]) {
-    switch(state) {
-      case XML_STATE_NOTHING:
-        if(c != '<') continue;
-        node->start = string + (i - 1);
-        state = XML_STATE_PARSING_NAME;
-        break;
 
-      case XML_STATE_PARSING_NAME:
+  while(c = data[i++]) {
-        if(c == ' ' || c == '\n' || c == '\r') continue;
+    switch(doing) {
-
+      case XML_DOING_NOTHING:
-        j = i - 1;
+        // Look for either an opening tag (<) or a word for a value.
-        while(c = string[j++]) {
+        if(c == '>') continue;
-          if(c == ' ') break;
+        if(c == '<') {
-          node->name[j] = c;
+          if(insideTag) {
-        }
+            i = xmlLoadChild(xml->children + xml->childrenCount++, data, i-1);
-        i = j;
+            doing = XML_PARSING_CHILD;
-        state = XML_STATE_PARSING_ATTRIBUTES;
+          } else {
-        break;
+            doing = XML_PARSING_TAG_NAME;
-
+            level++;
-      case XML_STATE_PARSING_ATTRIBUTES:
+            insideTag = true;
-        if(c == ' ' || c == '\n' || c == '\r') continue;
-        if(c == '>') {
-          node->internal = string + i;
-          break;
-          continue;
-        }
-
-        // Parse Name
-        node->attributeNames[node->attributeCount] = string + (i - 1);
-        node->attributeNameLengths[node->attributeCount] = 0;
-        while(c == ' ' && c == '\n' && c == '\r' && c != '>' && c != '=' && c != '\0') {
-          c = string[i++];
-          node->attributeNameLengths[node->attributeCount]++;
-        }
-
-        if(c == '>') {
-          i--;
-          node->attributeValues[node->attributeCount] = NULL;
-          node->attributeValueLengths[node->attributeCount] = 0;
-          node->attributeCount++;
-          continue;
-        }
-
-        // Wait for = sign
-        while(c == ' ' || c == '\n' || c == '\r') c = string[i++];
-
-        // Handle booleans
-        if(c != '=') {
-          node->attributeValues[node->attributeCount] = NULL;
-          node->attributeValueLengths[node->attributeCount] = 0;
-          node->attributeCount++;
-          i--;
-          continue;
-        }
-        
-        node->attributeValues[node->attributeCount] = string + i;
-        node->attributeValueLengths[node->attributeCount] = 0;
-        do {
-          c = string[i++];
-          node->attributeNameLengths[node->attributeCount]++;
-          if(c == '\0' || c == '"') break;
-          if(c == '\\') {
-            i++;
-            node->attributeNameLengths[node->attributeCount]++;
           }
-        } while(c);
+          continue;
-        
+        }
-        node->attributeCount++;
+
+        if(xmlIsWhitespace(c)) continue;
+        doing = XML_PARSING_VALUE;
+        buffer[bufferLength++] = c;
         break;
+      
+      case XML_PARSING_TAG_NAME:
+        // Just keep reading until we either hit a space (end of the tag name)
+        // or a closing tag value, either / or >
+        if(xmlIsWhitespace(c) || c == '>' || c == '/') {
+          buffer[bufferLength] = '\0';
+          xml->node = buffer;
+          buffer = malloc(sizeof(char) * XML_TEXT_BUFFER_MAX);
+          bufferLength = 0;
+          if(c == '/') {
+            level--;
+            insideTag = false;
+            doing = XML_PARSING_CLOSE;
+          } else {
+            doing = c == '>' ? XML_DOING_NOTHING : XML_LOOKING_FOR_ATTRIBUTE;
+          }
+          continue;
+        }
+        buffer[bufferLength++] = c;
+        break;
+      
+      case XML_LOOKING_FOR_ATTRIBUTE:
+        // Look until we hit either the end of a tag, or the attribute itself
+        if(xmlIsWhitespace(c) || c == '>' || c == '/' || c == '=') {
+          if(c == '>' || c == '/') {
+            doing = XML_DOING_NOTHING;
+            if(c == '/') {
+              level--;
+              insideTag = false;
+              doing = XML_PARSING_CLOSE;
+            }
+          } else if(c == '=') {
+            doing = XML_LOOKING_FOR_ATTRIBUTE_VALUE;
+          } else {
+            doing = XML_LOOKING_FOR_ATTRIBUTE;
+          }
+
+          if(bufferLength > 0) {
+            buffer[bufferLength] = '\0';
+            xml->attributeNames[xml->attributeCount++] = buffer;
+            xml->attributeDatas[xml->attributeCount] = NULL;
+            buffer = malloc(sizeof(char) * XML_TEXT_BUFFER_MAX);
+            bufferLength = 0;
+          }
+          continue;
+        }
+
+        buffer[bufferLength++] = c;
+        break;
+
+      case XML_LOOKING_FOR_ATTRIBUTE_VALUE:
+        // Keep looking until we find a quote mark
+        if(xmlIsWhitespace(c)) continue;
+        if(c == '>' || c == '/') {
+          doing = XML_DOING_NOTHING;
+          insideTag = false;
+          continue;
+        }
+
+        if(c != '"') continue;
+        doing = XML_PARSING_ATTRIBUTE_VALUE;
+        break;
+
+      case XML_PARSING_ATTRIBUTE_VALUE:
+        // Parse the attribute value until we find a quote mark.
+        if(c == '"') {
+          doing = XML_LOOKING_FOR_ATTRIBUTE;
+          buffer[bufferLength] = '\0';
+          xml->attributeDatas[xml->attributeCount - 1] = buffer;
+          buffer = malloc(sizeof(char) * XML_TEXT_BUFFER_MAX);
+          bufferLength = 0;
+          continue;
+        }
+
+        buffer[bufferLength++] = c;
+        break;
+
+      case XML_PARSING_VALUE:
+        // Keep parsing child until we find a < for an opening/closing tag.
+        if(c == '<') {
+          // In HTML Spec there could be a child here but not in XML spec.
+          doing = XML_PARSING_CLOSE;
+          buffer[bufferLength] = '\0';
+          bufferLength = 0;
+          xml->value = buffer;
+          buffer = malloc(sizeof(char) * XML_TEXT_BUFFER_MAX);
+          continue;
+        }
+
+        buffer[bufferLength++] = c;
+        break;
+        
+      case XML_PARSING_CHILD:
+        if(c == '<') {
+          // Read ahead and confirm this is a close or not
+          if(data[i] == '/') {
+            doing = XML_PARSING_CLOSE;
+            continue;
+          }
+
+          // Likely another child.
+          i = xmlLoadChild(xml->children + xml->childrenCount++, data, i-1);
+        }
+
+        if(xmlIsWhitespace(c)) continue;
+
+        // In HTML Spec there's a chance for there to be a value here, but not
+        // in the XML spec.
+        break;
+
+      case XML_PARSING_CLOSE:
+        // Just keep parsing until the tag closer finishes.
+        if(c != '>') continue;
+        doing = XML_DOING_NOTHING;
+        
+        //TODO: Return index or something?
+        free(buffer);
+        return i;
 
       default:
         break;
     }
   }
+
+  free(buffer);
+  return i;
+}
+
+void xmlLoad(xml_t *xml, char *data) {
+  xmlLoadChild(xml, data, 0);
+}
+
+void xmlDispose(xml_t *xml) {
+  uint8_t i;
+
+  // Dispose children recursively
+  for(i = 0; i < xml->childrenCount; i++) {
+    xmlDispose(xml->children + i);
+  }
+
+  // Free children array.
+  free(xml->children);
+
+  // Dispose attributes
+  for(i = 0; i < xml->attributeCount; i++) {
+    free(xml->attributeNames[i]);
+    if((xml->attributeDatas + i) != NULL) {
+      free(xml->attributeDatas[i]);
+    }
+  }
+  
+  free(xml->node);
+  if(xml-> value != NULL) free(xml->value);
+}
+
+int16_t xmlGetAttributeByName(xml_t *xml, char *name) {
+  int16_t i;
+  for(i = 0; i < xml->attributeCount; i++) {
+    if(strcmp(xml->attributeNames[i], name) == 0) return i;
+  }
+  return -1;
+}
+
+bool xmlIsWhitespace(char c) {
+  return c == ' ' || c == '\r' || c == '\n' || c == '\t';
 }

tools/utils/xml.h

@@ -9,26 +9,59 @@
 #include "common.h"
 #include "file.h"
 
-#define XML_NODE_CHILD_MAX 32
+#define XML_DOING_NOTHING 0x00
-#define XML_NODE_NAME_MAX 32
+#define XML_PARSING_TAG_NAME 0x01
-#define XML_NODE_ATTRIBUTES_MAX 32
+#define XML_LOOKING_FOR_ATTRIBUTE 0x02
+#define XML_PARSING_ATTRIBUTE_NAME 0x03
+#define XML_LOOKING_FOR_ATTRIBUTE_VALUE 0x04
+#define XML_PARSING_ATTRIBUTE_VALUE 0x05
+#define XML_PARSING_VALUE 0x06
+#define XML_PARSING_CHILD 0x07
+#define XML_PARSING_CLOSE 0x08
 
-#define XML_STATE_NOTHING 0x00
+#define XML_TEXT_BUFFER_MAX 256
-#define XML_STATE_PARSING_NAME 0x01
+#define XML_CHILD_COUNT_MAX 16
-#define XML_STATE_PARSING_ATTRIBUTES 0x02
+#define XML_ATTRIBUTE_MAX 16
 
-typedef struct {
+typedef struct _xml_t xml_t;
-  char *start;
-  char *internal;
-  char name[XML_NODE_NAME_MAX];
 
-  char *attributeNames[XML_NODE_ATTRIBUTES_MAX];
+typedef struct _xml_t {
-  uint8_t attributeNameLengths[XML_NODE_ATTRIBUTES_MAX];
+  char *node;
-  char *attributeValues[XML_NODE_ATTRIBUTES_MAX];
+  char *value;
-  uint8_t attributeValueLengths[XML_NODE_ATTRIBUTES_MAX];
+
+  char *attributeNames[XML_ATTRIBUTE_MAX];
+  char *attributeDatas[XML_ATTRIBUTE_MAX];
   uint8_t attributeCount;
-} xmlnode_t;
 
+  xml_t *children;
+  uint8_t childrenCount;
+} xml_t;
 
+/**
+ * Load an XML child from a string buffer.
+ * 
+ * @param xml XML to load.
+ * @param data Data to parse
+ * @param i Character index within the data
+ * @return The index in the data string this XML node ends.
+ */
+int32_t xmlLoadChild(xml_t *xml, char *data, int32_t i);
 
-void xmlParseElement(xmlnode_t *node, char *string);
+/**
+ * Load an XML String into an XML memory.
+ * 
+ * @param xml XML to load into.
+ * @param data XML string.
+ */
+void xmlLoad(xml_t *xml, char *data);
+
+/**
+ * Dispose a previously loaded XML.
+ * 
+ * @param xml XML to dispose.
+ */
+void xmlDispose(xml_t *xml);
+
+int16_t xmlGetAttributeByName(xml_t *xml, char *name);
+
+bool xmlIsWhitespace(char c);

tools/vn/CMakeLists.txt

@@ -15,6 +15,7 @@ target_sources(character_generator
     character_generator.c
     ../utils/file.c
     ../utils/xml.c
+    ../utils/image.c
 )
 target_include_directories(character_generator
   PUBLIC
@@ -28,7 +29,7 @@ target_link_libraries(character_generator
 # Function Target
 function(tool_vn_character target in out)
   add_custom_target(vn_character_${target}
-    COMMAND character_generator "${in}" "${TEMP_DIR}/${out}"
+    COMMAND character_generator "${in}" "${TEMP_DIR}/${out}.png"
     COMMENT "Generating character ${target} from ${in}"
     DEPENDS character_generator ${ARGN}
   )

tools/vn/character-sheet-generator.js

@@ -1,139 +0,0 @@
-const path = require('path');
-const { imageCreate, imageWrite, imageLoad, imageCopy } = require('./../utils/image');
-const fs = require('fs');
-const xml = require('xml-js');
-const { args } = require('./../utils/args');
-const { mkdirp } = require('../utils/file');
-
-// Parse Args
-// if(!args.temp) throw new Error(`Missing temp argument`);
-if(!args.in) throw new Error(`Missing in argument`);
-if(!args.out) throw new Error(`Missing out argument`);
-if(!args.dep) throw new Error(`Missing dep argument`);
-if(!args.in.endsWith('xml')) throw new Error(`Invalid in XML`);
-if(!args.out.endsWith('png')) throw new Error(`Invalid out PNG`);
-
-// Determine in and out.
-const file = path.resolve(args.in);
-const outFile = path.resolve(args.out);
-
-console.log(outFile);
-
-// const cOut = path.resolve(args.temp, 'vn', `${args.dep}.c`);
-// const hOut = path.resolve(args.temp, 'vn', `${args.dep}.h`);
-if(!fs.existsSync(file)) throw new Error(`Could not find ${file}`);
-// if(fs.existsSync(outFile) && fs.existsSync(cOut) && fs.existsSync(hOut)) return;
-if(fs.existsSync(outFile)) return;
-
-// Load XML
-const data = xml.xml2js(fs.readFileSync(file, 'utf-8'));
-const [ character ] = data.elements;
-
-// Validate file.
-if(!character.attributes.context) throw new Error(`Missing context`)
-const dir = path.resolve(path.dirname(file), character.attributes.context);
-
-// Parse base and layers
-const base = character.elements.find(e => e.name == 'base').attributes;
-if(!base) throw new Error(`Failed to find base`);
-const layers = character.elements
-  .filter(e => e.name == 'layer')
-  .map(e => e.attributes)
-  .map(e => ({
-    ...e,
-    x: parseInt(e.x),
-    y: parseInt(e.y),
-    width: parseInt(e.width),
-    height: parseInt(e.height)
-  }))
-;
-
-(async () => {
-  // Load the base
-  const baseImage = await imageLoad(path.join(dir, base.file));
-
-  let columnsMax = 0;
-  let widthMax = 0;
-  let strLayers = ``;
-
-  layers.forEach((layer,row) => {
-    if(!layer.width || !layer.height || !layer.x || !layer.y) {
-      throw new Error(`Missing layer info`);
-    }
-
-    const layerDir = path.join(dir, layer.directory);
-    const scan = fs.readdirSync(layerDir);
-    columnsMax = Math.max(scan.length, columnsMax);
-    widthMax = Math.max(widthMax, layer.width);
-  });
-
-  // Create the output buffer
-  const out = imageCreate(
-    baseImage.width + (columnsMax * widthMax),
-    baseImage.height
-  );
-
-  // Copy the base
-  imageCopy(out, baseImage, 0, 0);
-  
-  // Now begin copying the children, row is defined by the directory
-  let y = 0;
-  for(let row = 0; row < layers.length; row++) {
-    const layer = layers[row];
-    const layerDir = path.join(dir, layer.directory);
-    const scan = fs.readdirSync(layerDir);
-
-    // Column defined by the file index
-    for(let col = 0; col < scan.length; col++) {
-      const img = await imageLoad(path.join(layerDir, scan[col]));
-      console.log('Copying', scan[col]);
-      imageCopy(out, img,
-        baseImage.width+(col*layer.width), y,
-        layer
-      );
-    }
-
-    strLayers += `
-      vnCharacterLayerAdd(vnc, ${scan.length},
-        ${baseImage.width}, ${y},
-        ${layer.x}, ${layer.y},
-        ${layer.width}, ${layer.height}
-      );
-    `;
-
-    y += layer.height;
-  }
-
-  mkdirp(outFile);
-  await imageWrite(out, outFile);
-  
-  let name = character.attributes.name || args.name || args.dep;
-  
-  // mkdirp(cOut);
-  // fs.writeFileSync(cOut, `
-  //   #include "${args.dep}.h"
-
-  //   void vnCharacter${name}Init(vncharacter_t *vnc, texture_t *texture) {
-  //     assetTextureLoad(texture, VN_CHARACTER_${name.toUpperCase()}_TEXTURE);
-  //     vnCharacterInit(vnc, texture);
-
-  //     // Base Layer
-  //     vnCharacterLayerAdd(vnc, 1, 0, 0, 0, 0, ${baseImage.width}, ${baseImage.height});
-
-  //     // Layers
-  //     ${strLayers}
-  //   }
-  // `);
-
-  // fs.writeFileSync(hOut, `
-  //   #pragma once
-  //   #include <libs.h>
-  //   #include <vn/vncharacter.h>
-  //   #include <display/texture.h>
-  //   #include <file/asset.h>
-
-  //   #define VN_CHARACTER_${name.toUpperCase()}_TEXTURE "${args.out}"
-    
-  //   void vnCharacter${name}Init(vncharacter_t *vnc, texture_t *texture);
-  // `);
-})().catch(console.error);

tools/vn/character_generator.c

@@ -12,9 +12,16 @@
 
 int main(int argc, char *argv[]) {
   FILE *file;
-  char *in;
+  char *in, *out;
-  char *out;
+  char bufferA[FILE_CHILD_NAME_MAX * FILE_CHILD_COUNT_MAX];
-  char xmlBuffer[2048];
+  char bufferB[FILENAME_MAX];
+  char directory[FILENAME_MAX];
+  uint8_t i, *pixels, *data;
+  int32_t fullWidth, fullHeight, size;
+  int32_t j, baseWidth, baseHeight, childrenCount, l, x, y, w, h, px, py, iw, ih;
+  xml_t node, *base, *child;
+  uint8_t childrenTypes[FILE_CHILD_COUNT_MAX];
+  char *children[FILE_CHILD_COUNT_MAX];
   
   if(argc != 3) {
     printf("Invalid number of arguments\n");
@@ -29,18 +36,230 @@ int main(int argc, char *argv[]) {
   fileNormalizeSlashes(in);
   fileNormalizeSlashes(out);
 
+  // Check the output doesn't already exist
+  file = fopen(out, "rb");
+  if(file != NULL) {
+    fclose(file);
+    return 0;
+  }
 
-  // Read in XML file
+  // Open XML file
   file = fopen(in, "rb");
   if(file == NULL) {
     printf("Failed to open file!\n");
     return 1;
   }
-  assetReadString(file, xmlBuffer);
+  
+  // Bufer XML data
+  assetReadString(file, bufferA);
+  fclose(file);
+  xmlLoad(&node, bufferA);
 
-  xmlnode_t node;
+  // Begin parsing
-  xmlParseElement(&node, xmlBuffer);
+  if(strcmp(node.node, "vncharacter") != 0) {
+    printf("Invalid character XML!\n");
+    xmlDispose(&node);
+    return 1;
+  }
+
+  // Find base
+  base = NULL;
+  for(i = 0; i < node.childrenCount; i++) {
+    if(strcmp(node.children[i].node, "base") != 0) continue;
+    base = node.children + i;
+    break;
+  }
+
+  if(base == NULL) {
+    printf("XML is missing base layer!\n");
+    xmlDispose(&node);
+    return 1;
+  }
+
+  // Prepare to load base info
+  fileGetDirectory(in, bufferA);
+  sprintf(directory, "%s%c%s", 
+    bufferA,
+    FILE_PATH_SEP,
+    node.attributeDatas[xmlGetAttributeByName(&node, "context")]
+  );
+
+  sprintf(bufferA, "%s%c%s",
+    directory,
+    FILE_PATH_SEP,
+    base->attributeDatas[xmlGetAttributeByName(base, "file")]
+  );
+  printf("Reading texture info for %s\n", bufferA);
+
+  file = fopen(bufferA, "rb");
+  if(file == NULL) {
+    printf("Failed to load base texture file %s!\n", bufferA);
+    xmlDispose(&node);
+    return 1;
+  }
+
+  // Read base info.
+  if(!stbi_info_from_file(file, &baseWidth, &baseHeight, NULL)) {
+    printf("Failed to read base texture %s!\n", bufferA);
+    xmlDispose(&node);
+    fclose(file);
+    return 1;
+  }
 
 
+  
+  // Read in the information for each layer.
+  fullWidth = 0;
+  fullHeight = 0;
+
+  for(i = 0; i < node.childrenCount; i++) {
+    child = node.children + i;
+    if(strcmp(child->node, "layer") != 0) continue;
+
+    // Get the full path of the directory where the layers' images reside
+    sprintf(bufferB, "%s%c%s",
+      directory,
+      FILE_PATH_SEP,
+      child->attributeDatas[xmlGetAttributeByName(child, "directory")]
+    );
+
+    // Scan the directory.
+    if(!fileListChildren(
+      bufferB, bufferA, &childrenCount, childrenTypes, children
+    )) {
+      printf("Failed to scandir!\n");
+      xmlDispose(&node);
+      fclose(file);
+      return 1;
+    }
+    
+    if(childrenCount == 0) continue;
+
+    // Update sizes
+    size = childrenCount * atoi(
+      child->attributeDatas[xmlGetAttributeByName(child, "width")]
+    );
+    if(size > fullWidth) fullWidth = size;
+    fullHeight += atoi(
+      child->attributeDatas[xmlGetAttributeByName(child, "height")]
+    );
+  }
+
+  // Update final full sizes
+  fullWidth += baseWidth;
+  fullHeight = fullHeight > baseHeight ? fullHeight : baseHeight;
+  l = STBI_rgb_alpha;
+
+  // Create output data
+  pixels = calloc(fullWidth * fullHeight * l, sizeof(uint8_t));
+  if(pixels == NULL) {
+    xmlDispose(&node);
+    fclose(file);
+    printf("Failed to create memory for pixels!\n");
+    return 1;
+  }
+
+  // Read in base data
+  data = stbi_load_from_file(file, &baseWidth, &baseHeight, NULL, l);
+  imageCopy(
+    data, baseWidth, baseHeight,
+    pixels, fullWidth, fullHeight,
+    -1, -1, -1, -1,
+    -1, -1,
+    l
+  );
+  stbi_image_free(data);
+  fclose(file);
+
+  // Now read in each layer
+  x = 0;
+  y = 0;
+  py = 0;
+
+  for(i = 0; i < node.childrenCount; i++) {
+    child = node.children + i;
+    if(strcmp(child->node, "layer") != 0) continue;
+
+    // Get the full path of the directory where the layers' images reside
+    sprintf(bufferB, "%s%c%s",
+      directory,
+      FILE_PATH_SEP,
+      child->attributeDatas[xmlGetAttributeByName(child, "directory")]
+    );
+    
+    // Scan the directory.
+    if(!fileListChildren(
+      bufferB, bufferA, &childrenCount, childrenTypes, children
+    )) {
+      printf("Failed to scandir!\n");
+      xmlDispose(&node);
+      free(pixels);
+      return 1;
+    }
+    if(childrenCount == 0) continue;
+
+    // Read in layer info
+    x = atoi(child->attributeDatas[xmlGetAttributeByName(child, "x")]);
+    y = atoi(child->attributeDatas[xmlGetAttributeByName(child, "y")]);
+    w = atoi(child->attributeDatas[xmlGetAttributeByName(child, "width")]);
+    h = atoi(child->attributeDatas[xmlGetAttributeByName(child, "height")]);
+
+    // Reset for the iteration.
+    px = baseWidth;
+    ih = 0;
+
+    // For each image in the layer...
+    for(j = 0; j < childrenCount; j++) {
+      // Find the path
+      sprintf(bufferB, "%s%c%s%c%s",
+        directory,
+        FILE_PATH_SEP,
+        child->attributeDatas[xmlGetAttributeByName(child, "directory")],
+        FILE_PATH_SEP,
+        children[j]
+      );
+
+      // Open image file
+      file = fopen(bufferB, "rb");
+      if(file == NULL) {
+        printf("Failed to open %s for reading!\n", bufferB);
+        xmlDispose(&node);
+        free(pixels);
+      }
+      
+      // Copy the cropped area
+      data = stbi_load_from_file(file, &iw, &ih, NULL, l);
+      imageCopy(
+        data, iw, ih,
+        pixels, fullWidth, fullHeight,
+        x, y, w, h,
+        px, py, l
+      );
+
+      // Cleanup
+      stbi_image_free(data);
+      fclose(file);
+
+      // Prep for next image
+      px += w;
+    }
+
+    // Prepare for next row.
+    py += h;
+  }
+
+  // Done with the XML!
+  xmlDispose(&node);
+
+
+  // Now write the data!
+  fileMkdirp(out);
+  stbi_write_png(out,
+    fullWidth, fullHeight, l, pixels,
+    fullWidth * l
+  );
+
+  // Cleanup
+  free(pixels);
   return 0;
 }