cafeberry/ImXui
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
ImXui/tools/xuitool.cpp
T
qloak 80e222fa04 initial commit
2026-08-27 17:15:05 -07:00

1015 lines
34 KiB
C++
Raw Permalink Blame History

#include "ImXui/XurFormat.h"
#include "ImXui/XurWriter.h"
#include "ImXui/XurXml.h"
#include <cstdio>
#include <cstring>
#include <cstdint>
#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
#include "zlib.h"
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
namespace {
const char* TOOL_VERSION = "0.1.0";
enum class FileFormat { Unknown, XUI, XUR };
struct XurHeaderInfo {
bool valid;
uint32_t version;
uint32_t flags;
uint32_t fileSize;
uint16_t sectionsCount;
XurHeaderInfo() : valid(false), version(0), flags(0), fileSize(0), sectionsCount(0) {}
};
std::string lower(const std::string& s) {
std::string r = s;
for (size_t i = 0; i < r.size(); i++)
if (r[i] >= 'A' && r[i] <= 'Z') r[i] = (char)(r[i] - 'A' + 'a');
return r;
}
std::string ws2s(const std::wstring& ws) {
return std::string(ws.begin(), ws.end());
}
bool hasExtension(const std::string& path, const char* ext) {
if (path.size() < strlen(ext)) return false;
return lower(path.substr(path.size() - strlen(ext))) == ext;
}
FileFormat detectFormat(const std::string& path) {
std::vector<uint8_t> head(16, 0);
{
std::ifstream ifs(path, std::ios::binary);
if (ifs) ifs.read((char*)head.data(), 16);
}
if (head.size() >= 4 && memcmp(head.data(), "XUIB", 4) == 0)
return FileFormat::XUR;
if (head.size() >= 1 && (head[0] == '<' || head[0] == 0xEF || head[0] == 0xFF || head[0] == 0xFE))
return FileFormat::XUI;
if (hasExtension(path, ".xur")) return FileFormat::XUR;
if (hasExtension(path, ".xui")) return FileFormat::XUI;
return FileFormat::Unknown;
}
XurHeaderInfo readXurHeader(const std::string& path) {
XurHeaderInfo info;
std::ifstream ifs(path, std::ios::binary);
if (!ifs) return info;
uint8_t bytes[20];
ifs.read((char*)bytes, 20);
if (ifs.gcount() < 20) return info;
if (memcmp(bytes, "XUIB", 4) != 0) return info;
auto be32 = [&](size_t off) -> uint32_t {
return ((uint32_t)bytes[off] << 24) | ((uint32_t)bytes[off + 1] << 16) |
((uint32_t)bytes[off + 2] << 8) | (uint32_t)bytes[off + 3];
};
auto be16 = [&](size_t off) -> uint16_t {
return (uint16_t)(((uint16_t)bytes[off] << 8) | (uint16_t)bytes[off + 1]);
};
info.valid = true;
info.version = be32(4);
info.flags = be32(8);
info.fileSize = be32(14);
info.sectionsCount = be16(18);
return info;
}
const char* formatName(FileFormat f) {
switch (f) {
case FileFormat::XUI: return "XUI v12";
case FileFormat::XUR: return "XUR";
default: return "unknown";
}
}
void usage() {
std::cout <<
"XUITool " << TOOL_VERSION << " - ImXui alternative to XUIHelper / XuiTool\n"
"Reads, writes and converts XUI and XUR files (Xbox 360 UI format).\n"
"\n"
"Usage:\n"
" xuitool about\n"
" Print version and supported formats.\n"
" xuitool info <file>\n"
" Detect format and print a summary of a .xui / .xur file.\n"
" xuitool validate <file>\n"
" Parse a file and report validity. Exit code 0 = valid.\n"
" xuitool conv -s <src> -o <dst> [-f xurv5|xuiv12]\n"
" Convert a single file. Input format is auto-detected; output\n"
" format comes from -f or is inferred from the output extension.\n"
" xuitool massconv -s <dir> -o <dir> [-f xurv5|xuiv12] [-r]\n"
" Convert every .xui / .xur file in a directory (recursive with -r).\n"
" xuitool swf2xui <file.swf> [output.xui]\n"
" Convert a Flash SWF to XUI XML (shapes, sprites, buttons).\n";
}
bool loadObject(const std::string& path, FileFormat fmt, ImXui::XurFormat::XurObject& out) {
if (fmt == FileFormat::XUR) {
auto doc = ImXui::XurFormat::XurParser::parseFromFile(path);
if (!doc || !ImXui::XurFormat::XurParser::validate(doc.get())) return false;
out = doc->rootObject;
return true;
}
out = ImXui::XurFormat::xuiFileToObject(path);
return !out.className.empty();
}
bool writeObject(const std::string& dst, const ImXui::XurFormat::XurObject& obj, bool toXur) {
if (toXur)
return ImXui::XurFormat::XurWriter::writeToFile(dst, obj);
return ImXui::XurFormat::xurObjectToXuiXml(obj, dst);
}
void dumpObjectTree(const ImXui::XurFormat::XurObject& obj, int depth) {
std::string indent((size_t)depth * 2, ' ');
std::cout << indent << obj.className << "\n";
for (auto& p : obj.properties) {
if (p.name == "Id" && p.type == ImXui::XurFormat::XurPropertyType_String)
std::cout << indent << " id=" << ws2s(p.value.stringVal) << "\n";
else if (p.name == "Visual" && p.type == ImXui::XurFormat::XurPropertyType_String)
std::cout << indent << " visual=" << ws2s(p.value.stringVal) << "\n";
else if (p.name == "Text" && p.type == ImXui::XurFormat::XurPropertyType_String)
std::cout << indent << " text=\"" << ws2s(p.value.stringVal) << "\"\n";
}
for (auto& c : obj.children)
dumpObjectTree(c, depth + 1);
}
int cmdAbout() {
std::cout <<
"XUITool " << TOOL_VERSION << "\n"
"An ImXui-based alternative to XUIHelper / XuiTool for editing the Xbox 360 UI format.\n"
"\n"
"Supported formats:\n"
" XUI v12 - XML scene files (version=\"000c\"), read/write\n"
" XUR v5 - compiled binary scenes, read/write\n"
" XUR v8+ - detected and reported, but not read/write capable in this build\n"
"\n"
"Library: ImXui (XurFormat, XurParser, XurWriter, XurXml)\n";
return 0;
}
int cmdInfo(const std::string& path) {
FileFormat fmt = detectFormat(path);
std::cout << "File: " << path << "\n";
std::cout << "Type: " << formatName(fmt) << "\n";
if (fmt == FileFormat::XUR) {
XurHeaderInfo hdr = readXurHeader(path);
if (!hdr.valid) {
std::cerr << "Error: not a XUR file\n";
return 1;
}
std::cout << "XUR version: " << hdr.version << "\n";
std::cout << "Flags: " << hdr.flags << "\n";
std::cout << "File size: " << hdr.fileSize << " bytes\n";
std::cout << "Sections: " << hdr.sectionsCount << "\n";
if (hdr.version != 5) {
std::cout << "Note: this build can only read/write XUR v5.\n";
return 1;
}
}
ImXui::XurFormat::XurObject obj;
if (!loadObject(path, fmt, obj)) {
std::cerr << "Error: failed to parse file\n";
return 1;
}
std::cout << "Root object: " << obj.className
<< " (" << obj.properties.size() << " props, "
<< obj.children.size() << " children)\n";
std::cout << "Object tree:\n";
dumpObjectTree(obj, 0);
return 0;
}
int cmdValidate(const std::string& path) {
FileFormat fmt = detectFormat(path);
if (fmt == FileFormat::XUR) {
XurHeaderInfo hdr = readXurHeader(path);
if (!hdr.valid) {
std::cerr << "Error: not a XUR file\n";
return 1;
}
if (hdr.version != 5) {
std::cerr << "Error: XUR v" << hdr.version << " is not supported (only v5)\n";
return 1;
}
auto doc = ImXui::XurFormat::XurParser::parseFromFile(path);
if (!doc || !ImXui::XurFormat::XurParser::validate(doc.get())) {
std::cerr << "Error: invalid XUR v5\n";
return 1;
}
std::cout << "OK: valid XUR v5\n";
return 0;
}
if (fmt == FileFormat::XUI) {
ImXui::XurFormat::XurObject obj = ImXui::XurFormat::xuiFileToObject(path);
if (obj.className.empty()) {
std::cerr << "Error: invalid XUI v12\n";
return 1;
}
std::cout << "OK: valid XUI v12\n";
return 0;
}
std::cerr << "Error: unrecognized file format\n";
return 1;
}
bool convertFile(const std::string& src, const std::string& dst,
FileFormat srcFmt, const std::string& outFormat) {
ImXui::XurFormat::XurObject obj;
if (!loadObject(src, srcFmt, obj)) {
std::cerr << "Error: failed to read '" << src << "'\n";
return false;
}
bool toXur;
if (outFormat == "xurv5") toXur = true;
else if (outFormat == "xuiv12") toXur = false;
else toXur = hasExtension(dst, ".xur");
if (!writeObject(dst, obj, toXur)) {
std::cerr << "Error: failed to write '" << dst << "'\n";
return false;
}
std::cout << "Converted " << src << " -> " << dst << "\n";
return true;
}
int cmdConv(int argc, char* argv[]) {
std::string src, dst, outFormat;
for (int i = 2; i < argc; i++) {
std::string a = argv[i];
if (a == "-s" && i + 1 < argc) src = argv[++i];
else if (a == "-o" && i + 1 < argc) dst = argv[++i];
else if (a == "-f" && i + 1 < argc) outFormat = lower(argv[++i]);
else {
std::cerr << "Unknown argument: " << a << "\n";
usage();
return 1;
}
}
if (src.empty() || dst.empty()) {
std::cerr << "conv requires -s <src> and -o <dst>\n";
usage();
return 1;
}
if (!outFormat.empty() && outFormat != "xurv5" && outFormat != "xuiv12") {
std::cerr << "Unknown output format '" << outFormat
<< "' (must be xurv5 or xuiv12)\n";
return 1;
}
FileFormat srcFmt = detectFormat(src);
if (srcFmt == FileFormat::Unknown) {
std::cerr << "Error: cannot detect format of '" << src << "'\n";
return 1;
}
if (srcFmt == FileFormat::XUR) {
XurHeaderInfo hdr = readXurHeader(src);
if (hdr.valid && hdr.version != 5) {
std::cerr << "Error: XUR v" << hdr.version << " is not supported (only v5)\n";
return 1;
}
}
return convertFile(src, dst, srcFmt, outFormat) ? 0 : 1;
}
#ifdef _WIN32
std::vector<std::string> listFiles(const std::string& dir, bool recursive) {
std::vector<std::string> files;
std::string pattern = dir + "\\*";
WIN32_FIND_DATAA fd;
HANDLE h = FindFirstFileA(pattern.c_str(), &fd);
if (h == INVALID_HANDLE_VALUE) return files;
do {
std::string name = fd.cFileName;
if (name == "." || name == "..") continue;
std::string full = dir + "\\" + name;
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
if (recursive) {
std::vector<std::string> sub = listFiles(full, recursive);
files.insert(files.end(), sub.begin(), sub.end());
}
} else if (hasExtension(name, ".xui") || hasExtension(name, ".xur")) {
files.push_back(full);
}
} while (FindNextFileA(h, &fd));
FindClose(h);
return files;
}
#else
#include <dirent.h>
#include <sys/stat.h>
static std::vector<std::string> listFiles(const std::string& dir, bool recursive) {
std::vector<std::string> files;
DIR* d = opendir(dir.c_str());
if (!d) return files;
struct dirent* ent;
while ((ent = readdir(d)) != nullptr) {
std::string name = ent->d_name;
if (name == "." || name == "..") continue;
std::string full = dir + "/" + name;
struct stat st;
if (stat(full.c_str(), &st) != 0) continue;
if (S_ISDIR(st.st_mode)) {
if (recursive) {
std::vector<std::string> sub = listFiles(full, recursive);
files.insert(files.end(), sub.begin(), sub.end());
}
} else if (hasExtension(name, ".xui") || hasExtension(name, ".xur")) {
files.push_back(full);
}
}
closedir(d);
return files;
}
#endif
int cmdMassConv(int argc, char* argv[]) {
std::string srcDir, dstDir, outFormat;
bool recursive = false;
for (int i = 2; i < argc; i++) {
std::string a = argv[i];
if (a == "-s" && i + 1 < argc) srcDir = argv[++i];
else if (a == "-o" && i + 1 < argc) dstDir = argv[++i];
else if (a == "-f" && i + 1 < argc) outFormat = lower(argv[++i]);
else if (a == "-r") recursive = true;
else {
std::cerr << "Unknown argument: " << a << "\n";
usage();
return 1;
}
}
if (srcDir.empty() || dstDir.empty()) {
std::cerr << "massconv requires -s <dir> and -o <dir>\n";
usage();
return 1;
}
if (!outFormat.empty() && outFormat != "xurv5" && outFormat != "xuiv12") {
std::cerr << "Unknown output format '" << outFormat
<< "' (must be xurv5 or xuiv12)\n";
return 1;
}
if (outFormat.empty()) outFormat = "xuiv12";
#ifdef _WIN32
CreateDirectoryA(dstDir.c_str(), nullptr);
#else
mkdir(dstDir.c_str(), 0755);
#endif
std::vector<std::string> files = listFiles(srcDir, recursive);
int ok = 0, failed = 0, skipped = 0;
for (auto& src : files) {
FileFormat srcFmt = detectFormat(src);
if (srcFmt == FileFormat::Unknown) { skipped++; continue; }
size_t sep = src.find_last_of("\\/");
std::string base = (sep == std::string::npos) ? src : src.substr(sep + 1);
size_t dot = base.find_last_of('.');
if (dot != std::string::npos) base = base.substr(0, dot);
std::string dst = dstDir + "\\" + base + (outFormat == "xurv5" ? ".xur" : ".xui");
bool srcIsXur = (srcFmt == FileFormat::XUR);
bool dstIsXur = (outFormat == "xurv5");
if (srcIsXur == dstIsXur) {
std::cout << "Skipping (already " << (srcIsXur ? "xurv5" : "xuiv12") << "): " << src << "\n";
skipped++;
continue;
}
if (srcFmt == FileFormat::XUR) {
XurHeaderInfo hdr = readXurHeader(src);
if (hdr.valid && hdr.version != 5) {
std::cout << "Skipping (unsupported XUR v" << hdr.version << "): " << src << "\n";
skipped++;
continue;
}
}
if (convertFile(src, dst, srcFmt, outFormat)) ok++;
else failed++;
}
std::cout << "massconv: " << ok << " converted, " << failed << " failed, "
<< skipped << " skipped\n";
return failed == 0 ? 0 : 1;
}
static bool decompressSWF(const uint8_t* compressed, size_t csize, std::vector<uint8_t>& out, size_t uncompressedSize) {
if (csize < 2) return false;
out.reserve(uncompressedSize > 0 ? uncompressedSize : 65536);
z_stream zs;
memset(&zs, 0, sizeof(zs));
// CWS is a zlib stream; skip the 2-byte header and inflate the raw deflate
if (inflateInit2(&zs, -MAX_WBITS) != Z_OK) return false;
zs.next_in = (Bytef*)(compressed + 2);
zs.avail_in = (uInt)(csize - 2);
std::vector<uint8_t> buf(65536);
int ret = Z_OK;
while (ret != Z_STREAM_END) {
zs.next_out = buf.data();
zs.avail_out = (uInt)buf.size();
ret = inflate(&zs, Z_NO_FLUSH);
if (ret != Z_OK && ret != Z_STREAM_END) {
inflateEnd(&zs);
return false;
}
out.insert(out.end(), buf.begin(), buf.end() - zs.avail_out);
}
inflateEnd(&zs);
return true;
}
#pragma pack(push, 1)
struct SwfHeader {
uint8_t signature[3];
uint8_t version;
uint32_t fileLength;
};
#pragma pack(pop)
struct SwfRect {
int32_t xMin, xMax, yMin, yMax;
};
struct SwfTag {
uint16_t type;
uint32_t length;
std::vector<uint8_t> data;
};
static uint8_t readU8(const uint8_t*& p) { return *p++; }
static uint16_t readU16(const uint8_t*& p) {
uint16_t v;
memcpy(&v, p, 2);
p += 2;
return v;
}
static uint32_t readU32(const uint8_t*& p) {
uint32_t v;
memcpy(&v, p, 4);
p += 4;
return v;
}
struct SwfMatrix {
float scaleX, scaleY;
float rotateSkew0, rotateSkew1;
float translateX, translateY;
};
static SwfRect readRect(const uint8_t*& p) {
SwfRect r = {};
uint8_t nBits = (*p) >> 3;
uint32_t bitBuf = 0;
int bitsRead = 0;
auto readBits = [&](int n) -> uint32_t {
uint32_t val = 0;
for (int i = 0; i < n; i++) {
if (bitsRead % 8 == 0) {
bitBuf = *p++;
}
val = (val << 1) | ((bitBuf >> (7 - (bitsRead % 8))) & 1);
bitsRead++;
}
return val;
};
bitBuf = *p++;
bitsRead = 5;
int32_t vals[4];
for (int i = 0; i < 4; i++) {
uint32_t v = readBits(nBits);
vals[i] = (int32_t)v;
}
r.xMin = vals[0] / 20;
r.xMax = vals[1] / 20;
r.yMin = vals[2] / 20;
r.yMax = vals[3] / 20;
if (bitsRead % 8 != 0) {
int skip = 8 - (bitsRead % 8);
readBits(skip);
}
return r;
}
static SwfMatrix readMatrix(const uint8_t*& p) {
SwfMatrix m = {1, 0, 0, 1, 0, 0};
uint32_t bitBuf = 0;
int bitsRead = 0;
auto readBits = [&](int n) -> uint32_t {
uint32_t val = 0;
for (int i = 0; i < n; i++) {
if (bitsRead % 8 == 0) {
bitBuf = *p++;
}
val = (val << 1) | ((bitBuf >> (7 - (bitsRead % 8))) & 1);
bitsRead++;
}
return val;
};
auto readSBits = [&](int n) -> int32_t {
uint32_t v = readBits(n);
if (v & (1u << (n - 1))) {
v |= ~((1u << n) - 1);
}
return (int32_t)v;
};
uint8_t hasScale = readBits(1);
if (hasScale) {
int nScaleBits = readBits(5);
m.scaleX = (float)readSBits(nScaleBits) / 65536.0f;
m.scaleY = (float)readSBits(nScaleBits) / 65536.0f;
}
uint8_t hasRotate = readBits(1);
if (hasRotate) {
int nRotateBits = readBits(5);
m.rotateSkew0 = (float)readSBits(nRotateBits) / 65536.0f;
m.rotateSkew1 = (float)readSBits(nRotateBits) / 65536.0f;
}
int nTranslateBits = readBits(5);
if (nTranslateBits > 0) {
m.translateX = (float)readSBits(nTranslateBits) / 20.0f;
m.translateY = (float)readSBits(nTranslateBits) / 20.0f;
}
if (bitsRead % 8 != 0) {
int skip = 8 - (bitsRead % 8);
readBits(skip);
}
return m;
}
class SwfParser {
public:
std::vector<uint8_t> data;
SwfHeader header;
SwfRect frameSize;
float frameRate;
uint16_t frameCount;
std::vector<SwfTag> tags;
bool parse(const std::string& path) {
std::ifstream ifs(path, std::ios::binary | std::ios::ate);
if (!ifs) return false;
std::streamsize sz = ifs.tellg();
ifs.seekg(0);
data.resize((size_t)sz);
if (!ifs.read((char*)data.data(), sz)) return false;
const uint8_t* p = data.data();
memcpy(&header, p, sizeof(SwfHeader));
p += sizeof(SwfHeader);
if (header.signature[0] != 'F' && header.signature[0] != 'C') return false;
if (header.signature[1] != 'W' || header.signature[2] != 'S') return false;
bool compressed = (header.signature[0] == 'C');
if (compressed) {
size_t uncompLen = header.fileLength;
const uint8_t* compStart = p;
size_t compSize = data.size() - (size_t)(p - data.data());
std::vector<uint8_t> decomp;
if (!decompressSWF(compStart, compSize, decomp, uncompLen)) {
std::cerr << " Decompression failed\n";
return false;
}
size_t hdrBytes = (size_t)(p - data.data());
std::vector<uint8_t> newData(hdrBytes + decomp.size());
memcpy(newData.data(), data.data(), hdrBytes);
if (!decomp.empty()) memcpy(newData.data() + hdrBytes, decomp.data(), decomp.size());
newData.swap(data);
p = data.data() + sizeof(SwfHeader);
header.signature[0] = 'F';
}
frameSize = readRect(p);
frameRate = (float)readU16(p) / 256.0f;
frameCount = readU16(p);
while ((size_t)(p - data.data()) < data.size()) {
uint16_t tagTypeAndLen = readU16(p);
uint16_t tagType = tagTypeAndLen >> 6;
uint32_t tagLen = tagTypeAndLen & 0x3F;
if (tagLen == 0x3F) {
tagLen = readU32(p);
}
if (tagType == 0) break;
SwfTag tag;
tag.type = tagType;
tag.length = tagLen;
if (tagLen > 0 && (size_t)(p - data.data() + tagLen) <= data.size()) {
tag.data.assign(p, p + tagLen);
p += tagLen;
}
tags.push_back(tag);
}
return true;
}
};
static std::string escapeXml(const std::string& s) {
std::string r;
for (char c : s) {
switch (c) {
case '&': r += "&amp;"; break;
case '<': r += "&lt;"; break;
case '>': r += "&gt;"; break;
case '\"': r += "&quot;"; break;
case '\'': r += "&apos;"; break;
default: r += c;
}
}
return r;
}
struct XuiElement {
std::string className;
std::map<std::string, std::string> props;
std::vector<XuiElement> children;
};
static void writeXuiElement(std::ostream& os, const XuiElement& el, int depth) {
std::string indent(depth * 2, ' ');
os << indent << "<" << el.className << ">\n";
if (!el.props.empty()) {
os << indent << " <Properties>\n";
for (auto& prop : el.props) {
os << indent << " <" << prop.first << ">" << escapeXml(prop.second) << "</" << prop.first << ">\n";
}
os << indent << " </Properties>\n";
}
for (auto& child : el.children) {
writeXuiElement(os, child, depth + 1);
}
os << indent << "</" << el.className << ">\n";
}
static void addProp(XuiElement& el, const std::string& key, const std::string& val) {
el.props[key] = val;
}
static std::string floatStr(float v) {
std::ostringstream ss;
ss << v;
return ss.str();
}
int cmdSwf2Xui(int argc, char* argv[]) {
if (argc < 2) {
std::cerr << "Usage: xuitool swf2xui <input.swf> [output.xui]\n";
std::cerr << " Converts basic Flash SWF files to XUI XML format.\n";
std::cerr << " Handles shapes, sprites, place/remove objects, and buttons.\n";
return 1;
}
std::string inPath = argv[1];
std::string outPath;
if (argc >= 3) {
outPath = argv[2];
} else {
if (inPath.size() >= 4 && inPath.substr(inPath.size() - 4) == ".swf") {
outPath = inPath.substr(0, inPath.size() - 4) + ".xui";
} else {
outPath = inPath + ".xui";
}
}
SwfParser parser;
if (!parser.parse(inPath)) {
std::cerr << "Error: failed to parse SWF file '" << inPath << "'\n";
std::cerr << "Note: Corrupt or unsupported SWF format\n";
return 1;
}
std::cout << "SWF: " << inPath << "\n";
std::cout << " Version: " << (int)parser.header.version << "\n";
std::cout << " FrameSize: " << parser.frameSize.xMax << "x" << parser.frameSize.yMax << "\n";
std::cout << " FrameRate: " << parser.frameRate << "\n";
std::cout << " FrameCount: " << parser.frameCount << "\n";
std::cout << " Tags: " << parser.tags.size() << "\n";
std::cout << " Tag types: ";
for (auto& tag : parser.tags) std::cout << tag.type << "(" << tag.length << ") ";
std::cout << "\n";
XuiElement root;
root.className = "XuiCanvas";
addProp(root, "Width", floatStr((float)parser.frameSize.xMax));
addProp(root, "Height", floatStr((float)parser.frameSize.yMax));
std::map<uint16_t, std::pair<uint16_t, std::vector<uint8_t>>> characters;
for (auto& tag : parser.tags) {
if (tag.type >= 1 && tag.type <= 88) {
switch (tag.type) {
case 76:
{
const uint8_t* sp = tag.data.data();
const uint8_t* send = tag.data.data() + tag.data.size();
uint16_t numSymbols = readU16(sp);
std::cout << " SymbolClass: " << numSymbols << " symbols\n";
for (uint16_t si = 0; si < numSymbols && sp < send; si++) {
uint16_t tagId = readU16(sp);
std::string name;
while (sp < send && *sp) { name += (char)*sp++; }
if (sp < send) sp++;
std::cout << " Symbol " << tagId << " -> " << name << "\n";
}
break;
}
case 2:
case 22:
case 32:
case 83:
case 11:
case 33:
case 37:
case 39:
case 34:
case 35:
{
const uint8_t* p = tag.data.data();
uint16_t charId = readU16(p);
characters[charId] = std::make_pair(tag.type, tag.data);
std::cout << " CharDef id=" << charId << " type=" << tag.type << " len=" << tag.length << "\n";
break;
}
}
}
}
std::map<int32_t, XuiElement> displayElements;
for (auto& tag : parser.tags) {
switch (tag.type) {
case 26:
{
const uint8_t* tp = tag.data.data();
const uint8_t* tend = tag.data.data() + tag.data.size();
uint8_t flags = readU8(tp);
uint8_t charIdByte = readU8(tp);
uint16_t charId = charIdByte;
SwfMatrix mat = {1, 0, 0, 1, 0, 0};
if (tp < tend) mat = readMatrix(tp);
static int po26Count = 0;
po26Count++;
auto it = characters.find(charId);
if (it != characters.end()) {
XuiElement el;
if (it->second.first == 39) {
el.className = "XuiScene";
} else if (it->second.first >= 11 && it->second.first <= 37) {
el.className = "XuiLabel";
} else {
el.className = "XuiImage";
}
addProp(el, "Id", "swf_char_" + std::to_string(charId) + "_p" + std::to_string(po26Count));
addProp(el, "X", floatStr(mat.translateX));
addProp(el, "Y", floatStr(mat.translateY));
addProp(el, "Width", "100.000000");
addProp(el, "Height", "100.000000");
addProp(el, "Show", "true");
std::cout << " PlaceObject26 flags=0x" << std::hex << (int)flags << std::dec << " charId=" << charId << " pos=(" << mat.translateX << "," << mat.translateY << ")\n";
displayElements[po26Count] = el;
} else {
std::cout << " PlaceObject26 flags=0x" << std::hex << (int)flags << std::dec << " charId=" << charId << " NOT FOUND\n";
}
break;
}
case 28:
{
const uint8_t* tp = tag.data.data();
uint16_t charId = readU16(tp);
int32_t depth = readU16(tp);
std::cout << " RemoveObject28 charId=" << charId << " depth=" << depth << "\n";
displayElements.erase(depth);
break;
}
case 33:
{
const uint8_t* tp = tag.data.data();
int32_t depth = readU16(tp);
std::cout << " RemoveObject33 depth=" << depth << "\n";
displayElements.erase(depth);
break;
}
case 43:
{
const uint8_t* tp = tag.data.data();
const uint8_t* tend = tag.data.data() + tag.data.size();
uint8_t flags = readU8(tp);
int32_t depth = readU16(tp);
uint16_t charId = 0;
SwfMatrix mat = {1, 0, 0, 1, 0, 0};
if (flags & 0x02) { charId = readU16(tp); }
if (flags & 0x04) {
if (tp < tend) mat = readMatrix(tp);
}
if (flags & 0x08) { }
if (flags & 0x10) { readU16(tp); }
if (flags & 0x20) {
while (tp < tend && *tp) tp++;
if (tp < tend) tp++;
}
if (flags & 0x40) { readU16(tp); }
if (flags & 0x80) { }
std::cout << " PlaceObject43 depth=" << depth << " charId=" << charId << " flags=0x" << std::hex << (int)flags << std::dec << " pos=(" << mat.translateX << "," << mat.translateY << ") found=" << characters.count(charId) << "\n";
if (flags & 0x01) {
displayElements.erase(depth);
} else {
auto it = characters.find(charId);
if (it != characters.end()) {
XuiElement el;
if (it->second.first == 39) {
el.className = "XuiScene";
} else if (it->second.first >= 34 && it->second.first <= 35) {
el.className = "XuiButton";
} else if (it->second.first >= 11 && it->second.first <= 37) {
el.className = "XuiLabel";
} else {
el.className = "XuiImage";
}
addProp(el, "Id", "swf_char_" + std::to_string(charId) + "_d" + std::to_string(depth));
addProp(el, "X", floatStr(mat.translateX));
addProp(el, "Y", floatStr(mat.translateY));
addProp(el, "Width", floatStr((float)parser.frameSize.xMax / 10.0f));
addProp(el, "Height", floatStr((float)parser.frameSize.yMax / 10.0f));
displayElements[depth] = el;
} else {
XuiElement el;
el.className = "XuiControl";
addProp(el, "Id", "swf_unknown_d" + std::to_string(depth));
addProp(el, "X", floatStr(mat.translateX));
addProp(el, "Y", floatStr(mat.translateY));
addProp(el, "Width", "50.000000");
addProp(el, "Height", "50.000000");
displayElements[depth] = el;
}
}
break;
}
case 70:
{
const uint8_t* tp = tag.data.data();
const uint8_t* tend = tag.data.data() + tag.data.size();
uint8_t flags = readU8(tp);
uint8_t flags2 = readU8(tp);
int32_t depth = readU16(tp);
std::string className;
while (tp < tend && *tp) { className += (char)*tp; }
if (tp < tend) tp++;
std::string instanceName;
{
const uint8_t* s = tend - 1;
while (s > tp && *s == 0) s--;
const uint8_t* strEnd = s + 1;
while (s > tp && *s != 0 && *s >= 0x20 && *s < 0x7F) s--;
s++;
if (strEnd > s) {
for (const uint8_t* p2 = s; p2 < strEnd; p2++) instanceName += (char)*p2;
while (!instanceName.empty() &&
!((instanceName[0] >= 'A' && instanceName[0] <= 'Z') ||
(instanceName[0] >= 'a' && instanceName[0] <= 'z') ||
(instanceName[0] >= '0' && instanceName[0] <= '9') ||
instanceName[0] == '_')) {
instanceName.erase(0, 1);
}
}
}
std::cout << " PlaceObject70 depth=" << depth << " class=\"" << className << "\"";
if (!instanceName.empty()) std::cout << " instance=\"" << instanceName << "\"";
std::cout << " tagLen=" << tag.length << "\n";
if (flags & 0x01) {
displayElements.erase(depth);
} else {
XuiElement el;
if (className.find("Button") != std::string::npos ||
className.find("button") != std::string::npos) {
el.className = "XuiButton";
} else if (className.find("Label") != std::string::npos ||
className.find("Text") != std::string::npos ||
className.find("text") != std::string::npos) {
el.className = "XuiLabel";
} else if (className.find("Image") != std::string::npos ||
className.find("Graphic") != std::string::npos) {
el.className = "XuiImage";
} else if (className.find("Scene") != std::string::npos ||
className.find("Menu") != std::string::npos ||
className.find("Panel") != std::string::npos ||
className.find("Dialog") != std::string::npos ||
className.find("Canvas") != std::string::npos) {
el.className = "XuiScene";
} else {
el.className = "XuiControl";
}
std::string id = !instanceName.empty() ? instanceName : className;
addProp(el, "Id", id);
addProp(el, "ClassName", className);
addProp(el, "X", "0.000000");
addProp(el, "Y", "0.000000");
addProp(el, "Width", floatStr((float)parser.frameSize.xMax / 10.0f));
addProp(el, "Height", floatStr((float)parser.frameSize.yMax / 10.0f));
displayElements[depth] = el;
}
break;
}
}
}
for (auto& de : displayElements) {
root.children.push_back(de.second);
}
std::ofstream ofs(outPath);
if (!ofs) {
std::cerr << "Error: cannot write to '" << outPath << "'\n";
return 1;
}
writeXuiElement(ofs, root, 0);
std::cout << "Wrote " << outPath << "\n";
return 0;
}
}
int main(int argc, char* argv[]) {
if (argc < 2) {
usage();
return 1;
}
std::string cmd = lower(argv[1]);
if (cmd == "about") return cmdAbout();
if (cmd == "info") {
if (argc < 3) { std::cerr << "Usage: xuitool info <file>\n"; return 1; }
return cmdInfo(argv[2]);
}
if (cmd == "validate") {
if (argc < 3) { std::cerr << "Usage: xuitool validate <file>\n"; return 1; }
return cmdValidate(argv[2]);
}
if (cmd == "conv") return cmdConv(argc, argv);
if (cmd == "massconv") return cmdMassConv(argc, argv);
if (cmd == "swf2xui") return cmdSwf2Xui(argc - 1, argv + 1);
std::cerr << "Unknown command: " << argv[1] << "\n";
usage();
return 1;
}
Reference in New Issue View Git Blame Copy Permalink