AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-12-08 16:24:55 +00:00
Code Issues Projects Releases Wiki Activity

temporary ID dumping hard-coded

Browse Source
This commit is contained in:
Jack Andersen
2015-10-25 16:31:09 -10:00
parent fb11af23c6
commit fa8b48d43e
16 changed files with 435 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
DataSpec/DNACommon/DNACommon.hpp
View File

@@ -73,6 +73,7 @@ public:
}
UniqueID32() = default;
UniqueID32(Athena::io::IStreamReader& reader) {read(reader);}
UniqueID32(const char* hexStr)
{
char copy[9];
@@ -111,6 +112,7 @@ public:
}
UniqueID64() = default;
UniqueID64(Athena::io::IStreamReader& reader) {read(reader);}
UniqueID64(const char* hexStr)
{
char copy[17];

188
DataSpec/DNACommon/MAPA.hpp
View File

@@ -1,4 +1,192 @@
#ifndef __DNACOMMON_MAPA_HPP__
#define __DNACOMMON_MAPA_HPP__
#include "DNACommon.hpp"
#include "GX.hpp"
namespace Retro
{
namespace DNAMAPA
{
template <typename PAKRouter, typename MAPA>
bool ReadMAPAToBlender(HECL::BlenderConnection& conn,
const MAPA& mapa,
const HECL::ProjectPath& outPath,
PAKRouter& pakRouter,
const typename PAKRouter::EntryType& entry,
bool force)
{
/* Rename MAPA for consistency */
HECL::ProjectPath mapaPath(outPath.getParentPath(), _S("!map.blend"));
if (!force && mapaPath.getPathType() == HECL::ProjectPath::PT_FILE)
return true;
if (!conn.createBlend(mapaPath, HECL::BlenderConnection::TypeMapArea))
return false;
HECL::BlenderConnection::PyOutStream os = conn.beginPythonOut(true);
os << "import bpy, bmesh\n"
"from mathutils import Matrix\n"
"\n"
"bpy.types.Object.retro_mappable_type = bpy.props.IntProperty(name='Retro: MAPA object type', default=-1)\n"
"bpy.types.Object.retro_mappable_unk = bpy.props.IntProperty(name='Retro: MAPA object unk')\n"
"bpy.types.Object.retro_mappable_sclyid = bpy.props.StringProperty(name='Retro: MAPA object SCLY ID')\n"
"\n"
"# Clear Scene\n"
"for ob in bpy.data.objects:\n"
" bpy.context.scene.objects.unlink(ob)\n"
" bpy.data.objects.remove(ob)\n"
"\n"
"def add_triangle(bm, verts):\n"
" verts = [bm.verts[vi] for vi in verts]\n"
" face = bm.faces.get(verts)\n"
" if face:\n"
" face = face.copy()\n"
" bm.verts.ensure_lookup_table()\n"
" face.normal_flip()\n"
" else:\n"
" bm.faces.new(verts)\n"
"\n"
"def add_border(bm, verts):\n"
" verts = [bm.verts[vi] for vi in verts]\n"
" edge = bm.edges.get(verts)\n"
" edge.seam = True\n"
"\n";
os.format("bpy.context.scene.name = 'MAPA_%s'\n",
entry.id.toString().c_str());
/* Add empties representing MappableObjects */
int moIdx = 0;
for (const typename MAPA::MappableObject& mo : mapa.mappableObjects)
{
os.format("obj = bpy.data.objects.new('MAPOBJ_%02d', None)\n"
"bpy.context.scene.objects.link(obj)\n"
"obj.retro_mappable_type = %d\n"
"obj.retro_mappable_unk = %d\n"
"obj.retro_mappable_sclyid = '%08X'\n"
"mtx = Matrix(((%f,%f,%f,%f),(%f,%f,%f,%f),(%f,%f,%f,%f),(0.0,0.0,0.0,1.0)))\n"
"mtxd = mtx.decompose()\n"
"obj.rotation_mode = 'QUATERNION'\n"
"obj.location = mtxd[0]\n"
"obj.rotation_quaternion = mtxd[1]\n"
"obj.scale = mtxd[2]\n",
moIdx, mo.type, mo.unknown1, mo.sclyId,
mo.transformMtx[0].vec[0], mo.transformMtx[0].vec[1], mo.transformMtx[0].vec[2], mo.transformMtx[0].vec[3],
mo.transformMtx[1].vec[0], mo.transformMtx[1].vec[1], mo.transformMtx[1].vec[2], mo.transformMtx[1].vec[3],
mo.transformMtx[2].vec[0], mo.transformMtx[2].vec[1], mo.transformMtx[2].vec[2], mo.transformMtx[2].vec[3]);
++moIdx;
}
os << "# Begin bmesh\n"
"bm = bmesh.new()\n"
"\n";
/* Read in verts */
for (const atVec3f& vert : mapa.vertices)
os.format("bm.verts.new((%f,%f,%f))\n",
vert.vec[0], vert.vec[1], vert.vec[2]);
os << "bm.verts.ensure_lookup_table()\n";
/* Read in surfaces */
for (const typename MAPA::Surface& surf : mapa.surfaces)
{
for (const typename MAPA::Surface::Primitive& prim : surf.primitives)
{
auto iit = prim.indices.cbegin();
/* 3 Prim Verts to start */
int c = 0;
unsigned int primVerts[3] =
{
*iit++,
*iit++,
*iit++
};
if (GX::Primitive(prim.type) == GX::TRIANGLESTRIP)
{
atUint8 flip = 0;
for (int v=0 ; v<prim.indexCount-2 ; ++v)
{
if (flip)
{
os.format("add_triangle(bm, (%u,%u,%u))\n",
primVerts[c%3],
primVerts[(c+2)%3],
primVerts[(c+1)%3]);
}
else
{
os.format("add_triangle(bm, (%u,%u,%u))\n",
primVerts[c%3],
primVerts[(c+1)%3],
primVerts[(c+2)%3]);
}
flip ^= 1;
bool peek = (v >= prim.indexCount - 3);
/* Advance one prim vert */
if (peek)
primVerts[c%3] = *iit;
else
primVerts[c%3] = *iit++;
++c;
}
}
else if (GX::Primitive(prim.type) == GX::TRIANGLES)
{
for (int v=0 ; v<prim.indexCount ; v+=3)
{
os.format("add_triangle(bm, (%u,%u,%u))\n",
primVerts[0],
primVerts[1],
primVerts[2]);
/* Break if done */
if (v+3 >= prim.indexCount)
break;
/* Advance 3 Prim Verts */
for (int pv=0 ; pv<3 ; ++pv)
primVerts[pv] = *iit++;
}
}
}
for (const typename MAPA::Surface::Border& border : surf.borders)
{
auto iit = border.indices.cbegin();
for (int i=0 ; i<border.indexCount-1 ; ++i)
{
os.format("add_border(bm, (%u,%u))\n",
*iit, *(iit+1));
++iit;
}
}
}
os << "mesh = bpy.data.meshes.new('MAP')\n"
"obj = bpy.data.objects.new(mesh.name, mesh)\n"
"bm.to_mesh(mesh)\n"
"bpy.context.scene.objects.link(obj)\n"
"bm.free()\n";
/* World background */
HECL::ProjectPath worldBlend(outPath.getParentPath().getParentPath(), "!world.blend");
if (worldBlend.getPathType() == HECL::ProjectPath::PT_FILE)
os.linkBackground("//../!world.blend", "World");
os.centerView();
os.close();
conn.saveBlend();
return true;
}
}
}
#endif // __DNACOMMON_MAPA_HPP__

74
DataSpec/DNACommon/PAK.hpp
View File

@@ -33,7 +33,7 @@ public:
m_pos += pos;
else if (origin == Athena::End)
m_pos = m_sz + pos;
if (m_pos >= m_sz)
if (m_pos > m_sz)
LogDNACommon.report(LogVisor::FatalError, "PAK stream cursor overrun");
}
atUint64 position() const {return m_pos;}
@@ -309,6 +309,43 @@ public:
progress(++count / bridgesSz);
++bridgeIdx;
}
/* TEMP: CSV dump */
FILE* fp = HECL::Fopen(_S("/home/jacko/Desktop/mp_res.txt"), _S("w"));
for (const auto& entry : m_uniqueEntries)
{
const EntryType* ent = entry.second.second;
fprintf(fp, "%s\t0x%s\t\t", ent->type.toString().c_str(), entry.first.toString().c_str());
switch (ent->unique.m_type)
{
case UniqueResult::UNIQUE_NOTFOUND:
case UniqueResult::UNIQUE_PAK:
{
const HECL::ProjectPath& pakPath = m_bridgePaths[entry.second.first].first;
fprintf(fp, _S("%s\n"), pakPath.getLastComponent());
break;
}
case UniqueResult::UNIQUE_LEVEL:
fprintf(fp, _S("%s\n"), ent->unique.m_levelName->c_str());
break;
case UniqueResult::UNIQUE_AREA:
fprintf(fp, _S("%s/%s\n"), ent->unique.m_levelName->c_str(), ent->unique.m_areaName->c_str());
break;
case UniqueResult::UNIQUE_LAYER:
fprintf(fp, _S("%s/%s/%s\n"), ent->unique.m_levelName->c_str(), ent->unique.m_areaName->c_str(), ent->unique.m_layerName->c_str());
break;
default:
fprintf(fp, "\n");
break;
}
}
fprintf(fp, "\n");
for (const auto& entry : m_sharedEntries)
{
const EntryType* ent = entry.second.second;
fprintf(fp, "%s\t0x%s\t\t\n", ent->type.toString().c_str(), entry.first.toString().c_str());
}
fclose(fp);
}
void enterPAKBridge(const BRIDGETYPE& pakBridge)
@@ -505,23 +542,33 @@ public:
float fsz = sz;
for (unsigned w=0 ; count<sz ; ++w)
{
for (const auto& item : m_pak->m_idMap)
for (const auto& item : m_pak->m_firstEntries)
{
ResExtractor<BRIDGETYPE> extractor = BRIDGETYPE::LookupExtractor(*item.second);
ResExtractor<BRIDGETYPE> extractor = BRIDGETYPE::LookupExtractor(*item);
if (extractor.weight != w)
continue;
std::string bestName = getBestEntryName(*item.second);
std::string bestName = getBestEntryName(*item);
HECL::SystemStringView bestNameView(bestName);
float thisFac = ++count / fsz;
progress(bestNameView.sys_str().c_str(), thisFac);
HECL::ProjectPath working = getWorking(item.second, extractor);
/* TODO: Position after extracted item */
HECL::ProjectPath cooked = getCooked(item);
if (force || cooked.getPathType() == HECL::ProjectPath::PT_NONE)
{
PAKEntryReadStream s = item->beginReadStream(*m_node);
FILE* fout = HECL::Fopen(cooked.getAbsolutePath().c_str(), _S("wb"));
fwrite(s.data(), 1, s.length(), fout);
fclose(fout);
}
HECL::ProjectPath working = getWorking(item, extractor);
if (extractor.func_a) /* Doesn't need PAKRouter access */
{
if (force || working.getPathType() == HECL::ProjectPath::PT_NONE)
{
PAKEntryReadStream s = item.second->beginReadStream(*m_node);
PAKEntryReadStream s = item->beginReadStream(*m_node);
extractor.func_a(s, working);
}
}
@@ -529,25 +576,14 @@ public:
{
if (force || working.getPathType() == HECL::ProjectPath::PT_NONE)
{
PAKEntryReadStream s = item.second->beginReadStream(*m_node);
extractor.func_b(m_dataSpec, s, working, *this, *item.second, force,
PAKEntryReadStream s = item->beginReadStream(*m_node);
extractor.func_b(m_dataSpec, s, working, *this, *item, force,
[&progress, thisFac](const HECL::SystemChar* update)
{
progress(update, thisFac);
});
}
}
/* Extract original cooked copy AFTER working so timestamps make
* the original a valid cached item */
HECL::ProjectPath cooked = getCooked(item.second);
if (force || cooked.getPathType() == HECL::ProjectPath::PT_NONE)
{
PAKEntryReadStream s = item.second->beginReadStream(*m_node);
FILE* fout = HECL::Fopen(cooked.getAbsolutePath().c_str(), _S("wb"));
fwrite(s.data(), 1, s.length(), fout);
fclose(fout);
}
}
}