Started fixing texture tool (incomplete)

src/dawn/scene/components/display/mesh/CMakeLists.txt

@@ -9,5 +9,6 @@ target_sources(${DAWN_TARGET_NAME}
     MeshRenderer.cpp
     CubeMeshHost.cpp
     CapsuleMeshHost.cpp
+    QuadMeshHost.cpp
     MeshHost.cpp
 )

src/dawn/scene/components/display/mesh/QuadMeshHost.cpp

@@ -0,0 +1,30 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "QuadMeshHost.hpp"
+
+using namespace Dawn;
+
+QuadMeshHost::QuadMeshHost(SceneItem *item) :
+  xy0(glm::vec2(-0.5f, -0.5f)), xy1(glm::vec2(0.5f, 0.5f)),
+  uv0(glm::vec2(0, 0)), uv1(glm::vec2(1, 1)),
+  MeshHost(item)
+{
+}
+
+void QuadMeshHost::onStart() {
+  this->mesh.createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
+
+  useEffect([&]{
+    QuadMesh::bufferQuadMesh(
+      &this->mesh,
+      glm::vec2(this->xy0),
+      glm::vec2(this->uv0),
+      glm::vec2(this->xy1),
+      glm::vec2(this->uv1),
+      0, 0
+    );
+  }, { &this->xy0, &this->xy1, &this->uv0, &this->uv1 })();
+}

src/dawn/scene/components/display/mesh/QuadMeshHost.hpp

@@ -0,0 +1,25 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "MeshHost.hpp"
+#include "display/mesh/QuadMesh.hpp"
+
+namespace Dawn {
+  class QuadMeshHost : public MeshHost {
+    public:
+      // @optional
+      StateProperty<glm::vec2> xy0;
+      // @optional
+      StateProperty<glm::vec2> xy1;
+      // @optional
+      StateProperty<glm::vec2> uv0;
+      // @optional
+      StateProperty<glm::vec2> uv1;
+
+      QuadMeshHost(SceneItem *item);
+      void onStart() override;
+  };
+}

src/dawn/scene/components/physics/2d/CharacterController2D.cpp

@@ -14,6 +14,8 @@ CharacterController2D::CharacterController2D(SceneItem *i) :
 
 void CharacterController2D::onStart() {
   useEvent([&](float_t delta){
+    if(velocity == glm::vec2(0, 0)) return;
+
     // Common variables
     auto myCollider = item->getComponent<Collider2D>();
 
@@ -62,11 +64,6 @@ void CharacterController2D::onStart() {
       }
     }
 
-    // if(
-    //   mathAbs<float_t>(moveAmount.x) <= 0.001f &&
-    //   mathAbs<float_t>(moveAmount.y) <= 0.001f
-    // ) return;
-
     transform->setLocalPosition(
       transform->getLocalPosition() + (glm::vec3(moveAmount.x, 0, moveAmount.y) * delta)
     );
@@ -83,5 +80,8 @@ void CharacterController2D::onStart() {
       }
     }
 
+    // Stop velocity near zero.
+    if(mathAbs<float_t>(velocity.x) <= 0.001f) velocity.x = 0;
+    if(mathAbs<float_t>(velocity.y) <= 0.001f) velocity.y = 0;
   }, getScene()->eventSceneUpdate);
 }

src/dawnrose/CMakeLists.txt

@@ -23,4 +23,6 @@ tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Player.xml)
 tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Urchin.xml)
 tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Crab.xml)
 tool_prefab(${ROSE_ASSETS_DIR}/prefabs/SwordHitbox.xml)
-tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Wall.xml)
+tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Wall.xml)
+
+tool_texture(texture_urchin ${ROSE_ASSETS_DIR}/textures/Urchin.png)

src/dawnrose/scenes/HelloWorldScene.hpp

@@ -43,13 +43,14 @@ namespace Dawn {
         camera = Camera::create(this);
         camera->fov = 0.436332f;
         camera->transform->lookAt(glm::vec3(10, 10, 10), glm::vec3(0, 0, 0));
-        auto gameCamera = camera->item->addComponent<GameCamera>();
+        // auto gameCamera = camera->item->addComponent<GameCamera>();
-        gameCamera->player = player->player;
+        // gameCamera->player = player->player;
       }
       
       std::vector<Asset*> getRequiredAssets() override {
         auto assMan = &this->game->assetManager;
         std::vector<Asset*> assets;
+        vectorAppend(&assets, Urchin::getRequiredAssets(assMan));
         return assets;
       }
 

src/dawntools/CMakeLists.txt

@@ -19,4 +19,5 @@ set(
 include(util/CMakeLists.txt)
 
 # Tools
-add_subdirectory(prefabtool)
+add_subdirectory(prefabtool)
+add_subdirectory(texturetool)

src/dawntools/prefabtool/CMakeLists.txt

@@ -32,6 +32,7 @@ target_include_directories(prefabtool
 # Definitions
 target_compile_definitions(prefabtool
   PUBLIC
+    ${DAWN_SHARED_DEFINITIONS}
     DAWN_TOOL_INSTANCE=PrefabTool
     DAWN_TOOL_HEADER="PrefabTool.hpp"
 )

src/dawntools/prefabtool/PrefabGen.cpp

@@ -34,17 +34,19 @@ void PrefabGen::generate(
 
   // Process assets
   int32_t assetNumber = 0;
+  std::map<std::string, std::string> assetMap;
   auto processAsset = [&](struct PrefabAsset a) {
     std::string assetType = "";
+    a.usageName = "asset" + std::to_string(assetNumber++);
     switch(a.type) {
       case PREFAB_ASSET_TYPE_TEXTURE:
         assetType = "TextureAsset";
+        assetMap[a.fileName] = "&" + a.usageName + "->texture";
         break;
 
       default:
         assertUnreachable();
     }
-    a.usageName = "asset" + std::to_string(assetNumber++);
     line(&methodInit.body, "auto " + a.usageName + " = man->get<" + assetType + ">(\"" + a.fileName + "\");", "");
     line(&methodAssets.body, "assets.push_back(man->get<" + assetType + ">(\"" + a.fileName + "\"));", "");
   };
@@ -77,7 +79,11 @@ void PrefabGen::generate(
     // Now set each property
     auto itValues = c.values.begin();
     while(itValues != c.values.end()) {
-      line(&methodInit.body, componentName + "->" + itValues->first + " = " + itValues->second + ";", "");
+      auto value = itValues->second;
+      if(assetMap.find(value) != assetMap.end()) {
+        value = assetMap[value];
+      }
+      line(&methodInit.body, componentName + "->" + itValues->first + " = " + value + ";", "");
       ++itValues;
     }
 

src/dawntools/texturetool/CMakeLists.txt

@@ -0,0 +1,53 @@
+# Copyright (c) 2021 Dominic Msters
+# 
+# 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 in)
+  set(DEPS "")
+  if(DAWN_BUILD_TOOLS)
+    set(DEPS texturetool)
+  endif()
+
+  add_custom_target(${target}
+    COMMAND texturetool --input="${DAWN_ASSETS_SOURCE_DIR}/${in}" --output="${DAWN_ASSETS_BUILD_DIR}/${target}"
+    COMMENT "Generating texture ${target} from ${in}"
+    DEPENDS ${DEPS}
+  )
+  add_dependencies(${DAWN_TARGET_NAME} ${target})
+endfunction()

src/dawntools/texturetool/TextureTool.cpp

@@ -0,0 +1,61 @@
+// 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" };
+}
+
+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)) return 1;
+
+  int w, h, channels;
+  auto dataImage = stbi_load_from_file(in.file, &w, &h, &channels, STBI_rgb_alpha);
+  if(dataImage == NULL) {
+    std::cout << "Failed to load input texture!" << std::endl;
+    return 1;
+  }
+  in.close();
+
+  // Convert to floating points
+  size_t len = STBI_rgb_alpha * w * h;
+
+  // 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;
+  }
+
+  // Write info
+  char headerBuffer[64];
+  size_t headerBufferLength = sprintf((char *)headerBuffer, "%i|%i|", w, h);
+  if(!out.writeRaw(headerBuffer, headerBufferLength)) {
+    std::cout << "Failed to write texture header for " << out.filename << std::endl;
+    return 1;
+  }
+
+  // Write texture
+  if(!out.writeRaw((char *)dataImage, sizeof(uint8_t) * len)) {
+    std::cout << "Failed to write texture data for " << out.filename << std::endl;
+    return 1;
+  }
+  stbi_image_free(dataImage);
+
+  return 0;
+}

src/dawntools/texturetool/TextureTool.hpp

@@ -0,0 +1,19 @@
+// 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;
+
+    public:
+      int32_t start();
+  };
+}

src/dawntools/util/Image.cpp

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "Image.hpp"
+
+#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];
+      }
+    }
+  }
+}

src/dawntools/util/Image.hpp

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "File.hpp"
+
+#include <stb_image.h>
+#include <stb_image_resize.h>
+#include <stb_image_write.h>
+
+/**
+ * Unused currently.
+ * 
+ * @param source 
+ * @param sourceWidth 
+ * @param sourceHeight 
+ * @param dest 
+ * @param destWidth 
+ * @param destHeight 
+ * @param cropX 
+ * @param cropY 
+ * @param cropWidth 
+ * @param cropHeight 
+ * @param pasteX 
+ * @param pasteY 
+ * @param channels 
+ */
+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
+);