metaforce/DataSpec/DNAMP1/FRME.cpp

622 lines
23 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