Merge pull request #5 from HarbourMasters/vertice-gen

Add undefined behaviour

Author: KiritoDv

assets/mk64/us/startup_logo.yml

@@ -0,0 +1,10 @@
+startup_logo/startup_logo:
+  name: startup_logo
+  type: vtx
+  size: 688
+  offset: 0
+  mio0: 0x825800
+# startup_logo/dl1: # not implemented yet
+#   type: display_list
+#   mio0: 0x825800
+#   offset: 0x35C0

src/Companion.cpp

@@ -15,6 +15,7 @@
 #include "factories/sm64/SDialogFactory.h"
 #include "factories/sm64/SDictionaryFactory.h"
 #include "factories/DisplayListFactory.h"
+#include "factories/VerticeFactory.h"
 #include "factories/sm64/SGeoFactory.h"
 #include "spdlog/spdlog.h"
 
@@ -39,7 +40,9 @@ void Companion::Init() {
     this->RegisterFactory("TEXTURE", new TextureFactory());
     this->RegisterFactory("BLOB", new BlobFactory());
 
-    // SM64 Specific
+    this->RegisterFactory("VTX", new VerticeFactory());
+
+    // SM64 specific
     this->RegisterFactory("SM64:DIALOG", new SDialogFactory());
     this->RegisterFactory("SM64:ANIM", new SAnimFactory());
     this->RegisterFactory("SM64:TEXT", new STextFactory());
@@ -113,6 +116,7 @@ void Companion::Process() {
 
         for(auto asset = root.begin(); asset != root.end(); ++asset){
             auto type = asset->second["type"].as<std::string>();
+            std::transform(type.begin(), type.end(), type.begin(), ::toupper);
 
             auto output = (directory / asset->first.as<std::string>()).string();
             std::replace(output.begin(), output.end(), '\\', '/');

src/factories/VerticeFactory.cpp

@@ -0,0 +1,75 @@
+#include "VerticeFactory.h"
+
+#include "utils/MIODecoder.h"
+#include "spdlog/spdlog.h"
+#include <iostream>
+#include <string>
+#include <fstream>  // for file stream
+
+namespace fs = std::filesystem;
+
+typedef short s16;
+typedef unsigned short u16;
+typedef unsigned char u8;
+
+#define str(value) std::to_string(value)
+
+// Byte swap a 16-bit unsigned integer
+std::uint16_t SwapBytes(std::uint16_t value) {
+    return ((value >> 8) & 0x00FF) | ((value << 8) & 0xFF00);
+}
+
+void WriteAllText(const std::string& filename, const std::string& text) {
+    std::ofstream outputFile(filename);
+
+    if (!outputFile.is_open()) {
+        std::cerr << "Failed to open the file: " << filename << std::endl;
+        return;  // Handle the error as needed
+    }
+
+    outputFile << text;
+    outputFile.close();
+}
+
+bool VerticeFactory::process(LUS::BinaryWriter* writer, YAML::Node& node, std::vector<uint8_t>& buffer) {
+
+    auto offset = node["offset"].as<size_t>();
+    auto mio0 = node["mio0"].as<size_t>();
+    auto numVerts = node["size"].as<size_t>();
+    auto name = node["name"].as<std::string>();
+
+    auto decoded = MIO0Decoder::Decode(buffer, mio0);
+
+    auto *data = decoded.data() + offset;
+
+    Vtx *vtx = reinterpret_cast<Vtx*>(data);
+
+    std::string text = "";
+
+    text += "Vtx "+ name + "[] = {\n";
+
+    for (size_t i = 0; i < numVerts; i++) {
+        s16 x = SwapBytes(vtx[i].v.ob[0]);
+        s16 y = SwapBytes(vtx[i].v.ob[1]);
+        s16 z = SwapBytes(vtx[i].v.ob[2]);
+
+        u16 flag = SwapBytes(vtx[i].v.flag);
+        s16 tc1   = SwapBytes(vtx[i].v.tc[0]);
+        s16 tc2   = SwapBytes(vtx[i].v.tc[1]);
+
+        u8 cn1    = vtx[i].v.cn[0];
+        u8 cn2    = vtx[i].v.cn[1];
+        u8 cn3    = vtx[i].v.cn[2];
+        u8 cn4    = vtx[i].v.cn[3];
+
+        text += "    {{ " + str(x) + ", " + str(y) + ", " + str(z) + "}, " + str(flag) + ", {" + str(tc1) + ", " + str(tc2) + "}, ";
+
+        text += "{ 0x" + str(cn1) + ", " + "0x" + str(cn2) + ", 0x" + str(cn3) + ", 0x" + str(cn4) + " }}},\n";        
+    }
+
+    text += ("};\n");
+
+	WriteAllText("out.txt", text);
+
+    return true;
+}

src/factories/VerticeFactory.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "RawFactory.h"
+
+class VerticeFactory : public RawFactory {
+/*
+ * Vertex (set up for use with colors)
+ */
+typedef struct {
+	short		ob[3];	/* x, y, z */
+	unsigned short	flag;
+	short		tc[2];	/* texture coord */
+	unsigned char	cn[4];	/* color & alpha */
+} Vtx_t;
+
+/*
+ * Vertex (set up for use with normals)
+ */
+typedef struct {
+	short		ob[3];	/* x, y, z */
+	unsigned short	flag;
+	short		tc[2];	/* texture coord */
+	signed char	n[3];	/* normal */
+	unsigned char   a;      /* alpha  */
+} Vtx_tn;
+
+typedef union {
+    Vtx_t		v;  /* Use this one for colors  */
+    Vtx_tn              n;  /* Use this one for normals */
+    long long int	force_structure_alignment;
+} Vtx;
+public:
+    VerticeFactory() = default;
+    bool process(LUS::BinaryWriter* write, YAML::Node& data, std::vector<uint8_t>& buffer) override;
+};