About to refactor all the tools to python.

.gitmodules

@@ -21,4 +21,4 @@
 	url = https://gitlab.freedesktop.org/freetype/freetype.git
 [submodule "lib/libarchive"]
 	path = lib/libarchive
-	url = https://github.com/libarchive/libarchive
+	url = https://github.com/libarchive/libarchive

cmake/targets/target-liminal-emscripten/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+set(DAWN_BUILDING dawnliminal CACHE INTERNAL ${DAWN_CACHE_TARGET})
+set(DAWN_BUILD_HOST_LIBS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})
+set(DAWN_TARGET_EMSCRIPTEN true CACHE INTERNAL ${DAWN_CACHE_TARGET})
+set(DAWN_TARGET_GLFW true CACHE INTERNAL ${DAWN_CACHE_TARGET})
+set(DAWN_TARGET_NAME "Liminal" CACHE INTERNAL ${DAWN_CACHE_TARGET})
+set(DAWN_VISUAL_NOVEL true CACHE INTERNAL ${DAWN_CACHE_TARGET})
+
+set(DAWN_EMSCRIPTEN_FLAGS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})

lib/CMakeLists.txt

@@ -5,8 +5,12 @@
 
 # GLFW
 if(DAWN_TARGET_GLFW)
-  add_subdirectory(glad)
+  if(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  add_subdirectory(glfw)
+    set(DAWN_EMSCRIPTEN_FLAGS "${DAWN_EMSCRIPTEN_FLAGS} -s USE_GLFW=3" CACHE INTERNAL ${DAWN_CACHE_TARGET})
+  else()
+    add_subdirectory(glad)
+    add_subdirectory(glfw)
+  endif()
 endif()
 
 # SDL
@@ -23,7 +27,11 @@ add_library(stb INTERFACE)
 target_include_directories(stb INTERFACE stb)
 
 # FreeType
-add_subdirectory(freetype)
+if(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
+  set(DAWN_EMSCRIPTEN_FLAGS "${DAWN_EMSCRIPTEN_FLAGS} -s USE_FREETYPE=1" CACHE INTERNAL ${DAWN_CACHE_TARGET})
+else()
+  add_subdirectory(freetype)
+endif()
 
 # LibArchive
 add_subdirectory(libarchive)
@@ -36,4 +44,11 @@ if(DAWN_TARGET_OPENAL)
   set(BUILD_TESTS OFF CACHE BOOL "Build tests" FORCE)
   set(BUILD_EXAMPLES OFF CACHE BOOL "Build examples" FORCE) 
   add_subdirectory(AudioFile)
+endif()
+
+# Test
+if(DEFINED DAWN_EMSCRIPTEN_FLAGS)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
 endif()

src/CMakeLists.txt

@@ -37,6 +37,8 @@ if(DEFINED DAWN_TARGET_NAME)
     add_subdirectory(dawnosx)
   elseif(DAWN_TARGET_VITA)
     add_subdirectory(dawnvita)
+  elseif(DAWN_TARGET_EMSCRIPTEN)
+    add_subdirectory(dawnemscripten)
   else()
     message(FATAL_ERROR "You need to define an entry target")
   endif()

src/dawn/asset/assets/TextureAsset.cpp

@@ -37,7 +37,6 @@ void TextureAsset::updateSync() {
 void TextureAsset::updateAsync() {
   if(this->state != 0x00) return;
   this->state = 0x01;
-  std::cout << "Update texture tool" << std::endl;
   this->loader.open();
   this->buffer = (uint8_t*)memoryAllocate(this->loader.getSize());
   this->loader.read(this->buffer, this->loader.getSize());

src/dawnemscripten/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Includes
+target_include_directories(${DAWN_TARGET_NAME}
+  PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+# Platform variables
+target_compile_definitions(${DAWN_TARGET_NAME}
+  PUBLIC
+    DAWN_ASSET_LOCATION="../../assets.tar"
+)
+
+# Subdirs
+add_subdirectory(host)
+
+# Ensures a .HTML file is generated.
+set(CMAKE_EXECUTABLE_SUFFIX ".html" CACHE INTERNAL ${DAWN_CACHE_TARGET})

src/dawnemscripten/host/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    DawnEmscripten.cpp
+)

src/dawnemscripten/host/DawnEmscripten.cpp

@@ -0,0 +1,11 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "host/DawnEmscripten.hpp"
+
+int main() {
+  printf("Hello Emscripten\n");
+  return 0;
+}

src/dawnemscripten/host/DawnEmscripten.hpp

@@ -0,0 +1,9 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <stdio.h>
+
+int main();

src/dawnliminal/CMakeLists.txt

@@ -15,6 +15,7 @@ target_include_directories(${DAWN_TARGET_NAME}
 # Subdirs
 add_subdirectory(game)
 add_subdirectory(save)
+add_subdirectory(vnscenes)
 
 # Assets
 include("${DAWN_ASSETS_SOURCE_DIR}/games/liminal/CMakeLists.txt")

src/dawnliminal/vnscenes/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    ScenePrologue8.cpp
+)

src/dawnliminal/vnscenes/ScenePrologue8.cpp

@@ -0,0 +1,117 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "ScenePrologue8.hpp"
+
+using namespace Dawn;
+
+void ScenePrologue8CustomEventForChoiceSet::onStart() {
+  auto scene = dynamic_cast<ScenePrologue8*>(this->manager->getScene());
+  assertNotNull(scene, "ScenePrologue8CustomEventForChoiceSet - Scene is null?");
+
+  this->choices = scene->remainingChoices;
+  this->key = "killer";
+  this->text = "It is...";
+
+  VNChoiceEvent::onStart();
+}
+
+void ScenePrologue8CustomEventForAfterChoice::onStart() {
+  auto prev = dynamic_cast<ScenePrologue8CustomEventForChoiceSet*>(this->previous);
+  assertNotNull(prev, "ScenePrologue8CustomEventForAfterChoice - Previous is null?");
+  auto scene = dynamic_cast<ScenePrologue8*>(this->manager->getScene());
+  assertNotNull(scene, "ScenePrologue8CustomEventForAfterChoice - Scene is null?");
+
+  auto key = prev->getChoiceKey();
+  scene->remainingChoices.erase(key);
+
+  this->next();
+}
+
+void ScenePrologue8CustomEventForAfterCharacterFollowup::onStart() {
+  auto scene = dynamic_cast<ScenePrologue8*>(this->manager->getScene());
+  assertNotNull(scene, "ScenePrologue8CustomEventForAfterChoice - Scene is null?");
+
+  if(scene->remainingChoices.empty()) {
+    auto sceneChange = this->manager->createEvent<VNSceneChangeEvent<ScenePrologue9>>();
+    this->then(sceneChange);
+  } else {
+    auto choiceSet = this->manager->createEvent<ScenePrologue8CustomEventForChoiceSet>();
+    this->then(choiceSet);
+  }
+}
+
+ScenePrologue8::ScenePrologue8(DawnGame *game) : SceneMonologue(game) {
+}
+
+std::vector<Asset*> ScenePrologue8::getRequiredAssets() {
+  auto man = &this->game->assetManager;
+  std::vector<Asset*> assets = SceneMonologue::getRequiredAssets();
+  return assets;
+}
+
+void ScenePrologue8::stage() {
+  SceneMonologue::stage();
+
+  remainingChoices["ave"] = "Ave?";
+  remainingChoices["ronin"] = "Ronin?";
+  remainingChoices["craig"] = "Craig?";
+
+  auto man = &this->game->assetManager;
+  assertNotNull(vnManager, "VNSceneGenInit - VN Manager is null?");
+  VNEvent *previous = vnManager->createEvent<VNDummyEvent>();
+  auto eventStart = previous;
+
+  auto event0 = vnManager->createEvent<VNSetDefaultFontEvent>();
+  event0->font = "<font font=\"font_main\" size=\"32.0f\">{{ text }}</font>";
+
+  auto eventChoice = vnManager->createEvent<ScenePrologue8CustomEventForChoiceSet>();
+  auto eventAfterChoice = vnManager->createEvent<ScenePrologue8CustomEventForAfterChoice>();
+  auto eventFollowUp = vnManager->createEvent<ScenePrologue8CustomEventForAfterCharacterFollowup>();
+
+  // Ave
+  auto eventIfAve = vnManager->createEvent<VNIfEvent>();
+  eventIfAve->key = "killer";
+  eventIfAve->value = "ave";
+  
+  auto eventTestAve = vnManager->createEvent<VNTextEvent>();
+  eventTestAve->text = "Ave?";
+  eventIfAve->ifTrue = eventTestAve;
+  eventIfAve->ifEnd = eventTestAve;
+  
+
+  // Craig
+  auto eventIfCraig = vnManager->createEvent<VNIfEvent>();
+  eventIfCraig->key = "killer";
+  eventIfCraig->value = "craig";
+
+  auto eventTestCraig = vnManager->createEvent<VNTextEvent>();
+  eventTestCraig->text = "Craig?";
+  eventIfCraig->ifTrue = eventTestCraig;
+  eventIfCraig->ifEnd = eventTestCraig;
+
+
+  // Ronin
+  auto eventIfRonin = vnManager->createEvent<VNIfEvent>();
+  eventIfRonin->key = "killer";
+  eventIfRonin->value = "ronin";
+
+  auto eventTestRonin = vnManager->createEvent<VNTextEvent>();
+  eventTestRonin->text = "Ronin?";
+  eventIfRonin->ifTrue = eventTestRonin;
+  eventIfRonin->ifEnd = eventTestRonin;
+
+
+  // End
+  eventStart->then(event0);
+  event0->then(eventChoice);
+  eventChoice->then(eventAfterChoice);
+  eventAfterChoice->then(eventIfAve);
+  eventIfAve->then(eventIfCraig);
+  eventIfCraig->then(eventIfRonin);
+  eventIfRonin->then(eventFollowUp);
+
+  vnManager->setEvent(eventStart);
+}

src/dawnliminal/vnscenes/ScenePrologue8.hpp

@@ -1,5 +1,9 @@
-#pragma once
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
 
+#pragma once
 #include "scenes/SceneMonologue.hpp"
 #include "games/vn/events/VNDummyEvent.hpp"
 #include "games/vn/events/VNSetDefaultFontEvent.hpp"
@@ -13,70 +17,27 @@
 namespace Dawn {
   class ScenePrologue8CustomEventForChoiceSet : public VNChoiceEvent {
     protected:
-      void onStart() override {
+      void onStart() override;
-        auto scene = dynamic_cast<ScenePrologue8*>this->manager->getScene();
-        assertNotNull(scene, "ScenePrologue8CustomEventForChoiceSet - Scene is null?");
-
-        this->choices = scene->remainingChoices;
-        this->key = "killer";
-        this->text = "It is...";
-
-        VNChoiceSetEvent::onStart();
-      }
   };
 
   class ScenePrologue8CustomEventForAfterChoice : public VNEvent {
     protected:
-      void onStart() override {
+      void onStart() override;
-        auto prev = dynamic_cast<ScenePrologue8CustomEventForChoiceSet*>(this->previous);
+  };
-        assertNotNull(prev, "ScenePrologue8CustomEventForAfterChoice - Previous is null?");
+  
-        auto scene = dynamic_cast<ScenePrologue8*>this->manager->getScene();
+  class ScenePrologue8CustomEventForAfterCharacterFollowup : public VNEvent {
-        assertNotNull(scene, "ScenePrologue8CustomEventForAfterChoice - Scene is null?");
+    protected:
-
+      void onStart() override;
-        auto key = prev->getChoiceKey();
-        scene->remainingChoices.erase(key);
-
-        this->next();
-      }
   };
 
   class ScenePrologue8 : public SceneMonologue {
     public:
       std::map<std::string, std::string> remainingChoices;
 
-      ScenePrologue8(DawnGame *game) : SceneMonologue(game) {
+      ScenePrologue8(DawnGame *game);
-      }
       
-      std::vector<Asset*> getRequiredAssets() override {
+      std::vector<Asset*> getRequiredAssets() override;
-        auto man = &this->game->assetManager;
-        std::vector<Asset*> assets = SceneMonologue::getRequiredAssets();
-        return assets;
-      }
       
-      void stage() override {
+      void stage() override;
-        SceneMonologue::stage();
-
-        remainingChoices["ave"] = "Ave?";
-        remainingChoices["ronin"] = "Ronin?";
-        remainingChoices["craig"] = "Craig?";
-
-        auto man = &this->game->assetManager;
-        assertNotNull(vnManager, "VNSceneGenInit - VN Manager is null?");
-        VNEvent *previous = vnManager->createEvent<VNDummyEvent>();
-        auto eventStart = previous;
-
-        auto event0 = vnManager->createEvent<VNSetDefaultFontEvent>();
-        event0->font = "<font font=\"font_main\" size=\"32.0f\">{{ text }}</font>";
-
-        auto event1 = vnManager->createEvent<ScenePrologue8CustomEventForChoiceSet>();
-        auto event2 = vnManager->createEvent<ScenePrologue8CustomEventForAfterChoice>();
-        auto sceneChange = vnManager->createEvent<VNSceneChangeEvent<ScenePrologue9>>();
-        
-        eventStart->then(event0);
-        event0->then(event1);
-        event1->then(event2);
-        event2->then(sceneChange);
-        vnManager->setEvent(eventStart);
-      }
   };
-}
+}

src/dawnshared/util/memory.cpp

@@ -6,14 +6,6 @@
 #include "memory.hpp"
 #include "assert/assert.hpp"
 
-void * operator new(size_t size) noexcept {
-  return memoryAllocate(size);
-}
-
-void operator delete (void *p) noexcept {
-  return memoryFree(p);
-}
-
 void * memoryAllocate(const size_t size) {
   assertTrue(size >= 0, "memoryAllocate: size must be greater than 0 or equal to.");
   void *x = (void *)memoryCallMalloc(size);

src/dawntools/texturetool/CMakeLists.txt

@@ -3,40 +3,6 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-# Texture Build Tool
-project(texturetool VERSION 1.0)
-add_executable(texturetool)
-
-target_sources(texturetool
-  PRIVATE
-    ${DAWN_SHARED_SOURCES}
-    ${DAWN_TOOL_SOURCES}
-    TextureTool.cpp
-    ../util/Image.cpp
-)
-
-target_include_directories(texturetool
-  PUBLIC
-    ${DAWN_SHARED_INCLUDES}
-    ${DAWN_TOOL_INCLUDES}
-    ${CMAKE_CURRENT_LIST_DIR}
-)
-
-# Definitions
-target_compile_definitions(texturetool
-  PUBLIC
-    ${DAWN_SHARED_DEFINITIONS}
-    DAWN_TOOL_INSTANCE=TextureTool
-    DAWN_TOOL_HEADER="TextureTool.hpp"
-)
-
-# Libraries
-target_link_libraries(texturetool
-  PUBLIC
-    ${DAWN_BUILD_HOST_LIBS}
-    stb
-)
-
 # Tool Function
 function(tool_texture target)
   # Defaults
@@ -64,28 +30,21 @@ function(tool_texture target)
   if(NOT DEFINED FILE)
     message(FATAL_ERROR "Missing FILE input")
   endif()
-
+  
-  set(DEPS "")
-  if(DAWN_BUILD_TOOLS)
-    set(DEPS texturetool)
-  endif()
-
   add_custom_target(${target}
-    COMMAND texturetool
+    COMMAND ${DAWN_TOOLS_DIR}/texturetool/texturetool.py
       --input="${FILE}"
-      --output="${DAWN_ASSETS_BUILD_DIR}/${target}"
+      --output="${DAWN_ASSETS_BUILD_DIR}/${target}.texture"
-      --wrapX="${WRAP_X}"
+      --wrap-x="${WRAP_X}"
-      --wrapY="${WRAP_Y}"
+      --wrap-y="${WRAP_Y}"
-      --filterMin="${FILTER_MIN}"
+      --filter-min="${FILTER_MIN}"
-      --filterMag="${FILTER_MIN}"
+      --filter-mag="${FILTER_MIN}"
       --scale="${SCALE}"
-      --cropStartX="${CROP_START_X}"
+      --crop-start-x="${CROP_START_X}"
-      --cropStartY="${CROP_START_Y}"
+      --crop-start-y="${CROP_START_Y}"
-      --cropEndX="${CROP_END_X}"
+      --crop-end-x="${CROP_END_X}"
-      --cropEndY="${CROP_END_Y}"
+      --crop-end-y="${CROP_END_Y}"
-      --preview="${DAWN_BUILD_DIR}/preview/${target}"
     COMMENT "Generating texture ${target} from ${FILE}"
-    DEPENDS ${DEPS}
   )
   add_dependencies(dawnassets ${target})
 endfunction()

src/dawntools/texturetool/TextureTool.cpp

@@ -1,193 +0,0 @@
-// Copyright (c) 2023 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "TextureTool.hpp"
-
-using namespace Dawn;
-
-std::vector<std::string> TextureTool::getRequiredFlags() {
-  return std::vector<std::string>{ "input", "output" };
-}
-
-std::map<std::string, std::string> TextureTool::getOptionalFlags() {
-  return {
-    { "wrapX", "clamp" },
-    { "wrapY", "clamp" },
-    { "filterMin", "linear" },
-    { "filterMax", "linear" },
-    { "scale", "" },
-    { "scaleWrapX", "clamp" },
-    { "scaleWrapY", "clamp" },
-    { "scaleFilterX", "nearest" },
-    { "scaleFilterY", "nearest" },
-    { "cropStartX", "" },
-    { "cropStartY", "" },
-    { "cropEndX", "" },
-    { "cropEndY", "" },
-    { "preview", "" }
-  };
-}
-
-int32_t TextureTool::start() {
-  // Finished with XML data, now we can write data out.
-  File fileOut(flags["output"] + ".texture");
-  if(fileOut.exists()) return 0;
-
-  // Load input file
-  File in(flags["input"]);
-  if(!in.open(FILE_MODE_READ)) {
-    std::cout << "Failed to open input file " << in.filename << std::endl;
-    return 1;
-  }
-  
-  int32_t originalWidth, originalHeight, channels;
-  auto bufferCurrent = stbi_load_from_file(
-    in.file,
-    &originalWidth,
-    &originalHeight,
-    &channels,
-    STBI_rgb_alpha
-  );
-  if(bufferCurrent == NULL) {
-    std::cout << "Failed to load input texture!" << std::endl;
-    return 1;
-  }
-  in.close();
-
-  // Create a temporary buffer to hold pixels.
-  size_t len = STBI_rgb_alpha * originalWidth * originalHeight;
-  uint8_t *bufferTemporary = (uint8_t*)malloc(sizeof(uint8_t) * len);
-  int32_t currentWidth = originalWidth;
-  int32_t currentHeight = originalHeight;
-
-  // Crop
-  int32_t cropStartX = 0;
-  int32_t cropStartY = 0;
-  int32_t cropEndX = 0;
-  int32_t cropEndY = 0;
-
-  if(!flags["cropStartX"].empty()) cropStartX = std::stoi(flags["cropStartX"]);
-  if(!flags["cropStartY"].empty()) cropStartY = std::stoi(flags["cropStartY"]);
-  if(!flags["cropEndX"].empty()) cropEndX = std::stoi(flags["cropEndX"]);
-  if(!flags["cropEndY"].empty()) cropEndY = std::stoi(flags["cropEndY"]);
-
-  if(cropStartX > 0 || cropStartY > 0 || cropEndX > 0 || cropEndY > 0) {
-    int32_t cropWidth = (cropEndX == 0 ? originalWidth : cropEndX) - cropStartX;
-    int32_t cropHeight = (cropEndY == 0 ? originalHeight : cropEndY) - cropStartY;
-
-    float_t s0, t0, s1, t1;
-    s0 = (float_t)cropStartX / (float_t)originalWidth;
-    t0 = (float_t)cropStartY / (float_t)originalHeight;
-    s1 = ((float_t)(cropEndX == 0 ? originalWidth : cropEndX) / (float_t)originalWidth);
-    t1 = ((float_t)(cropEndY == 0 ? originalHeight : cropEndY) / (float_t)originalHeight);
-
-    stbir_resize_region(
-      bufferCurrent, currentWidth, currentHeight, 0,
-      bufferTemporary, cropWidth, cropHeight, 0,
-      STBIR_TYPE_UINT8,
-      STBI_rgb_alpha, -1, 0,
-      STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP,
-      STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
-      STBIR_COLORSPACE_LINEAR, NULL,
-      s0, t0, s1, t1
-    );
-    memcpy(bufferCurrent, bufferTemporary, sizeof(uint8_t) * len);
-
-    currentWidth = cropWidth;
-    currentHeight = cropHeight;
-  }
-
-  // Scale
-  if(!flags["scale"].empty()) {
-    float_t scale = std::stof(flags["scale"]);
-    int32_t scaleWidth = currentWidth * scale;
-    int32_t scaleHeight = currentHeight * scale;
-
-    stbir_resize_uint8_generic(
-      bufferCurrent, currentWidth, currentHeight, 0,
-      bufferTemporary, scaleWidth, scaleHeight, 0,
-      STBI_rgb_alpha,  -1, 0,
-      STBIR_EDGE_CLAMP, STBIR_FILTER_DEFAULT, STBIR_COLORSPACE_LINEAR,
-      NULL
-    );
-    memcpy(bufferCurrent, bufferTemporary, sizeof(uint8_t) * len);
-
-    currentWidth = scaleWidth;
-    currentHeight = scaleHeight;
-  }
-
-  // Wrapping Settings
-  std::function<int32_t(std::string)> wrapFromString = [&](std::string wr) {
-    if(wr == "repeat") return 0;
-    if(wr == "mirror") return 1;
-    if(wr == "clamp") return 2;
-    if(wr == "border") return 3;
-    return -1;
-  };
-
-  int32_t wrapX = wrapFromString(flags["wrapX"]);
-  if(wrapX == -1) {
-    std::cout << "Invalid wrapX value " << flags["wrapX"] << std::endl;
-    return 1;
-  }
-
-  int32_t wrapY = wrapFromString(flags["wrapY"]);
-  if(wrapY == -1) {
-    std::cout << "Invalid wrapY value " << flags["wrapY"] << std::endl;
-    return 1;
-  }
-
-  // Write info
-  char headerBuffer[256];
-  size_t headerBufferLength = sprintf((char *)headerBuffer, "DT_2.00|%i|%i|%i|%i|%i|%i|%i|",
-    currentWidth,
-    currentHeight,
-    4,  // RGBA,
-    wrapX,  // WRAPX
-    wrapY,  // WRAPY
-    flags["filterMin"] == "nearest" ? 0 : 1,
-    flags["filterMag"] == "nearest" ? 0 : 1
-  );
-
-  // Open and create output
-  File out(flags["output"] + ".texture");
-  if(!out.mkdirp()) {
-    std::cout << "Failed to make output dir " << out.filename << std::endl;
-    return 1;
-  }
-  if(!out.open(FILE_MODE_WRITE)) {
-    std::cout << "Failed to open texture file for writing " << out.filename << std::endl;
-    return 1;
-  }
-  if(!out.writeRaw(headerBuffer, headerBufferLength)) {
-    std::cout << "Failed to write texture header for " << out.filename << std::endl;
-    return 1;
-  }
-
-  // Write preview
-  File preview(flags["preview"] + ".png");
-  if(!preview.mkdirp()) {
-    std::cout << "Failed to make preview dir " << preview.filename << std::endl;
-    return 1;
-  }
-  stbi_write_png(
-    preview.filename.c_str(),
-    currentWidth,
-    currentHeight,
-    STBI_rgb_alpha,
-    bufferCurrent,
-    0
-  );
-
-  // Write texture
-  if(!out.writeRaw((char*)bufferCurrent, sizeof(uint8_t) * len)) {
-    std::cout << "Failed to write texture data for " << out.filename << std::endl;
-    return 1;
-  }
-  free(bufferCurrent);
-  free(bufferTemporary);
-
-  return 0;
-}

src/dawntools/texturetool/TextureTool.hpp

@@ -1,20 +0,0 @@
-// Copyright (c) 2023 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "util/DawnTool.hpp"
-#include "util/File.hpp"
-#include "util/Image.hpp"
-
-namespace Dawn {
-  class TextureTool : public DawnTool {
-    protected:
-      std::vector<std::string> getRequiredFlags() override;
-      std::map<std::string, std::string> getOptionalFlags() override;
-
-    public:
-      int32_t start();
-  };
-}

src/dawntools/texturetool/texturetool.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+from PIL import Image
+import argparse
+import os
+
+# Args
+parser = argparse.ArgumentParser(description='Converts image textures to internal game data format.')
+parser.add_argument('-i', '--input');
+parser.add_argument('-o', '--output');
+parser.add_argument('-s', '--scale');
+parser.add_argument('-sf', '--scale-filter');
+parser.add_argument('-wx', '--wrap-x');
+parser.add_argument('-wy', '--wrap-y');
+parser.add_argument('-fi', '--filter-min')
+parser.add_argument('-fg', '--filter-mag')
+parser.add_argument('-csx', '--crop-start-x');
+parser.add_argument('-csy', '--crop-start-y');
+parser.add_argument('-cex', '--crop-end-x');
+parser.add_argument('-cey', '--crop-end-y');
+args = parser.parse_args()
+
+# Ensure input exists
+if not os.path.exists(args.input):
+  print(f"Input file '{args.input}' does not exist.")
+  exit(1)
+
+# Open image
+img = Image.open(args.input)
+
+# Normalize the image
+hasAlpha = img.mode == 'RGBA' or img.mode == 'LA'
+
+# Convert the image to RGB or RGBA mode based on alpha channel
+if hasAlpha:
+  img = img.convert('RGBA')
+else:
+  img = img.convert('RGB')
+
+  # Apply cropping
+crop_box = [
+  int(args.crop_start_x) if args.crop_start_x not in (None, "") else 0,
+  int(args.crop_start_y) if args.crop_start_y not in (None, "") else 0,
+  int(args.crop_end_x) if args.crop_end_x not in (None, "") else img.width,
+  int(args.crop_end_y) if args.crop_end_y not in (None, "") else img.height
+]
+img = img.crop(crop_box)
+  
+# Apply scaling
+if args.scale not in (None, ""):
+  scale = float(args.scale)
+  newSize = (int(img.width * scale), int(img.height * scale))
+  if args.scale_filter == 'NEAREST':
+    img = img.resize(newSize, Image.NEAREST)
+  elif args.scale_filter == 'BILINEAR':
+    img = img.resize(newSize, Image.BILINEAR)
+  elif args.scale_filter == 'BICUBIC':
+    img = img.resize(newSize, Image.BICUBIC)
+  elif args.scale_filter == 'LANCZOS':
+    img = img.resize(newSize, Image.LANCZOS)
+  else:
+    img = img.resize(newSize)
+
+
+# Filter
+if args.filter_min.lower() == 'NEAREST':
+  filterMin = 0
+else:
+  filterMin = 1
+
+if args.filter_mag.lower() == 'NEAREST':
+  filterMag = 0
+else:
+  filterMag = 1
+
+# Wrap
+if args.wrap_x.lower() == 'repeat':
+  wrapX = 0
+elif args.wrap_x.lower() == 'mirror':
+  wrapX = 1
+elif args.wrap_x.lower() == 'clamp':
+  wrapX = 2
+elif args.wrap_x.lower() == 'border':
+  wrapX = 3
+else:
+  wrapX = 2
+
+if args.wrap_y.lower() == 'repeat':
+  wrapY = 0
+elif args.wrap_y.lower() == 'mirror':
+  wrapY = 1
+elif args.wrap_y.lower() == 'clamp':
+  wrapY = 2
+elif args.wrap_y.lower() == 'border':
+  wrapY = 3
+else:
+  wrapY = 2
+
+# Get raw pixel data
+buffer = img.tobytes()
+
+# Create the output directory if it doesn't exist
+os.makedirs(os.path.dirname(args.output), exist_ok=True)
+
+# Write the image metadata and pixel data to the output file
+with open(args.output, 'wb') as f:
+  header = f"DT_2.00|{img.width}|{img.height}|{4 if hasAlpha else 3}|{wrapX}|{wrapY}|{filterMin}|{filterMag}|"
+  f.write(header.encode())
+  f.write(buffer)