mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-07-03 06:24:30 +00:00
Code Issues Projects Releases Wiki Activity

ZAPD update (#612)

Browse source 
* remove roompoly

* git subrepo pull --force tools/ZAPD

subrepo:
  subdir:   "tools/ZAPD"
  merged:   "fd4d53a26"
upstream:
  origin:   "https://github.com/zeldaret/ZAPD.git"
  branch:   "master"
  commit:   "fd4d53a26"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo.git"
  commit:   "2f68596"
This commit is contained in:
fig02 2021-01-08 19:38:28 -05:00 • committed by GitHub
parent 5c6335f9fb
commit 1ff2f0f849
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
171 changed files with 1567 additions and 826 deletions
Download patch file Download diff file Expand all files Collapse all files

4
tools/ZAPD/.gitrepo
View file

@ -6,7 +6,7 @@
[subrepo]
remote = https://github.com/zeldaret/ZAPD.git
branch = master
commit = 440ed2684bb9d02837bfef0c41e6c59e479897a4
parent = 1f7bebfc05c42cc4f100a1992970e78ef7055dbd
commit = fd4d53a2684871a1ac28668515d025470a45ef7f
parent = cbe216b1810f9274242d0088a7e3b15b0f95f55d
method = merge
cmdver = 0.4.3

45
tools/ZAPD/Jenkinsfile vendored Normal file
View file

@ -0,0 +1,45 @@
pipeline {
agent any
stages {
stage('Build ZAPD') {
steps {
sh 'make -j'
}
}
stage('Checkout oot') {
steps {
dir('oot') {
git url: 'https://github.com/zeldaret/oot.git'
}
}
}
stage('Set up oot') {
steps {
dir('oot') {
sh 'cp /usr/local/etc/roms/baserom_oot.z64 baserom_original.z64'
// Identical to `make setup` except for copying our newer ZAPD.out into oot
sh 'git submodule update --init --recursive'
sh 'make -C tools'
sh 'cp ../ZAPD.out tools/ZAPD/'
sh 'python3 fixbaserom.py'
sh 'python3 extract_baserom.py'
sh 'python3 extract_assets.py'
}
}
}
stage('Build oot') {
steps {
dir('oot') {
sh 'make -j'
}
}
}
}
post {
always {
cleanWs()
}
}
}

14
tools/ZAPD/Makefile
View file

@ -4,16 +4,24 @@ ifneq (, $(shell which ccache))
CC := ccache $(CC)
endif
CFLAGS := -g -std=c++17 -I ZAPD -I ZAPD/sqlite -O2 -rdynamic
CFLAGS := -g -std=c++17 -I ZAPD -I lib/assimp/include -I lib/elfio -I lib/json/include -I lib/stb -I lib/tinygltf -I lib/tinyxml2 -O2 -rdynamic
UNAME := $(shell uname)
FS_INC =
ifneq ($(UNAME), Darwin)
FS_INC += -lstdc++fs
endif
SRC_DIRS := ZAPD ZAPD/ZRoom ZAPD/ZRoom/Commands ZAPD/Overlays ZAPD/HighLevel ZAPD/OpenFBX
CPP_FILES := $(foreach dir,$(SRC_DIRS),$(wildcard $(dir)/*.cpp))
CPP_FILES += lib/tinyxml2/tinyxml2.cpp
O_FILES := $(CPP_FILES:.cpp=.o)
all: ZAPD.out
clean:
clean:
rm -f $(O_FILES) ZAPD.out
rebuild: clean all
@ -22,4 +30,4 @@ rebuild: clean all
$(CC) $(CFLAGS) -c $< -o $@
ZAPD.out: $(O_FILES)
$(CC) $(CFLAGS) $(O_FILES) -o $@ -lstdc++fs
$(CC) $(CFLAGS) $(O_FILES) -o $@ $(FS_INC)

112
tools/ZAPD/ZAPD/BitConverter.h
View file

@ -1,43 +1,129 @@
#pragma once
#include <limits>
#include <stdint.h>
#include <vector>
class BitConverter
{
public:
static inline int16_t ToInt16BE(uint8_t* data, int offset)
static inline int8_t ToInt8BE(const uint8_t* data, int offset)
{
return (data[offset + 0] << 8) + data[offset + 1];
return (uint8_t)data[offset + 0];
}
static inline int16_t ToInt16BE(std::vector<uint8_t> data, int offset)
static inline int8_t ToInt8BE(const std::vector<uint8_t>& data, int offset)
{
return (data[offset + 0] << 8) + data[offset + 1];
return (uint8_t)data[offset + 0];
}
static inline int32_t ToInt32BE(std::uint8_t* data, int offset)
static inline uint8_t ToUInt8BE(const uint8_t* data, int offset)
{
return (data[offset + 0] << 24) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
return (uint8_t)data[offset + 0];
}
static inline int32_t ToInt32BE(std::vector<uint8_t> data, int offset)
static inline uint8_t ToUInt8BE(const std::vector<uint8_t>& data, int offset)
{
return (data[offset + 0] << 24) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
return (uint8_t)data[offset + 0];
}
static inline uint64_t ToInt64BE(uint8_t* data, int offset)
static inline int16_t ToInt16BE(const uint8_t* data, int offset)
{
return ((uint16_t)data[offset + 0] << 8) + (uint16_t)data[offset + 1];
}
static inline int16_t ToInt16BE(const std::vector<uint8_t>& data, int offset)
{
return ((uint16_t)data[offset + 0] << 8) + (uint16_t)data[offset + 1];
}
static inline uint16_t ToUInt16BE(const uint8_t* data, int offset)
{
return ((uint16_t)data[offset + 0] << 8) + (uint16_t)data[offset + 1];
}
static inline uint16_t ToUInt16BE(const std::vector<uint8_t>& data, int offset)
{
return ((uint16_t)data[offset + 0] << 8) + (uint16_t)data[offset + 1];
}
static inline int32_t ToInt32BE(const uint8_t* data, int offset)
{
return ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) + ((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
}
static inline int32_t ToInt32BE(const std::vector<uint8_t>& data, int offset)
{
return ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) + ((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
}
static inline uint32_t ToUInt32BE(const uint8_t* data, int offset)
{
return ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) + ((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
}
static inline uint32_t ToUInt32BE(const std::vector<uint8_t>& data, int offset)
{
return ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) + ((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
}
static inline int64_t ToInt64BE(const uint8_t* data, int offset)
{
return ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) + ((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) + ((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) + ((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
}
static inline uint64_t ToInt64BE(std::vector<uint8_t> data, int offset)
static inline int64_t ToInt64BE(const std::vector<uint8_t>& data, int offset)
{
return ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) + ((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) + ((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) + ((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
}
static inline float ToFloatBE(std::vector<uint8_t> data, int offset)
static inline uint64_t ToUInt64BE(const uint8_t* data, int offset)
{
return (float)(data[offset + 0] << 24) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
return ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) + ((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) + ((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) + ((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
}
};
static inline uint64_t ToUInt64BE(const std::vector<uint8_t>& data, int offset)
{
return ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) + ((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) + ((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) + ((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
}
static inline float ToFloatBE(const uint8_t* data, int offset)
{
float value;
uint32_t floatData = ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) + ((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
static_assert(sizeof(uint32_t) == sizeof(float));
std::memcpy(&value, &floatData, sizeof(value));
return value;
}
static inline float ToFloatBE(const std::vector<uint8_t>& data, int offset)
{
float value;
uint32_t floatData = ((uint32_t)data[offset + 0] << 24) + ((uint32_t)data[offset + 1] << 16) + ((uint32_t)data[offset + 2] << 8) + (uint32_t)data[offset + 3];
static_assert(sizeof(uint32_t) == sizeof(float));
std::memcpy(&value, &floatData, sizeof(value));
return value;
}
static inline double ToDoubleBE(const uint8_t* data, int offset)
{
double value;
uint64_t floatData = ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) + ((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) + ((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) + ((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
static_assert(sizeof(uint64_t) == sizeof(double));
// Checks if the float format on the platform the ZAPD binary is running on supports the same float format as the object file.
static_assert(std::numeric_limits<float>::is_iec559);
std::memcpy(&value, &floatData, sizeof(value));
return value;
}
static inline double ToDoubleBE(const std::vector<uint8_t>& data, int offset)
{
double value;
uint64_t floatData = ((uint64_t)data[offset + 0] << 56) + ((uint64_t)data[offset + 1] << 48) + ((uint64_t)data[offset + 2] << 40) + ((uint64_t)data[offset + 3] << 32) + ((uint64_t)data[offset + 4] << 24) + ((uint64_t)data[offset + 5] << 16) + ((uint64_t)data[offset + 6] << 8) + ((uint64_t)data[offset + 7]);
static_assert(sizeof(uint64_t) == sizeof(double));
// Checks if the float format on the platform the ZAPD binary is running on supports the same float format as the object file.
static_assert(std::numeric_limits<double>::is_iec559);
std::memcpy(&value, &floatData, sizeof(value));
return value;
}
};

8
tools/ZAPD/ZAPD/Directory.h
View file

@ -3,7 +3,7 @@
#include <string>
#include <iostream>
#if defined(_MSC_VER) || defined(__clang__)
#if __has_include(<filesystem>)
#include <filesystem>
namespace fs = std::filesystem;
#else
@ -19,13 +19,13 @@ public:
return fs::current_path().u8string();
}
static bool Exists(std::string path)
static bool Exists(const std::string& path)
{
return fs::exists(fs::path(path));
}
static void CreateDirectory(std::string path)
static void CreateDirectory(const std::string& path)
{
fs::create_directory(path);
}
};
};

26
tools/ZAPD/ZAPD/File.h
View file

@ -11,23 +11,26 @@
class File
{
public:
static bool Exists(std::string filePath)
static bool Exists(const std::string& filePath)
{
std::ifstream file(filePath, std::ios::in | std::ios::binary | std::ios::ate);
return file.good();
}
static std::vector<uint8_t> ReadAllBytes(std::string filePath)
static std::vector<uint8_t> ReadAllBytes(const std::string& filePath)
{
std::ifstream file(filePath, std::ios::in | std::ios::binary | std::ios::ate);
int fileSize = (int)file.tellg();
file.seekg(0);
char* data = new char[fileSize];
file.read(data, fileSize);
return std::vector<uint8_t>(data, data + fileSize);
std::vector<uint8_t> result = std::vector<uint8_t>(data, data + fileSize);
delete data;
return result;
};
static std::string ReadAllText(std::string filePath)
static std::string ReadAllText(const std::string& filePath)
{
std::ifstream file(filePath, std::ios::in | std::ios::binary | std::ios::ate);
int fileSize = (int)file.tellg();
@ -35,10 +38,13 @@ public:
char* data = new char[fileSize+1];
memset(data, 0, fileSize + 1);
file.read(data, fileSize);
return std::string((const char*)data);
std::string str = std::string((const char*)data);
delete data;
return str;
};
static std::vector<std::string> ReadAllLines(std::string filePath)
static std::vector<std::string> ReadAllLines(const std::string& filePath)
{
std::string text = ReadAllText(filePath);
std::vector<std::string> lines = StringHelper::Split(text, "\n");
@ -46,15 +52,15 @@ public:
return lines;
};
static void WriteAllBytes(std::string filePath, std::vector<uint8_t> data)
static void WriteAllBytes(const std::string& filePath, const std::vector<uint8_t>& data)
{
std::ofstream file(filePath, std::ios::binary);
file.write((char*)data.data(), data.size());
};
static void WriteAllText(std::string filePath, std::string text)
static void WriteAllText(const std::string& filePath, const std::string& text)
{
std::ofstream file(filePath, std::ios::out);
file.write(text.c_str(), text.size());
}
};
};

6
tools/ZAPD/ZAPD/Globals.cpp
View file

@ -19,11 +19,11 @@ Globals::Globals()
segmentRefFiles = map<int, ZFile*>();
genSourceFile = true;
testMode = false;
debugMessages = false;
profile = false;
includeFilePrefix = false;
useExternalResources = true;
lastScene = nullptr;
verbosity = VERBOSITY_SILENT;
}
string Globals::FindSymbolSegRef(int segNumber, uint32_t symbolAddress)
@ -64,7 +64,7 @@ string Globals::FindSymbolSegRef(int segNumber, uint32_t symbolAddress)
return "ERROR";
}
void Globals::ReadConfigFile(string configFilePath)
void Globals::ReadConfigFile(const std::string& configFilePath)
{
XMLDocument doc;
XMLError eResult = doc.LoadFile(configFilePath.c_str());
@ -93,7 +93,7 @@ void Globals::ReadConfigFile(string configFilePath)
}
}
void Globals::GenSymbolMap(string symbolMapPath)
void Globals::GenSymbolMap(const std::string& symbolMapPath)
{
auto symbolLines = File::ReadAllLines(symbolMapPath);

15
tools/ZAPD/ZAPD/Globals.h
View file

@ -1,11 +1,18 @@
#pragma once
#include <map>
#include <string>
#include <vector>
#include "ZFile.h"
#include "ZTexture.h"
#include "ZRoom/ZRoom.h"
typedef enum VerbosityLevel {
VERBOSITY_SILENT,
VERBOSITY_INFO,
VERBOSITY_DEBUG
} VerbosityLevel;
class Globals
{
public:
@ -14,9 +21,9 @@ public:
bool genSourceFile; // Used for extraction
bool useExternalResources;
bool testMode; // Enables certain experimental features
bool debugMessages; // Enables certain printfs
bool profile; // Measure performance of certain operations
bool includeFilePrefix; // Include the file prefix in symbols
VerbosityLevel verbosity; // ZAPD outputs additional information
ZFileMode fileMode;
std::string baseRomPath, inputPath, outputPath, cfgPath;
TextureType texType;
@ -30,8 +37,8 @@ public:
Globals();
std::string FindSymbolSegRef(int segNumber, uint32_t symbolAddress);
void ReadConfigFile(std::string configFilePath);
void GenSymbolMap(std::string symbolMapPath);
void ReadConfigFile(const std::string& configFilePath);
void GenSymbolMap(const std::string& symbolMapPath);
void AddSegment(int segment);
bool HasSegment(int segment);
};
@ -49,4 +56,4 @@ public:
* Segment 13: icon_item_nes_static
*
* I'm thinking a config file could be usable, but I'll have to experiment...
*/
*/

2
tools/ZAPD/ZAPD/HighLevel/HLAnimationIntermediette.h
View file

@ -2,7 +2,7 @@
#include <stdint.h>
#include "../ZAnimation.h"
#include "../tinyxml2.h"
#include <tinyxml2.h>
#include "HLFileIntermediette.h"
/*

8
tools/ZAPD/ZAPD/HighLevel/HLModelIntermediette.cpp
View file

@ -6,10 +6,10 @@
#include "../File.h"
#ifdef USE_ASSIMP
#include "../assimp/Importer.hpp"
#include "../assimp/Exporter.hpp"
#include "../assimp/scene.h"
#include "../assimp/postprocess.h"
#include <assimp/Importer.hpp>
#include <assimp/Exporter.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#endif
using namespace std;

4
tools/ZAPD/ZAPD/HighLevel/HLModelIntermediette.h
View file

@ -7,8 +7,8 @@
#include "HLFileIntermediette.h"
#include "../ZDisplayList.h"
#include "../ZSkeleton.h"
#include "../tinyxml2.h"
#include "../assimp/scene.h"
#include <tinyxml2.h>
#include <assimp/scene.h>
/*
* An intermediette format for models. Goes from FBX<-->Intermediette<-->Display List C Code.

2
tools/ZAPD/ZAPD/HighLevel/HLTexture.cpp
View file

@ -1,6 +1,6 @@
#include "HLTexture.h"
#include "../StringHelper.h"
#include "../stb_image.h"
#include <stb_image.h>
using namespace std;

54
tools/ZAPD/ZAPD/Main.cpp
View file

@ -21,12 +21,12 @@
using namespace tinyxml2;
using namespace std;
bool Parse(string xmlFilePath, string basePath, string outPath, ZFileMode fileMode);
bool Parse(const std::string& xmlFilePath, const std::string& basePath, const std::string& outPath, ZFileMode fileMode);
void BuildAssetTexture(string pngFilePath, TextureType texType, string outPath);
void BuildAssetBlob(string blobFilePath, string outPath);
void BuildAssetModelIntermediette(string mdlPath, string outPath);
void BuildAssetAnimationIntermediette(string animPath, string outPath);
void BuildAssetTexture(const std::string& pngFilePath, TextureType texType, const std::string& outPath);
void BuildAssetBlob(const std::string& blobFilePath, const std::string& outPath);
void BuildAssetModelIntermediette(const std::string& mdlPath, const std::string& outPath);
void BuildAssetAnimationIntermediette(const std::string& animPath, const std::string& outPath);
int NewMain(int argc, char* argv[]);
@ -60,7 +60,6 @@ int main(int argc, char* argv[])
int NewMain(int argc, char* argv[])
{
// Syntax: ZAPD.exe [mode (b/btex/bovl/e)] (Arbritrary Number of Arguments)
printf("ZAPD: Zelda Asset Processor For Decomp\n");
if (argc < 2)
{
@ -130,11 +129,6 @@ int NewMain(int argc, char* argv[])
Globals::Instance->testMode = string(argv[i + 1]) == "1";
i++;
}
else if (arg == "-dm") // Debug Messages
{
Globals::Instance->debugMessages = string(argv[i + 1]) == "1";
i++;
}
else if (arg == "-profile") // Profile
{
Globals::Instance->profile = string(argv[i + 1]) == "1";
@ -179,6 +173,15 @@ int NewMain(int argc, char* argv[])
signal(SIGSEGV, ErrorHandler);
#endif
}
else if (arg == "-v") // Verbose
{
Globals::Instance->verbosity = (VerbosityLevel)strtol(argv[++i], NULL, 16);
}
}
if (Globals::Instance->verbosity >= VERBOSITY_INFO)
{
printf("ZAPD: Zelda Asset Processor For Decomp\n");
}
if (fileMode == ZFileMode::Build || fileMode == ZFileMode::Extract || fileMode == ZFileMode::BuildSourceFile)
@ -211,7 +214,7 @@ int NewMain(int argc, char* argv[])
else if (fileMode == ZFileMode::BuildOverlay)
{
ZOverlay* overlay = ZOverlay::FromBuild(Path::GetDirectoryName(Globals::Instance->inputPath), Path::GetDirectoryName(Globals::Instance->cfgPath));
if (overlay)
File::WriteAllText(Globals::Instance->outputPath, overlay->GetSourceOutputCode(""));
}
@ -219,7 +222,7 @@ int NewMain(int argc, char* argv[])
return 0;
}
bool Parse(string xmlFilePath, string basePath, string outPath, ZFileMode fileMode)
bool Parse(const std::string& xmlFilePath, const std::string& basePath, const std::string& outPath, ZFileMode fileMode)
{
XMLDocument doc;
XMLError eResult = doc.LoadFile(xmlFilePath.c_str());
@ -232,8 +235,6 @@ bool Parse(string xmlFilePath, string basePath, string outPath, ZFileMode fileMo
if (root == nullptr)
return false;
//vector<ZFile*> files = vector<ZFile*>();
for (XMLElement* child = root->FirstChildElement(); child != NULL; child = child->NextSiblingElement())
{
if (string(child->Name()) == "File")
@ -253,15 +254,16 @@ bool Parse(string xmlFilePath, string basePath, string outPath, ZFileMode fileMo
file->ExtractResources(outPath);
}
XMLElement* element = root->FirstChildElement("File");
// All done, free files
for (ZFile* file : Globals::Instance->files)
delete file;
if (element == nullptr)
return false;
Globals::Instance->files.clear();
return true;
}
void BuildAssetTexture(string pngFilePath, TextureType texType, string outPath)
void BuildAssetTexture(const std::string& pngFilePath, TextureType texType, const std::string& outPath)
{
vector<string> split = StringHelper::Split(outPath, "/");
string name = StringHelper::Split(split[split.size() - 1], ".")[0];
@ -275,11 +277,11 @@ void BuildAssetTexture(string pngFilePath, TextureType texType, string outPath)
string src = tex->GetSourceOutputCode(name);
File::WriteAllText(outPath, src);
delete tex;
}
void BuildAssetBlob(string blobFilePath, string outPath)
void BuildAssetBlob(const std::string& blobFilePath, const std::string& outPath)
{
vector<string> split = StringHelper::Split(outPath, "/");
ZBlob* blob = ZBlob::FromFile(blobFilePath);
@ -293,7 +295,7 @@ void BuildAssetBlob(string blobFilePath, string outPath)
delete blob;
}
void BuildAssetModelIntermediette(string mdlPath, string outPath)
void BuildAssetModelIntermediette(const std::string& mdlPath, const std::string& outPath)
{
XMLDocument doc;
XMLError eResult = doc.LoadFile(mdlPath.c_str());
@ -301,13 +303,13 @@ void BuildAssetModelIntermediette(string mdlPath, string outPath)
vector<string> split = StringHelper::Split(outPath, "/");
HLModelIntermediette* mdl = HLModelIntermediette::FromXML(doc.RootElement());
string output = mdl->OutputCode();
File::WriteAllText(outPath, output);
delete mdl;
}
void BuildAssetAnimationIntermediette(string animPath, string outPath)
void BuildAssetAnimationIntermediette(const std::string& animPath, const std::string& outPath)
{
vector<string> split = StringHelper::Split(outPath, "/");
ZFile* file = new ZFile("", split[split.size() - 2]);
@ -320,7 +322,7 @@ void BuildAssetAnimationIntermediette(string animPath, string outPath)
zAnim->GetSourceOutputCode(split[split.size() - 2]);
string output = "";
output += file->declarations[2]->text + "\n";
output += file->declarations[1]->text + "\n";
output += file->declarations[0]->text + "\n";
@ -329,4 +331,4 @@ void BuildAssetAnimationIntermediette(string animPath, string outPath)
delete zAnim;
delete file;
}
}

20
tools/ZAPD/ZAPD/Overlays/ZOverlay.cpp
View file

@ -41,14 +41,14 @@ ZOverlay* ZOverlay::FromBuild(string buildPath, string cfgFolderPath)
vector<RelocationEntry*> dataRelocs;
vector<RelocationEntry*> rodataRelocs;
// get the elf files
vector<elfio*> readers;
for (int i = 1; i < cfgLines.size(); i++)
for (int i = 1; i < cfgLines.size(); i++)
{
string elfPath = buildPath + "/" + cfgLines[i].substr(0, cfgLines[i].size()-2) + ".o";
elfio* reader = new elfio();
if (!reader->load(elfPath))
{
// not all files were compiled
@ -59,7 +59,7 @@ ZOverlay* ZOverlay::FromBuild(string buildPath, string cfgFolderPath)
delete ovl;
return nullptr;
}
readers.push_back(reader);
}
@ -108,7 +108,7 @@ ZOverlay* ZOverlay::FromBuild(string buildPath, string cfgFolderPath)
{
if (curSymShndx != SHN_UNDEF)
break;
if (reader == curReader)
continue;
@ -158,7 +158,7 @@ ZOverlay* ZOverlay::FromBuild(string buildPath, string cfgFolderPath)
}
}
}
// increase section offsets
for (int i = 0; i < sec_num; i++)
{
@ -177,7 +177,7 @@ ZOverlay* ZOverlay::FromBuild(string buildPath, string cfgFolderPath)
ovl->entries.push_back(reloc);
for (auto reloc : rodataRelocs)
ovl->entries.push_back(reloc);
for (auto r: readers)
delete r;
readers.clear();
@ -185,7 +185,7 @@ ZOverlay* ZOverlay::FromBuild(string buildPath, string cfgFolderPath)
return ovl;
}
string ZOverlay::GetSourceOutputCode(std::string prefix)
string ZOverlay::GetSourceOutputCode(const std::string& prefix)
{
string output = "";
@ -226,6 +226,6 @@ SectionType ZOverlay::GetSectionTypeFromStr(string sectionName)
return SectionType::RoData;
else if (sectionName == ".rel.bss" || sectionName == ".bss")
return SectionType::Bss;
return SectionType::ERROR;
}
}

10
tools/ZAPD/ZAPD/Overlays/ZOverlay.h
View file

@ -1,7 +1,7 @@
#pragma once
#include "../ZResource.h"
#include "../tinyxml2.h"
#include <tinyxml2.h>
#include <elfio/elfio.hpp>
enum SectionType
@ -28,9 +28,9 @@ public:
RelocationType relocationType;
int32_t offset;
RelocationEntry(SectionType nSecType, RelocationType nRelType, int32_t nOffset)
RelocationEntry(SectionType nSecType, RelocationType nRelType, int32_t nOffset)
{
sectionType = nSecType;
sectionType = nSecType;
relocationType = nRelType;
offset = nOffset;
}
@ -55,7 +55,7 @@ public:
ZOverlay(std::string nName);
~ZOverlay();
static ZOverlay* FromBuild(std::string buildPath, std::string cfgFolderPath);
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputCode(const std::string& prefix);
private:
std::vector<RelocationEntry*> entries;
@ -64,4 +64,4 @@ private:
static SectionType GetSectionTypeFromStr(std::string sectionName);
//static std::string GetOverlayNameFromElf(ELFIO::elfio& reader);
};
};

12
tools/ZAPD/ZAPD/Path.h
View file

@ -4,7 +4,7 @@
#include <iostream>
#include "StringHelper.h"
#if defined(_MSC_VER) || defined(__clang__)
#if __has_include(<filesystem>)
#include <filesystem>
namespace fs = std::filesystem;
#else
@ -15,18 +15,18 @@ namespace fs = std::experimental::filesystem;
class Path
{
public:
static std::string GetFileNameWithoutExtension(std::string input)
static std::string GetFileNameWithoutExtension(const std::string& input)
{
std::vector<std::string> split = StringHelper::Split(input, "/");
return split[split.size() - 1].substr(0, input.find_last_of("."));
};
static std::string GetFileNameExtension(std::string input)
static std::string GetFileNameExtension(const std::string& input)
{
return input.substr(input.find_last_of("."), input.length());
};
static std::string GetPath(std::string input)
static std::string GetPath(const std::string& input)
{
std::vector<std::string> split = StringHelper::Split(input, "/");
std::string output = "";
@ -40,8 +40,8 @@ public:
return output;
};
static std::string GetDirectoryName(std::string path)
static std::string GetDirectoryName(const std::string& path)
{
return fs::path(path).parent_path().u8string();
};
};
};

22
tools/ZAPD/ZAPD/StringHelper.h
View file

@ -2,13 +2,14 @@
#include <string>
#include <vector>
#include <numeric>
#include <stdarg.h>
#include <string.h>
class StringHelper
{
public:
static std::vector<std::string> Split(std::string s, std::string delimiter)
static std::vector<std::string> Split(std::string s, const std::string& delimiter)
{
std::vector<std::string> result;
@ -28,7 +29,7 @@ public:
return result;
}
static std::string Strip(std::string s, std::string delimiter)
static std::string Strip(std::string s, const std::string& delimiter)
{
size_t pos = 0;
std::string token;
@ -42,17 +43,17 @@ public:
return s;
}
static bool StartsWith(std::string s, std::string input)
static bool StartsWith(const std::string& s, const std::string& input)
{
return s.rfind(input, 0) == 0;
}
static bool Contains(std::string s, std::string input)
static bool Contains(const std::string& s, const std::string& input)
{
return s.find(input) != std::string::npos;
}
static bool EndsWith(std::string s, std::string input)
static bool EndsWith(const std::string& s, const std::string& input)
{
int inputLen = strlen(input.c_str());
return s.rfind(input) == (s.size() - inputLen);
@ -72,4 +73,13 @@ public:
output = buffer;
return output;
}
};
static std::string Implode(std::vector<std::string>& elements, const char* const separator)
{
return std::accumulate(std::begin(elements), std::end(elements), std::string(),
[separator](std::string& ss, std::string& s)
{
return ss.empty() ? s : ss + separator + s;
});
}
};

537
tools/ZAPD/ZAPD/ZAPD.vcxproj
View file

@ -1,269 +1,270 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>15.0</VCProjectVersion>
<ProjectGuid>{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}</ProjectGuid>
<RootNamespace>ZAPD</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
<ProjectName>ZAPD</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<IncludePath>$(ProjectDir)sqlite;$(ProjectDir);$(IncludePath)</IncludePath>
<LibraryPath>$(ProjectDir)Libs;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<IncludePath>$(IncludePath)</IncludePath>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard>
</ClCompile>
<Link>
<Profile>true</Profile>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING;USE_ASSIMP;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</ClCompile>
<Link>
<Profile>true</Profile>
<AdditionalDependencies>assimp-vc142-mt.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpplatest</LanguageStandard>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="Globals.cpp" />
<ClCompile Include="HighLevel\HLAnimationIntermediette.cpp" />
<ClCompile Include="HighLevel\HLModelIntermediette.cpp" />
<ClCompile Include="HighLevel\HLTexture.cpp" />
<ClCompile Include="Main.cpp" />
<ClCompile Include="Overlays\ZOverlay.cpp" />
<ClCompile Include="tinyxml2.cpp" />
<ClCompile Include="ZAnimation.cpp" />
<ClCompile Include="ZBlob.cpp" />
<ClCompile Include="ZCollision.cpp" />
<ClCompile Include="ZCutscene.cpp" />
<ClCompile Include="ZDisplayList.cpp" />
<ClCompile Include="ZFile.cpp" />
<ClCompile Include="ZSkeleton.cpp" />
<ClCompile Include="ZResource.cpp" />
<ClCompile Include="ZRoom\Commands\EndMarker.cpp" />
<ClCompile Include="ZRoom\Commands\SetActorList.cpp" />
<ClCompile Include="ZRoom\Commands\SetAlternateHeaders.cpp" />
<ClCompile Include="ZRoom\Commands\SetCameraSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetCollisionHeader.cpp" />
<ClCompile Include="ZRoom\Commands\SetCutscenes.cpp" />
<ClCompile Include="ZRoom\Commands\SetEchoSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetEntranceList.cpp" />
<ClCompile Include="ZRoom\Commands\SetExitList.cpp" />
<ClCompile Include="ZRoom\Commands\SetLightingSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetLightList.cpp" />
<ClCompile Include="ZRoom\Commands\SetMesh.cpp" />
<ClCompile Include="ZRoom\Commands\SetObjectList.cpp" />
<ClCompile Include="ZRoom\Commands\SetPathways.cpp" />
<ClCompile Include="ZRoom\Commands\SetRoomBehavior.cpp" />
<ClCompile Include="ZRoom\Commands\SetRoomList.cpp" />
<ClCompile Include="ZRoom\Commands\SetSkyboxModifier.cpp" />
<ClCompile Include="ZRoom\Commands\SetSkyboxSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetSoundSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetSpecialObjects.cpp" />
<ClCompile Include="ZRoom\Commands\SetStartPositionList.cpp" />
<ClCompile Include="ZRoom\Commands\SetTimeSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetTransitionActorList.cpp" />
<ClCompile Include="ZRoom\Commands\SetWind.cpp" />
<ClCompile Include="ZRoom\Commands\Unused09.cpp" />
<ClCompile Include="ZRoom\Commands\ZRoomCommandUnk.cpp" />
<ClCompile Include="ZRoom\ZRoom.cpp" />
<ClCompile Include="ZRoom\ZRoomCommand.cpp" />
<ClCompile Include="ZTexture.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="BitConverter.h" />
<ClInclude Include="Directory.h" />
<ClInclude Include="elfio\elfio.hpp" />
<ClInclude Include="elfio\elfio_dump.hpp" />
<ClInclude Include="elfio\elfio_dynamic.hpp" />
<ClInclude Include="elfio\elfio_header.hpp" />
<ClInclude Include="elfio\elfio_note.hpp" />
<ClInclude Include="elfio\elfio_relocation.hpp" />
<ClInclude Include="elfio\elfio_section.hpp" />
<ClInclude Include="elfio\elfio_segment.hpp" />
<ClInclude Include="elfio\elfio_strings.hpp" />
<ClInclude Include="elfio\elfio_symbols.hpp" />
<ClInclude Include="elfio\elfio_utils.hpp" />
<ClInclude Include="elfio\elf_types.hpp" />
<ClInclude Include="File.h" />
<ClInclude Include="Globals.h" />
<ClInclude Include="HighLevel\HLAnimation.h" />
<ClInclude Include="HighLevel\HLAnimationIntermediette.h" />
<ClInclude Include="HighLevel\HLFileIntermediette.h" />
<ClInclude Include="HighLevel\HLModelIntermediette.h" />
<ClInclude Include="HighLevel\HLTexture.h" />
<ClInclude Include="json.hpp" />
<ClInclude Include="OpenFBX\miniz.h" />
<ClInclude Include="OpenFBX\ofbx.h" />
<ClInclude Include="Overlays\ZOverlay.h" />
<ClInclude Include="Path.h" />
<ClInclude Include="sqlite_orm.h" />
<ClInclude Include="stb_image.h" />
<ClInclude Include="stb_image_write.h" />
<ClInclude Include="StringHelper.h" />
<ClInclude Include="tinyxml2.h" />
<ClInclude Include="tiny_gltf.h" />
<ClInclude Include="Vec3s.h" />
<ClInclude Include="ZAnimation.h" />
<ClInclude Include="ZBlob.h" />
<ClInclude Include="ZCollision.h" />
<ClInclude Include="ZCutscene.h" />
<ClInclude Include="ZDisplayList.h" />
<ClInclude Include="ZFile.h" />
<ClInclude Include="ZSkeleton.h" />
<ClInclude Include="ZResource.h" />
<ClInclude Include="ZRoom\ActorList.h" />
<ClInclude Include="ZRoom\Commands\EndMarker.h" />
<ClInclude Include="ZRoom\Commands\SetActorList.h" />
<ClInclude Include="ZRoom\Commands\SetAlternateHeaders.h" />
<ClInclude Include="ZRoom\Commands\SetCameraSettings.h" />
<ClInclude Include="ZRoom\Commands\SetCollisionHeader.h" />
<ClInclude Include="ZRoom\Commands\SetCutscenes.h" />
<ClInclude Include="ZRoom\Commands\SetEchoSettings.h" />
<ClInclude Include="ZRoom\Commands\SetEntranceList.h" />
<ClInclude Include="ZRoom\Commands\SetExitList.h" />
<ClInclude Include="ZRoom\Commands\SetLightingSettings.h" />
<ClInclude Include="ZRoom\Commands\SetLightList.h" />
<ClInclude Include="ZRoom\Commands\SetMesh.h" />
<ClInclude Include="ZRoom\Commands\SetObjectList.h" />
<ClInclude Include="ZRoom\Commands\SetPathways.h" />
<ClInclude Include="ZRoom\Commands\SetRoomBehavior.h" />
<ClInclude Include="ZRoom\Commands\SetRoomList.h" />
<ClInclude Include="ZRoom\Commands\SetSkyboxModifier.h" />
<ClInclude Include="ZRoom\Commands\SetSkyboxSettings.h" />
<ClInclude Include="ZRoom\Commands\SetSoundSettings.h" />
<ClInclude Include="ZRoom\Commands\SetSpecialObjects.h" />
<ClInclude Include="ZRoom\Commands\SetStartPositionList.h" />
<ClInclude Include="ZRoom\Commands\SetTimeSettings.h" />
<ClInclude Include="ZRoom\Commands\SetTransitionActorList.h" />
<ClInclude Include="ZRoom\Commands\SetWind.h" />
<ClInclude Include="ZRoom\Commands\Unused09.h" />
<ClInclude Include="ZRoom\Commands\ZRoomCommandUnk.h" />
<ClInclude Include="ZRoom\ObjectList.h" />
<ClInclude Include="ZRoom\ZRoom.h" />
<ClInclude Include="ZRoom\ZRoomCommand.h" />
<ClInclude Include="ZTexture.h" />
</ItemGroup>
<ItemGroup>
<Text Include="..\SymbolMap_OoTMqDbg.txt">
<DeploymentContent>true</DeploymentContent>
</Text>
</ItemGroup>
<ItemGroup>
<CopyFileToFolders Include="Libs\assimp-vc142-mt.dll">
<FileType>Document</FileType>
</CopyFileToFolders>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets" />
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>15.0</VCProjectVersion>
<ProjectGuid>{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}</ProjectGuid>
<RootNamespace>ZAPD</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
<ProjectName>ZAPD</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<IncludePath>$(SolutionDir)lib\tinyxml2;$(SolutionDir)lib\elfio;$(SolutionDir)lib\assimp\include;$(SolutionDir)lib\stb;$(ProjectDir);$(IncludePath)</IncludePath>
<LibraryPath>$(SolutionDir)lib\assimp-built;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<IncludePath>$(IncludePath)</IncludePath>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard>
</ClCompile>
<Link>
<Profile>true</Profile>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING;USE_ASSIMP;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
</ClCompile>
<Link>
<Profile>true</Profile>
<AdditionalDependencies>assimp-vc142-mt.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpplatest</LanguageStandard>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\lib\tinyxml2\tinyxml2.cpp" />
<ClCompile Include="Globals.cpp" />
<ClCompile Include="HighLevel\HLAnimationIntermediette.cpp" />
<ClCompile Include="HighLevel\HLModelIntermediette.cpp" />
<ClCompile Include="HighLevel\HLTexture.cpp" />
<ClCompile Include="Main.cpp" />
<ClCompile Include="Overlays\ZOverlay.cpp" />
<ClCompile Include="ZScalar.cpp" />
<ClCompile Include="ZAnimation.cpp" />
<ClCompile Include="ZBlob.cpp" />
<ClCompile Include="ZCollision.cpp" />
<ClCompile Include="ZCutscene.cpp" />
<ClCompile Include="ZDisplayList.cpp" />
<ClCompile Include="ZFile.cpp" />
<ClCompile Include="ZSkeleton.cpp" />
<ClCompile Include="ZResource.cpp" />
<ClCompile Include="ZRoom\Commands\EndMarker.cpp" />
<ClCompile Include="ZRoom\Commands\SetActorList.cpp" />
<ClCompile Include="ZRoom\Commands\SetAlternateHeaders.cpp" />
<ClCompile Include="ZRoom\Commands\SetCameraSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetCollisionHeader.cpp" />
<ClCompile Include="ZRoom\Commands\SetCutscenes.cpp" />
<ClCompile Include="ZRoom\Commands\SetEchoSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetEntranceList.cpp" />
<ClCompile Include="ZRoom\Commands\SetExitList.cpp" />
<ClCompile Include="ZRoom\Commands\SetLightingSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetLightList.cpp" />
<ClCompile Include="ZRoom\Commands\SetMesh.cpp" />
<ClCompile Include="ZRoom\Commands\SetObjectList.cpp" />
<ClCompile Include="ZRoom\Commands\SetPathways.cpp" />
<ClCompile Include="ZRoom\Commands\SetRoomBehavior.cpp" />
<ClCompile Include="ZRoom\Commands\SetRoomList.cpp" />
<ClCompile Include="ZRoom\Commands\SetSkyboxModifier.cpp" />
<ClCompile Include="ZRoom\Commands\SetSkyboxSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetSoundSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetSpecialObjects.cpp" />
<ClCompile Include="ZRoom\Commands\SetStartPositionList.cpp" />
<ClCompile Include="ZRoom\Commands\SetTimeSettings.cpp" />
<ClCompile Include="ZRoom\Commands\SetTransitionActorList.cpp" />
<ClCompile Include="ZRoom\Commands\SetWind.cpp" />
<ClCompile Include="ZRoom\Commands\Unused09.cpp" />
<ClCompile Include="ZRoom\Commands\ZRoomCommandUnk.cpp" />
<ClCompile Include="ZRoom\ZRoom.cpp" />
<ClCompile Include="ZRoom\ZRoomCommand.cpp" />
<ClCompile Include="ZTexture.cpp" />
<ClCompile Include="ZVector.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\lib\elfio\elfio\elfio.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_dump.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_dynamic.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_header.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_note.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_relocation.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_section.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_segment.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_strings.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_symbols.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elfio_utils.hpp" />
<ClInclude Include="..\lib\elfio\elfio\elf_types.hpp" />
<ClInclude Include="..\lib\json\include\nlohmann\json.hpp" />
<ClInclude Include="..\lib\stb\stb_image.h" />
<ClInclude Include="..\lib\stb\stb_image_write.h" />
<ClInclude Include="..\lib\stb\tinyxml2.h" />
<ClInclude Include="..\lib\tinygtlf\tiny_gltf.h" />
<ClInclude Include="BitConverter.h" />
<ClInclude Include="Directory.h" />
<ClInclude Include="File.h" />
<ClInclude Include="Globals.h" />
<ClInclude Include="HighLevel\HLAnimation.h" />
<ClInclude Include="HighLevel\HLAnimationIntermediette.h" />
<ClInclude Include="HighLevel\HLFileIntermediette.h" />
<ClInclude Include="HighLevel\HLModelIntermediette.h" />
<ClInclude Include="HighLevel\HLTexture.h" />
<ClInclude Include="Overlays\ZOverlay.h" />
<ClInclude Include="Path.h" />
<ClInclude Include="StringHelper.h" />
<ClInclude Include="Vec3s.h" />
<ClInclude Include="ZAnimation.h" />
<ClInclude Include="ZBlob.h" />
<ClInclude Include="ZCollision.h" />
<ClInclude Include="ZCutscene.h" />
<ClInclude Include="ZDisplayList.h" />
<ClInclude Include="ZFile.h" />
<ClInclude Include="ZScalar.h" />
<ClInclude Include="ZSkeleton.h" />
<ClInclude Include="ZResource.h" />
<ClInclude Include="ZRoom\ActorList.h" />
<ClInclude Include="ZRoom\Commands\EndMarker.h" />
<ClInclude Include="ZRoom\Commands\SetActorList.h" />
<ClInclude Include="ZRoom\Commands\SetAlternateHeaders.h" />
<ClInclude Include="ZRoom\Commands\SetCameraSettings.h" />
<ClInclude Include="ZRoom\Commands\SetCollisionHeader.h" />
<ClInclude Include="ZRoom\Commands\SetCutscenes.h" />
<ClInclude Include="ZRoom\Commands\SetEchoSettings.h" />
<ClInclude Include="ZRoom\Commands\SetEntranceList.h" />
<ClInclude Include="ZRoom\Commands\SetExitList.h" />
<ClInclude Include="ZRoom\Commands\SetLightingSettings.h" />
<ClInclude Include="ZRoom\Commands\SetLightList.h" />
<ClInclude Include="ZRoom\Commands\SetMesh.h" />
<ClInclude Include="ZRoom\Commands\SetObjectList.h" />
<ClInclude Include="ZRoom\Commands\SetPathways.h" />
<ClInclude Include="ZRoom\Commands\SetRoomBehavior.h" />
<ClInclude Include="ZRoom\Commands\SetRoomList.h" />
<ClInclude Include="ZRoom\Commands\SetSkyboxModifier.h" />
<ClInclude Include="ZRoom\Commands\SetSkyboxSettings.h" />
<ClInclude Include="ZRoom\Commands\SetSoundSettings.h" />
<ClInclude Include="ZRoom\Commands\SetSpecialObjects.h" />
<ClInclude Include="ZRoom\Commands\SetStartPositionList.h" />
<ClInclude Include="ZRoom\Commands\SetTimeSettings.h" />
<ClInclude Include="ZRoom\Commands\SetTransitionActorList.h" />
<ClInclude Include="ZRoom\Commands\SetWind.h" />
<ClInclude Include="ZRoom\Commands\Unused09.h" />
<ClInclude Include="ZRoom\Commands\ZRoomCommandUnk.h" />
<ClInclude Include="ZRoom\ObjectList.h" />
<ClInclude Include="ZRoom\ZRoom.h" />
<ClInclude Include="ZRoom\ZRoomCommand.h" />
<ClInclude Include="ZTexture.h" />
<ClInclude Include="ZVector.h" />
</ItemGroup>
<ItemGroup>
<Text Include="..\SymbolMap_OoTMqDbg.txt">
<DeploymentContent>true</DeploymentContent>
</Text>
</ItemGroup>
<ItemGroup>
<CopyFileToFolders Include="..\lib\assimp-built\assimp-vc142-mt.dll">
<FileType>Document</FileType>
</CopyFileToFolders>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets" />
</Project>

66
tools/ZAPD/ZAPD/ZAPD.vcxproj.filters
View file

@ -13,9 +13,6 @@
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="Header Files\OpenFBX">
<UniqueIdentifier>{c5d86b0a-fff0-47cf-83af-807dd8267ad1}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Libraries">
<UniqueIdentifier>{02148456-5068-4613-8478-f10addc58e70}</UniqueIdentifier>
</Filter>
@ -144,7 +141,7 @@
<ClCompile Include="ZRoom\Commands\SetCutscenes.cpp">
<Filter>Source Files\Z64\ZRoom\Commands</Filter>
</ClCompile>
<ClCompile Include="tinyxml2.cpp">
<ClCompile Include="..\lib\tinyxml2\tinyxml2.cpp">
<Filter>Source Files\Libraries</Filter>
</ClCompile>
<ClCompile Include="ZAnimation.cpp">
@ -192,6 +189,12 @@
<ClCompile Include="ZCollision.cpp">
<Filter>Source Files\Z64</Filter>
</ClCompile>
<ClCompile Include="ZScalar.cpp">
<Filter>Source Files\Z64</Filter>
</ClCompile>
<ClCompile Include="ZVector.cpp">
<Filter>Source Files\Z64</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Path.h">
@ -248,40 +251,40 @@
<ClInclude Include="ZRoom\Commands\SetStartPositionList.h">
<Filter>Header Files\Z64\ZRoom\Commands</Filter>
</ClInclude>
<ClInclude Include="elfio\elf_types.hpp">
<ClInclude Include="..\lib\elfio\elfio\elf_types.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_dump.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_dump.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_dynamic.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_dynamic.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_header.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_header.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_note.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_note.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_relocation.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_relocation.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_section.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_section.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_segment.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_segment.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_strings.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_strings.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_symbols.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_symbols.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="elfio\elfio_utils.hpp">
<ClInclude Include="..\lib\elfio\elfio\elfio_utils.hpp">
<Filter>Header Files\Libraries\elfio</Filter>
</ClInclude>
<ClInclude Include="StringHelper.h">
@ -335,25 +338,16 @@
<ClInclude Include="Vec3s.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="OpenFBX\ofbx.h">
<Filter>Header Files\OpenFBX</Filter>
</ClInclude>
<ClInclude Include="OpenFBX\miniz.h">
<Filter>Header Files\OpenFBX</Filter>
</ClInclude>
<ClInclude Include="json.hpp">
<ClInclude Include="..\lib\json\include\nlohmann\json.hpp">
<Filter>Header Files\Libraries</Filter>
</ClInclude>
<ClInclude Include="stb_image.h">
<ClInclude Include="..\lib\stb\stb_image.h">
<Filter>Header Files\Libraries</Filter>
</ClInclude>
<ClInclude Include="stb_image_write.h">
<ClInclude Include="..\lib\stb\stb_image_write.h">
<Filter>Header Files\Libraries</Filter>
</ClInclude>
<ClInclude Include="tiny_gltf.h">
<Filter>Header Files\Libraries</Filter>
</ClInclude>
<ClInclude Include="tinyxml2.h">
<ClInclude Include="..\lib\tinygtlf\tiny_gltf.h">
<Filter>Header Files\Libraries</Filter>
</ClInclude>
<ClInclude Include="Overlays\ZOverlay.h">
@ -404,12 +398,18 @@
<ClInclude Include="ZRoom\Commands\ZRoomCommandUnk.h">
<Filter>Header Files\Z64\ZRoom\Commands</Filter>
</ClInclude>
<ClInclude Include="sqlite_orm.h">
<Filter>Header Files\Libraries</Filter>
</ClInclude>
<ClInclude Include="ZCollision.h">
<Filter>Header Files\Z64</Filter>
</ClInclude>
<ClInclude Include="ZScalar.h">
<Filter>Header Files\Z64</Filter>
</ClInclude>
<ClInclude Include="ZVector.h">
<Filter>Header Files\Z64</Filter>
</ClInclude>
<ClInclude Include="..\lib\stb\tinyxml2.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<Text Include="..\SymbolMap_OoTMqDbg.txt">
@ -417,7 +417,7 @@
</Text>
</ItemGroup>
<ItemGroup>
<CopyFileToFolders Include="Libs\assimp-vc142-mt.dll">
<CopyFileToFolders Include="..\lib\assimp-built\assimp-vc142-mt.dll">
<Filter>Resource Files</Filter>
</CopyFileToFolders>
</ItemGroup>

27
tools/ZAPD/ZAPD/ZAnimation.cpp
View file

@ -1,4 +1,5 @@
#include "ZAnimation.h"
#include <utility>
#include "ZFile.h"
#include "BitConverter.h"
#include "StringHelper.h"
@ -15,13 +16,13 @@ ZAnimation::ZAnimation() : ZResource()
void ZAnimation::ParseRawData()
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
// Read the header
frameCount = BitConverter::ToInt16BE(data, rawDataIndex + 0);
}
void ZAnimation::Save(string outFolder)
void ZAnimation::Save(const std::string& outFolder)
{
if (Globals::Instance->testMode)
{
@ -40,7 +41,7 @@ void ZAnimation::ParseXML(tinyxml2::XMLElement* reader)
name = reader->Attribute("Name");
}
string ZAnimation::GetSourceOutputCode(string prefix)
string ZAnimation::GetSourceOutputCode(const std::string& prefix)
{
return "";
}
@ -52,7 +53,7 @@ ZNormalAnimation::ZNormalAnimation() : ZAnimation()
limit = 0;
}
std::string ZNormalAnimation::GetSourceOutputCode(std::string prefix)
std::string ZNormalAnimation::GetSourceOutputCode(const std::string& prefix)
{
if (parent != nullptr)
{
@ -61,7 +62,7 @@ std::string ZNormalAnimation::GetSourceOutputCode(std::string prefix)
string headerStr = StringHelper::Sprintf("{ %i }, %sFrameData, %sJointIndices, %i",
frameCount, defaultPrefix.c_str(), defaultPrefix.c_str(), limit);
parent->declarations[rawDataIndex] = new Declaration(DeclarationAlignment::None, 16, "AnimationHeader", StringHelper::Sprintf("%s", name.c_str()), false, headerStr);
parent->AddDeclaration(rawDataIndex, DeclarationAlignment::None, 16, "AnimationHeader", StringHelper::Sprintf("%s", name.c_str()), headerStr);
string indicesStr = "";
string valuesStr = " ";
@ -99,10 +100,10 @@ int ZNormalAnimation::GetRawDataSize()
return 16;
}
ZNormalAnimation* ZNormalAnimation::ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath)
ZNormalAnimation* ZNormalAnimation::ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, const std::string& nRelPath)
{
ZNormalAnimation* anim = new ZNormalAnimation();
anim->rawData = nRawData;
anim->rawData = std::move(nRawData);
anim->rawDataIndex = rawDataIndex;
anim->ParseXML(reader);
anim->ParseRawData();
@ -114,7 +115,7 @@ void ZNormalAnimation::ParseRawData()
{
ZAnimation::ParseRawData();
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
rotationValuesSeg = BitConverter::ToInt32BE(data, rawDataIndex + 4) & 0x00FFFFFF;
rotationIndicesSeg = BitConverter::ToInt32BE(data, rawDataIndex + 8) & 0x00FFFFFF;
@ -144,14 +145,14 @@ ZLinkAnimation::ZLinkAnimation() : ZAnimation()
segmentAddress = 0;
}
std::string ZLinkAnimation::GetSourceOutputCode(std::string prefix)
std::string ZLinkAnimation::GetSourceOutputCode(const std::string& prefix)
{
if (parent != nullptr)
{
string segSymbol = segmentAddress == 0 ? "NULL" : parent->GetDeclarationName(segmentAddress, StringHelper::Sprintf("%sSeg%06X", name.c_str(), segmentAddress));
string headerStr = StringHelper::Sprintf("{ %i }, 0x%08X",
frameCount, segmentAddress);
parent->declarations[rawDataIndex] = new Declaration(DeclarationAlignment::None, 16, "LinkAnimationHeader", StringHelper::Sprintf("%s", name.c_str()), false, headerStr);
parent->AddDeclaration(rawDataIndex, DeclarationAlignment::None, 16, "LinkAnimationHeader", StringHelper::Sprintf("%s", name.c_str()), headerStr);
}
return "";
@ -162,10 +163,10 @@ int ZLinkAnimation::GetRawDataSize()
return 8;
}
ZLinkAnimation* ZLinkAnimation::ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath)
ZLinkAnimation* ZLinkAnimation::ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, const std::string& nRelPath)
{
ZLinkAnimation* anim = new ZLinkAnimation();
anim->rawData = nRawData;
anim->rawData = std::move(nRawData);
anim->rawDataIndex = rawDataIndex;
anim->ParseXML(reader);
anim->ParseRawData();
@ -177,7 +178,7 @@ void ZLinkAnimation::ParseRawData()
{
ZAnimation::ParseRawData();
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
//segmentAddress = SEG2FILESPACE(BitConverter::ToInt32BE(data, rawDataIndex + 4));
segmentAddress = (BitConverter::ToInt32BE(data, rawDataIndex + 4));

18
tools/ZAPD/ZAPD/ZAnimation.h
View file

@ -20,14 +20,14 @@ class ZAnimation : public ZResource
public:
int16_t frameCount;
ZAnimation();
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputCode(const std::string& prefix);
protected:
virtual void ParseRawData();
void Save(std::string outFolder);
void Save(const std::string& outFolder);
void ParseXML(tinyxml2::XMLElement* reader);
};
@ -39,13 +39,13 @@ public:
uint32_t rotationValuesSeg;
uint32_t rotationIndicesSeg;
int16_t limit;
ZNormalAnimation();
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputCode(const std::string& prefix);
virtual int GetRawDataSize();
static ZNormalAnimation* ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath);
static ZNormalAnimation* ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, const std::string& nRelPath);
protected:
virtual void ParseRawData();
@ -58,11 +58,11 @@ public:
ZLinkAnimation();
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputCode(const std::string& prefix);
virtual int GetRawDataSize();
static ZLinkAnimation* ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath);
static ZLinkAnimation* ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, const std::string& nRelPath);
protected:
virtual void ParseRawData();
};
};

18
tools/ZAPD/ZAPD/ZBlob.cpp
View file

@ -13,14 +13,14 @@ ZBlob::ZBlob() : ZResource()
}
ZBlob::ZBlob(std::vector<uint8_t> nRawData, int nRawDataIndex, int size, std::string nName) : ZBlob()
ZBlob::ZBlob(const std::vector<uint8_t>& nRawData, int nRawDataIndex, int size, std::string nName) : ZBlob()
{
rawDataIndex = nRawDataIndex;
rawData = vector<uint8_t>(nRawData.data() + rawDataIndex, nRawData.data() + rawDataIndex + size);
name = nName;
name = std::move(nName);
}
ZBlob* ZBlob::ExtractFromXML(XMLElement* reader, vector<uint8_t> nRawData, int nRawDataIndex, string nRelPath)
ZBlob* ZBlob::ExtractFromXML(XMLElement* reader, const vector<uint8_t>& nRawData, int nRawDataIndex, string nRelPath)
{
ZBlob* blob = new ZBlob();
@ -29,12 +29,12 @@ ZBlob* ZBlob::ExtractFromXML(XMLElement* reader, vector<uint8_t> nRawData, int n
blob->ParseXML(reader);
int size = strtol(reader->Attribute("Size"), NULL, 16);
blob->rawData = vector<uint8_t>(nRawData.data() + blob->rawDataIndex, nRawData.data() + blob->rawDataIndex + size);
blob->relativePath = nRelPath;
blob->relativePath = std::move(nRelPath);
return blob;
}
ZBlob* ZBlob::BuildFromXML(XMLElement* reader, string inFolder, bool readFile)
ZBlob* ZBlob::BuildFromXML(XMLElement* reader, const std::string& inFolder, bool readFile)
{
ZBlob* blob = new ZBlob();
@ -46,7 +46,7 @@ ZBlob* ZBlob::BuildFromXML(XMLElement* reader, string inFolder, bool readFile)
return blob;
}
ZBlob* ZBlob::FromFile(string filePath)
ZBlob* ZBlob::FromFile(const std::string& filePath)
{
int comp;
ZBlob* blob = new ZBlob();
@ -56,7 +56,7 @@ ZBlob* ZBlob::FromFile(string filePath)
return blob;
}
string ZBlob::GetSourceOutputCode(std::string prefix)
string ZBlob::GetSourceOutputCode(const std::string& prefix)
{
sourceOutput = "";
//sourceOutput += StringHelper::Sprintf("u8 %s_%s[] = \n{\n", prefix.c_str(), name.c_str());
@ -77,12 +77,12 @@ string ZBlob::GetSourceOutputCode(std::string prefix)
return sourceOutput;
}
string ZBlob::GetSourceOutputHeader(std::string prefix)
string ZBlob::GetSourceOutputHeader(const std::string& prefix)
{
return StringHelper::Sprintf("extern u8 %s[];\n", name.c_str());
}
void ZBlob::Save(string outFolder)
void ZBlob::Save(const std::string& outFolder)
{
//printf("NAME = %s\n", name.c_str());
File::WriteAllBytes(outFolder + "/" + name + ".bin", rawData);

16
tools/ZAPD/ZAPD/ZBlob.h
View file

@ -6,18 +6,18 @@
class ZBlob : public ZResource
{
public:
ZBlob(std::vector<uint8_t> nRawData, int rawDataIndex, int size, std::string nName);
ZBlob(const std::vector<uint8_t>& nRawData, int rawDataIndex, int size, std::string nName);
static ZBlob* ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath);
static ZBlob* BuildFromXML(tinyxml2::XMLElement* reader, std::string inFolder, bool readFile);
static ZBlob* FromFile(std::string filePath);
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputHeader(std::string prefix);
void Save(std::string outFolder);
static ZBlob* ExtractFromXML(tinyxml2::XMLElement* reader, const std::vector<uint8_t>& nRawData, int rawDataIndex, std::string nRelPath);
static ZBlob* BuildFromXML(tinyxml2::XMLElement* reader, const std::string& inFolder, bool readFile);
static ZBlob* FromFile(const std::string& filePath);
std::string GetSourceOutputCode(const std::string& prefix);
std::string GetSourceOutputHeader(const std::string& prefix);
void Save(const std::string& outFolder);
bool IsExternalResource();
std::string GetExternalExtension();
ZResourceType GetResourceType();
private:
ZBlob();
};
};

59
tools/ZAPD/ZAPD/ZCollision.cpp
View file

@ -11,9 +11,9 @@ ZCollisionHeader::ZCollisionHeader()
}
ZCollisionHeader::ZCollisionHeader(ZFile* parent, std::string prefix, std::vector<uint8_t> rawData, int rawDataIndex)
ZCollisionHeader::ZCollisionHeader(ZFile* parent, const std::string& prefix, const std::vector<uint8_t>& rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
absMinX = BitConverter::ToInt16BE(data, rawDataIndex + 0);
absMinY = BitConverter::ToInt16BE(data, rawDataIndex + 2);
@ -53,14 +53,14 @@ ZCollisionHeader::ZCollisionHeader(ZFile* parent, std::string prefix, std::vecto
//if (highestPolyType > 0)
{
for (int i = 0; i < highestPolyType + 1; i++)
polygonTypes.push_back(BitConverter::ToInt64BE(data, polyTypeDefSegmentOffset + (i * 8)));
polygonTypes.push_back(BitConverter::ToUInt64BE(data, polyTypeDefSegmentOffset + (i * 8)));
}
//else
//{
//int polyTypesSize = abs(polyTypeDefSegmentOffset - camDataSegmentOffset) / 8;
//for (int i = 0; i < polyTypesSize; i++)
//polygonTypes.push_back(BitConverter::ToInt64BE(data, polyTypeDefSegmentOffset + (i * 8)));
//polygonTypes.push_back(BitConverter::ToUInt64BE(data, polyTypeDefSegmentOffset + (i * 8)));
//}
if (camDataSegmentOffset != 0)
@ -82,8 +82,8 @@ ZCollisionHeader::ZCollisionHeader(ZFile* parent, std::string prefix, std::vecto
}
if (waterBoxSegmentOffset != 0)
parent->declarations[waterBoxSegmentOffset] = new Declaration(DeclarationAlignment::None, 16 * waterBoxes.size(), "WaterBox",
StringHelper::Sprintf("%s_waterBoxes_%08X", prefix.c_str(), waterBoxSegmentOffset), true, declaration);
parent->AddDeclarationArray(waterBoxSegmentOffset, DeclarationAlignment::None, 16 * waterBoxes.size(), "WaterBox",
StringHelper::Sprintf("%s_waterBoxes_%08X", prefix.c_str(), waterBoxSegmentOffset), 0, declaration);
if (polygons.size() > 0)
{
@ -98,8 +98,7 @@ ZCollisionHeader::ZCollisionHeader(ZFile* parent, std::string prefix, std::vecto
}
if (polySegmentOffset != 0) {
parent->declarations[polySegmentOffset] = new Declaration(DeclarationAlignment::None, polygons.size() * 16, "RoomPoly", // TODO: Change this to CollisionPoly once the struct has been updated
StringHelper::Sprintf("%s_polygons_%08X", prefix.c_str(), polySegmentOffset), true, declaration);
parent->AddDeclarationArray(polySegmentOffset, DeclarationAlignment::None, polygons.size() * 16, "CollisionPoly", StringHelper::Sprintf("%s_polygons_%08X", prefix.c_str(), polySegmentOffset), 0, declaration);
}
}
@ -111,8 +110,8 @@ ZCollisionHeader::ZCollisionHeader(ZFile* parent, std::string prefix, std::vecto
}
if (polyTypeDefSegmentOffset != 0)
parent->declarations[polyTypeDefSegmentOffset] = new Declaration(DeclarationAlignment::None, polygonTypes.size() * 8,
"u32", StringHelper::Sprintf("%s_polygonTypes_%08X", prefix.c_str(), polyTypeDefSegmentOffset), true, declaration);
parent->AddDeclarationArray(polyTypeDefSegmentOffset, DeclarationAlignment::None, polygonTypes.size() * 8,
"u32", StringHelper::Sprintf("%s_polygonTypes_%08X", prefix.c_str(), polyTypeDefSegmentOffset), 0, declaration);
declaration = "";
@ -128,8 +127,8 @@ ZCollisionHeader::ZCollisionHeader(ZFile* parent, std::string prefix, std::vecto
}
if (vtxSegmentOffset != 0)
parent->declarations[vtxSegmentOffset] = new Declaration(DeclarationAlignment::None, vertices.size() * 6,
"Vec3s", StringHelper::Sprintf("%s_vtx_%08X", prefix.c_str(), vtxSegmentOffset), true, declaration);
parent->AddDeclarationArray(vtxSegmentOffset, DeclarationAlignment::None, vertices.size() * 6,
"Vec3s", StringHelper::Sprintf("%s_vtx_%08X", prefix.c_str(), vtxSegmentOffset), 0, declaration);
declaration = "";
}
@ -149,26 +148,34 @@ ZCollisionHeader::ZCollisionHeader(ZFile* parent, std::string prefix, std::vecto
prefix.c_str(), polySegmentOffset, prefix.c_str(), polyTypeDefSegmentOffset,
prefix.c_str(), camDataSegmentOffset, numWaterBoxes, waterBoxStr);
/*parent->AddDeclaration(rawDataIndex, DeclarationAlignment::None, DeclarationPadding::Pad16, 44, "CollisionHeader",
StringHelper::Sprintf("%s_collisionHeader_%08X", prefix.c_str(), rawDataIndex), declaration);*/
parent->AddDeclaration(rawDataIndex, DeclarationAlignment::None, DeclarationPadding::Pad16, 44, "CollisionHeader",
StringHelper::Sprintf("%s", prefix.c_str(), rawDataIndex), declaration);
}
ZCollisionHeader::~ZCollisionHeader()
{
for (VertexEntry* vtx : vertices)
delete vtx;
for (PolygonEntry* poly : polygons)
delete poly;
for (WaterBoxHeader* waterBox : waterBoxes)
delete waterBox;
}
ZCollisionHeader* ZCollisionHeader::ExtractFromXML(tinyxml2::XMLElement* reader, vector<uint8_t> nRawData, int rawDataIndex)
{
ZCollisionHeader* col = new ZCollisionHeader();
return col;
}
PolygonEntry::PolygonEntry(std::vector<uint8_t> rawData, int rawDataIndex)
PolygonEntry::PolygonEntry(const std::vector<uint8_t>& rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
type = BitConverter::ToInt16BE(data, rawDataIndex + 0);
vtxA = BitConverter::ToInt16BE(data, rawDataIndex + 2);
@ -180,18 +187,18 @@ PolygonEntry::PolygonEntry(std::vector<uint8_t> rawData, int rawDataIndex)
d = BitConverter::ToInt16BE(data, rawDataIndex + 14);
}
VertexEntry::VertexEntry(std::vector<uint8_t> rawData, int rawDataIndex)
VertexEntry::VertexEntry(const std::vector<uint8_t>& rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
x = BitConverter::ToInt16BE(data, rawDataIndex + 0);
y = BitConverter::ToInt16BE(data, rawDataIndex + 2);
z = BitConverter::ToInt16BE(data, rawDataIndex + 4);
}
WaterBoxHeader::WaterBoxHeader(std::vector<uint8_t> rawData, int rawDataIndex)
WaterBoxHeader::WaterBoxHeader(const std::vector<uint8_t>& rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
xMin = BitConverter::ToInt16BE(data, rawDataIndex + 0);
ySurface = BitConverter::ToInt16BE(data, rawDataIndex + 2);
@ -201,7 +208,7 @@ WaterBoxHeader::WaterBoxHeader(std::vector<uint8_t> rawData, int rawDataIndex)
properties = BitConverter::ToInt32BE(data, rawDataIndex + 12);
}
CameraDataList::CameraDataList(ZFile* parent, std::string prefix, std::vector<uint8_t> rawData, int rawDataIndex, int polyTypeDefSegmentOffset, int polygonTypesCnt)
CameraDataList::CameraDataList(ZFile* parent, const std::string& prefix, const std::vector<uint8_t>& rawData, int rawDataIndex, int polyTypeDefSegmentOffset, int polygonTypesCnt)
{
string declaration = "";
@ -267,9 +274,9 @@ CameraDataList::CameraDataList(ZFile* parent, std::string prefix, std::vector<ui
}
}
CameraPositionData::CameraPositionData(std::vector<uint8_t> rawData, int rawDataIndex)
CameraPositionData::CameraPositionData(const std::vector<uint8_t>& rawData, int rawDataIndex)
{
x = BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
y = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
z = BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
}
}

15
tools/ZAPD/ZAPD/ZCollision.h
View file

@ -11,7 +11,7 @@ public:
int16_t vtxA, vtxB, vtxC;
int16_t a, b, c, d;
PolygonEntry(std::vector<uint8_t> rawData, int rawDataIndex);
PolygonEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class VertexEntry
@ -19,7 +19,7 @@ class VertexEntry
public:
int16_t x, y, z;
VertexEntry(std::vector<uint8_t> rawData, int rawDataIndex);
VertexEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class WaterBoxHeader
@ -33,7 +33,7 @@ public:
int16_t pad;
int32_t properties;
WaterBoxHeader(std::vector<uint8_t> rawData, int rawDataIndex);
WaterBoxHeader(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CameraPositionData
@ -41,7 +41,7 @@ class CameraPositionData
public:
int16_t x, y, z;
CameraPositionData(std::vector<uint8_t> rawData, int rawDataIndex);
CameraPositionData(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CameraDataEntry
@ -58,7 +58,7 @@ public:
std::vector<CameraDataEntry*> entries;
std::vector<CameraPositionData*> cameraPositionData;
CameraDataList(ZFile* parent, std::string prefix, std::vector<uint8_t> rawData, int rawDataIndex, int polyTypeDefSegmentOffset, int polygonTypesCnt);
CameraDataList(ZFile* parent, const std::string& prefix, const std::vector<uint8_t>& rawData, int rawDataIndex, int polyTypeDefSegmentOffset, int polygonTypesCnt);
};
class ZCollisionHeader : public ZResource
@ -84,7 +84,8 @@ public:
ZCollisionHeader();
//ZCollisionHeader(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
ZCollisionHeader(ZFile* parent, std::string prefix, std::vector<uint8_t> rawData, int rawDataIndex);
ZCollisionHeader(ZFile* parent, const std::string& prefix, const std::vector<uint8_t>& rawData, int rawDataIndex);
~ZCollisionHeader();
static ZCollisionHeader* ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex);
};
};

162
tools/ZAPD/ZAPD/ZCutscene.cpp
View file

@ -6,7 +6,7 @@ using namespace std;
ZCutscene::ZCutscene(std::vector<uint8_t> nRawData, int rawDataIndex, int rawDataSize)
{
rawData = nRawData;
rawData = std::move(nRawData);
segmentOffset = rawDataIndex;
numCommands = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
@ -78,7 +78,13 @@ ZCutscene::ZCutscene(std::vector<uint8_t> nRawData, int rawDataIndex, int rawDat
}
}
string ZCutscene::GetSourceOutputCode(string prefix)
ZCutscene::~ZCutscene()
{
for (CutsceneCommand* cmd : commands)
delete cmd;
}
string ZCutscene::GetSourceOutputCode(const std::string& prefix)
{
string output = "";
int size = 0;
@ -160,17 +166,17 @@ CutsceneCommands ZCutscene::GetCommandFromID(int id)
return CutsceneCommands::Error;
}
CutsceneCommand::CutsceneCommand(vector<uint8_t> rawData, int rawDataIndex)
CutsceneCommand::CutsceneCommand(const vector<uint8_t>& rawData, int rawDataIndex)
{
}
string CutsceneCommand::GetCName(string prefix)
string CutsceneCommand::GetCName(const std::string& prefix)
{
return "SCmdCutsceneData";
}
string CutsceneCommand::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommand::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
return StringHelper::Sprintf("%s %sCutsceneData%04XCmd%02X = { 0x%02X,", GetCName(roomName).c_str(), roomName.c_str(), baseAddress, commandIndex, commandID);
}
@ -180,9 +186,9 @@ size_t CutsceneCommand::GetCommandSize()
return 4;
}
CutsceneCameraPoint::CutsceneCameraPoint(vector<uint8_t> rawData, int rawDataIndex)
CutsceneCameraPoint::CutsceneCameraPoint(const vector<uint8_t>& rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
continueFlag = data[rawDataIndex + 0];
cameraRoll = data[rawDataIndex + 1];
@ -196,9 +202,9 @@ CutsceneCameraPoint::CutsceneCameraPoint(vector<uint8_t> rawData, int rawDataInd
unused = BitConverter::ToInt16BE(data, rawDataIndex + 14);
}
CutsceneCommandSetCameraPos::CutsceneCommandSetCameraPos(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandSetCameraPos::CutsceneCommandSetCameraPos(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
base = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 2);
@ -224,12 +230,12 @@ CutsceneCommandSetCameraPos::CutsceneCommandSetCameraPos(vector<uint8_t> rawData
}
// TODO
string CutsceneCommandSetCameraPos::GetCName(string prefix)
string CutsceneCommandSetCameraPos::GetCName(const std::string& prefix)
{
return "";
}
string CutsceneCommandSetCameraPos::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandSetCameraPos::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -273,7 +279,7 @@ size_t CutsceneCommandSetCameraPos::GetCommandSize()
return 8 + (entries.size() * 16);
}
MusicFadeEntry::MusicFadeEntry(vector<uint8_t> rawData, int rawDataIndex)
MusicFadeEntry::MusicFadeEntry(const vector<uint8_t>& rawData, int rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
@ -291,7 +297,7 @@ MusicFadeEntry::MusicFadeEntry(vector<uint8_t> rawData, int rawDataIndex)
unknown10 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 44);
}
CutsceneCommandFadeBGM::CutsceneCommandFadeBGM(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandFadeBGM::CutsceneCommandFadeBGM(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
@ -304,12 +310,12 @@ CutsceneCommandFadeBGM::CutsceneCommandFadeBGM(vector<uint8_t> rawData, int rawD
}
}
string CutsceneCommandFadeBGM::GetCName(string prefix)
string CutsceneCommandFadeBGM::GetCName(const std::string& prefix)
{
return "CsCmdMusicFade";
}
string CutsceneCommandFadeBGM::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandFadeBGM::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -330,7 +336,7 @@ size_t CutsceneCommandFadeBGM::GetCommandSize()
return CutsceneCommand::GetCommandSize() + 0x30;
}
MusicChangeEntry::MusicChangeEntry(vector<uint8_t> rawData, int rawDataIndex)
MusicChangeEntry::MusicChangeEntry(const vector<uint8_t>& rawData, int rawDataIndex)
{
sequence = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
@ -345,7 +351,7 @@ MusicChangeEntry::MusicChangeEntry(vector<uint8_t> rawData, int rawDataIndex)
unknown7 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 32);
}
CutsceneCommandPlayBGM::CutsceneCommandPlayBGM(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandPlayBGM::CutsceneCommandPlayBGM(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
@ -358,7 +364,7 @@ CutsceneCommandPlayBGM::CutsceneCommandPlayBGM(vector<uint8_t> rawData, int rawD
}
}
string CutsceneCommandPlayBGM::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandPlayBGM::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -374,7 +380,7 @@ string CutsceneCommandPlayBGM::GenerateSourceCode(string roomName, int baseAddre
return result;
}
string CutsceneCommandPlayBGM::GetCName(string prefix)
string CutsceneCommandPlayBGM::GetCName(const std::string& prefix)
{
return "CsCmdMusicChange";
}
@ -384,7 +390,7 @@ size_t CutsceneCommandPlayBGM::GetCommandSize()
return CutsceneCommand::GetCommandSize() + 0x30;
}
CutsceneCommandStopBGM::CutsceneCommandStopBGM(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandStopBGM::CutsceneCommandStopBGM(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
@ -397,7 +403,7 @@ CutsceneCommandStopBGM::CutsceneCommandStopBGM(vector<uint8_t> rawData, int rawD
}
}
string CutsceneCommandStopBGM::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandStopBGM::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -413,7 +419,7 @@ string CutsceneCommandStopBGM::GenerateSourceCode(string roomName, int baseAddre
return result;
}
string CutsceneCommandStopBGM::GetCName(string prefix)
string CutsceneCommandStopBGM::GetCName(const std::string& prefix)
{
return "CsCmdMusicChange";
}
@ -423,7 +429,7 @@ size_t CutsceneCommandStopBGM::GetCommandSize()
return CutsceneCommand::GetCommandSize() + 0x30;
}
EnvLightingEntry::EnvLightingEntry(vector<uint8_t> rawData, int rawDataIndex)
EnvLightingEntry::EnvLightingEntry(const vector<uint8_t>& rawData, int rawDataIndex)
{
setting = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
@ -438,7 +444,7 @@ EnvLightingEntry::EnvLightingEntry(vector<uint8_t> rawData, int rawDataIndex)
unused7 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 32);
}
CutsceneCommandEnvLighting::CutsceneCommandEnvLighting(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandEnvLighting::CutsceneCommandEnvLighting(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
@ -451,7 +457,7 @@ CutsceneCommandEnvLighting::CutsceneCommandEnvLighting(vector<uint8_t> rawData,
}
}
string CutsceneCommandEnvLighting::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandEnvLighting::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -467,7 +473,7 @@ string CutsceneCommandEnvLighting::GenerateSourceCode(string roomName, int baseA
return result;
}
string CutsceneCommandEnvLighting::GetCName(string prefix)
string CutsceneCommandEnvLighting::GetCName(const std::string& prefix)
{
return "CsCmdEnvLighting";
}
@ -477,7 +483,7 @@ size_t CutsceneCommandEnvLighting::GetCommandSize()
return CutsceneCommand::GetCommandSize() + (0x30 * entries.size());
}
Unknown9Entry::Unknown9Entry(vector<uint8_t> rawData, int rawDataIndex)
Unknown9Entry::Unknown9Entry(const vector<uint8_t>& rawData, int rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
@ -489,7 +495,7 @@ Unknown9Entry::Unknown9Entry(vector<uint8_t> rawData, int rawDataIndex)
unused1 = rawData[rawDataIndex + 11];;
}
CutsceneCommandUnknown9::CutsceneCommandUnknown9(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandUnknown9::CutsceneCommandUnknown9(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
@ -502,7 +508,7 @@ CutsceneCommandUnknown9::CutsceneCommandUnknown9(vector<uint8_t> rawData, int ra
}
}
string CutsceneCommandUnknown9::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandUnknown9::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -517,7 +523,7 @@ string CutsceneCommandUnknown9::GenerateSourceCode(string roomName, int baseAddr
return result;
}
string CutsceneCommandUnknown9::GetCName(string prefix)
string CutsceneCommandUnknown9::GetCName(const std::string& prefix)
{
return "CsCmdUnknown9";
}
@ -527,7 +533,7 @@ size_t CutsceneCommandUnknown9::GetCommandSize()
return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
}
UnkEntry::UnkEntry(vector<uint8_t> rawData, int rawDataIndex)
UnkEntry::UnkEntry(const vector<uint8_t>& rawData, int rawDataIndex)
{
unused0 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
unused1 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 4);
@ -543,7 +549,7 @@ UnkEntry::UnkEntry(vector<uint8_t> rawData, int rawDataIndex)
unused11 = (uint32_t)BitConverter::ToInt32BE(rawData, rawDataIndex + 44);
}
CutsceneCommandUnknown::CutsceneCommandUnknown(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandUnknown::CutsceneCommandUnknown(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
@ -556,7 +562,7 @@ CutsceneCommandUnknown::CutsceneCommandUnknown(vector<uint8_t> rawData, int rawD
}
}
string CutsceneCommandUnknown::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandUnknown::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -572,7 +578,7 @@ string CutsceneCommandUnknown::GenerateSourceCode(string roomName, int baseAddre
return result;
}
string CutsceneCommandUnknown::GetCName(string prefix)
string CutsceneCommandUnknown::GetCName(const std::string& prefix)
{
return "CsCmdUnknown1A";
}
@ -582,7 +588,7 @@ size_t CutsceneCommandUnknown::GetCommandSize()
return CutsceneCommand::GetCommandSize() + (entries.size() * 0x30);
}
DayTimeEntry::DayTimeEntry(vector<uint8_t> rawData, int rawDataIndex)
DayTimeEntry::DayTimeEntry(const vector<uint8_t>& rawData, int rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
@ -592,7 +598,7 @@ DayTimeEntry::DayTimeEntry(vector<uint8_t> rawData, int rawDataIndex)
unused = rawData[rawDataIndex + 8];
}
CutsceneCommandDayTime::CutsceneCommandDayTime(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandDayTime::CutsceneCommandDayTime(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
@ -605,12 +611,12 @@ CutsceneCommandDayTime::CutsceneCommandDayTime(vector<uint8_t> rawData, int rawD
}
}
string CutsceneCommandDayTime::GetCName(string prefix)
string CutsceneCommandDayTime::GetCName(const std::string& prefix)
{
return "CsCmdDayTime";
}
string CutsceneCommandDayTime::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandDayTime::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -630,7 +636,7 @@ size_t CutsceneCommandDayTime::GetCommandSize()
return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
}
TextboxEntry::TextboxEntry(vector<uint8_t> rawData, int rawDataIndex)
TextboxEntry::TextboxEntry(const vector<uint8_t>& rawData, int rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
@ -640,7 +646,7 @@ TextboxEntry::TextboxEntry(vector<uint8_t> rawData, int rawDataIndex)
textID2 = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 10);
}
CutsceneCommandTextbox::CutsceneCommandTextbox(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandTextbox::CutsceneCommandTextbox(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
@ -653,12 +659,12 @@ CutsceneCommandTextbox::CutsceneCommandTextbox(vector<uint8_t> rawData, int rawD
}
}
string CutsceneCommandTextbox::GetCName(string prefix)
string CutsceneCommandTextbox::GetCName(const std::string& prefix)
{
return "CsCmdTextbox";
}
string CutsceneCommandTextbox::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandTextbox::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -685,9 +691,9 @@ size_t CutsceneCommandTextbox::GetCommandSize()
return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
}
ActorAction::ActorAction(vector<uint8_t> rawData, int rawDataIndex)
ActorAction::ActorAction(const vector<uint8_t>& rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
action = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 2);
@ -706,7 +712,7 @@ ActorAction::ActorAction(vector<uint8_t> rawData, int rawDataIndex)
normalZ = BitConverter::ToInt32BE(data, rawDataIndex + 44);
}
CutsceneCommandActorAction::CutsceneCommandActorAction(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandActorAction::CutsceneCommandActorAction(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
@ -719,7 +725,7 @@ CutsceneCommandActorAction::CutsceneCommandActorAction(vector<uint8_t> rawData,
}
}
string CutsceneCommandActorAction::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandActorAction::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -735,7 +741,7 @@ string CutsceneCommandActorAction::GenerateSourceCode(string roomName, int baseA
return result;
}
string CutsceneCommandActorAction::GetCName(string prefix)
string CutsceneCommandActorAction::GetCName(const std::string& prefix)
{
return "CsCmdBase";
}
@ -745,7 +751,7 @@ size_t CutsceneCommandActorAction::GetCommandSize()
return CutsceneCommand::GetCommandSize() + (entries.size() * 0x30);
}
CutsceneCommandTerminator::CutsceneCommandTerminator(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandTerminator::CutsceneCommandTerminator(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
rawDataIndex += 4;
@ -755,12 +761,12 @@ CutsceneCommandTerminator::CutsceneCommandTerminator(vector<uint8_t> rawData, in
unknown = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 6);
}
string CutsceneCommandTerminator::GetCName(string prefix)
string CutsceneCommandTerminator::GetCName(const std::string& prefix)
{
return "CsCmdBase";
}
string CutsceneCommandTerminator::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandTerminator::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -774,14 +780,14 @@ size_t CutsceneCommandTerminator::GetCommandSize()
return CutsceneCommand::GetCommandSize() + 8;
}
CutsceneCommandEnd::CutsceneCommandEnd(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandEnd::CutsceneCommandEnd(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
}
string CutsceneCommandEnd::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandEnd::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -790,7 +796,7 @@ string CutsceneCommandEnd::GenerateSourceCode(string roomName, int baseAddress)
return result;
}
string CutsceneCommandEnd::GetCName(string prefix)
string CutsceneCommandEnd::GetCName(const std::string& prefix)
{
return "CsCmdBase";
}
@ -800,27 +806,27 @@ size_t CutsceneCommandEnd::GetCommandSize()
return CutsceneCommand::GetCommandSize() + 6;
}
SpecialActionEntry::SpecialActionEntry(vector<uint8_t> rawData, int rawDataIndex)
SpecialActionEntry::SpecialActionEntry(const vector<uint8_t>& rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
base = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 4);
unused0 = (uint16_t)BitConverter::ToInt16BE(data, rawDataIndex + 6);
unused1 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 8);
unused2 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 12);
unused3 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 16);
unused4 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 20);
unused5 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 24);
unused6 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 28);
unused7 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 32);
unused8 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 36);
unused9 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 40);
unused10 = (uint32_t)BitConverter::ToInt32BE(data, rawDataIndex + 44);
base = BitConverter::ToUInt16BE(data, rawDataIndex + 0);
startFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 2);
endFrame = BitConverter::ToUInt16BE(data, rawDataIndex + 4);
unused0 = BitConverter::ToUInt16BE(data, rawDataIndex + 6);
unused1 = BitConverter::ToUInt32BE(data, rawDataIndex + 8);
unused2 = BitConverter::ToUInt32BE(data, rawDataIndex + 12);
unused3 = BitConverter::ToUInt32BE(data, rawDataIndex + 16);
unused4 = BitConverter::ToUInt32BE(data, rawDataIndex + 20);
unused5 = BitConverter::ToUInt32BE(data, rawDataIndex + 24);
unused6 = BitConverter::ToUInt32BE(data, rawDataIndex + 28);
unused7 = BitConverter::ToUInt32BE(data, rawDataIndex + 32);
unused8 = BitConverter::ToUInt32BE(data, rawDataIndex + 36);
unused9 = BitConverter::ToUInt32BE(data, rawDataIndex + 40);
unused10 = BitConverter::ToUInt32BE(data, rawDataIndex + 44);
}
CutsceneCommandSpecialAction::CutsceneCommandSpecialAction(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandSpecialAction::CutsceneCommandSpecialAction(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
int numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
@ -833,7 +839,7 @@ CutsceneCommandSpecialAction::CutsceneCommandSpecialAction(vector<uint8_t> rawDa
}
}
string CutsceneCommandSpecialAction::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandSpecialAction::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
string result = "";
@ -844,12 +850,12 @@ string CutsceneCommandSpecialAction::GenerateSourceCode(string roomName, int bas
result += StringHelper::Sprintf("\t\tCS_MISC(0x%04X, %i, %i, 0x%04X, 0x%04X, 0x%04X, %i, %i, %i, %i, %i, %i, %i, %i),\n", entries[i]->base, entries[i]->startFrame, entries[i]->endFrame,
entries[i]->unused0, entries[i]->unused1, entries[i]->unused2, entries[i]->unused3, entries[i]->unused4, entries[i]->unused5, entries[i]->unused6,
entries[i]->unused7, entries[i]->unused8, entries[i]->unused9, entries[i]->unused10);
}
}
return result;
}
string CutsceneCommandSpecialAction::GetCName(string prefix)
string CutsceneCommandSpecialAction::GetCName(const std::string& prefix)
{
return "CsCmdBase";
}
@ -859,14 +865,14 @@ size_t CutsceneCommandSpecialAction::GetCommandSize()
return CutsceneCommand::GetCommandSize() + (0x30 * entries.size());
}
CutsceneCommandNop::CutsceneCommandNop(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandNop::CutsceneCommandNop(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
base = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 0);
startFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
}
string CutsceneCommandNop::GetCName(string prefix)
string CutsceneCommandNop::GetCName(const std::string& prefix)
{
return "CsCmdBase";
}
@ -876,7 +882,7 @@ size_t CutsceneCommandNop::GetCommandSize()
return CutsceneCommand::GetCommandSize() + 6;
}
CutsceneCommandSceneTransFX::CutsceneCommandSceneTransFX(vector<uint8_t> rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
CutsceneCommandSceneTransFX::CutsceneCommandSceneTransFX(const vector<uint8_t>& rawData, int rawDataIndex) : CutsceneCommand(rawData, rawDataIndex)
{
rawDataIndex += 4;
@ -885,12 +891,12 @@ CutsceneCommandSceneTransFX::CutsceneCommandSceneTransFX(vector<uint8_t> rawData
endFrame = (uint16_t)BitConverter::ToInt16BE(rawData, rawDataIndex + 4);
}
string CutsceneCommandSceneTransFX::GenerateSourceCode(string roomName, int baseAddress)
string CutsceneCommandSceneTransFX::GenerateSourceCode(const std::string& roomName, int baseAddress)
{
return StringHelper::Sprintf("CS_SCENE_TRANS_FX(%i, %i, %i, %i),\n", base, startFrame, endFrame);
}
string CutsceneCommandSceneTransFX::GetCName(string prefix)
string CutsceneCommandSceneTransFX::GetCName(const std::string& prefix)
{
return "CsCmdBase";
}

121
tools/ZAPD/ZAPD/ZCutscene.h
View file

@ -52,7 +52,7 @@ public:
int16_t posX, posY, posZ;
int16_t unused;
CutsceneCameraPoint(std::vector<uint8_t> rawData, int rawDataIndex);
CutsceneCameraPoint(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommand
@ -61,9 +61,9 @@ public:
uint32_t commandID;
uint32_t commandIndex;
CutsceneCommand(std::vector<uint8_t> rawData, int rawDataIndex);
virtual std::string GetCName(std::string prefix);
virtual std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommand(const std::vector<uint8_t>& rawData, int rawDataIndex);
virtual std::string GetCName(const std::string& prefix);
virtual std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
virtual size_t GetCommandSize();
};
@ -77,9 +77,9 @@ public:
std::vector<CutsceneCameraPoint*> entries;
CutsceneCommandSetCameraPos(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandSetCameraPos(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -101,7 +101,7 @@ public:
uint32_t unused9;
uint32_t unused10;
SpecialActionEntry(std::vector<uint8_t> rawData, int rawDataIndex);
SpecialActionEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandSpecialAction : public CutsceneCommand
@ -109,9 +109,9 @@ class CutsceneCommandSpecialAction : public CutsceneCommand
public:
std::vector<SpecialActionEntry*> entries;
CutsceneCommandSpecialAction(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandSpecialAction(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -133,7 +133,7 @@ public:
uint32_t unknown9;
uint32_t unknown10;
MusicFadeEntry(std::vector<uint8_t> rawData, int rawDataIndex);
MusicFadeEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandFadeBGM : public CutsceneCommand
@ -141,9 +141,9 @@ class CutsceneCommandFadeBGM : public CutsceneCommand
public:
std::vector<MusicFadeEntry*> entries;
CutsceneCommandFadeBGM( std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandFadeBGM( const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -162,7 +162,7 @@ public:
uint32_t unknown6;
uint32_t unknown7;
MusicChangeEntry(std::vector<uint8_t> rawData, int rawDataIndex);
MusicChangeEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandPlayBGM : public CutsceneCommand
@ -170,9 +170,9 @@ class CutsceneCommandPlayBGM : public CutsceneCommand
public:
std::vector<MusicChangeEntry*> entries;
CutsceneCommandPlayBGM(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandPlayBGM(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -181,9 +181,9 @@ class CutsceneCommandStopBGM : public CutsceneCommand
public:
std::vector<MusicChangeEntry*> entries;
CutsceneCommandStopBGM(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandStopBGM(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -202,7 +202,7 @@ public:
uint32_t unused6;
uint32_t unused7;
EnvLightingEntry(std::vector<uint8_t> rawData, int rawDataIndex);
EnvLightingEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandEnvLighting : public CutsceneCommand
@ -210,9 +210,9 @@ class CutsceneCommandEnvLighting : public CutsceneCommand
public:
std::vector<EnvLightingEntry*> entries;
CutsceneCommandEnvLighting(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandEnvLighting(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -223,9 +223,9 @@ public:
uint16_t startFrame;
uint16_t endFrame;
CutsceneCommandSceneTransFX(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandSceneTransFX(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -241,7 +241,7 @@ public:
uint8_t unused0;
uint8_t unused1;
Unknown9Entry(std::vector<uint8_t> rawData, int rawDataIndex);
Unknown9Entry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandUnknown9 : public CutsceneCommand
@ -249,9 +249,9 @@ class CutsceneCommandUnknown9 : public CutsceneCommand
public:
std::vector<Unknown9Entry*> entries;
CutsceneCommandUnknown9(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandUnknown9(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -271,7 +271,7 @@ public:
uint32_t unused10;
uint32_t unused11;
UnkEntry(std::vector<uint8_t> rawData, int rawDataIndex);
UnkEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandUnknown : public CutsceneCommand
@ -279,9 +279,9 @@ class CutsceneCommandUnknown : public CutsceneCommand
public:
std::vector<UnkEntry*> entries;
CutsceneCommandUnknown(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandUnknown(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -295,7 +295,7 @@ public:
uint8_t minute;
uint8_t unused;
DayTimeEntry(std::vector<uint8_t> rawData, int rawDataIndex);
DayTimeEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandDayTime : public CutsceneCommand
@ -303,9 +303,9 @@ class CutsceneCommandDayTime : public CutsceneCommand
public:
std::vector<DayTimeEntry*> entries;
CutsceneCommandDayTime(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandDayTime(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -319,7 +319,7 @@ public:
uint16_t textID1;
uint16_t textID2;
TextboxEntry(std::vector<uint8_t> rawData, int rawDataIndex);
TextboxEntry(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandTextbox : public CutsceneCommand
@ -327,9 +327,9 @@ class CutsceneCommandTextbox : public CutsceneCommand
public:
std::vector<TextboxEntry*> entries;
CutsceneCommandTextbox(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandTextbox(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -344,7 +344,7 @@ public:
int32_t endPosX, endPosY, endPosZ;
int32_t normalX, normalY, normalZ;
ActorAction(std::vector<uint8_t> rawData, int rawDataIndex);
ActorAction(const std::vector<uint8_t>& rawData, int rawDataIndex);
};
class CutsceneCommandActorAction : public CutsceneCommand
@ -352,9 +352,9 @@ class CutsceneCommandActorAction : public CutsceneCommand
public:
std::vector<ActorAction*> entries;
CutsceneCommandActorAction(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandActorAction(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -366,9 +366,9 @@ public:
uint16_t endFrame;
uint16_t unknown;
CutsceneCommandTerminator(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandTerminator(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -379,9 +379,9 @@ public:
uint16_t startFrame;
uint16_t endFrame;
CutsceneCommandEnd(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
std::string GenerateSourceCode(std::string roomName, int baseAddress);
CutsceneCommandEnd(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
std::string GenerateSourceCode(const std::string& roomName, int baseAddress);
size_t GetCommandSize();
};
@ -392,8 +392,8 @@ public:
uint16_t startFrame;
uint16_t endFrame;
CutsceneCommandNop(std::vector<uint8_t> rawData, int rawDataIndex);
std::string GetCName(std::string prefix);
CutsceneCommandNop(const std::vector<uint8_t>& rawData, int rawDataIndex);
std::string GetCName(const std::string& prefix);
size_t GetCommandSize();
};
@ -401,14 +401,15 @@ class ZCutscene : public ZResource
{
public:
uint32_t segmentOffset;
CutsceneCommands GetCommandFromID(int id);
ZCutscene(std::vector<uint8_t> nRawData, int rawDataIndex, int rawDataSize);
~ZCutscene();
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputCode(const std::string& prefix);
int GetRawDataSize();
private:
int numCommands;
int endFrame;
std::vector<CutsceneCommand*> commands;
};
};

133
tools/ZAPD/ZAPD/ZDisplayList.cpp
View file

@ -23,6 +23,7 @@ ZDisplayList::ZDisplayList() : ZResource()
lastTexSiz = F3DZEXTexSizes::G_IM_SIZ_16b;
lastTexSizTest = F3DZEXTexSizes::G_IM_SIZ_16b;
lastTexLoaded = false;
lastTexIsPalette = false;
name = "";
scene = nullptr;
@ -79,7 +80,7 @@ void ZDisplayList::ParseRawData()
instructions.reserve(numInstructions);
for (int i = 0; i < numInstructions; i++)
instructions.push_back(BitConverter::ToInt64BE(rawDataArr, (i * 8)));
instructions.push_back(BitConverter::ToUInt64BE(rawDataArr, (i * 8)));
}
int ZDisplayList::GetDListLength(vector<uint8_t> rawData, int rawDataIndex)
@ -156,19 +157,14 @@ int ZDisplayList::OptimizationCheck_LoadTextureBlock(int startIndex, string& out
siz = (__ & 0x18) >> 3;
texAddr = SEG2FILESPACE(data);
int segmentNumber = (data & 0xFF000000) >> 24;
if (segmentNumber == 0x80) // Is this texture defined in code?
texAddr -= SEG2FILESPACE(parent->baseAddress);
lastTexSeg = (data & 0xFF000000);
if (texAddr == 0xb880e0)
{
int bp = 0;
}
Declaration* texDecl = nullptr;
if (parent != nullptr)
{
texDecl = parent->GetDeclaration(texAddr);
@ -199,7 +195,7 @@ int ZDisplayList::OptimizationCheck_LoadTextureBlock(int startIndex, string& out
uint64_t data = instructions[startIndex + 1];
tmem = (data & 0b0000000000000000111111111111111100000000000000000000000000000000) >> 32;
cmt = (data & 0b0000000000000000000000000000000000000000000011000000000000000000) >> 18;
maskt = (data & 0b0000000000000000000000000000000000000000000000111100000000000000) >> 14;
shiftt = (data & 0b0000000000000000000000000000000000000000000000000011110000000000) >> 10;
@ -245,11 +241,6 @@ int ZDisplayList::OptimizationCheck_LoadTextureBlock(int startIndex, string& out
if (sizB == (int)F3DZEXTexSizes::G_IM_SIZ_4b && fmt == (int)F3DZEXTexFormats::G_IM_FMT_IA)
shiftAmtH = 3;
if (texAddr == 0xb880e0)
{
int bp = 0;
}
width = (uuu >> shiftAmtW) + 1;
height = (vvv >> shiftAmtH) + 1;
@ -260,7 +251,7 @@ int ZDisplayList::OptimizationCheck_LoadTextureBlock(int startIndex, string& out
string fmtTbl[] = { "G_IM_FMT_RGBA", "G_IM_FMT_YUV", "G_IM_FMT_CI", "G_IM_FMT_IA", "G_IM_FMT_I" };
string sizTbl[] = { "G_IM_SIZ_4b", "G_IM_SIZ_8b", "G_IM_SIZ_16b", "G_IM_SIZ_32b" };
//output += StringHelper::Sprintf("gsDPLoadTextureBlock(%s, %s, %s, %i, %i, %i, %i, %i, %i, %i, %i, %i),",
//output += StringHelper::Sprintf("gsDPLoadTextureBlock(%s, %s, %s, %i, %i, %i, %i, %i, %i, %i, %i, %i),",
//texStr.c_str(), fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), width, height, pal, cms, cmt, masks, maskt, shifts, shiftt);
if (siz == 2 && sizB == 0)
@ -304,11 +295,6 @@ int ZDisplayList::OptimizationCheck_LoadTextureBlock(int startIndex, string& out
lastTexSiz = (F3DZEXTexSizes)siz;
lastTexLoaded = true;
if (lastTexAddr == 0x8798)
{
int bp = 0;
}
TextureGenCheck(prefix);
return (int)sequence.size();
@ -317,17 +303,17 @@ int ZDisplayList::OptimizationCheck_LoadTextureBlock(int startIndex, string& out
return -1;
}
string ZDisplayList::GetSourceOutputHeader(string prefix)
string ZDisplayList::GetSourceOutputHeader(const std::string& prefix)
{
return "";
}
string ZDisplayList::GetSourceOutputCode(std::string prefix)
string ZDisplayList::GetSourceOutputCode(const std::string& prefix)
{
char line[4096];
string sourceOutput = "";
for (int i = 0; i < instructions.size(); i++)
for (int i = 0; i < instructions.size(); i++)
{
F3DZEXOpcode opcode = (F3DZEXOpcode)(instructions[i] >> 56);
uint64_t data = instructions[i];
@ -355,7 +341,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
int segNum = (data & 0xFF000000) >> 24;
Declaration* dListDecl = nullptr;
if (parent != nullptr)
dListDecl = parent->GetDeclaration(SEG2FILESPACE(data));
@ -370,14 +356,14 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
if (dListDecl != nullptr)
sprintf(line, "gsSPBranchList(%s),", dListDecl->varName.c_str());
else
sprintf(line, "gsSPBranchList(%sDlist0x%06X),", prefix.c_str(), SEG2FILESPACE(data));
sprintf(line, "gsSPBranchList(%sDlist0x%06lX),", prefix.c_str(), SEG2FILESPACE(data));
}
else
{
if (dListDecl != nullptr)
sprintf(line, "gsSPDisplayList(%s),", dListDecl->varName.c_str());
else
sprintf(line, "gsSPDisplayList(%sDlist0x%06X),", prefix.c_str(), SEG2FILESPACE(data));
sprintf(line, "gsSPDisplayList(%sDlist0x%06lX),", prefix.c_str(), SEG2FILESPACE(data));
}
int segmentNumber = (data & 0xFF000000) >> 24;
@ -495,9 +481,9 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
uint32_t fmt = (__ & 0xE0) >> 5;
uint32_t siz = (__ & 0x18) >> 3;
if (Globals::Instance->debugMessages)
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("TextureGenCheck G_SETTIMG\n");
TextureGenCheck(prefix); // HOTSPOT
lastTexFmt = (F3DZEXTexFormats)fmt;
@ -513,11 +499,9 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
if (segmentNumber != 2)
{
char texStr[2048];
int32_t texAddress = SEG2FILESPACE(data);
Declaration* texDecl = nullptr;
if (parent != nullptr)
{
if (Globals::Instance->HasSegment(segmentNumber))
@ -548,7 +532,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
else
{
//sprintf(line, "gsDPSetTextureImage(%s, %s, %i, 0x%08X),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, data & 0xFFFFFFFF);
sprintf(line, "gsDPSetTextureImage(%s, %s, %i, %sTex_%06X),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, scene->GetName().c_str(), data & 0x00FFFFFF);
sprintf(line, "gsDPSetTextureImage(%s, %s, %i, %sTex_%06lX),", fmtTbl[fmt].c_str(), sizTbl[siz].c_str(), www + 1, scene->GetName().c_str(), SEG2FILESPACE(data));
}
}
break;
@ -592,7 +576,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
if (geoModeParam & 0x00800000)
geoModeStr += " | G_CLIPPING";
if (ssssssss != 0)
{
if ((~cccccc & 0xFF000000) != 0)
@ -602,7 +586,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
}
else
sprintf(line, "gsSPClearGeometryMode(%s),", geoModeStr.c_str());
//sprintf(line, "gsSPGeometryMode(0x%08X, 0x%08X),", ~cccccc, ssssssss);
}
break;
@ -632,7 +616,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
int mode2 = (dd & 0x33330000) >> 0;
// TODO: Jesus Christ This is Messy
uint32_t tblA[] =
{
G_RM_FOG_SHADE_A, G_RM_FOG_PRIM_A, G_RM_PASS, G_RM_AA_ZB_OPA_SURF,
@ -671,7 +655,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
G_RM_ADD2, G_RM_NOOP2,G_RM_VISCVG2, G_RM_OPA_CI2
};
map<uint32_t, string> str =
map<uint32_t, string> str =
{
{ G_RM_FOG_SHADE_A, "G_RM_FOG_SHADE_A" },
{ G_RM_FOG_PRIM_A, "G_RM_FOG_PRIM_A" },
@ -865,13 +849,13 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
lastTexWidth = (uuu >> shiftAmtW) + 1;
lastTexHeight = (vvv >> shiftAmtH) + 1;
if (Globals::Instance->debugMessages)
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("lastTexWidth: %i lastTexHeight: %i, lastTexSizTest: 0x%x, lastTexFmt: 0x%x\n", lastTexWidth, lastTexHeight, (uint32_t)lastTexSizTest, (uint32_t)lastTexFmt);
if (Globals::Instance->debugMessages)
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("TextureGenCheck G_SETTILESIZE\n");
TextureGenCheck(prefix);
sprintf(line, "gsDPSetTileSize(%i, %i, %i, %i, %i),", i, sss, ttt, uuu, vvv);
@ -928,10 +912,11 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
lastTexHeight = sqrt(ccc + 1);
lastTexLoaded = true;
lastTexIsPalette = true;
if (Globals::Instance->debugMessages)
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("TextureGenCheck G_LOADTLUT (lastCISiz: %i)\n", (uint32_t)lastCISiz);
TextureGenCheck(prefix);
sprintf(line, "gsDPLoadTLUTCmd(%i, %i),", t, ccc);
@ -995,9 +980,9 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
case F3DZEXOpcode::G_ENDDL:
sprintf(line, "gsSPEndDisplayList(),");
if (Globals::Instance->debugMessages)
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("TextureGenCheck G_ENDDL\n");
TextureGenCheck(prefix);
break;
case F3DZEXOpcode::G_RDPHALF_1:
@ -1060,7 +1045,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
#endif
sourceOutput += line;
if (i < instructions.size() - 1)
sourceOutput += "\n";
}
@ -1091,7 +1076,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
}
defines += StringHelper::Sprintf("#define %sVtx_%06X ((u32)%sVtx_%06X + 0x%06X)\n", prefix.c_str(), verticesSorted[i + 1].first, prefix.c_str(), verticesSorted[i].first, verticesSorted[i + 1].first - verticesSorted[i].first);
int nSize = (int)vertices[verticesSorted[i].first].size();
vertices.erase(verticesSorted[i + 1].first);
@ -1126,8 +1111,8 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
if (parent != nullptr)
{
parent->AddDeclarationArray(item.first, DeclarationAlignment::None, item.second.size() * 16, "Vtx",
StringHelper::Sprintf("%sVtx_%06X", prefix.c_str(), item.first, item.second.size()), 0, declaration);
parent->AddDeclarationArray(item.first, DeclarationAlignment::None, item.second.size() * 16, "static Vtx",
StringHelper::Sprintf("%sVtx_%06X", prefix.c_str(), item.first, item.second.size()), item.second.size(), declaration);
}
}
@ -1178,24 +1163,32 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
break;
int texSize = textures[texturesSorted[i].first]->GetRawDataSize();
if ((texturesSorted[i].first + texSize) > texturesSorted[i + 1].first)
{
int intersectAmt = (texturesSorted[i].first + texSize) - texturesSorted[i + 1].first;
// If we're working with a palette, resize it to its "real" dimensions
if (texturesSorted[i].second->isPalette)
{
texturesSorted[i].second->SetWidth(intersectAmt / 2);
texturesSorted[i].second->SetHeight(1);
}
else
{
defines += StringHelper::Sprintf("#define %sTex_%06X ((u32)%sTex_%06X + 0x%06X)\n", prefix.c_str(), texturesSorted[i + 1].first, prefix.c_str(),
texturesSorted[i].first, texturesSorted[i + 1].first - texturesSorted[i].first);
defines += StringHelper::Sprintf("#define %sTex_%06X ((u32)%sTex_%06X + 0x%06X)\n", prefix.c_str(), texturesSorted[i + 1].first, prefix.c_str(),
texturesSorted[i].first, texturesSorted[i + 1].first - texturesSorted[i].first);
textures.erase(texturesSorted[i + 1].first);
texturesSorted.erase(texturesSorted.begin() + i + 1);
textures.erase(texturesSorted[i + 1].first);
texturesSorted.erase(texturesSorted.begin() + i + 1);
i--;
i--;
}
}
}
}
}
// Generate Texture Declarations
for (pair<int32_t, ZTexture*> item : textures)
{
@ -1208,7 +1201,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
{
if (parent->GetDeclaration(item.first) == nullptr)
{
if (Globals::Instance->debugMessages)
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("SAVING IMAGE TO %s\n", Globals::Instance->outputPath.c_str());
item.second->Save(Globals::Instance->outputPath);
@ -1222,7 +1215,7 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
}
}
if (parent != nullptr)
{
parent->AddDeclarationArray(rawDataIndex, DeclarationAlignment::None, GetRawDataSize(), "Gfx", StringHelper::Sprintf("%s", name.c_str()), 0, sourceOutput);
@ -1235,28 +1228,28 @@ string ZDisplayList::GetSourceOutputCode(std::string prefix)
// HOTSPOT
void ZDisplayList::TextureGenCheck(string prefix)
{
if (TextureGenCheck(fileData, textures, scene, parent, prefix, lastTexWidth, lastTexHeight, lastTexAddr, lastTexSeg, lastTexFmt, lastTexSiz, lastTexLoaded))
if (TextureGenCheck(fileData, textures, scene, parent, prefix, lastTexWidth, lastTexHeight, lastTexAddr, lastTexSeg, lastTexFmt, lastTexSiz, lastTexLoaded, lastTexIsPalette))
{
lastTexAddr = 0;
lastTexLoaded = false;
lastTexIsPalette = false;
}
}
// HOTSPOT
bool ZDisplayList::TextureGenCheck(vector<uint8_t> fileData, map<uint32_t, ZTexture*>& textures, ZRoom* scene, ZFile* parent, string prefix, uint32_t texWidth, uint32_t texHeight, uint32_t texAddr, uint32_t texSeg, F3DZEXTexFormats texFmt, F3DZEXTexSizes texSiz, bool texLoaded)
bool ZDisplayList::TextureGenCheck(vector<uint8_t> fileData, map<uint32_t, ZTexture*>& textures, ZRoom* scene, ZFile* parent, string prefix, uint32_t texWidth, uint32_t texHeight, uint32_t texAddr, uint32_t texSeg, F3DZEXTexFormats texFmt, F3DZEXTexSizes texSiz, bool texLoaded, bool texIsPalette)
{
int segmentNumber = (texSeg & 0xFF000000) >> 24;
if (Globals::Instance->debugMessages)
printf("TextureGenCheck seg=%i width=%i height=%i addr=0x%06X\n", segmentNumber, texWidth, texHeight, texAddr);
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("TextureGenCheck seg=%i width=%i height=%i ispal=%i addr=0x%06X\n", segmentNumber, texWidth, texHeight, texIsPalette, texAddr);
if (texAddr != 0 && texWidth != 0 && texHeight != 0 && texLoaded && Globals::Instance->HasSegment(segmentNumber))
{
if (segmentNumber != 2) // Not from a scene file
{
ZTexture* tex = ZTexture::FromBinary(TexFormatToTexType(texFmt, texSiz), fileData, texAddr, StringHelper::Sprintf("%sTex_%06X", prefix.c_str(), texAddr), texWidth, texHeight);
//tex->Save(Globals::Instance->outputPath);
tex->isPalette = texIsPalette;
textures[texAddr] = tex;
return true;
@ -1266,12 +1259,10 @@ bool ZDisplayList::TextureGenCheck(vector<uint8_t> fileData, map<uint32_t, ZText
ZTexture* tex = ZTexture::FromBinary(TexFormatToTexType(texFmt, texSiz), scene->GetRawData(), texAddr,
StringHelper::Sprintf("%sTex_%06X", Globals::Instance->lastScene->GetName().c_str(), texAddr), texWidth, texHeight);
//tex->Save(Globals::Instance->outputPath);
if (scene != nullptr)
{
scene->textures[texAddr] = tex;
scene->parent->AddDeclarationIncludeArray(texAddr, StringHelper::Sprintf("%s/%s.%s.inc.c",
scene->parent->AddDeclarationIncludeArray(texAddr, StringHelper::Sprintf("%s/%s.%s.inc.c",
Globals::Instance->outputPath.c_str(), Path::GetFileNameWithoutExtension(tex->GetName()).c_str(), tex->GetExternalExtension().c_str()), tex->GetRawDataSize(),
"u64", StringHelper::Sprintf("%sTex_%06X", Globals::Instance->lastScene->GetName().c_str(), texAddr), 0);
}
@ -1318,7 +1309,7 @@ TextureType ZDisplayList::TexFormatToTexType(F3DZEXTexFormats fmt, F3DZEXTexSize
return TextureType::RGBA16bpp;
}
void ZDisplayList::Save(string outFolder)
void ZDisplayList::Save(const std::string& outFolder)
{
//HLModelIntermediette* mdl = HLModelIntermediette::FromZDisplayList(this);
@ -1382,7 +1373,7 @@ Vertex::Vertex(int16_t nX, int16_t nY, int16_t nZ, uint16_t nFlag, int16_t nS, i
Vertex::Vertex(std::vector<uint8_t> rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
x = BitConverter::ToInt16BE(data, rawDataIndex + 0);
y = BitConverter::ToInt16BE(data, rawDataIndex + 2);
@ -1394,4 +1385,4 @@ Vertex::Vertex(std::vector<uint8_t> rawData, int rawDataIndex)
g = data[rawDataIndex + 13];
b = data[rawDataIndex + 14];
a = data[rawDataIndex + 15];
}
}

13
tools/ZAPD/ZAPD/ZDisplayList.h
View file

@ -205,7 +205,7 @@ public:
uint16_t flag;
int16_t s, t;
uint8_t r, g, b, a;
Vertex();
Vertex(int16_t nX, int16_t nY, int16_t nZ, uint16_t nFlag, int16_t nS, int16_t nT, uint8_t nR, uint8_t nG, uint8_t nB, uint8_t nA);
Vertex(std::vector<uint8_t> rawData, int rawDataIndex);
@ -219,6 +219,7 @@ protected:
F3DZEXTexFormats lastTexFmt;
F3DZEXTexSizes lastTexSiz, lastTexSizTest, lastCISiz;
bool lastTexLoaded;
bool lastTexIsPalette;
//void ParseXML(tinyxml2::XMLElement* reader);
static TextureType TexFormatToTexType(F3DZEXTexFormats fmt, F3DZEXTexSizes siz);
@ -253,13 +254,13 @@ public:
static ZDisplayList* BuildFromXML(tinyxml2::XMLElement* reader, std::string inFolder, bool readFile);
void TextureGenCheck(std::string prefix);
static bool TextureGenCheck(std::vector<uint8_t> fileData, std::map<uint32_t, ZTexture*>& textures, ZRoom* scene, ZFile* parent, std::string prefix, uint32_t texWidth, uint32_t texHeight, uint32_t texAddr, uint32_t texSeg, F3DZEXTexFormats texFmt, F3DZEXTexSizes texSiz, bool texLoaded);
static bool TextureGenCheck(std::vector<uint8_t> fileData, std::map<uint32_t, ZTexture*>& textures, ZRoom* scene, ZFile* parent, std::string prefix, uint32_t texWidth, uint32_t texHeight, uint32_t texAddr, uint32_t texSeg, F3DZEXTexFormats texFmt, F3DZEXTexSizes texSiz, bool texLoaded, bool texIsPalette);
static int GetDListLength(std::vector<uint8_t> rawData, int rawDataIndex);
std::vector<uint8_t> GetRawData();
int GetRawDataSize();
std::string GetSourceOutputHeader(std::string prefix);
std::string GetSourceOutputCode(std::string prefix);
void Save(std::string outFolder);
std::string GetSourceOutputHeader(const std::string& prefix);
std::string GetSourceOutputCode(const std::string& prefix);
void Save(const std::string& outFolder);
virtual void GenerateHLIntermediette(HLFileIntermediette& hlFile);
};
};

113
tools/ZAPD/ZAPD/ZFile.cpp
View file

@ -6,6 +6,8 @@
#include "ZAnimation.h"
#include "ZSkeleton.h"
#include "ZCollision.h"
#include "ZScalar.h"
#include "ZVector.h"
#include "Path.h"
#include "File.h"
#include "Directory.h"
@ -50,6 +52,12 @@ ZFile::ZFile(ZFileMode mode, XMLElement* reader, string nBasePath, string nOutPa
ParseXML(mode, reader, placeholderMode);
}
ZFile::~ZFile()
{
for (ZResource* res : resources)
delete res;
}
void ZFile::ParseXML(ZFileMode mode, XMLElement* reader, bool placeholderMode)
{
name = reader->Attribute("Name");
@ -90,7 +98,8 @@ void ZFile::ParseXML(ZFileMode mode, XMLElement* reader, bool placeholderMode)
if (child->Attribute("Offset") != NULL)
rawDataIndex = strtol(StringHelper::Split(child->Attribute("Offset"), "0x")[1].c_str(), NULL, 16);
printf("%s: 0x%06X\n", child->Attribute("Name"), rawDataIndex);
if (Globals::Instance->verbosity >= VERBOSITY_INFO)
printf("%s: 0x%06X\n", child->Attribute("Name"), rawDataIndex);
if (string(child->Name()) == "Texture")
{
@ -239,25 +248,50 @@ void ZFile::ParseXML(ZFileMode mode, XMLElement* reader, bool placeholderMode)
resources.push_back(res);
}
else if (string(child->Name()) == "Vec3s")
{
}
else if (string(child->Name()) == "Vec3f")
else if (string(child->Name()) == "Scalar")
{
ZScalar* scalar = nullptr;
}
else if (string(child->Name()) == "Vec3i")
{
if (mode == ZFileMode::Extract)
scalar = ZScalar::ExtractFromXML(child, rawData, rawDataIndex, folderName);
}
else if (string(child->Name()) == "String")
{
if (scalar != nullptr)
{
scalar->parent = this;
resources.push_back(scalar);
rawDataIndex += scalar->GetRawDataSize();
}
else
{
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("No ZScalar created!!");
}
}
else if (string(child->Name()) == "Vector")
{
ZVector* vector = nullptr;
if (mode == ZFileMode::Extract)
vector = ZVector::ExtractFromXML(child, rawData, rawDataIndex, folderName);
if (vector != nullptr)
{
vector->parent = this;
resources.push_back(vector);
rawDataIndex += vector->GetRawDataSize();
}
else
{
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("No ZVector created!!");
}
}
else
{
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("Encountered unknown resource type: %s\n", string(child->Name()).c_str());
}
}
}
@ -328,7 +362,9 @@ void ZFile::ExtractResources(string outputDir)
for (ZResource* res : resources)
{
printf("Saving resource %s\n", res->GetName().c_str());
if (Globals::Instance->verbosity >= VERBOSITY_INFO)
printf("Saving resource %s\n", res->GetName().c_str());
res->CalcHash(); // TEST
res->Save(outputPath);
}
@ -621,6 +657,7 @@ string ZFile::ProcessDeclarations()
// Account for padding/alignment
int lastAddr = 0;
int lastSize = 0;
//printf("RANGE START: 0x%06X - RANGE END: 0x%06X\n", rangeStart, rangeEnd);
@ -707,45 +744,47 @@ string ZFile::ProcessDeclarations()
// Handle unaccounted data
lastAddr = 0;
lastSize = 0;
for (pair<int32_t, Declaration*> item : declarationKeysSorted)
{
if (lastAddr != 0 && item.first >= rangeStart && item.first < rangeEnd)
if (item.first >= rangeStart && item.first < rangeEnd)
{
if (lastAddr + declarations[lastAddr]->size > item.first)
if (lastAddr != 0 && declarations.find(lastAddr) != declarations.end() && lastAddr + declarations[lastAddr]->size > item.first)
{
// UH OH!
int bp = 0;
printf("WARNING: Intersection detected from 0x%06X:0x%06X, conflicts with 0x%06X\n", lastAddr, lastAddr + declarations[lastAddr]->size, item.first);
}
uint8_t* rawDataArr = rawData.data();
if (lastAddr + declarations[lastAddr]->size != item.first)
if (lastAddr + lastSize != item.first)
{
int diff = item.first - (lastAddr + declarations[lastAddr]->size);
//int diff = item.first - (lastAddr + declarations[lastAddr]->size);
int diff = item.first - (lastAddr + lastSize);
string src = " ";
for (int i = 0; i < diff; i++)
{
src += StringHelper::Sprintf("0x%02X, ", rawDataArr[lastAddr + declarations[lastAddr]->size + i]);
//src += StringHelper::Sprintf("0x%02X, ", rawDataArr[lastAddr + declarations[lastAddr]->size + i]);
src += StringHelper::Sprintf("0x%02X, ", rawDataArr[lastAddr + lastSize + i]);
if ((i % 16 == 15) && (i != (diff - 1)))
src += "\n ";
}
if (declarations.find(lastAddr + declarations[lastAddr]->size) == declarations.end())
if (declarations.find(lastAddr + lastSize) == declarations.end())
{
if (diff > 0)
{
AddDeclarationArray(lastAddr + declarations[lastAddr]->size, DeclarationAlignment::None, diff, "static u8", StringHelper::Sprintf("unaccounted_%06X", lastAddr + declarations[lastAddr]->size),
diff, src);
//AddDeclarationArray(lastAddr + declarations[lastAddr]->size, DeclarationAlignment::None, diff, "static u8", StringHelper::Sprintf("unaccounted_%06X", lastAddr + declarations[lastAddr]->size), diff, src);
AddDeclarationArray(lastAddr + lastSize, DeclarationAlignment::None, diff, "static u8", StringHelper::Sprintf("unaccounted_%06X", lastAddr + lastSize), diff, src);
}
}
}
}
lastAddr = item.first;
lastSize = item.second->size;
}
// TODO: THIS CONTAINS REDUNDANCIES. CLEAN THIS UP!
@ -780,6 +819,30 @@ string ZFile::ProcessDeclarations()
return lhs.first < rhs.first;
});
// First, handle the prototypes (static only for now)
int protoCnt = 0;
for (pair<int32_t, Declaration*> item : declarationKeysSorted)
{
if (item.second->includePath == "" && StringHelper::StartsWith(item.second->varType, "static ") && !StringHelper::StartsWith(item.second->varName, "unaccounted_"))
{
if (item.second->isArray)
{
if (item.second->arrayItemCnt == 0)
output += StringHelper::Sprintf("%s %s[];\n", item.second->varType.c_str(), item.second->varName.c_str());
else
output += StringHelper::Sprintf("%s %s[%i];\n", item.second->varType.c_str(), item.second->varName.c_str(), item.second->arrayItemCnt);
}
else
output += StringHelper::Sprintf("%s %s;\n", item.second->varType.c_str(), item.second->varName.c_str());
protoCnt++;
}
}
if (protoCnt > 0)
output += "\n";
// Next, output the actual declarations
for (pair<int32_t, Declaration*> item : declarationKeysSorted)
{
if (item.second->includePath != "")

1
tools/ZAPD/ZAPD/ZFile.h
View file

@ -28,6 +28,7 @@ public:
ZFile(std::string nOutPath, std::string nName);
ZFile(ZFileMode mode, tinyxml2::XMLElement* reader, std::string nBasePath, std::string nOutPath, bool placeholderMode);
~ZFile();
std::string GetVarName(int address);
void ExtractResources(std::string outputDir);

8
tools/ZAPD/ZAPD/ZResource.cpp
View file

@ -25,7 +25,7 @@ void ZResource::ParseXML(tinyxml2::XMLElement* reader)
outName = name;
}
void ZResource::Save(string outFolder)
void ZResource::Save(const std::string& outFolder)
{
}
@ -46,7 +46,7 @@ std::string ZResource::GetOutName()
void ZResource::SetName(string nName)
{
name = nName;
name = std::move(nName);
}
bool ZResource::IsExternalResource()
@ -84,12 +84,12 @@ void ZResource::SetRawDataIndex(int value)
rawDataIndex = value;
}
string ZResource::GetSourceOutputCode(std::string prefix)
string ZResource::GetSourceOutputCode(const std::string& prefix)
{
return "";
}
string ZResource::GetSourceOutputHeader(std::string prefix)
string ZResource::GetSourceOutputHeader(const std::string& prefix)
{
return "";
}

12
tools/ZAPD/ZAPD/ZResource.h
View file

@ -33,7 +33,9 @@ enum class ZResourceType
Cutscene,
Blob,
Limb,
Skeleton
Skeleton,
Scalar,
Vector
};
class ZResource
@ -45,7 +47,7 @@ public:
ZResource();
virtual void ParseXML(tinyxml2::XMLElement* reader);
virtual void Save(std::string outFolder);
virtual void Save(const std::string& outFolder);
virtual void PreGenSourceFiles();
std::string GetName();
std::string GetOutName();
@ -57,8 +59,8 @@ public:
virtual int GetRawDataIndex();
virtual int GetRawDataSize();
virtual void SetRawDataIndex(int value);
virtual std::string GetSourceOutputCode(std::string prefix);
virtual std::string GetSourceOutputHeader(std::string prefix);
virtual std::string GetSourceOutputCode(const std::string& prefix);
virtual std::string GetSourceOutputHeader(const std::string& prefix);
virtual void GenerateHLIntermediette(HLFileIntermediette& hlFile);
virtual ZResourceType GetResourceType();
virtual void CalcHash();
@ -115,4 +117,4 @@ public:
protected:
Declaration(DeclarationAlignment nAlignment, DeclarationPadding nPadding, uint32_t nSize, std::string nText);
};
};

16
tools/ZAPD/ZAPD/ZRoom/Commands/SetActorList.cpp
View file

@ -19,6 +19,14 @@ SetActorList::SetActorList(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawD
zRoom->parent->AddDeclarationPlaceholder(segmentOffset);
}
SetActorList::~SetActorList()
{
for (ActorSpawnEntry* entry : actors)
delete entry;
actors.clear();
}
string SetActorList::GetSourceOutputCode(std::string prefix)
{
return "";
@ -66,9 +74,9 @@ string SetActorList::GenerateSourceCodePass2(string roomName, int baseAddress)
index++;
}
zRoom->parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::None, DeclarationPadding::Pad16, actors.size() * 16,
zRoom->parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::None, DeclarationPadding::Pad16, actors.size() * 16,
"ActorEntry", StringHelper::Sprintf("%sActorList0x%06X", roomName.c_str(), segmentOffset), actors.size(), declaration);
return sourceOutput;
}
@ -94,7 +102,7 @@ RoomCommand SetActorList::GetRoomCommand()
ActorSpawnEntry::ActorSpawnEntry(std::vector<uint8_t> rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
actorNum = BitConverter::ToInt16BE(data, rawDataIndex + 0);
posX = BitConverter::ToInt16BE(data, rawDataIndex + 2);
@ -104,4 +112,4 @@ ActorSpawnEntry::ActorSpawnEntry(std::vector<uint8_t> rawData, int rawDataIndex)
rotY = BitConverter::ToInt16BE(data, rawDataIndex + 10);
rotZ = BitConverter::ToInt16BE(data, rawDataIndex + 12);
initVar = BitConverter::ToInt16BE(data, rawDataIndex + 14);
}
}

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetActorList.h
View file

@ -21,6 +21,7 @@ class SetActorList : public ZRoomCommand
{
public:
SetActorList(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
~SetActorList();
std::string GetSourceOutputCode(std::string prefix);
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);

4
tools/ZAPD/ZAPD/ZRoom/Commands/SetAlternateHeaders.cpp
View file

@ -44,8 +44,8 @@ string SetAlternateHeaders::GenerateSourceCodePass1(string roomName, int baseAdd
declaration += StringHelper::Sprintf("\t(u32)&%sSet%04XCmd00,\n", roomName.c_str(), headers[i] & 0x00FFFFFF);
}
zRoom->parent->declarations[segmentOffset] = new Declaration(DeclarationAlignment::None, headers.size() * 4,
"u32", StringHelper::Sprintf("%sAlternateHeaders0x%06X", roomName.c_str(), segmentOffset), true, declaration);
zRoom->parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::None, headers.size() * 4,
"u32", StringHelper::Sprintf("%sAlternateHeaders0x%06X", roomName.c_str(), segmentOffset), 0, declaration);
return sourceOutput;
}

9
tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.cpp
View file

@ -22,6 +22,15 @@ SetCutscenes::SetCutscenes(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawD
StringHelper::Sprintf("%sCutsceneData0x%06X", zRoom->GetName().c_str(), segmentOffset), 0, output);
}
SetCutscenes::~SetCutscenes()
{
if (cutscene != nullptr)
{
delete cutscene;
cutscene = nullptr;
}
}
string SetCutscenes::GenerateSourceCodePass1(string roomName, int baseAddress)
{
return StringHelper::Sprintf("%s 0, (u32)%sCutsceneData0x%06X", ZRoomCommand::GenerateSourceCodePass1(roomName, baseAddress).c_str(), zRoom->GetName().c_str(), segmentOffset);

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.h
View file

@ -7,6 +7,7 @@ class SetCutscenes : public ZRoomCommand
{
public:
SetCutscenes(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
~SetCutscenes();
std::string GetSourceOutputCode(std::string prefix);
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);

6
tools/ZAPD/ZAPD/ZRoom/Commands/SetEntranceList.cpp
View file

@ -16,6 +16,12 @@ SetEntranceList::SetEntranceList(ZRoom* nZRoom, std::vector<uint8_t> rawData, in
_rawDataIndex = rawDataIndex;
}
SetEntranceList::~SetEntranceList()
{
for (EntranceEntry* entry : entrances)
delete entry;
}
string SetEntranceList::GenerateSourceCodePass1(string roomName, int baseAddress)
{
string sourceOutput = StringHelper::Sprintf("%s 0x00, (u32)&%sEntranceList0x%06X", ZRoomCommand::GenerateSourceCodePass1(roomName, baseAddress).c_str(), zRoom->GetName().c_str(), segmentOffset);

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetEntranceList.h
View file

@ -15,6 +15,7 @@ class SetEntranceList : public ZRoomCommand
{
public:
SetEntranceList(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
~SetEntranceList();
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);
virtual std::string GenerateExterns();

10
tools/ZAPD/ZAPD/ZRoom/Commands/SetLightingSettings.cpp
View file

@ -35,6 +35,12 @@ SetLightingSettings::SetLightingSettings(ZRoom* nZRoom, std::vector<uint8_t> raw
}
}
SetLightingSettings::~SetLightingSettings()
{
for (LightingSettings* setting : settings)
delete setting;
}
string SetLightingSettings::GenerateSourceCodePass1(string roomName, int baseAddress)
{
return StringHelper::Sprintf("%s %i, (u32)&%sLightSettings0x%06X", ZRoomCommand::GenerateSourceCodePass1(roomName, baseAddress).c_str(), settings.size(), zRoom->GetName().c_str(), segmentOffset);
@ -62,7 +68,7 @@ RoomCommand SetLightingSettings::GetRoomCommand()
LightingSettings::LightingSettings(vector<uint8_t> rawData, int rawDataIndex)
{
uint8_t* data = rawData.data();
const uint8_t* data = rawData.data();
ambientClrR = data[rawDataIndex + 0];
ambientClrG = data[rawDataIndex + 1];
@ -90,4 +96,4 @@ LightingSettings::LightingSettings(vector<uint8_t> rawData, int rawDataIndex)
unk = BitConverter::ToInt16BE(data, rawDataIndex + 18);
drawDistance = BitConverter::ToInt16BE(data, rawDataIndex + 20);
}
}

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetLightingSettings.h
View file

@ -21,6 +21,7 @@ class SetLightingSettings : public ZRoomCommand
{
public:
SetLightingSettings(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
~SetLightingSettings();
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);
virtual std::string GenerateSourceCodePass2(std::string roomName, int baseAddress);

38
tools/ZAPD/ZAPD/ZRoom/Commands/SetMesh.cpp
View file

@ -109,8 +109,6 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
zRoom->parent->AddDeclaration(meshHeader0->dListStart + (meshHeader0->entries.size() * 8) + 0, DeclarationAlignment::None, DeclarationPadding::Pad16, 4, "static s32",
"terminatorMaybe", " 0x01000000 ");
//zRoom->parent->declarations[meshHeader0->dListStart] = new Declaration(DeclarationAlignment::None, DeclarationPadding::Pad16, (meshHeader0->entries.size() * 8) + 4, declaration);
meshHeader = meshHeader0;
}
else if (meshHeaderType == 1)
@ -146,11 +144,6 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
zRoom->parent->AddDeclaration(segmentOffset, DeclarationAlignment::None, DeclarationPadding::Pad16, 0x1E, "MeshHeader1Single",
StringHelper::Sprintf("%sMeshHeader0x%06X", zRoom->GetName().c_str(), segmentOffset), declaration);
//if (headerSingle->imagePtr != 0)
//{
//zRoom->declarations[headerSingle->imagePtr] = new Declaration(DeclarationAlignment::None, DeclarationPadding::Pad16, 0x1E, declaration);
//}
meshHeader1 = headerSingle;
; }
else if (fmt == 2) // Multi-Format
@ -164,21 +157,18 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
headerMulti->bgCnt = rawData[segmentOffset + 8];
headerMulti->bgRecordPtr = BitConverter::ToInt32BE(rawData, segmentOffset + 12);
//zRoom->declarations[segmentOffset] = new Declaration(DeclarationAlignment::None, DeclarationPadding::Pad16, 12, "");
declaration += StringHelper::Sprintf("{ { 1 }, 2, 0x%06X }, 0x%06X, 0x%06X",
headerMulti->entryRecord, headerMulti->bgCnt, headerMulti->bgRecordPtr);
zRoom->parent->AddDeclaration(segmentOffset, DeclarationAlignment::None, DeclarationPadding::Pad16, 16, "MeshHeader1Multi",
StringHelper::Sprintf("%sMeshHeader0x%06X", zRoom->GetName().c_str(), segmentOffset), declaration);
//zRoom->parent->declarations[segmentOffset] = new Declaration(DeclarationAlignment::None, DeclarationPadding::Pad16, 16, declaration);
meshHeader1 = headerMulti;
}
else // UH OH
{
int bp = 0;
if (Globals::Instance->verbosity >= VERBOSITY_INFO)
printf("WARNING: MeshHeader FMT %i not implemented!\n", fmt);
}
meshHeader1->headerType = 1;
@ -290,6 +280,15 @@ SetMesh::SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex,
}
}
SetMesh::~SetMesh()
{
if (meshHeader != nullptr)
{
delete meshHeader;
meshHeader = nullptr;
}
}
void SetMesh::GenDListDeclarations(std::vector<uint8_t> rawData, ZDisplayList* dList)
{
string sourceOutput = dList->GetSourceOutputCode(zRoom->GetName()); // HOTSPOT
@ -301,15 +300,15 @@ void SetMesh::GenDListDeclarations(std::vector<uint8_t> rawData, ZDisplayList* d
else
srcVarName = StringHelper::Sprintf("%s", dList->GetName().c_str());
zRoom->parent->AddDeclarationArray(dList->GetRawDataIndex(), DeclarationAlignment::None, dList->GetRawDataSize(), "Gfx", srcVarName, 0, sourceOutput);
zRoom->parent->AddDeclarationArray(dList->GetRawDataIndex(), DeclarationAlignment::None, dList->GetRawDataSize(), "static Gfx", srcVarName, dList->GetRawDataSize() / 8, sourceOutput);
for (ZDisplayList* otherDList : dList->otherDLists)
GenDListDeclarations(rawData, otherDList);
for (pair<uint32_t, string> vtxEntry : dList->vtxDeclarations)
{
zRoom->parent->AddDeclarationArray(vtxEntry.first, DeclarationAlignment::Align8, dList->vertices[vtxEntry.first].size() * 16, "Vtx",
StringHelper::Sprintf("%sVtx_%06X", zRoom->GetName().c_str(), vtxEntry.first), 0, vtxEntry.second);
zRoom->parent->AddDeclarationArray(vtxEntry.first, DeclarationAlignment::Align8, dList->vertices[vtxEntry.first].size() * 16, "static Vtx",
StringHelper::Sprintf("%sVtx_%06X", zRoom->GetName().c_str(), vtxEntry.first), dList->vertices[vtxEntry.first].size(), vtxEntry.second);
//zRoom->parent->declarations[vtxEntry.first] = new Declaration(DeclarationAlignment::Align8, dList->vertices[vtxEntry.first].size() * 16, vtxEntry.second);
}
@ -317,11 +316,8 @@ void SetMesh::GenDListDeclarations(std::vector<uint8_t> rawData, ZDisplayList* d
for (pair<uint32_t, string> texEntry : dList->texDeclarations)
{
zRoom->textures[texEntry.first] = dList->textures[texEntry.first];
//zRoom->parent->AddDeclarationArray(texEntry.first, DeclarationAlignment::None, dList->textures[texEntry.first]->GetRawDataSize(), "u64",
//zRoom->textures[texEntry.first]->GetName(), 0, texEntry.second);
if (Globals::Instance->debugMessages)
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("SAVING IMAGE TO %s\n", Globals::Instance->outputPath.c_str());
zRoom->textures[texEntry.first]->Save(Globals::Instance->outputPath);
@ -344,8 +340,8 @@ std::string SetMesh::GenDListExterns(ZDisplayList* dList)
for (ZDisplayList* otherDList : dList->otherDLists)
sourceOutput += GenDListExterns(otherDList);
for (pair<uint32_t, string> vtxEntry : dList->vtxDeclarations)
sourceOutput += StringHelper::Sprintf("extern Vtx %sVtx_%06X[%i];\n", zRoom->GetName().c_str(), vtxEntry.first, dList->vertices[vtxEntry.first].size());
//for (pair<uint32_t, string> vtxEntry : dList->vtxDeclarations)
//sourceOutput += StringHelper::Sprintf("extern Vtx %sVtx_%06X[%i];\n", zRoom->GetName().c_str(), vtxEntry.first, dList->vertices[vtxEntry.first].size());
for (pair<uint32_t, string> texEntry : dList->texDeclarations)
sourceOutput += StringHelper::Sprintf("extern u64 %sTex_%06X[];\n", zRoom->GetName().c_str(), texEntry.first);

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetMesh.h
View file

@ -102,6 +102,7 @@ class SetMesh : public ZRoomCommand
{
public:
SetMesh(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex, int segAddressOffset);
~SetMesh();
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);
//virtual std::string GenerateSourceCodePass2(std::string roomName, int baseAddress);

9
tools/ZAPD/ZAPD/ZRoom/Commands/SetPathways.cpp
View file

@ -19,10 +19,13 @@ SetPathways::SetPathways(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDat
uint32_t currentPtr = listSegmentOffset;
if (segmentOffset != 0)
zRoom->parent->declarations[segmentOffset] = new Declaration(DeclarationAlignment::None, 0, "", "", false, "");
zRoom->parent->AddDeclarationPlaceholder(segmentOffset);
}
//if (listSegmentOffset != 0)
//zRoom->declarations[listSegmentOffset] = new Declaration(DeclarationAlignment::None, 0, "");
SetPathways::~SetPathways()
{
for (PathwayEntry* entry : pathways)
delete entry;
}
void SetPathways::InitList(uint32_t address)

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetPathways.h
View file

@ -13,6 +13,7 @@ class SetPathways : public ZRoomCommand
{
public:
SetPathways(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
~SetPathways();
std::string GetSourceOutputCode(std::string prefix);
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);

21
tools/ZAPD/ZAPD/ZRoom/Commands/SetRoomList.cpp
View file

@ -23,19 +23,12 @@ SetRoomList::SetRoomList(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDat
currentPtr += 8;
}
}
//string declaration = "";
/*for (int i = 0; i < rooms.size(); i++)
{
RoomEntry* entry = rooms[i];
string roomName = StringHelper::Sprintf("%sRoom%i", StringHelper::Split(zRoom->GetName(), "_scene")[0].c_str(), i);
declaration += StringHelper::Sprintf("\t{ (u32)%sSegmentRomStart, (u32)%sSegmentRomEnd },\n", roomName.c_str(), roomName.c_str());
}*/
//zRoom->parent->declarations[segmentOffset] = new Declaration(DeclarationAlignment::None, rooms.size() * 8,
//"RomFile", StringHelper::Sprintf("%sRoomList0x%06X", zRoom->GetName().c_str(), segmentOffset), true, declaration);
SetRoomList::~SetRoomList()
{
for (RoomEntry* entry : rooms)
delete entry;
}
string SetRoomList::GenerateSourceCodePass1(string roomName, int baseAddress)
@ -79,8 +72,8 @@ std::string SetRoomList::PreGenSourceFiles()
}
}
zRoom->parent->declarations[segmentOffset] = new Declaration(DeclarationAlignment::None, rooms.size() * 8,
"RomFile", StringHelper::Sprintf("%sRoomList0x%06X", zRoom->GetName().c_str(), segmentOffset), true, declaration);
zRoom->parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::None, rooms.size() * 8,
"RomFile", StringHelper::Sprintf("%sRoomList0x%06X", zRoom->GetName().c_str(), segmentOffset), 0, declaration);
return std::string();
}

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetRoomList.h
View file

@ -16,6 +16,7 @@ class SetRoomList : public ZRoomCommand
{
public:
SetRoomList(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
~SetRoomList();
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);
virtual std::string GenerateSourceCodePass2(std::string roomName, int baseAddress);

6
tools/ZAPD/ZAPD/ZRoom/Commands/SetStartPositionList.cpp
View file

@ -26,6 +26,12 @@ SetStartPositionList::SetStartPositionList(ZRoom* nZRoom, std::vector<uint8_t> r
}
}
SetStartPositionList::~SetStartPositionList()
{
for (ActorSpawnEntry* entry : actors)
delete entry;
}
string SetStartPositionList::GenerateSourceCodePass1(string roomName, int baseAddress)
{
string sourceOutput = "";

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetStartPositionList.h
View file

@ -10,6 +10,7 @@ public:
std::vector<ActorSpawnEntry*> actors;
SetStartPositionList(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
~SetStartPositionList();
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);
virtual std::string GenerateSourceCodePass2(std::string roomName, int baseAddress);

10
tools/ZAPD/ZAPD/ZRoom/Commands/SetTransitionActorList.cpp
View file

@ -25,6 +25,12 @@ SetTransitionActorList::SetTransitionActorList(ZRoom* nZRoom, std::vector<uint8_
}
}
SetTransitionActorList::~SetTransitionActorList()
{
for (TransitionActorEntry* actor : transitionActors)
delete actor;
}
string SetTransitionActorList::GetSourceOutputCode(std::string prefix)
{
return "";
@ -38,8 +44,8 @@ string SetTransitionActorList::GenerateSourceCodePass1(string roomName, int base
for (TransitionActorEntry* entry : transitionActors)
declaration += StringHelper::Sprintf("\t{ %i, %i, %i, %i, %s, %i, %i, %i, %i, 0x%04X }, \n", entry->frontObjectRoom, entry->frontTransitionReaction, entry->backObjectRoom, entry->backTransitionReaction, ActorList[entry->actorNum].c_str(), entry->posX, entry->posY, entry->posZ, entry->rotY, (uint16_t)entry->initVar);
zRoom->parent->declarations[segmentOffset] = new Declaration(DeclarationAlignment::None, transitionActors.size() * 16, "TransitionActorEntry",
StringHelper::Sprintf("%sTransitionActorList0x%06X", roomName.c_str(), segmentOffset), true, declaration);
zRoom->parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::None, transitionActors.size() * 16, "TransitionActorEntry",
StringHelper::Sprintf("%sTransitionActorList0x%06X", roomName.c_str(), segmentOffset), 0, declaration);
return sourceOutput;
}

1
tools/ZAPD/ZAPD/ZRoom/Commands/SetTransitionActorList.h
View file

@ -21,6 +21,7 @@ class SetTransitionActorList : public ZRoomCommand
{
public:
SetTransitionActorList(ZRoom* nZRoom, std::vector<uint8_t> rawData, int rawDataIndex);
~SetTransitionActorList();
std::string GetSourceOutputCode(std::string prefix);
virtual std::string GenerateSourceCodePass1(std::string roomName, int baseAddress);

36
tools/ZAPD/ZAPD/ZRoom/ZRoom.cpp
View file

@ -48,6 +48,12 @@ ZRoom::ZRoom() : ZResource()
scene = nullptr;
}
ZRoom::~ZRoom()
{
for (ZRoomCommand* cmd : commands)
delete cmd;
}
ZRoom* ZRoom::ExtractFromXML(XMLElement* reader, vector<uint8_t> nRawData, int rawDataIndex, string nRelPath, ZFile* nParent, ZRoom* nScene)
{
ZRoom* room = new ZRoom();
@ -78,7 +84,7 @@ ZRoom* ZRoom::ExtractFromXML(XMLElement* reader, vector<uint8_t> nRawData, int r
if (string(child->Name()) == "DListHint")
{
string comment = "";
if (child->Attribute("Comment") != NULL)
comment = "// " + string(child->Attribute("Comment")) + "\n";
@ -86,10 +92,8 @@ ZRoom* ZRoom::ExtractFromXML(XMLElement* reader, vector<uint8_t> nRawData, int r
int address = strtol(StringHelper::Split(addressStr, "0x")[1].c_str(), NULL, 16);
ZDisplayList* dList = new ZDisplayList(room->rawData, address, ZDisplayList::GetDListLength(room->rawData, address));
//room->parent->declarations[address] = new Declaration(DeclarationAlignment::None, dList->GetRawDataSize(), comment + dList->GetSourceOutputCode(room->name));
//room->parent->AddDeclarationArray(address, DeclarationAlignment::None, dList->GetRawDataSize(), "Gfx", "", 0, comment + dList->GetSourceOutputCode(room->name));
dList->GetSourceOutputCode(room->name);
delete dList;
}
else if (string(child->Name()) == "BlobHint")
{
@ -118,7 +122,7 @@ ZRoom* ZRoom::ExtractFromXML(XMLElement* reader, vector<uint8_t> nRawData, int r
int address = strtol(StringHelper::Split(addressStr, "0x")[1].c_str(), NULL, 16);
ZCutscene* cutscene = new ZCutscene(room->rawData, address, 9999);
room->parent->AddDeclarationArray(address, DeclarationAlignment::None, DeclarationPadding::Pad16, cutscene->GetRawDataSize(), "s32",
StringHelper::Sprintf("%sCutsceneData0x%06X", room->name.c_str(), cutscene->segmentOffset), 0, cutscene->GetSourceOutputCode(room->name));
}
@ -201,7 +205,7 @@ void ZRoom::ParseCommands(std::vector<ZRoomCommand*>& commandList, CommandSet co
if (commandsLeft <= 0)
break;
RoomCommand opcode = (RoomCommand)rawData[rawDataIndex];
RoomCommand opcode = (RoomCommand)rawData[rawDataIndex];
ZRoomCommand* cmd = nullptr;
@ -280,7 +284,7 @@ void ZRoom::ProcessCommandSets()
cmd->commandSet = commandSet & 0x00FFFFFF;
string pass1 = cmd->GenerateSourceCodePass1(name, cmd->commandSet);
Declaration* decl = parent->AddDeclaration(cmd->cmdAddress, i == 0 ? DeclarationAlignment::Align16 : DeclarationAlignment::None, 8, cmd->GetCommandCName(),
Declaration* decl = parent->AddDeclaration(cmd->cmdAddress, i == 0 ? DeclarationAlignment::Align16 : DeclarationAlignment::None, 8, StringHelper::Sprintf("static %s", cmd->GetCommandCName().c_str()),
StringHelper::Sprintf("%sSet%04XCmd%02X", name.c_str(), commandSet & 0x00FFFFFF, cmd->cmdIndex, cmd->cmdID),
StringHelper::Sprintf("%s", pass1.c_str()));
@ -298,7 +302,7 @@ void ZRoom::ProcessCommandSets()
string pass2 = cmd->GenerateSourceCodePass2(name, cmd->commandSet);
if (pass2 != "")
parent->AddDeclaration(cmd->cmdAddress, DeclarationAlignment::None, 8, cmd->GetCommandCName(), StringHelper::Sprintf("%sSet%04XCmd%02X", name.c_str(), cmd->commandSet & 0x00FFFFFF, cmd->cmdIndex, cmd->cmdID), StringHelper::Sprintf("%s // 0x%04X", pass2.c_str(), cmd->cmdAddress));
parent->AddDeclaration(cmd->cmdAddress, DeclarationAlignment::None, 8, StringHelper::Sprintf("static %s", cmd->GetCommandCName().c_str()), StringHelper::Sprintf("%sSet%04XCmd%02X", name.c_str(), cmd->commandSet & 0x00FFFFFF, cmd->cmdIndex, cmd->cmdID), StringHelper::Sprintf("%s // 0x%04X", pass2.c_str(), cmd->cmdAddress));
}
}
@ -308,7 +312,7 @@ void ZRoom::ProcessCommandSets()
*/
void ZRoom::SyotesRoomHack()
{
char headerData[] =
char headerData[] =
{
0x0A, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x08
};
@ -392,10 +396,10 @@ size_t ZRoom::GetCommandSizeFromNeighbor(ZRoomCommand* cmd)
return 0;
}
string ZRoom::GetSourceOutputHeader(string prefix)
string ZRoom::GetSourceOutputHeader(const std::string& prefix)
{
sourceOutput = "";
for (ZRoomCommand* cmd : commands)
sourceOutput += cmd->GenerateExterns();
@ -407,7 +411,7 @@ string ZRoom::GetSourceOutputHeader(string prefix)
return sourceOutput;
}
string ZRoom::GetSourceOutputCode(std::string prefix)
string ZRoom::GetSourceOutputCode(const std::string& prefix)
{
sourceOutput = "";
@ -466,9 +470,9 @@ string ZRoom::GetSourceOutputCode(std::string prefix)
declaration += item.second->GetSourceOutputCode(prefix);
if (Globals::Instance->debugMessages)
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("SAVING IMAGE TO %s\n", Globals::Instance->outputPath.c_str());
item.second->Save(Globals::Instance->outputPath);
parent->AddDeclarationIncludeArray(item.first, StringHelper::Sprintf("%s/%s.%s.inc.c",
@ -501,7 +505,7 @@ ZResourceType ZRoom::GetResourceType()
return ZResourceType::Room;
}
void ZRoom::Save(string outFolder)
void ZRoom::Save(const std::string& outFolder)
{
for (ZRoomCommand* cmd : commands)
cmd->Save();
@ -578,4 +582,4 @@ CommandSet::CommandSet(int32_t nAddress, int32_t nCommandCount)
{
address = nAddress;
commandCount = nCommandCount;
}
}

11
tools/ZAPD/ZAPD/ZRoom/ZRoom.h
View file

@ -3,7 +3,7 @@
#include "../ZResource.h"
#include "ZRoomCommand.h"
#include "ZTexture.h"
#include "../tinyxml2.h"
#include <tinyxml2.h>
#include <vector>
#include <map>
@ -14,12 +14,13 @@ class ZRoom : public ZResource
protected:
std::vector<ZRoomCommand*> commands;
std::string GetSourceOutputHeader(std::string prefix);
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputHeader(const std::string& prefix);
std::string GetSourceOutputCode(const std::string& prefix);
void ProcessCommandSets();
void SyotesRoomHack();
ZRoom();
~ZRoom();
public:
ZRoom* scene;
@ -36,7 +37,7 @@ public:
std::vector<uint8_t> GetRawData();
int GetRawDataSize();
virtual ZResourceType GetResourceType();
virtual void Save(std::string outFolder);
virtual void Save(const std::string& outFolder);
virtual void PreGenSourceFiles();
};
@ -47,4 +48,4 @@ struct CommandSet
CommandSet(int32_t nAddress);
CommandSet(int32_t nAddress, int32_t nCommandCount);
};
};

2
tools/ZAPD/ZAPD/ZRoom/ZRoomCommand.h
View file

@ -1,6 +1,6 @@
#pragma once
#include "../tinyxml2.h"
#include <tinyxml2.h>
#include <vector>
#include <string>

231
tools/ZAPD/ZAPD/ZScalar.cpp Normal file
View file

@ -0,0 +1,231 @@
#include "ZScalar.h"
#include "ZFile.h"
#include "BitConverter.h"
#include "StringHelper.h"
#include "File.h"
#include "Globals.h"
ZScalar* ZScalar::ExtractFromXML(tinyxml2::XMLElement* reader, const std::vector<uint8_t>& nRawData, const int rawDataIndex, const std::string& nRelPath)
{
ZScalar* scalar = new ZScalar();
scalar->rawData = nRawData;
scalar->rawDataIndex = rawDataIndex;
scalar->ParseXML(reader);
scalar->ParseRawData();
return scalar;
}
ZScalar::ZScalar() : ZResource()
{
memset(&scalarData, 0, sizeof(ZScalarData));
scalarType = ZSCALAR_NONE;
}
ZScalar::ZScalar(const ZScalarType scalarType) : ZScalar()
{
this->scalarType = scalarType;
}
void ZScalar::ParseXML(tinyxml2::XMLElement* reader)
{
ZResource::ParseXML(reader);
name = reader->Attribute("Name");
std::string type = reader->Attribute("Type");
scalarType = ZScalar::MapOutputTypeToScalarType(type);
}
ZScalarType ZScalar::MapOutputTypeToScalarType(const std::string& type) {
if (type == "s8")
{
return ZSCALAR_S8;
}
else if (type == "u8")
{
return ZSCALAR_U8;
}
else if (type == "s16")
{
return ZSCALAR_S16;
}
else if (type == "u16")
{
return ZSCALAR_U16;
}
else if (type == "s32")
{
return ZSCALAR_S32;
}
else if (type == "u32")
{
return ZSCALAR_U32;
}
else if (type == "s64")
{
return ZSCALAR_S64;
}
else if (type == "u64")
{
return ZSCALAR_U64;
}
else if (type == "f32")
{
return ZSCALAR_F32;
}
else if (type == "f64")
{
return ZSCALAR_F64;
}
return ZSCALAR_NONE;
}
std::string ZScalar::MapScalarTypeToOutputType(const ZScalarType scalarType)
{
switch (scalarType) {
case ZSCALAR_S8:
return "s8";
case ZSCALAR_U8:
return "u8";
case ZSCALAR_S16:
return "s16";
case ZSCALAR_U16:
return "u16";
case ZSCALAR_S32:
return "s32";
case ZSCALAR_U32:
return "u32";
case ZSCALAR_S64:
return "s64";
case ZSCALAR_U64:
return "u64";
case ZSCALAR_F32:
return "f32";
case ZSCALAR_F64:
return "f64";
default:
return "";
}
}
int ZScalar::MapTypeToSize(const ZScalarType scalarType)
{
switch (scalarType) {
case ZSCALAR_S8:
return sizeof(scalarData.s8);
case ZSCALAR_U8:
return sizeof(scalarData.u8);
case ZSCALAR_S16:
return sizeof(scalarData.s16);
case ZSCALAR_U16:
return sizeof(scalarData.u16);
case ZSCALAR_S32:
return sizeof(scalarData.s32);
case ZSCALAR_U32:
return sizeof(scalarData.u32);
case ZSCALAR_S64:
return sizeof(scalarData.s64);
case ZSCALAR_U64:
return sizeof(scalarData.u64);
case ZSCALAR_F32:
return sizeof(scalarData.f32);
case ZSCALAR_F64:
return sizeof(scalarData.f64);
default:
return 0;
}
}
int ZScalar::GetRawDataSize()
{
return ZScalar::MapTypeToSize(scalarType);
}
void ZScalar::ParseRawData()
{
ZScalar::ParseRawData(rawData, rawDataIndex);
}
void ZScalar::ParseRawData(const std::vector<uint8_t>& data, const int offset)
{
switch (scalarType) {
case ZSCALAR_S8:
scalarData.s8 = BitConverter::ToInt8BE(data, offset);
break;
case ZSCALAR_U8:
scalarData.u8 = BitConverter::ToUInt8BE(data, offset);
break;
case ZSCALAR_S16:
scalarData.s16 = BitConverter::ToInt16BE(data, offset);
break;
case ZSCALAR_U16:
scalarData.u16 = BitConverter::ToUInt16BE(data, offset);
break;
case ZSCALAR_S32:
scalarData.s32 = BitConverter::ToInt32BE(data, offset);
break;
case ZSCALAR_U32:
scalarData.u32 = BitConverter::ToUInt32BE(data, offset);
break;
case ZSCALAR_S64:
scalarData.s64 = BitConverter::ToInt64BE(data, offset);
break;
case ZSCALAR_U64:
scalarData.u64 = BitConverter::ToUInt64BE(data, offset);
break;
case ZSCALAR_F32:
scalarData.f32 = BitConverter::ToFloatBE(data, offset);
break;
case ZSCALAR_F64:
scalarData.f64 = BitConverter::ToDoubleBE(data, offset);
break;
}
}
std::string ZScalar::GetSourceTypeName()
{
return ZScalar::MapScalarTypeToOutputType(scalarType);
}
std::string ZScalar::GetSourceValue()
{
switch (scalarType) {
case ZSCALAR_S8:
return StringHelper::Sprintf("%hhd", scalarData.s8);
case ZSCALAR_U8:
return StringHelper::Sprintf("%hhu", scalarData.u8);
case ZSCALAR_S16:
return StringHelper::Sprintf("%hd", scalarData.s16);
case ZSCALAR_U16:
return StringHelper::Sprintf("%hu", scalarData.u16);
case ZSCALAR_S32:
return StringHelper::Sprintf("%d", scalarData.s32);
case ZSCALAR_U32:
return StringHelper::Sprintf("%u", scalarData.u32);
case ZSCALAR_S64:
return StringHelper::Sprintf("%lld", scalarData.s64);
case ZSCALAR_U64:
return StringHelper::Sprintf("%llu", scalarData.u64);
case ZSCALAR_F32:
return StringHelper::Sprintf("%f", scalarData.f32);
case ZSCALAR_F64:
return StringHelper::Sprintf("%lf", scalarData.f64);
default:
return "";
}
}
std::string ZScalar::GetSourceOutputCode(const std::string& prefix)
{
if (parent != nullptr)
parent->AddDeclaration(rawDataIndex, DeclarationAlignment::None, GetRawDataSize(), GetSourceTypeName(), GetName(), GetSourceValue());
return "";
}
ZResourceType ZScalar::GetResourceType()
{
return ZResourceType::Scalar;
}

61
tools/ZAPD/ZAPD/ZScalar.h Normal file
View file

@ -0,0 +1,61 @@
#pragma once
#include <vector>
#include <string>
#include <stdint.h>
#include "ZResource.h"
#include "tinyxml2.h"
typedef enum ZScalarType {
ZSCALAR_NONE,
ZSCALAR_S8,
ZSCALAR_U8,
ZSCALAR_S16,
ZSCALAR_U16,
ZSCALAR_S32,
ZSCALAR_U32,
ZSCALAR_S64,
ZSCALAR_U64,
ZSCALAR_F32,
ZSCALAR_F64
} ZScalarType;
typedef union ZScalarData {
uint8_t u8;
int8_t s8;
uint16_t u16;
int16_t s16;
uint32_t u32;
int32_t s32;
uint64_t u64;
int64_t s64;
float f32;
double f64;
} ZScalarData;
class ZScalar : public ZResource
{
friend class ZVector;
public:
ZScalarData scalarData;
ZScalarType scalarType;
ZScalar();
ZScalar(const ZScalarType scalarType);
void ParseXML(tinyxml2::XMLElement* reader);
std::string GetSourceTypeName();
std::string GetSourceValue();
std::string GetSourceOutputCode(const std::string& prefix);
int GetRawDataSize();
ZResourceType GetResourceType();
static ZScalar* ExtractFromXML(tinyxml2::XMLElement* reader, const std::vector<uint8_t>& nRawData, const int rawDataIndex, const std::string& nRelPath);
static int MapTypeToSize(const ZScalarType scalarType);
static ZScalarType MapOutputTypeToScalarType(const std::string& type);
static std::string MapScalarTypeToOutputType(const ZScalarType scalarType);
protected:
void ParseRawData();
void ParseRawData(const std::vector<uint8_t>& data, const int offset);
};

20
tools/ZAPD/ZAPD/ZSkeleton.cpp
View file

@ -50,16 +50,16 @@ ZLimbStandard* ZLimbStandard::FromRawData(std::vector<uint8_t> nRawData, int raw
limb->transX = BitConverter::ToInt16BE(nRawData, rawDataIndex + 0);
limb->transY = BitConverter::ToInt16BE(nRawData, rawDataIndex + 2);
limb->transZ = BitConverter::ToInt16BE(nRawData, rawDataIndex + 4);
limb->childIndex = nRawData[rawDataIndex + 6];
limb->siblingIndex = nRawData[rawDataIndex + 7];
limb->dListPtr = BitConverter::ToInt32BE(nRawData, rawDataIndex + 8) & 0x00FFFFFF;
return limb;
}
string ZLimbStandard::GetSourceOutputCode(string prefix)
string ZLimbStandard::GetSourceOutputCode(const std::string& prefix)
{
string dListStr = dListPtr == 0 ? "NULL" : StringHelper::Sprintf("%s", parent->GetVarName(dListPtr).c_str());
@ -154,7 +154,7 @@ ZSkeleton* ZSkeleton::FromXML(XMLElement* reader, vector<uint8_t> nRawData, int
return skeleton;
}
std::string ZSkeleton::GetSourceOutputCode(std::string prefix)
std::string ZSkeleton::GetSourceOutputCode(const std::string& prefix)
{
if (parent != nullptr)
{
@ -164,7 +164,7 @@ std::string ZSkeleton::GetSourceOutputCode(std::string prefix)
for (int i = 0; i < limbs.size(); i++)
{
ZLimbStandard* limb = limbs[i];
string defaultDLName = StringHelper::Sprintf("%sLimbDL_%06X", defaultPrefix.c_str(), limb->dListPtr);
string dListStr = limb->dListPtr == 0 ? "NULL" : StringHelper::Sprintf("%s", parent->GetDeclarationName(limb->dListPtr, defaultDLName).c_str());
@ -224,10 +224,12 @@ std::string ZSkeleton::GetSourceOutputCode(std::string prefix)
//string decl = StringHelper::Sprintf(" &_%sLimb_%04X,\n", prefix.c_str(), limb->address);
string decl = "";
if (parent->HasDeclaration(limb->address))
if (parent->HasDeclaration(limb->address)) {
decl = StringHelper::Sprintf(" &%s,", parent->GetDeclarationName(limb->address).c_str());
if (i != (limbs.size() - 1))
if (i != (limbs.size() - 1)) {
decl += "\n";
}
}
tblStr += decl;
}
@ -257,7 +259,7 @@ std::string ZSkeleton::GetSourceOutputCode(std::string prefix)
return "";
}
void ZSkeleton::Save(string outFolder)
void ZSkeleton::Save(const std::string& outFolder)
{
}
@ -286,7 +288,7 @@ ZLimbLOD* ZLimbLOD::FromRawData(vector<uint8_t> nRawData, int rawDataIndex)
return limb;
}
string ZLimbLOD::GetSourceOutputCode(string prefix)
string ZLimbLOD::GetSourceOutputCode(const std::string& prefix)
{
return std::string();
}

10
tools/ZAPD/ZAPD/ZSkeleton.h
View file

@ -25,7 +25,7 @@ struct ZLimbStandard : public ZResource
ZLimbStandard();
static ZLimbStandard* FromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath, ZFile* parent);
static ZLimbStandard* FromRawData(std::vector<uint8_t> nRawData, int rawDataIndex);
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputCode(const std::string& prefix);
virtual int GetRawDataSize();
};
@ -36,7 +36,7 @@ struct ZLimbLOD : ZLimbStandard
ZLimbLOD();
//static ZLimbLOD* FromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath, ZFile* parent);
static ZLimbLOD* FromRawData(std::vector<uint8_t> nRawData, int rawDataIndex);
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputCode(const std::string& prefix);
virtual int GetRawDataSize();
};
@ -58,7 +58,7 @@ public:
ZSkeleton();
virtual void GenerateHLIntermediette(HLFileIntermediette& hlFile);
static ZSkeleton* FromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath, ZFile* nParent);
void Save(std::string outFolder);
void Save(const std::string& outFolder);
std::string GetSourceOutputCode(std::string prefix);
};
std::string GetSourceOutputCode(const std::string& prefix);
};

46
tools/ZAPD/ZAPD/ZTexture.cpp
View file

@ -21,6 +21,7 @@ ZTexture::ZTexture() : ZResource()
width = 0;
height = 0;
type = TextureType::Error;
isPalette = false;
}
ZTexture::~ZTexture()
@ -98,12 +99,12 @@ ZTexture* ZTexture::FromPNG(string pngFilePath, TextureType texType)
ZTexture* tex = new ZTexture();
tex->type = texType;
tex->name = StringHelper::Split(Path::GetFileNameWithoutExtension(pngFilePath), ".")[0];
tex->bmpRgb = (uint8_t*)stbi_load((pngFilePath).c_str(), &tex->width, &tex->height, &comp, STBI_rgb);
stbi_image_free(tex->bmpRgb);
tex->bmpRgb = nullptr;
tex->rawData = vector<uint8_t>(tex->GetRawDataSize());
switch (texType)
{
case TextureType::RGBA16bpp: tex->PrepareRawDataRGBA16(pngFilePath); break;
@ -116,7 +117,7 @@ ZTexture* ZTexture::FromPNG(string pngFilePath, TextureType texType)
case TextureType::Palette4bpp: tex->PrepareRawDataPalette4(pngFilePath); break;
case TextureType::Palette8bpp: tex->PrepareRawDataPalette8(pngFilePath); break;
}
tex->FixRawData();
return tex;
@ -129,7 +130,7 @@ ZTexture* ZTexture::FromHLTexture(HLTexture* hlTex)
tex->width = hlTex->width;
tex->height = hlTex->height;
tex->type = (TextureType)hlTex->type;
return tex;
}
@ -139,14 +140,14 @@ void ZTexture::ParseXML(XMLElement* reader)
if (reader->Attribute("Width") != nullptr)
width = atoi(reader->Attribute("Width"));
if (reader->Attribute("Height") != nullptr)
height = atoi(reader->Attribute("Height"));
string formatStr = reader->Attribute("Format");
type = GetTextureTypeFromString(formatStr);
if (type == TextureType::Error)
throw "Format " + formatStr + " is not supported!";
}
@ -260,7 +261,7 @@ void ZTexture::PrepareBitmapGrayscale8()
for (int x = 0; x < width; x++)
{
int pos = ((y * width) + x) * 1;
bmpRgb[(((y * width) + x) * 3) + 0] = rawData[pos];
bmpRgb[(((y * width) + x) * 3) + 1] = rawData[pos];
bmpRgb[(((y * width) + x) * 3) + 2] = rawData[pos];
@ -363,7 +364,7 @@ void ZTexture::PrepareBitmapPalette8()
for (int x = 0; x < width; x++)
{
int pos = ((y * width) + x) * 1;
bmpRgb[(((y * width) + x) * 3) + 0] = rawData[pos];
bmpRgb[(((y * width) + x) * 3) + 1] = rawData[pos];
bmpRgb[(((y * width) + x) * 3) + 2] = rawData[pos];
@ -426,7 +427,7 @@ void ZTexture::PrepareRawDataRGBA32(string rgbaPath)
int comp;
bmpRgba = (uint8_t*)stbi_load(rgbaPath.c_str(), &width, &height, &comp, STBI_rgb_alpha);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
@ -518,7 +519,7 @@ void ZTexture::PrepareRawDataGrayscaleAlpha8(string grayAlphaPath)
int comp;
bmpRgba = (uint8_t*)stbi_load(grayAlphaPath.c_str(), &width, &height, &comp, STBI_rgb_alpha);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
@ -657,7 +658,22 @@ int ZTexture::GetHeight()
return height;
}
void ZTexture::Save(string outFolder)
void ZTexture::SetWidth(int nWidth)
{
width = nWidth;
}
void ZTexture::SetHeight(int nHeight)
{
height = nHeight;
}
TextureType ZTexture::GetTextureType()
{
return type;
}
void ZTexture::Save(const std::string& outFolder)
{
if (type == TextureType::RGBA32bpp)
stbi_write_png((outFolder + "/" + outName + ".rgba32.png").c_str(), width, height, 4, bmpRgba, width * 4);
@ -683,7 +699,7 @@ void ZTexture::Save(string outFolder)
}
// HOTSPOT
string ZTexture::GetSourceOutputCode(std::string prefix)
string ZTexture::GetSourceOutputCode(const std::string& prefix)
{
sourceOutput = "";
@ -703,7 +719,7 @@ string ZTexture::GetSourceOutputCode(std::string prefix)
if (i % 32 == 0)
sourceOutput += "\t";
sourceOutput += StringHelper::Sprintf("0x%016llX, ", BitConverter::ToInt64BE(rawDataArr, i));
sourceOutput += StringHelper::Sprintf("0x%016llX, ", BitConverter::ToUInt64BE(rawDataArr, i));
if (i % 32 == 24)
sourceOutput += StringHelper::Sprintf(" // 0x%06X \n", rawDataIndex + ((i / 32) * 32));
@ -748,7 +764,7 @@ std::string ZTexture::GetExternalExtension()
}
string ZTexture::GetSourceOutputHeader(std::string prefix)
string ZTexture::GetSourceOutputHeader(const std::string& prefix)
{
//return StringHelper::Sprintf("extern u64 %s[];\n", name.c_str());
return "";
@ -778,4 +794,4 @@ TextureType ZTexture::GetTextureTypeFromString(string str)
texType = TextureType::Palette8bpp;
return texType;
}
}

13
tools/ZAPD/ZAPD/ZTexture.h
View file

@ -60,6 +60,8 @@ public:
ZTexture();
~ZTexture();
bool isPalette;
static ZTexture* BuildFromXML(tinyxml2::XMLElement* reader, std::string inFolder, bool readFile);
static ZTexture* ExtractFromXML(tinyxml2::XMLElement* reader, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nRelPath);
static ZTexture* FromBinary(TextureType nType, std::vector<uint8_t> nRawData, int rawDataIndex, std::string nName, int nWidth, int nHeight);
@ -67,8 +69,8 @@ public:
static ZTexture* FromHLTexture(HLTexture* hlTex);
static TextureType GetTextureTypeFromString(std::string str);
std::string GetSourceOutputCode(std::string prefix);
std::string GetSourceOutputHeader(std::string prefix);
std::string GetSourceOutputCode(const std::string& prefix) override;
std::string GetSourceOutputHeader(const std::string& prefix) override;
std::vector<uint8_t> GetRawData();
int GetRawDataSize();
@ -76,6 +78,9 @@ public:
std::string GetIMSizFromType();
int GetWidth();
int GetHeight();
void Save(std::string outFolder);
void SetWidth(int nWidth);
void SetHeight(int nHeight);
TextureType GetTextureType();
void Save(const std::string& outFolder);
std::string GetExternalExtension();
};
};

111
tools/ZAPD/ZAPD/ZVector.cpp Normal file
View file

@ -0,0 +1,111 @@
#include "ZVector.h"
#include "ZFile.h"
#include "BitConverter.h"
#include "StringHelper.h"
#include "File.h"
#include "Globals.h"
#include <assert.h>
ZVector::ZVector() : ZResource()
{
scalars = std::vector<ZScalar*>();
this->scalarType = ZSCALAR_NONE;
this->dimensions = 0;
}
ZVector* ZVector::ExtractFromXML(tinyxml2::XMLElement* reader, const std::vector<uint8_t>& nRawData, const int rawDataIndex, const std::string& nRelPath)
{
ZVector* vector = new ZVector();
vector->rawData = nRawData;
vector->rawDataIndex = rawDataIndex;
vector->ParseXML(reader);
vector->ParseRawData();
return vector;
}
void ZVector::ParseXML(tinyxml2::XMLElement* reader)
{
ZResource::ParseXML(reader);
name = reader->Attribute("Name");
std::string type = reader->Attribute("Type");
this->scalarType = ZScalar::MapOutputTypeToScalarType(type);
std::string dimensions = reader->Attribute("Dimensions");
this->dimensions = strtol(dimensions.c_str(), NULL, 16);
}
void ZVector::ParseRawData()
{
int currentRawDataIndex = this->rawDataIndex;
scalars.clear();
for (int i = 0; i < this->dimensions; i++) {
ZScalar* scalar = new ZScalar(this->scalarType);
scalar->rawDataIndex = currentRawDataIndex;
scalar->rawData = this->rawData;
scalar->ParseRawData();
currentRawDataIndex += scalar->GetRawDataSize();
this->scalars.push_back(scalar);
}
// Ensure the scalars vector has the same number of elements as the vector dimension.
assert(this->scalars.size() == this->dimensions);
}
int ZVector::GetRawDataSize()
{
int size = 0;
for (int i = 0; i < this->scalars.size(); i++)
size += this->scalars[i]->GetRawDataSize();
return size;
}
std::string ZVector::GetSourceTypeName()
{
if (dimensions == 3 && scalarType == ZSCALAR_F32)
{
return "Vec3f";
}
else if (dimensions == 3 && scalarType == ZSCALAR_S16)
{
return "Vec3s";
}
else if (dimensions == 3 && scalarType == ZSCALAR_S32)
{
return "Vec3i";
}
else
{
std::string output = StringHelper::Sprintf("Encountered unsupported vector type: %d dimensions, %s type", dimensions, ZScalar::MapScalarTypeToOutputType(scalarType));
if (Globals::Instance->verbosity >= VERBOSITY_DEBUG)
printf("%s\n", output.c_str());
throw output;
}
}
std::string ZVector::GetSourceValue()
{
std::vector<std::string> strings = std::vector<std::string>();
for (int i = 0; i < this->scalars.size(); i++)
strings.push_back(scalars[i]->GetSourceValue());
return StringHelper::Implode(strings, ", ");
}
std::string ZVector::GetSourceOutputCode(const std::string& prefix)
{
if (parent != nullptr)
parent->AddDeclaration(rawDataIndex, DeclarationAlignment::None, GetRawDataSize(), GetSourceTypeName(), GetName(), GetSourceValue());
return "";
}
ZResourceType ZVector::GetResourceType()
{
return ZResourceType::Vector;
}

30
tools/ZAPD/ZAPD/ZVector.h Normal file
View file

@ -0,0 +1,30 @@
#pragma once
#include <vector>
#include <string>
#include <stdint.h>
#include "ZResource.h"
#include "ZScalar.h"
#include "tinyxml2.h"
class ZVector : public ZResource
{
public:
std::vector<ZScalar*> scalars;
ZScalarType scalarType;
uint32_t dimensions;
ZVector();
void ParseXML(tinyxml2::XMLElement* reader);
std::string GetSourceTypeName();
std::string GetSourceValue();
std::string GetSourceOutputCode(const std::string& prefix);
int GetRawDataSize();
ZResourceType GetResourceType();
static ZVector* ExtractFromXML(tinyxml2::XMLElement* reader, const std::vector<uint8_t>& nRawData, const int rawDataIndex, const std::string& nRelPath);
protected:
void ParseRawData();
};

0
tools/ZAPD/ZAPD/Libs/assimp-vc142-mt.dll → tools/ZAPD/lib/assimp-built/assimp-vc142-mt.dll
View file

0
tools/ZAPD/ZAPD/Libs/assimp-vc142-mt.lib → tools/ZAPD/lib/assimp-built/assimp-vc142-mt.lib
View file

0
tools/ZAPD/ZAPD/assimp/.editorconfig → tools/ZAPD/lib/assimp/include/assimp/.editorconfig
View file

0
tools/ZAPD/ZAPD/assimp/BaseImporter.h → tools/ZAPD/lib/assimp/include/assimp/BaseImporter.h
View file

0
tools/ZAPD/ZAPD/assimp/Bitmap.h → tools/ZAPD/lib/assimp/include/assimp/Bitmap.h
View file

0
tools/ZAPD/ZAPD/assimp/BlobIOSystem.h → tools/ZAPD/lib/assimp/include/assimp/BlobIOSystem.h
View file

0
tools/ZAPD/ZAPD/assimp/ByteSwapper.h → tools/ZAPD/lib/assimp/include/assimp/ByteSwapper.h
View file

0
tools/ZAPD/ZAPD/assimp/Compiler/poppack1.h → tools/ZAPD/lib/assimp/include/assimp/Compiler/poppack1.h
View file

0
tools/ZAPD/ZAPD/assimp/Compiler/pstdint.h → tools/ZAPD/lib/assimp/include/assimp/Compiler/pstdint.h
View file

0
tools/ZAPD/ZAPD/assimp/Compiler/pushpack1.h → tools/ZAPD/lib/assimp/include/assimp/Compiler/pushpack1.h
View file

0
tools/ZAPD/ZAPD/assimp/CreateAnimMesh.h → tools/ZAPD/lib/assimp/include/assimp/CreateAnimMesh.h
View file

0
tools/ZAPD/ZAPD/assimp/DefaultIOStream.h → tools/ZAPD/lib/assimp/include/assimp/DefaultIOStream.h
View file

0
tools/ZAPD/ZAPD/assimp/DefaultIOSystem.h → tools/ZAPD/lib/assimp/include/assimp/DefaultIOSystem.h
View file

0
tools/ZAPD/ZAPD/assimp/DefaultLogger.hpp → tools/ZAPD/lib/assimp/include/assimp/DefaultLogger.hpp
View file

0
tools/ZAPD/ZAPD/assimp/Defines.h → tools/ZAPD/lib/assimp/include/assimp/Defines.h
View file

0
tools/ZAPD/ZAPD/assimp/Exceptional.h → tools/ZAPD/lib/assimp/include/assimp/Exceptional.h
View file

0
tools/ZAPD/ZAPD/assimp/Exporter.hpp → tools/ZAPD/lib/assimp/include/assimp/Exporter.hpp
View file

0
tools/ZAPD/ZAPD/assimp/GenericProperty.h → tools/ZAPD/lib/assimp/include/assimp/GenericProperty.h
View file

0
tools/ZAPD/ZAPD/assimp/Hash.h → tools/ZAPD/lib/assimp/include/assimp/Hash.h
View file

0
tools/ZAPD/ZAPD/assimp/IOStream.hpp → tools/ZAPD/lib/assimp/include/assimp/IOStream.hpp
View file

0
tools/ZAPD/ZAPD/assimp/IOStreamBuffer.h → tools/ZAPD/lib/assimp/include/assimp/IOStreamBuffer.h
View file

0
tools/ZAPD/ZAPD/assimp/IOSystem.hpp → tools/ZAPD/lib/assimp/include/assimp/IOSystem.hpp
View file

0
tools/ZAPD/ZAPD/assimp/Importer.hpp → tools/ZAPD/lib/assimp/include/assimp/Importer.hpp
View file

0
tools/ZAPD/ZAPD/assimp/LineSplitter.h → tools/ZAPD/lib/assimp/include/assimp/LineSplitter.h
View file

0
tools/ZAPD/ZAPD/assimp/LogAux.h → tools/ZAPD/lib/assimp/include/assimp/LogAux.h
View file

0
tools/ZAPD/ZAPD/assimp/LogStream.hpp → tools/ZAPD/lib/assimp/include/assimp/LogStream.hpp
View file

0
tools/ZAPD/ZAPD/assimp/Logger.hpp → tools/ZAPD/lib/assimp/include/assimp/Logger.hpp
View file

0
tools/ZAPD/ZAPD/assimp/Macros.h → tools/ZAPD/lib/assimp/include/assimp/Macros.h
View file

0
tools/ZAPD/ZAPD/assimp/MathFunctions.h → tools/ZAPD/lib/assimp/include/assimp/MathFunctions.h
View file

0
tools/ZAPD/ZAPD/assimp/MemoryIOWrapper.h → tools/ZAPD/lib/assimp/include/assimp/MemoryIOWrapper.h
View file

0
tools/ZAPD/ZAPD/assimp/NullLogger.hpp → tools/ZAPD/lib/assimp/include/assimp/NullLogger.hpp
View file

0
tools/ZAPD/ZAPD/assimp/ParsingUtils.h → tools/ZAPD/lib/assimp/include/assimp/ParsingUtils.h
View file

0
tools/ZAPD/ZAPD/assimp/Profiler.h → tools/ZAPD/lib/assimp/include/assimp/Profiler.h
View file

0
tools/ZAPD/ZAPD/assimp/ProgressHandler.hpp → tools/ZAPD/lib/assimp/include/assimp/ProgressHandler.hpp
View file

0
tools/ZAPD/ZAPD/assimp/RemoveComments.h → tools/ZAPD/lib/assimp/include/assimp/RemoveComments.h
View file

0
tools/ZAPD/ZAPD/assimp/SGSpatialSort.h → tools/ZAPD/lib/assimp/include/assimp/SGSpatialSort.h
View file

0
tools/ZAPD/ZAPD/assimp/SceneCombiner.h → tools/ZAPD/lib/assimp/include/assimp/SceneCombiner.h
View file

Some files were not shown because too many files have changed in this diff Show more