mirror of https://github.com/AxioDL/metaforce.git
606 lines
25 KiB
C++
606 lines
25 KiB
C++
#include "FRME.hpp"
|
|
#include "DataSpec/DNACommon/TXTR.hpp"
|
|
#include "hecl/Blender/Connection.hpp"
|
|
|
|
namespace DataSpec::DNAMP1 {
|
|
|
|
template <>
|
|
void FRME::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader) {
|
|
/* version */
|
|
version = __dna_reader.readUint32Big();
|
|
/* unk1 */
|
|
unk1 = __dna_reader.readUint32Big();
|
|
/* modelCount */
|
|
modelCount = __dna_reader.readUint32Big();
|
|
/* unk3 */
|
|
unk3 = __dna_reader.readUint32Big();
|
|
/* widgetCount */
|
|
widgetCount = __dna_reader.readUint32Big();
|
|
/* widgets */
|
|
__dna_reader.enumerate<Widget>(widgets, widgetCount, [this](athena::io::IStreamReader& reader, Widget& w) {
|
|
w.owner = this;
|
|
w.read(reader);
|
|
});
|
|
}
|
|
|
|
template <>
|
|
void FRME::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer) {
|
|
/* version */
|
|
__dna_writer.writeUint32Big(version);
|
|
/* unk1 */
|
|
__dna_writer.writeUint32Big(unk1);
|
|
/* modelCount */
|
|
__dna_writer.writeUint32Big(modelCount);
|
|
/* unk3 */
|
|
__dna_writer.writeUint32Big(unk3);
|
|
/* widgetCount */
|
|
__dna_writer.writeUint32Big(widgetCount);
|
|
/* widgets */
|
|
__dna_writer.enumerate(widgets);
|
|
}
|
|
|
|
template <>
|
|
void FRME::Enumerate<BigDNA::BinarySize>(size_t& __isz) {
|
|
for (const Widget& w : widgets)
|
|
w.binarySize(__isz);
|
|
__isz += 20;
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader) {
|
|
/* type */
|
|
type.read(__dna_reader);
|
|
/* header */
|
|
header.read(__dna_reader);
|
|
switch (type.toUint32()) {
|
|
case SBIG('BWIG'):
|
|
widgetInfo = std::make_unique<BWIGInfo>();
|
|
break;
|
|
case SBIG('HWIG'):
|
|
widgetInfo = std::make_unique<HWIGInfo>();
|
|
break;
|
|
case SBIG('CAMR'):
|
|
widgetInfo = std::make_unique<CAMRInfo>();
|
|
break;
|
|
case SBIG('LITE'):
|
|
widgetInfo = std::make_unique<LITEInfo>();
|
|
break;
|
|
case SBIG('ENRG'):
|
|
widgetInfo = std::make_unique<ENRGInfo>();
|
|
break;
|
|
case SBIG('MODL'):
|
|
widgetInfo = std::make_unique<MODLInfo>();
|
|
break;
|
|
case SBIG('METR'):
|
|
widgetInfo = std::make_unique<METRInfo>();
|
|
break;
|
|
case SBIG('GRUP'):
|
|
widgetInfo = std::make_unique<GRUPInfo>();
|
|
break;
|
|
case SBIG('PANE'):
|
|
widgetInfo = std::make_unique<PANEInfo>();
|
|
break;
|
|
case SBIG('TXPN'):
|
|
widgetInfo = std::make_unique<TXPNInfo>(owner->version);
|
|
break;
|
|
case SBIG('IMGP'):
|
|
widgetInfo = std::make_unique<IMGPInfo>();
|
|
break;
|
|
case SBIG('TBGP'):
|
|
widgetInfo = std::make_unique<TBGPInfo>();
|
|
break;
|
|
case SBIG('SLGP'):
|
|
widgetInfo = std::make_unique<SLGPInfo>();
|
|
break;
|
|
default:
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unsupported FRME widget type {}")), type);
|
|
}
|
|
|
|
/* widgetInfo */
|
|
widgetInfo->read(__dna_reader);
|
|
|
|
/* isWorker */
|
|
isWorker = __dna_reader.readBool();
|
|
if (isWorker) {
|
|
/* workerId */
|
|
workerId = __dna_reader.readUint16Big();
|
|
}
|
|
/* origin */
|
|
origin = __dna_reader.readVec3fBig();
|
|
/* basis[0] */
|
|
basis[0] = __dna_reader.readVec3fBig();
|
|
/* basis[1] */
|
|
basis[1] = __dna_reader.readVec3fBig();
|
|
/* basis[2] */
|
|
basis[2] = __dna_reader.readVec3fBig();
|
|
/* rotationCenter */
|
|
rotationCenter = __dna_reader.readVec3fBig();
|
|
/* unk1 */
|
|
unk1 = __dna_reader.readInt32Big();
|
|
/* unk2 */
|
|
unk2 = __dna_reader.readInt16Big();
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer) {
|
|
/* type */
|
|
DNAFourCC _type = widgetInfo ? widgetInfo->fourcc() : FOURCC('BWIG');
|
|
_type.write(__dna_writer);
|
|
/* header */
|
|
header.write(__dna_writer);
|
|
|
|
/* widgetInfo */
|
|
if (widgetInfo)
|
|
widgetInfo->write(__dna_writer);
|
|
|
|
/* isWorker */
|
|
__dna_writer.writeBool(isWorker);
|
|
if (isWorker) {
|
|
/* workerId */
|
|
__dna_writer.writeUint16Big(workerId);
|
|
}
|
|
/* origin */
|
|
__dna_writer.writeVec3fBig(origin);
|
|
/* basis[0] */
|
|
__dna_writer.writeVec3fBig(basis[0]);
|
|
/* basis[1] */
|
|
__dna_writer.writeVec3fBig(basis[1]);
|
|
/* basis[2] */
|
|
__dna_writer.writeVec3fBig(basis[2]);
|
|
/* rotationCenter */
|
|
__dna_writer.writeVec3fBig(rotationCenter);
|
|
/* unk1 */
|
|
__dna_writer.writeInt32Big(unk1);
|
|
/* unk2 */
|
|
__dna_writer.writeInt16Big(unk2);
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::Enumerate<BigDNA::BinarySize>(size_t& __isz) {
|
|
type.binarySize(__isz);
|
|
header.binarySize(__isz);
|
|
if (widgetInfo)
|
|
widgetInfo->binarySize(__isz);
|
|
if (isWorker)
|
|
__isz += 4;
|
|
__isz += 67;
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::CAMRInfo::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader) {
|
|
projectionType = ProjectionType(__dna_reader.readUint32Big());
|
|
if (projectionType == ProjectionType::Perspective) {
|
|
projection = std::make_unique<PerspectiveProjection>();
|
|
} else if (projectionType == ProjectionType::Orthographic) {
|
|
projection = std::make_unique<OrthographicProjection>();
|
|
} else {
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Invalid CAMR projection mode! {}")), int(projectionType));
|
|
}
|
|
|
|
projection->read(__dna_reader);
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::CAMRInfo::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer) {
|
|
if (!projection)
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Invalid CAMR projection object!")));
|
|
if (projection->type != projectionType)
|
|
Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("CAMR projection type does not match actual projection type!")));
|
|
|
|
__dna_writer.writeUint32Big(atUint32(projectionType));
|
|
projection->write(__dna_writer);
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::CAMRInfo::Enumerate<BigDNA::BinarySize>(size_t& __isz) {
|
|
projection->binarySize(__isz);
|
|
__isz += 4;
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::LITEInfo::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader) {
|
|
/* type */
|
|
type = ELightType(__dna_reader.readUint32Big());
|
|
/* distC */
|
|
distC = __dna_reader.readFloatBig();
|
|
/* distL */
|
|
distL = __dna_reader.readFloatBig();
|
|
/* distQ */
|
|
distQ = __dna_reader.readFloatBig();
|
|
/* angC */
|
|
angC = __dna_reader.readFloatBig();
|
|
/* angL */
|
|
angL = __dna_reader.readFloatBig();
|
|
/* angQ */
|
|
angQ = __dna_reader.readFloatBig();
|
|
/* loadedIdx */
|
|
loadedIdx = __dna_reader.readUint32Big();
|
|
|
|
/* cutoff */
|
|
if (type == ELightType::Spot)
|
|
cutoff = __dna_reader.readFloatBig();
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::LITEInfo::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer) {
|
|
/* type */
|
|
__dna_writer.writeUint32Big(atUint32(type));
|
|
/* distC */
|
|
__dna_writer.writeFloatBig(distC);
|
|
/* distL */
|
|
__dna_writer.writeFloatBig(distL);
|
|
/* distQ */
|
|
__dna_writer.writeFloatBig(distQ);
|
|
/* angC */
|
|
__dna_writer.writeFloatBig(angC);
|
|
/* angL */
|
|
__dna_writer.writeFloatBig(angL);
|
|
/* angQ */
|
|
__dna_writer.writeFloatBig(angQ);
|
|
/* loadedIdx */
|
|
__dna_writer.writeUint32Big(loadedIdx);
|
|
|
|
/* cutoff */
|
|
if (type == ELightType::Spot)
|
|
__dna_writer.writeFloatBig(cutoff);
|
|
}
|
|
|
|
template <>
|
|
void FRME::Widget::LITEInfo::Enumerate<BigDNA::BinarySize>(size_t& __isz) {
|
|
__isz += ((type == ELightType::Spot) ? 36 : 32);
|
|
}
|
|
|
|
template <class Op>
|
|
void FRME::Widget::TXPNInfo::Enumerate(typename Op::StreamT& s) {
|
|
Do<Op>(athena::io::PropId{"xDim"}, xDim, s);
|
|
Do<Op>(athena::io::PropId{"zDim"}, zDim, s);
|
|
Do<Op>(athena::io::PropId{"scaleCenter"}, scaleCenter, s);
|
|
Do<Op>(athena::io::PropId{"font"}, font, s);
|
|
Do<Op>(athena::io::PropId{"wordWrap"}, wordWrap, s);
|
|
Do<Op>(athena::io::PropId{"horizontal"}, horizontal, s);
|
|
Do<Op>(athena::io::PropId{"justification"}, justification, s);
|
|
Do<Op>(athena::io::PropId{"verticalJustification"}, verticalJustification, s);
|
|
Do<Op>(athena::io::PropId{"fillColor"}, fillColor, s);
|
|
Do<Op>(athena::io::PropId{"outlineColor"}, outlineColor, s);
|
|
Do<Op>(athena::io::PropId{"blockExtent"}, blockExtent, s);
|
|
if (version == 1) {
|
|
Do<Op>(athena::io::PropId{"jpnFont"}, jpnFont, s);
|
|
Do<Op>(athena::io::PropId{"jpnPointScale[0]"}, jpnPointScale[0], s);
|
|
Do<Op>(athena::io::PropId{"jpnPointScale[1]"}, jpnPointScale[1], s);
|
|
}
|
|
}
|
|
|
|
AT_SPECIALIZE_DNA(FRME::Widget::TXPNInfo)
|
|
|
|
bool FRME::Extract(const SpecBase& dataSpec, PAKEntryReadStream& rs, const hecl::ProjectPath& outPath,
|
|
PAKRouter<PAKBridge>& pakRouter, const PAK::Entry& entry, bool force, hecl::blender::Token& btok,
|
|
std::function<void(const hecl::SystemChar*)> fileChanged) {
|
|
if (!force && outPath.isFile())
|
|
return true;
|
|
|
|
FRME frme;
|
|
frme.read(rs);
|
|
|
|
hecl::blender::Connection& conn = btok.getBlenderConnection();
|
|
if (!conn.createBlend(outPath, hecl::blender::BlendType::Frame))
|
|
return false;
|
|
|
|
hecl::blender::PyOutStream os = conn.beginPythonOut(true);
|
|
|
|
os << "import bpy, math, bmesh\n"
|
|
"from mathutils import Matrix, Quaternion\n"
|
|
"# Clear Scene\n"
|
|
"if len(bpy.data.collections):\n"
|
|
" bpy.data.collections.remove(bpy.data.collections[0])\n"
|
|
"\n"
|
|
"def duplicateObject(copy_obj):\n"
|
|
" # Create new mesh\n"
|
|
" mesh = bpy.data.meshes.new(copy_obj.name)\n"
|
|
" # Create new object associated with the mesh\n"
|
|
" ob_new = bpy.data.objects.new(copy_obj.name, mesh)\n"
|
|
" # Copy data block from the old object into the new object\n"
|
|
" ob_new.data = copy_obj.data\n"
|
|
" ob_new.scale = copy_obj.scale\n"
|
|
" ob_new.location = copy_obj.location\n"
|
|
" # Link new object to the given scene and select it\n"
|
|
" bpy.context.scene.collection.objects.link(ob_new)\n"
|
|
" return ob_new\n";
|
|
|
|
os.format(FMT_STRING("bpy.context.scene.name = '{}'\n"
|
|
"bpy.context.scene.render.resolution_x = 640\n"
|
|
"bpy.context.scene.render.resolution_y = 480\n"
|
|
"bpy.context.scene.world.use_nodes = True\n"
|
|
"bg_node = bpy.context.scene.world.node_tree.nodes['Background']\n"
|
|
"bg_node.inputs[1].default_value = 0.0\n"),
|
|
pakRouter.getBestEntryName(entry));
|
|
|
|
int pIdx = 0;
|
|
for (const FRME::Widget& w : frme.widgets) {
|
|
os << "binding = None\n"
|
|
"angle = Quaternion((1.0, 0.0, 0.0), 0)\n";
|
|
if (w.type == SBIG('CAMR')) {
|
|
using CAMRInfo = Widget::CAMRInfo;
|
|
os.format(FMT_STRING("cam = bpy.data.cameras.new(name='{}')\n"
|
|
"binding = cam\n"),
|
|
w.header.name);
|
|
if (CAMRInfo* info = static_cast<CAMRInfo*>(w.widgetInfo.get())) {
|
|
if (info->projectionType == CAMRInfo::ProjectionType::Orthographic) {
|
|
CAMRInfo::OrthographicProjection* proj =
|
|
static_cast<CAMRInfo::OrthographicProjection*>(info->projection.get());
|
|
os.format(FMT_STRING("cam.type = 'ORTHO'\n"
|
|
"cam.ortho_scale = {}\n"
|
|
"cam.clip_start = {}\n"
|
|
"cam.clip_end = {}\n"),
|
|
std::fabs(proj->right - proj->left), proj->znear, proj->zfar);
|
|
} else if (info->projectionType == CAMRInfo::ProjectionType::Perspective) {
|
|
CAMRInfo::PerspectiveProjection* proj = static_cast<CAMRInfo::PerspectiveProjection*>(info->projection.get());
|
|
os.format(FMT_STRING("cam.type = 'PERSP'\n"
|
|
"cam.lens_unit = 'FOV'\n"
|
|
"cam.clip_start = {}\n"
|
|
"cam.clip_end = {}\n"
|
|
"bpy.context.scene.render.resolution_x = 480 * {}\n"),
|
|
proj->znear, proj->zfar, proj->aspect);
|
|
if (proj->aspect > 1.f)
|
|
os.format(FMT_STRING("cam.angle = math.atan2({}, 1.0 / math.tan(math.radians({} / 2.0))) * 2.0\n"),
|
|
proj->aspect, proj->fov);
|
|
else
|
|
os.format(FMT_STRING("cam.angle = math.radians({})\n"), proj->fov);
|
|
}
|
|
}
|
|
os << "angle = Quaternion((1.0, 0.0, 0.0), math.radians(90.0))\n";
|
|
} else if (w.type == SBIG('LITE')) {
|
|
using LITEInfo = Widget::LITEInfo;
|
|
if (LITEInfo* info = static_cast<LITEInfo*>(w.widgetInfo.get())) {
|
|
switch (info->type) {
|
|
case LITEInfo::ELightType::LocalAmbient: {
|
|
zeus::simd_floats colorF(w.header.color.simd);
|
|
os.format(FMT_STRING("bg_node.inputs[0].default_value = ({},{},{},1.0)\n"
|
|
"bg_node.inputs[1].default_value = {}\n"),
|
|
colorF[0], colorF[1], colorF[2], info->distQ / 8.0);
|
|
break;
|
|
}
|
|
case LITEInfo::ELightType::Spot:
|
|
case LITEInfo::ELightType::Directional:
|
|
os << "angle = Quaternion((1.0, 0.0, 0.0), math.radians(90.0))\n";
|
|
[[fallthrough]];
|
|
default: {
|
|
zeus::simd_floats colorF(w.header.color.simd);
|
|
os.format(FMT_STRING("lamp = bpy.data.lights.new(name='{}', type='POINT')\n"
|
|
"lamp.color = ({}, {}, {})\n"
|
|
"lamp.hecl_falloff_constant = {}\n"
|
|
"lamp.hecl_falloff_linear = {}\n"
|
|
"lamp.hecl_falloff_quadratic = {}\n"
|
|
"lamp.retro_light_angle_constant = {}\n"
|
|
"lamp.retro_light_angle_linear = {}\n"
|
|
"lamp.retro_light_angle_quadratic = {}\n"
|
|
"lamp.retro_light_index = {}\n"
|
|
"binding = lamp\n"),
|
|
w.header.name, colorF[0], colorF[1], colorF[2], info->distC, info->distL, info->distQ, info->angC,
|
|
info->angL, info->angQ, info->loadedIdx);
|
|
if (info->type == LITEInfo::ELightType::Spot)
|
|
os.format(FMT_STRING("lamp.type = 'SPOT'\n"
|
|
"lamp.spot_size = {}\n"),
|
|
info->cutoff);
|
|
else if (info->type == LITEInfo::ELightType::Directional)
|
|
os << "lamp.type = 'SUN'\n";
|
|
}
|
|
}
|
|
}
|
|
} else if (w.type == SBIG('IMGP')) {
|
|
using IMGPInfo = Widget::IMGPInfo;
|
|
if (IMGPInfo* info = static_cast<IMGPInfo*>(w.widgetInfo.get())) {
|
|
std::string texName;
|
|
hecl::SystemString resPath;
|
|
if (info->texture.isValid()) {
|
|
texName = pakRouter.getBestEntryName(info->texture);
|
|
const nod::Node* node;
|
|
const PAKRouter<PAKBridge>::EntryType* texEntry = pakRouter.lookupEntry(info->texture, &node);
|
|
hecl::ProjectPath txtrPath = pakRouter.getWorking(texEntry);
|
|
if (txtrPath.isNone()) {
|
|
txtrPath.makeDirChain(false);
|
|
PAKEntryReadStream rs = texEntry->beginReadStream(*node);
|
|
TXTR::Extract(rs, txtrPath);
|
|
}
|
|
resPath = pakRouter.getResourceRelativePath(entry, info->texture);
|
|
}
|
|
|
|
if (resPath.size()) {
|
|
hecl::SystemUTF8Conv resPathView(resPath);
|
|
os.format(FMT_STRING("if '{}' in bpy.data.images:\n"
|
|
" image = bpy.data.images['{}']\n"
|
|
"else:\n"
|
|
" image = bpy.data.images.load('''//{}''')\n"
|
|
" image.name = '{}'\n"),
|
|
texName, texName, resPathView, texName);
|
|
} else {
|
|
os << "image = None\n";
|
|
}
|
|
|
|
os.format(FMT_STRING("material = bpy.data.materials.new('{}')\n"
|
|
"material.use_nodes = True\n"
|
|
"new_nodetree = material.node_tree\n"
|
|
"for n in new_nodetree.nodes:\n"
|
|
" new_nodetree.nodes.remove(n)\n"
|
|
"tex_node = new_nodetree.nodes.new('ShaderNodeTexImage')\n"
|
|
"tex_node.image = image\n"
|
|
"bm = bmesh.new()\n"
|
|
"verts = []\n"),
|
|
w.header.name);
|
|
|
|
for (uint32_t i = 0; i < info->quadCoordCount; ++i) {
|
|
int ti;
|
|
if (i == 2)
|
|
ti = 3;
|
|
else if (i == 3)
|
|
ti = 2;
|
|
else
|
|
ti = i;
|
|
zeus::simd_floats f(info->quadCoords[ti].simd);
|
|
os.format(FMT_STRING("verts.append(bm.verts.new(({},{},{})))\n"), f[0], f[1], f[2]);
|
|
}
|
|
os << "bm.faces.new(verts)\n"
|
|
"bm.loops.layers.uv.new('UV')\n"
|
|
"bm.verts.ensure_lookup_table()\n";
|
|
for (uint32_t i = 0; i < info->uvCoordCount; ++i) {
|
|
int ti;
|
|
if (i == 2)
|
|
ti = 3;
|
|
else if (i == 3)
|
|
ti = 2;
|
|
else
|
|
ti = i;
|
|
zeus::simd_floats f(info->uvCoords[ti].simd);
|
|
os.format(FMT_STRING("bm.verts[{}].link_loops[0][bm.loops.layers.uv[0]].uv = ({},{})\n"), i, f[0], f[1]);
|
|
}
|
|
os.format(FMT_STRING("binding = bpy.data.meshes.new('{}')\n"
|
|
"bm.to_mesh(binding)\n"
|
|
"bm.free()\n"
|
|
"binding.materials.append(material)\n"),
|
|
w.header.name);
|
|
}
|
|
}
|
|
|
|
zeus::simd_floats colorF(w.header.color.simd);
|
|
os.format(FMT_STRING("frme_obj = bpy.data.objects.new(name='{}', object_data=binding)\n"
|
|
"frme_obj.pass_index = {}\n"
|
|
"parentName = '{}'\n"
|
|
"frme_obj.retro_widget_type = 'RETRO_{}'\n"
|
|
"frme_obj.retro_widget_use_anim_controller = {}\n"
|
|
"frme_obj.retro_widget_default_visible = {}\n"
|
|
"frme_obj.retro_widget_default_active = {}\n"
|
|
"frme_obj.retro_widget_cull_faces = {}\n"
|
|
"frme_obj.retro_widget_color = ({},{},{},{})\n"
|
|
"frme_obj.retro_widget_model_draw_flags = "
|
|
"bpy.types.Object.retro_widget_model_draw_flags[1]['items'][{}][0]\n"
|
|
"frme_obj.retro_widget_is_worker = {}\n"
|
|
"frme_obj.retro_widget_worker_id = {}\n"
|
|
"if parentName not in bpy.data.objects:\n"
|
|
" frme_obj.retro_widget_parent = parentName\n"
|
|
"else:\n"
|
|
" frme_obj.parent = bpy.data.objects[parentName]\n"),
|
|
w.header.name, pIdx++, w.header.parent, w.type, w.header.useAnimController ? "True" : "False",
|
|
w.header.defaultVisible ? "True" : "False", w.header.defaultActive ? "True" : "False",
|
|
w.header.cullFaces ? "True" : "False", colorF[0], colorF[1], colorF[2], colorF[3],
|
|
w.header.modelDrawFlags, w.isWorker ? "True" : "False", w.workerId);
|
|
|
|
if (w.type == SBIG('MODL')) {
|
|
using MODLInfo = FRME::Widget::MODLInfo;
|
|
MODLInfo* info = static_cast<MODLInfo*>(w.widgetInfo.get());
|
|
hecl::ProjectPath modelPath = pakRouter.getWorking(info->model);
|
|
const PAKRouter<PAKBridge>::EntryType* cmdlE = pakRouter.lookupEntry(info->model, nullptr, true, true);
|
|
|
|
os.linkMesh(modelPath.getAbsolutePathUTF8(), pakRouter.getBestEntryName(*cmdlE));
|
|
|
|
os.format(FMT_STRING("frme_obj.retro_model_light_mask = {}\n"), info->lightMask);
|
|
os << "print(obj.name)\n"
|
|
"copy_obj = duplicateObject(obj)\n"
|
|
"copy_obj.parent = frme_obj\n"
|
|
"copy_obj.hide_set(False)\n";
|
|
} else if (w.type == SBIG('CAMR')) {
|
|
os << "bpy.context.scene.camera = frme_obj\n"
|
|
"if 'Camera' in bpy.data.objects:\n"
|
|
" cam = bpy.data.objects['Camera']\n"
|
|
" #bpy.context.scene.objects.unlink(cam)\n"
|
|
" bpy.data.objects.remove(cam)\n";
|
|
} else if (w.type == SBIG('PANE')) {
|
|
using PANEInfo = Widget::PANEInfo;
|
|
if (PANEInfo* info = static_cast<PANEInfo*>(w.widgetInfo.get())) {
|
|
zeus::simd_floats f(info->scaleCenter.simd);
|
|
os.format(FMT_STRING("frme_obj.retro_pane_dimensions = ({},{})\n"
|
|
"frme_obj.retro_pane_scale_center = ({},{},{})\n"),
|
|
info->xDim, info->zDim, f[0], f[1], f[2]);
|
|
}
|
|
} else if (w.type == SBIG('TXPN')) {
|
|
using TXPNInfo = Widget::TXPNInfo;
|
|
if (TXPNInfo* info = static_cast<TXPNInfo*>(w.widgetInfo.get())) {
|
|
hecl::ProjectPath fontPath = pakRouter.getWorking(info->font, true);
|
|
hecl::ProjectPath jpFontPath;
|
|
if (frme.version >= 1)
|
|
jpFontPath = pakRouter.getWorking(info->jpnFont, true);
|
|
|
|
zeus::simd_floats scaleF(info->scaleCenter.simd);
|
|
zeus::simd_floats fillF(info->fillColor.simd);
|
|
zeus::simd_floats outlineF(info->outlineColor.simd);
|
|
zeus::simd_floats extentF(info->blockExtent.simd);
|
|
os.format(FMT_STRING("frme_obj.retro_pane_dimensions = ({},{})\n"
|
|
"frme_obj.retro_pane_scale_center = ({},{},{})\n"
|
|
"frme_obj.retro_textpane_font_path = '{}'\n"
|
|
"frme_obj.retro_textpane_word_wrap = {}\n"
|
|
"frme_obj.retro_textpane_horizontal = {}\n"
|
|
"frme_obj.retro_textpane_fill_color = ({},{},{},{})\n"
|
|
"frme_obj.retro_textpane_outline_color = ({},{},{},{})\n"
|
|
"frme_obj.retro_textpane_block_extent = ({},{})\n"
|
|
"frme_obj.retro_textpane_jp_font_path = '{}'\n"
|
|
"frme_obj.retro_textpane_jp_font_scale = ({},{})\n"
|
|
"frme_obj.retro_textpane_hjustification = "
|
|
"bpy.types.Object.retro_textpane_hjustification[1]['items'][{}][0]\n"
|
|
"frme_obj.retro_textpane_vjustification = "
|
|
"bpy.types.Object.retro_textpane_vjustification[1]['items'][{}][0]\n"),
|
|
info->xDim, info->zDim, scaleF[0], scaleF[1], scaleF[2], fontPath.getRelativePathUTF8(),
|
|
info->wordWrap ? "True" : "False", info->horizontal ? "True" : "False", fillF[0], fillF[1], fillF[2],
|
|
fillF[3], outlineF[0], outlineF[1], outlineF[2], outlineF[3], extentF[0], extentF[1],
|
|
jpFontPath.getRelativePathUTF8(), info->jpnPointScale[0], info->jpnPointScale[1],
|
|
int(info->justification), int(info->verticalJustification));
|
|
}
|
|
} else if (w.type == SBIG('TBGP')) {
|
|
using TBGPInfo = Widget::TBGPInfo;
|
|
if (TBGPInfo* info = static_cast<TBGPInfo*>(w.widgetInfo.get())) {
|
|
os.format(FMT_STRING("frme_obj.retro_tablegroup_elem_count = {}\n"
|
|
"frme_obj.retro_tablegroup_elem_default = {}\n"
|
|
"frme_obj.retro_tablegroup_wraparound = {}\n"),
|
|
info->elementCount, info->defaultSelection, info->selectWraparound ? "True" : "False");
|
|
}
|
|
} else if (w.type == SBIG('GRUP')) {
|
|
using GRUPInfo = Widget::GRUPInfo;
|
|
if (GRUPInfo* info = static_cast<GRUPInfo*>(w.widgetInfo.get())) {
|
|
os.format(FMT_STRING("frme_obj.retro_group_default_worker = {}\n"), info->defaultWorker);
|
|
}
|
|
} else if (w.type == SBIG('SLGP')) {
|
|
using SLGPInfo = Widget::SLGPInfo;
|
|
if (SLGPInfo* info = static_cast<SLGPInfo*>(w.widgetInfo.get())) {
|
|
os.format(FMT_STRING("frme_obj.retro_slider_min = {}\n"
|
|
"frme_obj.retro_slider_max = {}\n"
|
|
"frme_obj.retro_slider_default = {}\n"
|
|
"frme_obj.retro_slider_increment = {}\n"),
|
|
info->min, info->max, info->cur, info->increment);
|
|
}
|
|
} else if (w.type == SBIG('ENRG')) {
|
|
using ENRGInfo = Widget::ENRGInfo;
|
|
if (ENRGInfo* info = static_cast<ENRGInfo*>(w.widgetInfo.get())) {
|
|
hecl::ProjectPath txtrPath = pakRouter.getWorking(info->texture);
|
|
if (txtrPath)
|
|
os.format(FMT_STRING("frme_obj.retro_energybar_texture_path = '{}'\n"), txtrPath.getRelativePathUTF8());
|
|
}
|
|
} else if (w.type == SBIG('METR')) {
|
|
using METRInfo = Widget::METRInfo;
|
|
if (METRInfo* info = static_cast<METRInfo*>(w.widgetInfo.get())) {
|
|
os.format(FMT_STRING("frme_obj.retro_meter_no_round_up = {}\n"
|
|
"frme_obj.retro_meter_max_capacity = {}\n"
|
|
"frme_obj.retro_meter_worker_count = {}\n"),
|
|
info->noRoundUp ? "True" : "False", info->maxCapacity, info->workerCount);
|
|
}
|
|
}
|
|
|
|
zeus::simd_floats xfMtxF[3];
|
|
for (int i = 0; i < 3; ++i)
|
|
w.basis[i].simd.copy_to(xfMtxF[i]);
|
|
zeus::simd_floats originF(w.origin.simd);
|
|
os.format(FMT_STRING("mtx = Matrix((({},{},{},{}),({},{},{},{}),({},{},{},{}),(0.0,0.0,0.0,1.0)))\n"
|
|
"mtxd = mtx.decompose()\n"
|
|
"frme_obj.rotation_mode = 'QUATERNION'\n"
|
|
"frme_obj.location = mtxd[0]\n"
|
|
"frme_obj.rotation_quaternion = mtxd[1] @ angle\n"
|
|
"frme_obj.scale = mtxd[2]\n"
|
|
"bpy.context.scene.collection.objects.link(frme_obj)\n"),
|
|
xfMtxF[0][0], xfMtxF[0][1], xfMtxF[0][2], originF[0], xfMtxF[1][0], xfMtxF[1][1], xfMtxF[1][2],
|
|
originF[1], xfMtxF[2][0], xfMtxF[2][1], xfMtxF[2][2], originF[2]);
|
|
}
|
|
|
|
os.centerView();
|
|
os.close();
|
|
conn.saveBlend();
|
|
return true;
|
|
}
|
|
|
|
} // namespace DataSpec::DNAMP1
|