YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Converted tooling to C.

Browse Source
This commit is contained in:
Dominic Masters
2021-11-07 23:34:05 -08:00
parent a2a839cbac
commit a6bae07e38
18 changed files with 637 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
CMakeLists.txt
View File

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

1
lib/libzip Submodule

Submodule lib/libzip added at 945768eca2

1
lib/zlib Submodule

Submodule lib/zlib added at cacf7f1d4e

1
tools/display/CMakeLists.txt
View File

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

21
tools/display/texture_generation.c
View File

@ -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

12
tools/utils/args.js
View File

@ -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
};

7
tools/utils/common.h
View File

@ -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>

63
tools/utils/file.c
View File

@ -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
}

18
tools/utils/file.h
View File

@ -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
);

19
tools/utils/file.js
View File

@ -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
}

55
tools/utils/image.c Normal file
View File

@ -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];
}
}
}
}

10
tools/utils/image.h
View File

@ -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
);

103
tools/utils/image.js
View File

@ -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
}

262
tools/utils/xml.c
View File

@ -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;
uint8_t state;
int32_t level = 0;
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;
state = XML_STATE_NOTHING;
while(c = string[i++]) {
switch(state) {
case XML_STATE_NOTHING:
if(c != '<') continue;
node->start = string + (i - 1);
state = XML_STATE_PARSING_NAME;
break;
xml->children = malloc(sizeof(xml_t) * XML_CHILD_COUNT_MAX);
xml->childrenCount = 0;
case XML_STATE_PARSING_NAME:
if(c == ' ' || c == '\n' || c == '\r') continue;
j = i - 1;
while(c = string[j++]) {
if(c == ' ') break;
node->name[j] = c;
}
i = j;
state = XML_STATE_PARSING_ATTRIBUTES;
break;
case XML_STATE_PARSING_ATTRIBUTES:
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 = data[i++]) {
switch(doing) {
case XML_DOING_NOTHING:
// Look for either an opening tag (<) or a word for a value.
if(c == '>') continue;
if(c == '<') {
if(insideTag) {
i = xmlLoadChild(xml->children + xml->childrenCount++, data, i-1);
doing = XML_PARSING_CHILD;
} else {
doing = XML_PARSING_TAG_NAME;
level++;
insideTag = true;
}
} while(c);
node->attributeCount++;
continue;
}
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';
}

65
tools/utils/xml.h
View File

@ -9,26 +9,59 @@
#include "common.h"
#include "file.h"
#define XML_NODE_CHILD_MAX 32
#define XML_NODE_NAME_MAX 32
#define XML_NODE_ATTRIBUTES_MAX 32
#define XML_DOING_NOTHING 0x00
#define XML_PARSING_TAG_NAME 0x01
#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_STATE_PARSING_NAME 0x01
#define XML_STATE_PARSING_ATTRIBUTES 0x02
#define XML_TEXT_BUFFER_MAX 256
#define XML_CHILD_COUNT_MAX 16
#define XML_ATTRIBUTE_MAX 16
typedef struct {
char *start;
char *internal;
char name[XML_NODE_NAME_MAX];
typedef struct _xml_t xml_t;
char *attributeNames[XML_NODE_ATTRIBUTES_MAX];
uint8_t attributeNameLengths[XML_NODE_ATTRIBUTES_MAX];
char *attributeValues[XML_NODE_ATTRIBUTES_MAX];
uint8_t attributeValueLengths[XML_NODE_ATTRIBUTES_MAX];
typedef struct _xml_t {
char *node;
char *value;
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);

3
tools/vn/CMakeLists.txt
View File

@ -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}
)

139
tools/vn/character-sheet-generator.js
View File

@ -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);

233
tools/vn/character_generator.c
View File

@ -12,9 +12,16 @@
int main(int argc, char *argv[]) {
FILE *file;
char *in;
char *out;
char xmlBuffer[2048];
char *in, *out;
char bufferA[FILE_CHILD_NAME_MAX * FILE_CHILD_COUNT_MAX];
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;
xmlParseElement(&node, xmlBuffer);
// Begin parsing
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;
}