summaryrefslogtreecommitdiff
path: root/lsrlytexporter.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lsrlytexporter.cpp')
-rw-r--r--lsrlytexporter.cpp1176
1 files changed, 1176 insertions, 0 deletions
diff --git a/lsrlytexporter.cpp b/lsrlytexporter.cpp
new file mode 100644
index 0000000..42fb587
--- /dev/null
+++ b/lsrlytexporter.cpp
@@ -0,0 +1,1176 @@
+#include "lsrlytexporter.h"
+#include "lyt/layout.h"
+#include "wii/texpalette.h"
+#include <QXmlStreamWriter>
+#include <QDir>
+#include <QFile>
+#include <QSet>
+#include <QMapIterator>
+
+static void collectPanesForList(QList<LYTPane *> *list, LYTPane *pane) {
+ list->append(pane);
+
+ foreach (LYTPane *p, pane->children)
+ collectPanesForList(list, p);
+}
+
+static void outputPaneTree(QXmlStreamWriter *w, LYTPane *pane) {
+ w->writeStartElement("paneTree");
+ w->writeAttribute("name", pane->name);
+
+ foreach (LYTPane *p, pane->children)
+ outputPaneTree(w, p);
+
+ w->writeEndElement();
+}
+
+static void writeTexCoordSet(QXmlStreamWriter &w, const LYTTexCoords &set) {
+ w.writeStartElement("texCoord");
+
+ static const char *vnames[] = {
+ "texLT", "texRT", "texLB", "texRB"
+ };
+ for (int i = 0; i < 4; i++) {
+ w.writeEmptyElement(vnames[i]);
+ w.writeAttribute("s", QString::number(set.coord[i].x()));
+ w.writeAttribute("t", QString::number(set.coord[i].y()));
+ }
+
+ w.writeEndElement(); // texCoord
+}
+
+static void writeAttribColour(QXmlStreamWriter &w, const QColor &c, bool hasAlpha=true) {
+ w.writeAttribute("r", QString::number(c.red()));
+ w.writeAttribute("g", QString::number(c.green()));
+ w.writeAttribute("b", QString::number(c.blue()));
+ if (hasAlpha)
+ w.writeAttribute("a", QString::number(c.alpha()));
+}
+
+static void writeAttribColourNoAlpha(QXmlStreamWriter &w, const QColor &c) {
+ writeAttribColour(w, c, false);
+}
+
+static bool isMaterialDetailed(const LYTMaterial &mat) {
+ int chk = 0;
+ if (mat.hasAlphaCompare) chk += 1;
+ if (mat.hasBlendMode) chk += 1;
+ if (mat.hasChanCtrl) chk += 1;
+ if (mat.hasMatCol) chk += 1;
+ if (mat.hasTevSwapTable) chk += 1;
+ if (chk == 0) return false;
+ if (chk == 5) return true;
+ qWarning("HUH????");
+ return false;
+}
+
+static void writeMaterial(QXmlStreamWriter &w, const LYTMaterial &mat, QSet<QString> &usedNames) {
+ bool isDetail = mat.hasChanCtrl;
+
+ QString matname = mat.name;
+ while (usedNames.contains(matname)) {
+ matname[0] = QChar(matname.at(0).unicode() + 1);
+ if (matname[0] == ('Z'+1))
+ matname[0] = 'a';
+ if (matname[0] == ('z'+1))
+ matname[0] = 'A';
+ }
+ usedNames.insert(matname);
+
+ w.writeStartElement("material");
+ w.writeAttribute("name", matname);
+ {
+ w.writeEmptyElement("blackColor");
+ writeAttribColourNoAlpha(w, mat.colours[0]);
+ w.writeEmptyElement("whiteColor");
+ writeAttribColourNoAlpha(w, mat.colours[1]);
+
+ static const char *Filters[] = {"Near", "Linear"};
+ static const char *Wraps[] = {"Clamp", "Repeat", "Mirror"};
+
+ foreach (const LYTTexMap &tm, mat.texMaps) {
+ w.writeEmptyElement("texMap");
+
+ QString niceName = tm.textureName;
+ niceName.replace(".tpl", "");
+ w.writeAttribute("imageName", niceName);
+ w.writeAttribute("wrap_s", Wraps[tm.wrap_s]);
+ w.writeAttribute("wrap_t", Wraps[tm.wrap_t]);
+ w.writeAttribute("filterMin", Filters[tm.min_filter]);
+ w.writeAttribute("filterMax", Filters[tm.mag_filter]);
+ // Left out on purpose: paletteName
+ }
+
+ foreach (const LYTTexSRT &srt, mat.texSRTs) {
+ w.writeStartElement("texMatrix");
+ w.writeAttribute("rotate", QString::number(srt.rotate));
+
+ w.writeEmptyElement("scale");
+ w.writeAttribute("x", QString::number(srt.xScale));
+ w.writeAttribute("y", QString::number(srt.yScale));
+
+ w.writeEmptyElement("translate");
+ w.writeAttribute("x", QString::number(srt.xTrans));
+ w.writeAttribute("y", QString::number(srt.yTrans));
+
+ w.writeEndElement(); // texMatrix
+ }
+
+ foreach (const LYTTexCoordGen &cg, mat.texCoordGens) {
+ w.writeEmptyElement("texCoordGen");
+ w.writeAttribute("func", (cg.genType == 1 ? "Mtx2x4" : "ERROR"));
+ w.writeAttribute("srcParam", (cg.src>=4 && cg.src<=11)?QString("Tex%1").arg(cg.src-4):"ERROR");
+ int fixMtx = (cg.mtx == 60) ? -1 : ((cg.mtx / 3) - 10);
+ w.writeAttribute("matrix", QString::number(fixMtx));
+ }
+
+ // this is most likely INCORRECT.
+ w.writeEmptyElement("textureStage");
+ w.writeAttribute("texMap", "0");
+ w.writeAttribute("texCoordGen", "0");
+
+ w.writeEmptyElement("texBlendRatio");
+ w.writeAttribute("color", "255");
+
+ // TODO: textureStage, texBlendRatio, indirectStages(MaterialWarp),..?
+ }
+ w.writeEndElement(); // material
+
+ w.writeStartElement("materialRevo");
+ w.writeAttribute("name", matname);
+ if (isDetail) {
+ w.writeAttribute("tevStageNum", QString::number(mat.tevStages.count()));
+ w.writeAttribute("indirectStageNum", QString::number(mat.indTexStages.count()));
+ }
+ {
+ qDebug("Chk: %c%c%c%c%c %d,%d,%d,%d,%d,%d",
+ mat.hasAlphaCompare?'x':'_',
+ mat.hasBlendMode?'x':'_',
+ mat.hasChanCtrl?'x':'_',
+ mat.hasMatCol?'x':'_',
+ mat.hasTevSwapTable?'x':'_',
+ mat.indTexSRTs.count(),
+ mat.indTexStages.count(),
+ mat.tevStages.count(),
+ mat.texCoordGens.count(),
+ mat.texMaps.count(),
+ mat.texSRTs.count());
+
+ w.writeEmptyElement("channelControl");
+ w.writeAttribute("channel", "Color0");
+ w.writeAttribute("materialSource", mat.hasChanCtrl?(mat.chanCtrl.colourMatSrc==0?"Register":"Vertex"):"Vertex");
+
+ w.writeEmptyElement("channelControl");
+ w.writeAttribute("channel", "Alpha0");
+ w.writeAttribute("materialSource", mat.hasChanCtrl?(mat.chanCtrl.colourMatSrc==0?"Register":"Vertex"):"Vertex");
+
+ w.writeEmptyElement("matColReg");
+ writeAttribColour(w, mat.hasMatCol ? mat.matCol : QColor::fromRgb(255,255,255,255));
+
+ for (int i = 0; i < 3; i++) {
+ w.writeEmptyElement("tevColReg");
+ writeAttribColour(w, mat.colours[i]);
+ }
+
+ for (int i = 0; i < 4; i++) {
+ w.writeEmptyElement("tevConstReg");
+ writeAttribColour(w, mat.tevKColour[i]);
+ }
+
+ // blehhhhhhhhhhhh DRY!!!
+ static const char *Filters[] = {"Near", "Linear"};
+ static const char *Wraps[] = {"Clamp", "Repeat", "Mirror"};
+
+ foreach (const LYTTexMap &tm, mat.texMaps) {
+ w.writeEmptyElement("texMap");
+
+ QString niceName = tm.textureName;
+ niceName.replace(".tpl", "");
+ w.writeAttribute("imageName", niceName);
+ w.writeAttribute("wrap_s", Wraps[tm.wrap_s]);
+ w.writeAttribute("wrap_t", Wraps[tm.wrap_t]);
+ w.writeAttribute("filterMin", Filters[tm.min_filter]);
+ w.writeAttribute("filterMax", Filters[tm.mag_filter]);
+ // Left out on purpose: paletteName
+ }
+
+ foreach (const LYTTexSRT &srt, mat.texSRTs) {
+ w.writeStartElement("texMatrix");
+ w.writeAttribute("rotate", QString::number(srt.rotate));
+
+ w.writeEmptyElement("scale");
+ w.writeAttribute("x", QString::number(srt.xScale));
+ w.writeAttribute("y", QString::number(srt.yScale));
+
+ w.writeEmptyElement("translate");
+ w.writeAttribute("x", QString::number(srt.xTrans));
+ w.writeAttribute("y", QString::number(srt.yTrans));
+
+ w.writeEndElement(); // texMatrix
+ }
+
+ foreach (const LYTTexCoordGen &cg, mat.texCoordGens) {
+ w.writeEmptyElement("texCoordGen");
+ w.writeAttribute("func", (cg.genType == 1 ? "Mtx2x4" : "ERROR"));
+ w.writeAttribute("srcParam", (cg.src>=4 && cg.src<=11)?QString("Tex%1").arg(cg.src-4):"ERROR");
+ int fixMtx = (cg.mtx == 60) ? -1 : ((cg.mtx / 3) - 10);
+ w.writeAttribute("matrix", QString::number(fixMtx));
+ }
+ // end horrible lack of DRY
+
+ if (mat.hasTevSwapTable) {
+ static const char *Swaps[] = {"Red","Green","Blue","Alpha"};
+ for (int i = 0; i < 4; i++) {
+ w.writeEmptyElement("swapTable");
+ w.writeAttribute("r", Swaps[mat.tevSwapTable.mode[i].red]);
+ w.writeAttribute("g", Swaps[mat.tevSwapTable.mode[i].green]);
+ w.writeAttribute("b", Swaps[mat.tevSwapTable.mode[i].blue]);
+ w.writeAttribute("a", Swaps[mat.tevSwapTable.mode[i].alpha]);
+ }
+ } else {
+ for (int i = 0; i < 4; i++) {
+ w.writeEmptyElement("swapTable");
+ w.writeAttribute("r", "Red");
+ w.writeAttribute("g", "Green");
+ w.writeAttribute("b", "Blue");
+ w.writeAttribute("a", "Alpha");
+ }
+ }
+
+ foreach (const LYTTexSRT &srt, mat.indTexSRTs) {
+ w.writeStartElement("indirectMatrix");
+ w.writeAttribute("rotate", QString::number(srt.rotate));
+
+ w.writeEmptyElement("scale");
+ w.writeAttribute("x", QString::number(srt.xScale));
+ w.writeAttribute("y", QString::number(srt.yScale));
+
+ w.writeEmptyElement("translate");
+ w.writeAttribute("x", QString::number(srt.xTrans));
+ w.writeAttribute("y", QString::number(srt.yTrans));
+
+ w.writeEndElement(); // texMatrix
+ }
+
+ static const char *IndScale[] = {
+ "V1","V2","V4","V8","V16","V32","V64","V128","V256"
+ };
+ foreach (const LYTIndirectStage &ist, mat.indTexStages) {
+ w.writeEmptyElement("indirectStage");
+ w.writeAttribute("texMap", QString::number(ist.texMap));
+ w.writeAttribute("texCoord", QString::number(ist.texCoord));
+ w.writeAttribute("scale_s", IndScale[ist.wrap_s]);
+ w.writeAttribute("scale_t", IndScale[ist.wrap_t]);
+ }
+
+ // for no indirects? no idea
+ if (mat.indTexSRTs.count() == 0) {
+ for (int i = 0; i < 3; i++) {
+ w.writeStartElement("indirectMatrix");
+ w.writeAttribute("rotate", "0");
+
+ w.writeEmptyElement("scale");
+ w.writeAttribute("x", "1");
+ w.writeAttribute("y", "1");
+
+ w.writeEmptyElement("translate");
+ w.writeAttribute("x", "0");
+ w.writeAttribute("y", "0");
+
+ w.writeEndElement(); // indirectMatrix
+ }
+ }
+
+ if (mat.indTexStages.count() == 0) {
+ for (int i = 0; i < 4; i++) {
+ w.writeEmptyElement("indirectStage");
+ w.writeAttribute("texMap", "0");
+ w.writeAttribute("texCoordGen", "0");
+ w.writeAttribute("scale_s", "V1");
+ w.writeAttribute("scale_t", "V1");
+ }
+ }
+
+ // the rest
+
+ static const char *TevCChan[] = {
+ "xERR","xERR","xERR","xERR","Color0a0","xERR",
+ "ColorZero","xERR","xERR"
+ };
+ static const char *CArg[] = {
+ "CPrev","APrev","C0","A0","C1","A1","C2","A2",
+ "TexC","TexA","RasC","RasA","V1_0","V0_5","Konst","V0"
+ };
+ static const char *AArg[] = {
+ "APrev","A0","A1","A2","TexA","RasA","Konst","V0"
+ };
+ static const char *KCSel[] = {
+ "V8_8","V7_8","V6_8","V5_8","V4_8","V3_8","V2_8","V1_8",
+ "xERR","xERR","xERR","xERR",
+ "K0","K1","K2","K3",
+ "K0_r","K1_r","K2_r","K3_r",
+ "K0_g","K1_g","K2_g","K3_g",
+ "K0_b","K1_b","K2_b","K3_b",
+ "K0_a","K1_a","K2_a","K3_a"
+ };
+ static const char *KASel[] = {
+ "V8_8","V7_8","V6_8","V5_8","V4_8","V3_8","V2_8","V1_8",
+ "xERR","xERR","xERR","xERR","xERR","xERR","xERR","xERR",
+ "K0_r","K1_r","K2_r","K3_r",
+ "K0_g","K1_g","K2_g","K3_g",
+ "K0_b","K1_b","K2_b","K3_b",
+ "K0_a","K1_a","K2_a","K3_a"
+ };
+ static const char *ColOp[] = {
+ "Add","Sub","x","x","x","x","x","x",
+ "Comp_r8_gt","Comp_r8_eq",
+ "Comp_gr16_gt","Comp_gr16_eq",
+ "Comp_bgr24_gt","Comp_bgr24_eq",
+ "Comp_rgb8_gt","Comp_rgb8_eq"
+ };
+ static const char *AlOp[] = {
+ "Add","Sub","x","x","x","x","x","x",
+ "Comp_r8_gt","Comp_r8_eq",
+ "Comp_gr16_gt","Comp_gr16_eq",
+ "Comp_bgr24_gt","Comp_bgr24_eq",
+ "Comp_a8_gt","Comp_a8_eq"
+ };
+ static const char *Bias[] = {"V0", "P0_5", "M0_5"};
+ static const char *Scale[] = {"V1", "V2", "V4", "V1_2"};
+ static const char *Reg[] = {"Prev", "Reg0", "Reg1", "Reg2"};
+ foreach (const LYTTevStage &st, mat.tevStages) {
+ w.writeStartElement("tevStage");
+ w.writeAttribute("colorChannel", (st.colour==-1)?"ColorNull":TevCChan[st.colour]);
+ w.writeAttribute("texMap", QString::number(st.texMap));
+ w.writeAttribute("texCoordGen", QString::number(st.texCoord));
+ w.writeAttribute("rasColSwap", QString::number(st.rasSwapMode));
+ w.writeAttribute("texColSwap", QString::number(st.texSwapMode));
+
+ w.writeEmptyElement("color");
+ w.writeAttribute("a", CArg[st.colourInA]);
+ w.writeAttribute("b", CArg[st.colourInB]);
+ w.writeAttribute("c", CArg[st.colourInC]);
+ w.writeAttribute("d", CArg[st.colourInD]);
+ w.writeAttribute("konst", KCSel[st.colourConst]);
+ w.writeAttribute("op", ColOp[st.colourOp]);
+ w.writeAttribute("bias", Bias[st.colourBias]);
+ w.writeAttribute("scale", Scale[st.colourScale]);
+ w.writeAttribute("clamp", st.colourClamp?"true":"false");
+ w.writeAttribute("outReg", Reg[st.colourOutReg]);
+
+ w.writeEmptyElement("alpha");
+ w.writeAttribute("a", AArg[st.alphaInA]);
+ w.writeAttribute("b", AArg[st.alphaInB]);
+ w.writeAttribute("c", AArg[st.alphaInC]);
+ w.writeAttribute("d", AArg[st.alphaInD]);
+ w.writeAttribute("konst", KASel[st.alphaConst]);
+ w.writeAttribute("op", AlOp[st.alphaOp]);
+ w.writeAttribute("bias", Bias[st.alphaBias]);
+ w.writeAttribute("scale", Scale[st.alphaScale]);
+ w.writeAttribute("clamp", st.alphaClamp?"true":"false");
+ w.writeAttribute("outReg", Reg[st.alphaOutReg]);
+
+ static const char *IFormat[] = {"V8","V5","V4","V3"};
+ static const char *IBias[] = {"None","S","T","ST","U","SU","TU","STU"};
+ static const char *IMtx[] = {"Off","V0","V1","V2","x","S0","S1","S2","x","T0","T1","T2"};
+ static const char *IWrap[] = {"Off","V256","V128","V64","V32","V16","V0"};
+
+ w.writeEmptyElement("indirect");
+ w.writeAttribute("indStage", QString::number(st.indStage));
+ w.writeAttribute("format", IFormat[st.indFormat]);
+ w.writeAttribute("bias", IBias[st.indBias]);
+ w.writeAttribute("matrix", IMtx[st.indMatrix]);
+ w.writeAttribute("wrap_s", IWrap[st.indWrapS]);
+ w.writeAttribute("wrap_t", IWrap[st.indWrapT]);
+ w.writeAttribute("addPrev", st.indAddPrev?"true":"false");
+ w.writeAttribute("utcLod", st.indUtcLod?"true":"false");
+ if (st.indAlphaSel != 0)
+ qFatal("indAlphaSel not off!");
+ w.writeAttribute("alpha", "Off");
+
+ w.writeEndElement(); // tevStage
+ }
+
+ // wtf bbq
+ if (mat.tevStages.count() == 0) {
+ // todo: different for >1 texture? must check.
+ w.writeStartElement("tevStage");
+ w.writeAttribute("colorChannel", "Color0a0");
+ w.writeAttribute("texMap", "-1");
+ w.writeAttribute("texCoordGen", "-1");
+ w.writeAttribute("rasColSwap", "0");
+ w.writeAttribute("texColSwap", "0");
+
+ w.writeEmptyElement("color");
+ w.writeAttribute("a", "RasC");
+ w.writeAttribute("b", "V0");
+ w.writeAttribute("c", "V0");
+ w.writeAttribute("d", "V0");
+ w.writeAttribute("konst", "K0");
+ w.writeAttribute("op", "Add");
+ w.writeAttribute("bias", "V0");
+ w.writeAttribute("scale", "V1");
+ w.writeAttribute("clamp", "true");
+ w.writeAttribute("outReg", "Prev");
+
+ w.writeEmptyElement("alpha");
+ w.writeAttribute("a", "RasA");
+ w.writeAttribute("b", "V0");
+ w.writeAttribute("c", "V0");
+ w.writeAttribute("d", "V0");
+ w.writeAttribute("konst", "K0_a");
+ w.writeAttribute("op", "Add");
+ w.writeAttribute("bias", "V0");
+ w.writeAttribute("scale", "V1");
+ w.writeAttribute("clamp", "true");
+ w.writeAttribute("outReg", "Prev");
+
+ w.writeEmptyElement("indirect");
+ w.writeAttribute("indStage", "0");
+ w.writeAttribute("format", "V8");
+ w.writeAttribute("bias", "STU");
+ w.writeAttribute("matrix", "Off");
+ w.writeAttribute("wrap_s", "Off");
+ w.writeAttribute("wrap_t", "Off");
+ w.writeAttribute("addPrev", "false");
+ w.writeAttribute("alpha", "Off");
+ w.writeAttribute("utcLod", "false");
+
+ w.writeEndElement(); // tevStage
+ }
+
+ if (mat.hasAlphaCompare) {
+ static const char *Compare[] = {"Never","Less","Equal","LEqual","Greater","NEqual","GEqual","Always"};
+ static const char *AlphaOp[] = {"And","Or","Xor","Xnor"};
+ w.writeEmptyElement("alphaCompare");
+ w.writeAttribute("comp0", Compare[mat.alphaCompare.comp0]);
+ w.writeAttribute("ref0", QString::number(mat.alphaCompare.ref0));
+ w.writeAttribute("op", AlphaOp[mat.alphaCompare.op]);
+ w.writeAttribute("comp1", Compare[mat.alphaCompare.comp1]);
+ w.writeAttribute("ref1", QString::number(mat.alphaCompare.ref1));
+ } else {
+ w.writeEmptyElement("alphaCompare");
+ w.writeAttribute("comp0", "Always");
+ w.writeAttribute("ref0", "0");
+ w.writeAttribute("op", "And");
+ w.writeAttribute("comp1", "Always");
+ w.writeAttribute("ref1", "0");
+ }
+
+ if (mat.hasBlendMode) {
+ static const char *BmType[] = {"None","Blend","Logic","Subtract"};
+ static const char *SrcFactor[] = {"V0","V1_0","DstClr","InvDstClr","SrcAlpha","InvSrcAlpha","DstAlpha","InvDstAlpha"};
+ static const char *DstFactor[] = {"V0","V1_0","SrcClr","InvSrcClr","SrcAlpha","InvSrcAlpha","DstAlpha","InvDstAlpha"};
+ static const char *LogicOp[] = {
+ "Clear", "And", "RevAnd", "Copy",
+ "InvAnd", "NoOp", "Xor", "Or",
+ "Nor", "Equiv", "Inv", "RevOr",
+ "InvCopy", "InvOr", "Nand", "Set"
+ };
+ w.writeEmptyElement("blendMode");
+ w.writeAttribute("type", BmType[mat.blendMode.type]);
+ w.writeAttribute("srcFactor", SrcFactor[mat.blendMode.srcFactor]);
+ w.writeAttribute("dstFactor", DstFactor[mat.blendMode.destFactor]);
+ w.writeAttribute("op", LogicOp[mat.blendMode.op]);
+ } else {
+ w.writeEmptyElement("blendMode");
+ w.writeAttribute("type", "Blend");
+ w.writeAttribute("srcFactor", "SrcAlpha");
+ w.writeAttribute("dstFactor", "InvSrcAlpha");
+ w.writeAttribute("op", "Copy");
+ }
+
+ // what have I missed...? tevStageNum attrib?, displayFace attrib?,
+ // indirectStageNum attrib?
+ }
+ w.writeEndElement(); // materialRevo
+}
+
+static void exportRlyt(LYTLayout *layout, QIODevice *output, const QMap<QString, GX::TextureFormat> &texFormats) {
+ QXmlStreamWriter w(output);
+ w.setAutoFormatting(true);
+
+ w.writeStartDocument();
+
+ w.writeStartElement("nw4r_layout");
+ w.writeDefaultNamespace("http://www.nintendo.co.jp/NW4R/LayoutEditor");
+ w.writeAttribute("version", "1.2.0");
+
+ w.writeStartElement("head");
+ {
+ w.writeEmptyElement("create");
+ w.writeAttribute("user", "someone");
+ w.writeAttribute("host", "somewhere");
+ w.writeAttribute("date", "2006-07-26T10:20:54.551+09:00");
+ w.writeAttribute("source", "");
+
+ w.writeEmptyElement("title");
+
+ w.writeEmptyElement("comment");
+
+ w.writeEmptyElement("generator");
+ w.writeAttribute("name", "LayoutStudio");
+ w.writeAttribute("version", "NONE_OF_YOUR_BUSINESS");
+ }
+ w.writeEndElement(); // head
+
+ w.writeStartElement("body");
+ w.writeStartElement("rlyt");
+
+
+ // Stuff begins here
+ QSet<QString> usedNames;
+
+ static const char *PaneKinds[] = {
+ "Null", "Picture", "TextBox", "Window", "Bounding"
+ };
+ static const char *HorzOrigin[] = {"Left", "Center", "Right"};
+ static const char *VertOrigin[] = {"Top", "Center", "Bottom"};
+
+ w.writeStartElement("paneSet");
+ {
+ // Collect pane list
+ QList<LYTPane *> paneList;
+ collectPanesForList(&paneList, layout->rootPane);
+
+ // now write them all
+ foreach (LYTPane *p, paneList) {
+ w.writeStartElement("pane");
+ w.writeAttribute("kind", PaneKinds[(int)p->type()]);
+ w.writeAttribute("name", p->name);
+ w.writeAttribute("visible", p->visible?"true":"false");
+ w.writeAttribute("locked", "false");
+ w.writeAttribute("alpha", QString::number(p->alpha));
+ if (p->influencedAlpha)
+ w.writeAttribute("influencedAlpha", "true");
+ if (p->isWidescreen)
+ w.writeAttribute("locationAdjust", "true");
+ {
+ w.writeEmptyElement("comment");
+
+ w.writeEmptyElement("basePositionType");
+ w.writeAttribute("x", HorzOrigin[(int)p->horzOrigin]);
+ w.writeAttribute("y", VertOrigin[(int)p->vertOrigin]);
+
+ w.writeEmptyElement("translate");
+ w.writeAttribute("x", QString::number(p->xTrans));
+ w.writeAttribute("y", QString::number(p->yTrans));
+ w.writeAttribute("z", QString::number(p->zTrans));
+
+ w.writeEmptyElement("rotate");
+ w.writeAttribute("x", QString::number(p->xRot));
+ w.writeAttribute("y", QString::number(p->yRot));
+ w.writeAttribute("z", QString::number(p->zRot));
+
+ w.writeEmptyElement("scale");
+ w.writeAttribute("x", QString::number(p->xScale));
+ w.writeAttribute("y", QString::number(p->yScale));
+
+ w.writeEmptyElement("size");
+ w.writeAttribute("x", QString::number(p->width));
+ w.writeAttribute("y", QString::number(p->height));
+
+
+ if (p->type() == LYTPane::PictureType) {
+ LYTPicture *pic = (LYTPicture*)p;
+
+ const LYTMaterial &mat = *(layout->materials.getMaterialByName(pic->materialName));
+
+ w.writeStartElement("picture");
+ w.writeAttribute("detailSetting", isMaterialDetailed(mat)?"true":"false");
+
+ static const char *vnames[] = {
+ "vtxColLT", "vtxColRT", "vtxColLB", "vtxColRB"
+ };
+ for (int i = 0; i < 4; i++) {
+ w.writeEmptyElement(vnames[i]);
+ writeAttribColour(w, pic->vtxColours[i]);
+ }
+
+ for (int i = 0; i < pic->texCoords.count(); i++)
+ writeTexCoordSet(w, pic->texCoords.at(i));
+
+ writeMaterial(w, mat, usedNames);
+
+ w.writeEndElement(); // picture
+
+ } else if (p->type() == LYTPane::TextBoxType) {
+ LYTTextBox *tb = (LYTTextBox*)p;
+
+ static const char *TextAlignments[] = {
+ "Synchronous", "Left", "Center", "Right"
+ };
+
+ w.writeStartElement("textBox");
+ w.writeAttribute("font", tb->fontName);
+ w.writeAttribute("textAlignment", TextAlignments[(int)tb->alignment]);
+ w.writeAttribute("lineSpace", QString::number(tb->lineSpace));
+ w.writeAttribute("charSpace", QString::number(tb->charSpace));
+ w.writeAttribute("allocateStringLength", QString::number(tb->bufferLength));
+
+ w.writeEmptyElement("fontSize");
+ w.writeAttribute("x", QString::number(tb->fontSizeX));
+ w.writeAttribute("y", QString::number(tb->fontSizeY));
+
+ w.writeTextElement("text", tb->text);
+
+ w.writeEmptyElement("topColor");
+ writeAttribColour(w, tb->colour1);
+
+ w.writeEmptyElement("bottomColor");
+ writeAttribColour(w, tb->colour2);
+
+ w.writeEmptyElement("positionType");
+ w.writeAttribute("x", HorzOrigin[(int)tb->textHorzPos]);
+ w.writeAttribute("y", VertOrigin[(int)tb->textVertPos]);
+
+ writeMaterial(w, *(layout->materials.getMaterialByName(tb->materialName)), usedNames);
+
+ w.writeEndElement(); // textBox
+
+ } else if (p->type() == LYTPane::WindowType) {
+ LYTWindow *win = (LYTWindow*)p;
+
+ w.writeStartElement("window");
+
+ w.writeStartElement("content");
+ {
+ const LYTMaterial &mat = *(layout->materials.getMaterialByName(win->contentMaterialName));
+ w.writeAttribute("detailSetting", isMaterialDetailed(mat)?"true":"false");
+
+ static const char *vnames[] = {
+ "vtxColLT", "vtxColRT", "vtxColLB", "vtxColRB"
+ };
+ for (int i = 0; i < 4; i++) {
+ w.writeEmptyElement(vnames[i]);
+ writeAttribColour(w, win->contentVtxColours[i]);
+ }
+
+ foreach (const LYTTexCoords &set, win->contentTexCoords)
+ writeTexCoordSet(w, set);
+
+ writeMaterial(w, mat, usedNames);
+ }
+ w.writeEndElement(); // content
+
+ const char *wframetypes[] = {
+ "CornerLT", "CornerRT", "CornerLB", "CornerRB",
+ "FrameT", "FrameB", "FrameL", "FrameR"
+ };
+ int frameidx = 0;
+ foreach (const LYTWindowFrame *fr, win->frames) {
+ const LYTMaterial &fmat = *(layout->materials.getMaterialByName(fr->materialName));
+
+ w.writeStartElement("frame");
+ w.writeAttribute("frameType", wframetypes[frameidx]);
+ w.writeAttribute("detailSetting", isMaterialDetailed(fmat)?"true":"false");
+
+ static const char *tflipNames[] = {
+ "None", "FlipH", "FlipV", "Rotate90", "Rotate180", "Rotate270"
+ };
+ w.writeTextElement("textureFlip", tflipNames[(int)fr->type]);
+
+ writeMaterial(w, fmat, usedNames);
+
+ w.writeEndElement(); // frame
+
+ frameidx++;
+ }
+
+ w.writeEmptyElement("contentInflation");
+ w.writeAttribute("l", QString::number(win->contentOverflowLeft));
+ w.writeAttribute("r", QString::number(win->contentOverflowRight));
+ w.writeAttribute("t", QString::number(win->contentOverflowTop));
+ w.writeAttribute("b", QString::number(win->contentOverflowBottom));
+
+ w.writeEndElement(); // window
+
+ } else if (p->type() == LYTPane::BoundingType) {
+ w.writeEmptyElement("bounding");
+ }
+
+
+ w.writeStartElement("userData");
+ w.writeEmptyElement("string");
+ w.writeEndElement();
+ }
+ w.writeEndElement(); // pane
+ }
+ }
+ w.writeEndElement(); // paneSet
+
+
+ // Now, the hierarchy
+ w.writeStartElement("paneHierarchy");
+ {
+ outputPaneTree(&w, layout->rootPane);
+ }
+ w.writeEndElement(); // paneHierarchy
+
+
+ w.writeStartElement("groupSet");
+ {
+ w.writeStartElement("group");
+ w.writeAttribute("name", "RootGroup");
+ {
+ foreach (LYTGroup *g, layout->groups) {
+ w.writeStartElement("group");
+ w.writeAttribute("name", g->name);
+ {
+ foreach (LYTPane *p, g->panes) {
+ w.writeEmptyElement("paneRef");
+ w.writeAttribute("name", p->name);
+ }
+ w.writeEmptyElement("comment");
+ }
+ w.writeEndElement(); // group
+ }
+
+ w.writeEmptyElement("comment");
+ }
+ w.writeEndElement(); // group
+ }
+ w.writeEndElement(); // groupSet
+
+
+ w.writeStartElement("screenSetting");
+ w.writeAttribute("origin", "Normal");
+ {
+ w.writeEmptyElement("layoutSize");
+ w.writeAttribute("x", QString::number(layout->width));
+ w.writeAttribute("y", QString::number(layout->height));
+
+ w.writeStartElement("backGround");
+ {
+ w.writeEmptyElement("color");
+ w.writeAttribute("r", "169");
+ w.writeAttribute("g", "169");
+ w.writeAttribute("b", "169");
+ w.writeAttribute("a", "255");
+ }
+ w.writeEndElement(); // backGround
+
+ w.writeStartElement("grid");
+ w.writeAttribute("thickLineInterval", "40");
+ w.writeAttribute("thinDivisionNum", "4");
+ w.writeAttribute("visible", "true");
+ w.writeAttribute("moveMethod", "Grid");
+ {
+ w.writeEmptyElement("color");
+ w.writeAttribute("r", "128");
+ w.writeAttribute("g", "128");
+ w.writeAttribute("b", "64");
+ w.writeAttribute("a", "128");
+ }
+ w.writeEndElement(); // grid
+ }
+ w.writeEndElement(); // screenSetting
+
+
+ const char *TexFormats[] = {
+ "I4", "I8", "IA4", "IA8", "RGB565", "RGB5A3", "RGBA8",
+ "xxx", "C4x", "C8x", "C14x", "xxx", "xxx", "xxx", "CMPR"
+ };
+
+ QStringList texfiles = layout->generateTextureRefs();
+ foreach (const QString &texfile, texfiles) {
+ QString stripname = texfile;
+ stripname.replace(".tpl", "");
+
+ w.writeEmptyElement("textureFile");
+ w.writeAttribute("imagePath", QString("texture\\%1.tga").arg(stripname));
+ w.writeAttribute("format", TexFormats[(int)texFormats.value(stripname)]);
+ }
+
+
+ // find out all the fonts that are used
+ QStringList fonts;
+ layout->rootPane->addFontRefsToList(fonts);
+
+ foreach (const QString &fontfile, fonts) {
+ w.writeEmptyElement("fontFile");
+ w.writeAttribute("path", QString("..\\fonts\\%1").arg(fontfile));
+ }
+
+
+ // Finish up
+
+
+ w.writeEndElement(); // rlyt
+ w.writeEndElement(); // body
+
+ w.writeEndDocument();
+}
+
+
+static void exportTexture(const WiiTPLTexture &tex, QIODevice *outputDevice) {
+ QDataStream out(outputDevice);
+ out.setByteOrder(QDataStream::LittleEndian);
+
+ out << (quint8)0x14; // ID length
+ out << (quint8)0; // no colour map
+ out << (quint8)2; // uncompressed true colour
+ WritePadding(5, out); // colour map spec, not used
+ out << (quint16)0; // X origin
+ out << (quint16)0; // Y origin
+ out << (quint16)tex.image.width(); // width
+ out << (quint16)tex.image.height(); // height
+ out << (quint8)32; // bit depth
+ out << (quint8)8; // alpha channel, direction (dir not used)
+
+ out.writeRawData("NW4R_Tga Ver1.0\0\0\0\xc1\xb0", 0x14);
+
+ // put together the image
+ for (int y = tex.image.height() - 1; y >= 0; y--) {
+ const QRgb *line = (const QRgb*)tex.image.scanLine(y);
+ for (int x = 0; x < tex.image.width(); x++) {
+ out << (quint32)line[x];
+ }
+ }
+
+ // now, data...
+ static const char *TexFormats[] = {
+ "i4", "i8", "ia4", "ia8", "rgb565", "rgb5a3", "rgba8",
+ "XXX", "c4", "c8", "c14", "XXX", "XXX", "XXX", "cmpr"
+ };
+
+ out.setByteOrder(QDataStream::BigEndian);
+
+ // format block
+ out.writeRawData("nw4r_tfm", 8);
+ const char *tfm = TexFormats[(int)tex.format];
+ quint32 tfm_size = 12 + qstrlen(tfm);
+ out << tfm_size;
+ out.writeRawData(tfm, qstrlen(tfm));
+
+ // end block
+ out.writeRawData("nw4r_end", 8);
+ out << (quint32)12;
+}
+
+#include "lyt/animation.h"
+
+static int AnimKeyFor(LYTAnimPiece::Type type, const LYTAnimEntry &entry) {
+ switch (type) {
+ case LYTAnimPiece::TexSRTAnim:
+ case LYTAnimPiece::IndTexSRTAnim:
+ case LYTAnimPiece::TexPatAnim:
+ return (entry.id << 8) | entry.target;
+ default:
+ return entry.target;
+ }
+}
+
+struct AnimExportThing {
+ QVector<LYTAnimHermiteKey> hermites;
+ QVector<LYTAnimStepKey> steps;
+ QStringList refRes;
+};
+
+void LSExportPackage(LYTPackageBase *pkg, QString dirStr) {
+ QDir dir(dirStr);
+ if (!dir.exists())
+ dir.mkpath(".");
+
+ if (!dir.exists("texture"))
+ dir.mkdir("texture");
+
+ QMap<QString, GX::TextureFormat> texFormats;
+
+ QStringList texes = pkg->listTextures();
+ foreach (const QString &tplName, texes) {
+ if (!tplName.endsWith(".tpl"))
+ continue;
+
+ QByteArray tplData = pkg->getTexture(tplName);
+ QDataStream ds(tplData);
+ WiiTexPalette tpl(ds);
+
+ const WiiTPLTexture &tex = tpl.textures.first();
+
+ QString texName = tplName;
+ texName.replace(".tpl", "");
+
+ texFormats.insert(texName, tex.format);
+
+ QFile tgaFile(dir.filePath(QString("texture/%1.tga").arg(texName)));
+ tgaFile.open(QFile::WriteOnly);
+ exportTexture(tex, &tgaFile);
+ tgaFile.close();
+ }
+
+ QString brlytName = pkg->listLayouts().first();
+ QString lytName = brlytName;
+ lytName.replace(".brlyt", "");
+
+ LYTLayout layout(*pkg, brlytName);
+
+ QFile rlytFile(dir.filePath(QString("%1.rlyt").arg(lytName)));
+ rlytFile.open(QFile::WriteOnly);
+ exportRlyt(&layout, &rlytFile, texFormats);
+ rlytFile.close();
+
+
+ // Now handle the rlan
+ QStringList brlans = pkg->listAnims();
+ QMap<int, LYTAnimation *> animPtrsByTag;
+ foreach (const QString &brlanName, brlans) {
+ if (!brlanName.endsWith(".brlan"))
+ continue;
+
+ QByteArray brlanData = pkg->getAnim(brlanName);
+ LYTAnimation *anim = new LYTAnimation(brlanData);
+
+ animPtrsByTag.insert(anim->sourceTagNumber, anim);
+ }
+
+ QFile rlanFile(dir.filePath(QString("%1.rlan").arg(lytName)));
+ rlanFile.open(QFile::WriteOnly);
+ QXmlStreamWriter aw(&rlanFile);
+
+ aw.setAutoFormatting(true);
+ aw.writeStartDocument();
+
+ aw.writeStartElement("nw4r_layout");
+ aw.writeDefaultNamespace("http://www.nintendo.co.jp/NW4R/LayoutEditor");
+ aw.writeAttribute("version", "1.2.0");
+
+ aw.writeStartElement("head");
+ {
+ aw.writeEmptyElement("create");
+ aw.writeAttribute("user", "someone");
+ aw.writeAttribute("host", "somewhere");
+ aw.writeAttribute("date", "2006-07-26T10:20:54.551+09:00");
+ aw.writeAttribute("source", "");
+
+ aw.writeEmptyElement("title");
+
+ aw.writeEmptyElement("comment");
+
+ aw.writeEmptyElement("generator");
+ aw.writeAttribute("name", "LayoutStudio");
+ aw.writeAttribute("version", "NONE_OF_YOUR_BUSINESS");
+ }
+ aw.writeEndElement(); // head
+
+ aw.writeStartElement("body");
+ {
+ int minFrame = 0x7fffffff, maxFrame = -1;
+ foreach (const LYTAnimation *anim, animPtrsByTag) {
+ aw.writeStartElement("animTag");
+ aw.writeAttribute("name", anim->name);
+ aw.writeAttribute("startFrame", QString::number(anim->sourceStartFrame));
+ aw.writeAttribute("endFrame", QString::number(anim->sourceEndFrame));
+ aw.writeAttribute("fileName", anim->name);
+ aw.writeAttribute("descendingBind", anim->recursiveBind?"true":"false");
+ aw.writeAttribute("animLoop", anim->loop?"Loop":"OneTime");
+
+ if (anim->sourceStartFrame < minFrame)
+ minFrame = anim->sourceStartFrame;
+ if (anim->sourceEndFrame > maxFrame)
+ maxFrame = anim->sourceEndFrame;
+
+ aw.writeEmptyElement("comment");
+
+ foreach (const LYTAnimGroupInfo &grp, anim->groups) {
+ aw.writeEmptyElement("group");
+ aw.writeAttribute("name", grp.name);
+ }
+
+ aw.writeEndElement(); // animTag
+ }
+
+ // This is probably not the most efficient way to do this
+ // but who gives a shit
+ QSet<LYTAnimPiece::Type> usedAnimTypes;
+ foreach (const LYTAnimation *anim, animPtrsByTag) {
+ foreach (const LYTAnimBlock &block, anim->blocks) {
+ foreach (const LYTAnimPiece &piece, block.pieces) {
+ usedAnimTypes.insert(piece.type);
+ }
+ }
+ }
+
+ // Now do processing for each type
+ static const char *AnimTypes[] = {
+ "PainSRT", "TextureSRT", "Visibility", "VertexColor",
+ "MaterialColor", "TexturePattern", "IndTextureSRT"
+ };
+ foreach (LYTAnimPiece::Type type, usedAnimTypes) {
+ aw.writeStartElement("rlan");
+ aw.writeAttribute("animType", AnimTypes[(int)type]);
+ aw.writeAttribute("startFrame", QString::number(minFrame));
+ aw.writeAttribute("endFrame", QString::number(maxFrame));
+ aw.writeAttribute("convertStartFrame", QString::number(minFrame));
+ aw.writeAttribute("convertEndFrame", QString::number(maxFrame));
+
+ // collect the contents
+ QMap<QString,bool> contentsUsed;
+
+ foreach (const LYTAnimation *anim, animPtrsByTag) {
+ foreach (const LYTAnimBlock &block, anim->blocks) {
+ foreach (const LYTAnimPiece &piece, block.pieces) {
+ if (piece.type == type)
+ contentsUsed.insert(block.name, true);
+ }
+ }
+ }
+
+ // now put them together!
+ QMapIterator<QString,bool> contentsUsedIter(contentsUsed);
+ while (contentsUsedIter.hasNext()) {
+ contentsUsedIter.next();
+
+ aw.writeStartElement("animContent");
+ aw.writeAttribute("name", contentsUsedIter.key());
+
+ // Collect the targets being used
+ QMap<int,AnimExportThing> targetsUsed;
+ foreach (const LYTAnimation *anim, animPtrsByTag) {
+ foreach (const LYTAnimBlock &block, anim->blocks) {
+ if (block.name != contentsUsedIter.key())
+ continue;
+
+ foreach (const LYTAnimPiece &piece, block.pieces) {
+ if (piece.type != type)
+ continue;
+
+ foreach (const LYTAnimEntry &entry, piece.entries) {
+ int key = AnimKeyFor(type, entry);
+ if (!targetsUsed.contains(key))
+ targetsUsed.insert(key, AnimExportThing());
+
+ AnimExportThing &thing = targetsUsed[key];
+ if (entry.curveType == 0)
+ qFatal("what!");
+ else if (entry.curveType == 1) {
+ // step keys
+ foreach (const LYTAnimStepKey &key, entry.stepKeys) {
+ LYTAnimStepKey newKey = key;
+ newKey.frame += anim->sourceStartFrame;
+ thing.steps.append(newKey);
+ }
+ } else if (entry.curveType == 2) {
+ // hermite keys
+ foreach (const LYTAnimHermiteKey &key, entry.keys) {
+ LYTAnimHermiteKey newKey = key;
+ newKey.frame += anim->sourceStartFrame;
+ thing.hermites.append(newKey);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Now export them...
+ QMapIterator<int,AnimExportThing> tuIter(targetsUsed);
+ while (tuIter.hasNext()) {
+ tuIter.next();
+
+ // assemble the start tag
+ int ak = tuIter.key();
+
+ static const char *PainTargets[] = {
+ "TranslateX", "TranslateY", "TranslateZ",
+ "RotateX", "RotateY", "RotateZ",
+ "ScaleX", "ScaleY",
+ "SizeW", "SizeH"
+ };
+
+ static const char *VtxColTargets[] = {
+ "LT_r", "LT_g", "LT_b", "LT_a",
+ "RT_r", "RT_g", "RT_b", "RT_a",
+ "LB_r", "LB_g", "LB_b", "LB_a",
+ "RB_r", "RB_g", "RB_b", "RB_a",
+ "PaneAlpha"
+ };
+
+ static const char *MatColTargets[] = {
+ "MatColor0_r", "MatColor0_g", "MatColor0_b", "MatColor0_a",
+ "TevColor0_r", "TevColor0_g", "TevColor0_b", "TevColor0_a",
+ "TevColor1_r", "TevColor1_g", "TevColor1_b", "TevColor1_a",
+ "TevColor2_r", "TevColor2_g", "TevColor2_b", "TevColor2_a",
+ "TevKonst0_r", "TevKonst0_g", "TevKonst0_b", "TevKonst0_a",
+ "TevKonst1_r", "TevKonst1_g", "TevKonst1_b", "TevKonst1_a",
+ "TevKonst2_r", "TevKonst2_g", "TevKonst2_b", "TevKonst2_a",
+ "TevKonst3_r", "TevKonst3_g", "TevKonst3_b", "TevKonst3_a"
+ };
+
+ static const char *SRTTargets[] = {
+ "TranslateS", "TranslateT", "Rotate", "ScaleS", "ScaleT"
+ };
+
+ static const char *PatTargets[] = {
+ "Image", "Palette"
+ };
+
+ switch (type) {
+ case LYTAnimPiece::PaneAnim:
+ aw.writeStartElement("animPainSRTTarget");
+ aw.writeAttribute("target", PainTargets[ak]);
+ break;
+ case LYTAnimPiece::VisAnim:
+ aw.writeStartElement("animVisibilityTarget");
+ aw.writeAttribute("target", "Visibility");
+ break;
+ case LYTAnimPiece::VtxClrAnim:
+ aw.writeStartElement("animVertexColorTarget");
+ aw.writeAttribute("target", VtxColTargets[ak]);
+ break;
+ case LYTAnimPiece::MatClrAnim:
+ aw.writeStartElement("animMaterialColorTarget");
+ aw.writeAttribute("target", MatColTargets[ak]);
+ break;
+ case LYTAnimPiece::TexSRTAnim:
+ aw.writeStartElement("animTexSRTTarget");
+ aw.writeAttribute("id", QString::number(ak>>8));
+ aw.writeAttribute("target", SRTTargets[ak&0xFF]);
+ break;
+ case LYTAnimPiece::IndTexSRTAnim:
+ aw.writeStartElement("animIndTexSRTTarget");
+ aw.writeAttribute("id", QString::number(ak>>8));
+ aw.writeAttribute("target", SRTTargets[ak&0xFF]);
+ break;
+ case LYTAnimPiece::TexPatAnim:
+ aw.writeStartElement("animTexPatternTarget");
+ aw.writeAttribute("id", QString::number(ak>>8));
+ aw.writeAttribute("target", PatTargets[ak&0xFF]);
+
+ //foreach (const QString &bee, )
+ break;
+ }
+
+ foreach (const LYTAnimHermiteKey &key, tuIter.value().hermites) {
+ aw.writeEmptyElement("key");
+ aw.writeAttribute("frame", QString::number(key.frame));
+ aw.writeAttribute("value", QString::number(key.value));
+ aw.writeAttribute("slope", QString::number(key.slope));
+ }
+
+ foreach (const LYTAnimStepKey &key, tuIter.value().steps) {
+ aw.writeEmptyElement("key");
+ aw.writeAttribute("frame", QString::number(key.frame));
+ aw.writeAttribute("value", QString::number(key.value));
+ aw.writeAttribute("slopeType", "Step");
+ }
+
+ aw.writeEndElement(); // target thing
+ }
+
+ aw.writeEndElement(); // animContent
+ }
+
+ aw.writeEndElement(); // rlan
+ }
+ }
+ aw.writeEndElement(); // body
+
+ aw.writeEndElement(); // nw4r_layout
+
+ aw.writeEndDocument();
+
+ rlanFile.close();
+
+ qDeleteAll(animPtrsByTag.begin(), animPtrsByTag.end());
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 23:13:11 +0000