2022-04-11 21:59:37 -04:00
|
|
|
#include "mainwindow.h"
|
|
|
|
|
2022-04-12 16:19:06 -04:00
|
|
|
#include <QWindow>
|
|
|
|
#include <QVulkanInstance>
|
2022-04-12 12:19:46 -04:00
|
|
|
#include <QHBoxLayout>
|
2022-04-11 21:59:37 -04:00
|
|
|
#include <QTableWidget>
|
|
|
|
#include <fmt/core.h>
|
|
|
|
#include <QListWidget>
|
2022-04-11 23:11:33 -04:00
|
|
|
#include <QVulkanWindow>
|
2022-04-12 00:30:17 -04:00
|
|
|
#include <QLineEdit>
|
|
|
|
#include <QResizeEvent>
|
2022-04-12 12:39:33 -04:00
|
|
|
#include <QComboBox>
|
2022-04-12 16:19:06 -04:00
|
|
|
#include <QTimer>
|
2022-04-12 20:02:50 -04:00
|
|
|
#include <assimp/Exporter.hpp>
|
|
|
|
#include <assimp/scene.h>
|
|
|
|
#include <assimp/postprocess.h>
|
2022-04-12 20:18:22 -04:00
|
|
|
#include <QPushButton>
|
|
|
|
#include <QFileDialog>
|
2022-04-17 20:02:06 -04:00
|
|
|
#include <magic_enum.hpp>
|
2022-04-28 17:50:05 -04:00
|
|
|
#include <glm/gtc/quaternion.hpp>
|
2022-04-28 23:20:58 -04:00
|
|
|
#include <QMenuBar>
|
|
|
|
#include <QAction>
|
2022-04-28 17:50:05 -04:00
|
|
|
#include <glm/gtc/type_ptr.hpp>
|
2022-05-03 13:19:48 -04:00
|
|
|
#include <QTreeWidget>
|
2022-08-10 14:52:28 -04:00
|
|
|
#include <physis.hpp>
|
|
|
|
#include <glm/glm.hpp>
|
2022-04-11 21:59:37 -04:00
|
|
|
|
2022-04-28 17:50:05 -04:00
|
|
|
#include "vec3edit.h"
|
2022-04-11 21:59:37 -04:00
|
|
|
|
2022-04-12 16:19:06 -04:00
|
|
|
#ifndef USE_STANDALONE_WINDOW
|
2022-04-11 23:11:33 -04:00
|
|
|
class VulkanWindow : public QWindow
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
VulkanWindow(Renderer* renderer, QVulkanInstance* instance) : m_renderer(renderer), m_instance(instance) {
|
|
|
|
setSurfaceType(VulkanSurface);
|
|
|
|
setVulkanInstance(instance);
|
|
|
|
}
|
|
|
|
|
|
|
|
void exposeEvent(QExposeEvent *) {
|
|
|
|
if (isExposed()) {
|
|
|
|
if (!m_initialized) {
|
|
|
|
m_initialized = true;
|
2022-04-12 00:30:17 -04:00
|
|
|
|
|
|
|
auto surface = m_instance->surfaceForWindow(this);
|
2022-04-12 12:19:46 -04:00
|
|
|
if(!m_renderer->initSwapchain(surface, width(), height()))
|
|
|
|
m_initialized = false;
|
|
|
|
else
|
|
|
|
render();
|
2022-04-11 23:11:33 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool event(QEvent *e) {
|
|
|
|
if (e->type() == QEvent::UpdateRequest)
|
|
|
|
render();
|
|
|
|
|
2022-04-12 00:30:17 -04:00
|
|
|
if (e->type() == QEvent::Resize) {
|
|
|
|
QResizeEvent* resizeEvent = (QResizeEvent*)e;
|
|
|
|
auto surface = m_instance->surfaceForWindow(this);
|
|
|
|
m_renderer->resize(surface, resizeEvent->size().width(), resizeEvent->size().height());
|
|
|
|
}
|
|
|
|
|
2022-04-11 23:11:33 -04:00
|
|
|
return QWindow::event(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
void render() {
|
2022-04-12 01:57:37 -04:00
|
|
|
m_renderer->render(models);
|
2022-04-12 00:30:17 -04:00
|
|
|
m_instance->presentQueued(this);
|
2022-04-11 23:11:33 -04:00
|
|
|
requestUpdate();
|
|
|
|
}
|
|
|
|
|
2022-04-12 01:57:37 -04:00
|
|
|
std::vector<RenderModel> models;
|
|
|
|
|
2022-04-11 23:11:33 -04:00
|
|
|
private:
|
|
|
|
bool m_initialized = false;
|
|
|
|
Renderer* m_renderer;
|
|
|
|
QVulkanInstance* m_instance;
|
|
|
|
};
|
2022-04-12 16:19:06 -04:00
|
|
|
#else
|
|
|
|
#include "standalonewindow.h"
|
2022-04-17 16:55:54 -04:00
|
|
|
#include "equipment.h"
|
|
|
|
|
2022-04-12 16:19:06 -04:00
|
|
|
#endif
|
2022-04-11 23:11:33 -04:00
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
void MainWindow::calculate_bone_inverse_pose(physis_Skeleton& skeleton, physis_Bone& bone, physis_Bone* parent_bone) {
|
|
|
|
const glm::mat4 parentMatrix = parent_bone == nullptr ? glm::mat4(1.0f) : extraBone[parent_bone->index].inversePose;
|
2022-04-28 17:50:05 -04:00
|
|
|
|
|
|
|
glm::mat4 local(1.0f);
|
|
|
|
local = glm::translate(local, glm::vec3(bone.position[0], bone.position[1], bone.position[2]));
|
|
|
|
local *= glm::mat4_cast(glm::quat(bone.rotation[3], bone.rotation[0], bone.rotation[1], bone.rotation[2]));
|
|
|
|
local = glm::scale(local, glm::vec3(bone.scale[0], bone.scale[1], bone.scale[2]));
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
extraBone[bone.index].inversePose = parentMatrix * local;
|
2022-04-28 17:50:05 -04:00
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < skeleton.num_bones; i++) {
|
|
|
|
if(skeleton.bones[i].parent_bone != nullptr && strcmp(skeleton.bones[i].parent_bone->name, bone.name) == 0) {
|
|
|
|
calculate_bone_inverse_pose(skeleton, skeleton.bones[i], &bone);
|
|
|
|
}
|
2022-04-28 17:50:05 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
void addItem(physis_Skeleton& skeleton, physis_Bone& bone, QTreeWidget* widget, QTreeWidgetItem* parent_item = nullptr) {
|
2022-05-03 13:19:48 -04:00
|
|
|
auto item = new QTreeWidgetItem();
|
2022-08-10 14:52:28 -04:00
|
|
|
item->setText(0, bone.name);
|
2022-05-03 13:19:48 -04:00
|
|
|
|
|
|
|
if(parent_item == nullptr) {
|
|
|
|
widget->addTopLevelItem(item);
|
|
|
|
} else {
|
|
|
|
parent_item->addChild(item);
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < skeleton.num_bones; i++) {
|
|
|
|
if(skeleton.bones[i].parent_bone != nullptr && strcmp(skeleton.bones[i].parent_bone->name, bone.name) == 0)
|
|
|
|
addItem(skeleton, skeleton.bones[i], widget, item);
|
2022-05-03 13:19:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
MainWindow::MainWindow(GameData* in_data) : data(*in_data) {
|
2022-04-11 21:59:37 -04:00
|
|
|
setWindowTitle("mdlviewer");
|
2022-04-12 12:19:46 -04:00
|
|
|
setMinimumSize(QSize(640, 480));
|
2022-04-11 21:59:37 -04:00
|
|
|
|
2022-04-28 23:20:58 -04:00
|
|
|
auto fileMenu = menuBar()->addMenu("File");
|
|
|
|
|
|
|
|
auto openMDLFile = fileMenu->addAction("Open MDL...");
|
|
|
|
connect(openMDLFile, &QAction::triggered, [=] {
|
|
|
|
auto fileName = QFileDialog::getOpenFileName(nullptr,
|
|
|
|
"Open MDL File",
|
|
|
|
"~",
|
|
|
|
"FFXIV Model File (*.mdl)");
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
auto buffer = physis_read_file(fileName.toStdString().c_str());
|
|
|
|
|
|
|
|
loadedGear.model = physis_mdl_parse(buffer.size, buffer.data);
|
2022-04-28 23:20:58 -04:00
|
|
|
|
|
|
|
reloadGearAppearance();
|
|
|
|
});
|
|
|
|
|
2022-04-11 21:59:37 -04:00
|
|
|
auto dummyWidget = new QWidget();
|
|
|
|
setCentralWidget(dummyWidget);
|
|
|
|
|
2022-04-12 12:19:46 -04:00
|
|
|
auto layout = new QHBoxLayout();
|
2022-04-11 21:59:37 -04:00
|
|
|
dummyWidget->setLayout(layout);
|
2022-04-11 23:11:33 -04:00
|
|
|
|
2022-04-12 12:19:46 -04:00
|
|
|
// smallclothes body
|
|
|
|
{
|
|
|
|
GearInfo info = {};
|
|
|
|
info.name = "Smallclothes Body";
|
|
|
|
info.slot = Slot::Body;
|
|
|
|
|
|
|
|
gears.push_back(info);
|
|
|
|
}
|
|
|
|
|
|
|
|
// smallclothes legs
|
|
|
|
{
|
|
|
|
GearInfo info = {};
|
|
|
|
info.name = "Smallclothes Legs";
|
|
|
|
info.slot = Slot::Legs;
|
|
|
|
|
|
|
|
gears.push_back(info);
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
auto exh = physis_gamedata_read_excel_sheet_header(&data, "Item");
|
|
|
|
auto exd = physis_gamedata_read_excel_sheet(&data, "Item", exh, Language::English, 1);
|
2022-04-12 15:28:29 -04:00
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < exd.row_count; i++) {
|
|
|
|
const auto row = exd.row_data[i];
|
|
|
|
auto primaryModel = row.column_data[47].u_int64._0;
|
|
|
|
auto secondaryModel = row.column_data[48].u_int64._0;
|
2022-04-12 15:28:29 -04:00
|
|
|
|
|
|
|
int16_t parts[4];
|
|
|
|
memcpy(parts, &primaryModel, sizeof(int16_t) * 4);
|
|
|
|
|
|
|
|
GearInfo info = {};
|
2022-08-10 14:52:28 -04:00
|
|
|
info.name = row.column_data[9].string._0;
|
|
|
|
info.slot = physis_slot_from_id(row.column_data[17].u_int8._0);
|
2022-04-12 15:28:29 -04:00
|
|
|
info.modelInfo.primaryID = parts[0];
|
|
|
|
|
|
|
|
gears.push_back(info);
|
|
|
|
}
|
|
|
|
|
2022-04-12 12:19:46 -04:00
|
|
|
auto listWidget = new QListWidget();
|
|
|
|
for(auto gear : gears)
|
|
|
|
listWidget->addItem(gear.name.c_str());
|
|
|
|
|
|
|
|
listWidget->setMaximumWidth(200);
|
|
|
|
|
|
|
|
layout->addWidget(listWidget);
|
2022-04-11 23:11:33 -04:00
|
|
|
|
2022-04-12 00:30:17 -04:00
|
|
|
renderer = new Renderer();
|
2022-04-11 23:11:33 -04:00
|
|
|
|
2022-04-12 16:19:06 -04:00
|
|
|
auto viewportLayout = new QVBoxLayout();
|
|
|
|
layout->addLayout(viewportLayout);
|
|
|
|
|
|
|
|
#ifndef USE_STANDALONE_WINDOW
|
2022-04-12 12:39:33 -04:00
|
|
|
auto inst = new QVulkanInstance();
|
2022-04-12 00:30:17 -04:00
|
|
|
inst->setVkInstance(renderer->instance);
|
|
|
|
inst->setFlags(QVulkanInstance::Flag::NoDebugOutputRedirect);
|
|
|
|
inst->create();
|
2022-04-11 23:11:33 -04:00
|
|
|
|
2022-04-12 12:39:33 -04:00
|
|
|
vkWindow = new VulkanWindow(renderer, inst);
|
2022-04-12 00:30:17 -04:00
|
|
|
vkWindow->setVulkanInstance(inst);
|
2022-04-11 23:11:33 -04:00
|
|
|
|
|
|
|
auto widget = QWidget::createWindowContainer(vkWindow);
|
|
|
|
|
2022-04-12 12:39:33 -04:00
|
|
|
viewportLayout->addWidget(widget);
|
2022-04-12 16:19:06 -04:00
|
|
|
#else
|
|
|
|
standaloneWindow = new StandaloneWindow(renderer);
|
|
|
|
renderer->initSwapchain(standaloneWindow->getSurface(renderer->instance), 640, 480);
|
|
|
|
|
|
|
|
QTimer* timer = new QTimer();
|
|
|
|
connect(timer, &QTimer::timeout, this, [this] {
|
|
|
|
standaloneWindow->render();
|
|
|
|
});
|
|
|
|
timer->start(1000);
|
|
|
|
#endif
|
2022-04-12 12:19:46 -04:00
|
|
|
|
2022-04-12 20:18:22 -04:00
|
|
|
QHBoxLayout* controlLayout = new QHBoxLayout();
|
|
|
|
viewportLayout->addLayout(controlLayout);
|
|
|
|
|
2022-04-17 20:02:06 -04:00
|
|
|
raceCombo = new QComboBox();
|
2022-04-12 12:39:33 -04:00
|
|
|
|
|
|
|
connect(raceCombo, qOverload<int>(&QComboBox::currentIndexChanged), [this](int index) {
|
|
|
|
currentRace = (Race)index;
|
2022-04-17 20:02:06 -04:00
|
|
|
reloadGearModel();
|
2022-04-12 12:39:33 -04:00
|
|
|
});
|
|
|
|
|
2022-04-12 20:18:22 -04:00
|
|
|
controlLayout->addWidget(raceCombo);
|
|
|
|
|
2022-04-17 20:02:06 -04:00
|
|
|
lodCombo = new QComboBox();
|
2022-04-14 10:32:41 -04:00
|
|
|
|
|
|
|
connect(lodCombo, qOverload<int>(&QComboBox::currentIndexChanged), [this](int index) {
|
|
|
|
currentLod = index;
|
2022-04-17 20:02:06 -04:00
|
|
|
reloadGearAppearance();
|
2022-04-14 10:32:41 -04:00
|
|
|
});
|
|
|
|
|
|
|
|
controlLayout->addWidget(lodCombo);
|
|
|
|
|
2022-04-12 20:18:22 -04:00
|
|
|
QPushButton* exportButton = new QPushButton("Export");
|
|
|
|
|
|
|
|
connect(exportButton, &QPushButton::clicked, [this] {
|
|
|
|
QString fileName = QFileDialog::getSaveFileName(this, tr("Save Model"),
|
|
|
|
"model.fbx",
|
|
|
|
tr("FBX Files (*.fbx)"));
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
physis_MDL model;
|
2022-04-16 16:38:48 -04:00
|
|
|
#ifdef USE_STANDALONE_WINDOW
|
|
|
|
model = standaloneWindow->models[0].model;
|
|
|
|
#else
|
|
|
|
model = vkWindow->models[0].model;
|
|
|
|
#endif
|
2022-06-22 23:16:56 -04:00
|
|
|
exportModel(model, skeleton, fileName);
|
2022-04-12 20:18:22 -04:00
|
|
|
});
|
|
|
|
|
|
|
|
controlLayout->addWidget(exportButton);
|
2022-04-12 12:39:33 -04:00
|
|
|
|
|
|
|
connect(listWidget, &QListWidget::itemClicked, [this](QListWidgetItem* item) {
|
|
|
|
for(auto& gear : gears) {
|
2022-04-17 20:02:06 -04:00
|
|
|
if(gear.name == item->text().toStdString()) {
|
|
|
|
loadInitialGearInfo(gear);
|
|
|
|
return;
|
|
|
|
}
|
2022-04-12 12:19:46 -04:00
|
|
|
}
|
|
|
|
});
|
2022-04-28 17:50:05 -04:00
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
skeleton = physis_skeleton_from_skel(physis_read_file("c0101b0001.skel"));
|
|
|
|
extraBone.resize(skeleton.num_bones);
|
2022-04-28 17:50:05 -04:00
|
|
|
calculate_bone_inverse_pose(skeleton, *skeleton.root_bone, nullptr);
|
|
|
|
|
2022-05-03 13:19:48 -04:00
|
|
|
auto boneListWidget = new QTreeWidget();
|
2022-08-10 14:52:28 -04:00
|
|
|
for(auto& bone : extraBone) {
|
2022-04-28 17:50:05 -04:00
|
|
|
bone.inversePose = glm::inverse(bone.inversePose);
|
|
|
|
}
|
|
|
|
|
2022-05-03 13:19:48 -04:00
|
|
|
addItem(skeleton, *skeleton.root_bone, boneListWidget);
|
|
|
|
|
2022-04-28 17:50:05 -04:00
|
|
|
boneListWidget->setMaximumWidth(200);
|
|
|
|
|
2022-05-03 13:19:48 -04:00
|
|
|
connect(boneListWidget, &QTreeWidget::itemClicked, [this](QTreeWidgetItem* item, int column) {
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < skeleton.num_bones; i++) {
|
|
|
|
if(strcmp(skeleton.bones[i].name, item->text(column).toStdString().c_str()) == 0) {
|
|
|
|
currentScale = glm::make_vec3(skeleton.bones[i].scale);
|
|
|
|
currentEditedBone = &skeleton.bones[i];
|
2022-04-28 17:50:05 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
layout->addWidget(boneListWidget);
|
|
|
|
|
|
|
|
Vector3Edit* scaleEdit = new Vector3Edit(currentScale);
|
|
|
|
connect(scaleEdit, &Vector3Edit::onValueChanged, [this] {
|
2022-08-10 14:52:28 -04:00
|
|
|
memcpy(currentEditedBone->scale, glm::value_ptr(currentScale), sizeof(float) * 3);
|
2022-04-28 17:50:05 -04:00
|
|
|
reloadGearAppearance();
|
|
|
|
});
|
|
|
|
layout->addWidget(scaleEdit);
|
2022-04-12 12:39:33 -04:00
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
void MainWindow::exportModel(physis_MDL& model, physis_Skeleton& skeleton, QString fileName) {
|
2022-04-12 20:02:50 -04:00
|
|
|
Assimp::Exporter exporter;
|
|
|
|
|
|
|
|
aiScene scene;
|
|
|
|
scene.mRootNode = new aiNode();
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
scene.mRootNode->mNumChildren = model.lods[0].num_parts + 1; // plus one for the skeleton
|
2022-04-12 20:18:22 -04:00
|
|
|
scene.mRootNode->mChildren = new aiNode*[scene.mRootNode->mNumChildren];
|
2022-04-12 20:02:50 -04:00
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
scene.mNumMeshes = model.lods[0].num_parts;
|
2022-04-12 20:02:50 -04:00
|
|
|
scene.mMeshes = new aiMesh*[scene.mNumMeshes];
|
|
|
|
|
2022-06-22 23:16:56 -04:00
|
|
|
auto skeleton_node = new aiNode();
|
|
|
|
skeleton_node->mName = "Skeleton";
|
|
|
|
skeleton_node->mNumChildren = 1;
|
|
|
|
skeleton_node->mChildren = new aiNode*[skeleton_node->mNumChildren];
|
|
|
|
|
|
|
|
scene.mRootNode->mChildren[scene.mRootNode->mNumChildren - 1] = skeleton_node;
|
|
|
|
|
|
|
|
std::vector<aiNode*> skeletonNodes;
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < model.num_affected_bones; i++) {
|
2022-06-22 23:16:56 -04:00
|
|
|
auto& node = skeletonNodes.emplace_back();
|
|
|
|
node = new aiNode();
|
2022-08-10 14:52:28 -04:00
|
|
|
node->mName = model.affected_bone_names[i];
|
2022-06-22 23:16:56 -04:00
|
|
|
|
|
|
|
int real_bone_id = 0;
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int k = 0; k < skeleton.num_bones; k++) {
|
|
|
|
if(strcmp(skeleton.bones[k].name, model.affected_bone_names[i]) == 0) {
|
2022-06-22 23:16:56 -04:00
|
|
|
real_bone_id = k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
node->mChildren = new aiNode*[model.num_affected_bones];
|
2022-06-22 23:16:56 -04:00
|
|
|
|
|
|
|
auto& real_bone = skeleton.bones[real_bone_id];
|
2022-08-10 14:52:28 -04:00
|
|
|
memcpy(&node->mTransformation, glm::value_ptr(extraBone[real_bone.index].finalTransform), sizeof(aiMatrix4x4));
|
2022-06-22 23:16:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// setup parenting
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < model.num_affected_bones; i++) {
|
2022-06-22 23:16:56 -04:00
|
|
|
int real_bone_id = 0;
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int k = 0; k < skeleton.num_bones; k++) {
|
|
|
|
if(strcmp(skeleton.bones[k].name, model.affected_bone_names[i]) == 0) {
|
2022-06-22 23:16:56 -04:00
|
|
|
real_bone_id = k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
auto& real_bone = skeleton.bones[real_bone_id];
|
2022-08-10 14:52:28 -04:00
|
|
|
if(real_bone.parent_bone != nullptr) {
|
|
|
|
for(int k = 0; k < model.num_affected_bones; k++) {
|
|
|
|
if(strcmp(model.affected_bone_names[k], real_bone.parent_bone->name) == 0) {
|
2022-06-22 23:16:56 -04:00
|
|
|
skeletonNodes[i]->mParent = skeletonNodes[k];
|
|
|
|
skeletonNodes[k]->mChildren[skeletonNodes[k]->mNumChildren++] = skeletonNodes[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
skeleton_node->mChildren[0] = new aiNode();
|
|
|
|
skeleton_node->mChildren[0]->mName = "root";
|
2022-08-10 14:52:28 -04:00
|
|
|
skeleton_node->mChildren[0]->mChildren = new aiNode*[model.num_affected_bones];
|
2022-06-22 23:16:56 -04:00
|
|
|
|
|
|
|
for(int i = 0; i < skeletonNodes.size(); i++) {
|
|
|
|
if(skeletonNodes[i]->mParent == nullptr) {
|
|
|
|
skeleton_node->mChildren[0]->mChildren[skeleton_node->mChildren[0]->mNumChildren++] = skeletonNodes[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < model.lods[0].num_parts; i++) {
|
2022-04-12 20:18:22 -04:00
|
|
|
scene.mMeshes[i] = new aiMesh();
|
|
|
|
scene.mMeshes[i]->mMaterialIndex = 0;
|
|
|
|
|
|
|
|
auto& node = scene.mRootNode->mChildren[i];
|
|
|
|
node = new aiNode();
|
|
|
|
node->mNumMeshes = 1;
|
|
|
|
node->mMeshes = new unsigned int [scene.mRootNode->mNumMeshes];
|
|
|
|
node->mMeshes[0] = i;
|
|
|
|
|
|
|
|
auto mesh = scene.mMeshes[i];
|
2022-08-10 14:52:28 -04:00
|
|
|
mesh->mNumVertices = model.lods[0].parts[i].num_vertices;
|
2022-04-12 20:18:22 -04:00
|
|
|
mesh->mVertices = new aiVector3D [mesh->mNumVertices];
|
2022-06-23 16:11:01 -04:00
|
|
|
mesh->mNormals = new aiVector3D [mesh->mNumVertices];
|
|
|
|
mesh->mTextureCoords[0] = new aiVector3D [mesh->mNumVertices];
|
|
|
|
mesh->mNumUVComponents[0] = 2;
|
2022-04-12 20:18:22 -04:00
|
|
|
for(int j = 0; j < mesh->mNumVertices; j++) {
|
|
|
|
auto vertex = model.lods[0].parts[i].vertices[j];
|
|
|
|
mesh->mVertices[j] = aiVector3D(vertex.position[0], vertex.position[1], vertex.position[2]);
|
2022-06-23 16:11:01 -04:00
|
|
|
mesh->mNormals[j] = aiVector3D (vertex.normal[0], vertex.normal[1], vertex.normal[2]);
|
|
|
|
mesh->mTextureCoords[0][j] = aiVector3D(vertex.uv[0], vertex.uv[1], 0.0f);
|
2022-04-12 20:18:22 -04:00
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
mesh->mNumBones = model.num_affected_bones;
|
2022-06-22 23:16:56 -04:00
|
|
|
mesh->mBones = new aiBone*[mesh->mNumBones];
|
|
|
|
for(int j = 0; j < mesh->mNumBones; j++) {
|
|
|
|
int real_bone_id = j;
|
|
|
|
/*for(int k = 0; k < skeleton.bones.size(); k++) {
|
|
|
|
if(skeleton.bones[k].name == model.affectedBoneNames[j]) {
|
|
|
|
real_bone_id = k;
|
|
|
|
}
|
|
|
|
}*/
|
|
|
|
|
|
|
|
mesh->mBones[j] = new aiBone();
|
2022-08-10 14:52:28 -04:00
|
|
|
mesh->mBones[j]->mName = model.affected_bone_names[j];
|
2022-06-23 16:11:01 -04:00
|
|
|
mesh->mBones[j]->mNumWeights = mesh->mNumVertices * 4;
|
2022-06-22 23:16:56 -04:00
|
|
|
mesh->mBones[j]->mWeights = new aiVertexWeight[mesh->mBones[j]->mNumWeights];
|
|
|
|
mesh->mBones[j]->mNode = skeleton_node->mChildren[j];
|
|
|
|
|
|
|
|
for(int k = 0; k < mesh->mNumVertices; k++) {
|
2022-06-23 16:11:01 -04:00
|
|
|
for(int z = 0; z < 4; z++) {
|
2022-08-10 14:52:28 -04:00
|
|
|
if (model.lods[0].parts[i].vertices[k].bone_id[z] == real_bone_id) {
|
2022-06-23 16:11:01 -04:00
|
|
|
auto &weight = mesh->mBones[j]->mWeights[k * 4 + z];
|
|
|
|
weight.mVertexId = k;
|
2022-08-10 14:52:28 -04:00
|
|
|
weight.mWeight = model.lods[0].parts[i].vertices[k].bone_weight[z];
|
2022-06-23 16:11:01 -04:00
|
|
|
}
|
2022-06-22 23:16:56 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
mesh->mNumFaces = model.lods[0].parts[i].num_indices / 3;
|
2022-04-12 20:18:22 -04:00
|
|
|
mesh->mFaces = new aiFace[mesh->mNumFaces];
|
2022-04-12 20:02:50 -04:00
|
|
|
|
2022-04-12 20:18:22 -04:00
|
|
|
int lastFace = 0;
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int j = 0; j < model.lods[0].parts[i].num_indices; j += 3) {
|
2022-04-12 20:18:22 -04:00
|
|
|
aiFace& face = mesh->mFaces[lastFace++];
|
2022-04-12 20:02:50 -04:00
|
|
|
|
2022-04-12 20:18:22 -04:00
|
|
|
face.mNumIndices = 3;
|
|
|
|
face.mIndices = new unsigned int[face.mNumIndices];
|
2022-04-12 20:02:50 -04:00
|
|
|
|
2022-04-12 20:18:22 -04:00
|
|
|
face.mIndices[0] = model.lods[0].parts[i].indices[j];
|
|
|
|
face.mIndices[1] = model.lods[0].parts[i].indices[j + 1];
|
|
|
|
face.mIndices[2] = model.lods[0].parts[i].indices[j + 2];
|
|
|
|
}
|
2022-04-12 20:02:50 -04:00
|
|
|
}
|
|
|
|
|
2022-04-12 20:18:22 -04:00
|
|
|
scene.mNumMaterials = 1;
|
|
|
|
scene.mMaterials = new aiMaterial*[1];
|
|
|
|
scene.mMaterials[0] = new aiMaterial();
|
|
|
|
|
|
|
|
exporter.Export(&scene, "fbx", fileName.toStdString());
|
2022-04-12 20:02:50 -04:00
|
|
|
}
|
2022-04-17 20:02:06 -04:00
|
|
|
|
|
|
|
void MainWindow::loadInitialGearInfo(GearInfo& info) {
|
|
|
|
loadedGear.gearInfo = &info;
|
|
|
|
|
|
|
|
raceCombo->clear();
|
|
|
|
for(auto [race, race_name] : magic_enum::enum_entries<Race>()) {
|
2022-08-10 14:52:28 -04:00
|
|
|
auto equip_path = physis_build_equipment_path(loadedGear.gearInfo->modelInfo.primaryID, race, currentSubrace, currentGender, loadedGear.gearInfo->slot);
|
|
|
|
|
|
|
|
if(physis_gamedata_exists(&data, equip_path))
|
|
|
|
raceCombo->addItem(race_name.data());
|
2022-04-17 20:02:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
currentLod = 0;
|
2022-08-10 14:52:28 -04:00
|
|
|
currentRace = Race::Hyur;
|
2022-04-17 20:02:06 -04:00
|
|
|
|
|
|
|
reloadGearModel();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MainWindow::reloadGearModel() {
|
2022-08-10 14:52:28 -04:00
|
|
|
auto mdl_data = physis_gamedata_extract_file(&data, physis_build_equipment_path(loadedGear.gearInfo->modelInfo.primaryID, currentRace, currentSubrace, currentGender, loadedGear.gearInfo->slot));
|
2022-04-17 20:02:06 -04:00
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
loadedGear.model = physis_mdl_parse(mdl_data.size, mdl_data.data);
|
2022-04-17 20:02:06 -04:00
|
|
|
|
2022-08-11 17:53:56 -04:00
|
|
|
std::string mtrl_path = loadedGear.gearInfo->getMtrlPath(101);
|
|
|
|
qDebug() << "MTRL path: " << mtrl_path.c_str();
|
|
|
|
|
|
|
|
if(physis_gamedata_exists(&data, mtrl_path.c_str())) {
|
|
|
|
qDebug() << "loading mtrl...";
|
|
|
|
loadedGear.material = physis_material_parse(physis_gamedata_extract_file(&data, mtrl_path.c_str()));
|
|
|
|
}
|
|
|
|
|
2022-04-17 20:02:06 -04:00
|
|
|
lodCombo->clear();
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < loadedGear.model.num_lod; i++)
|
2022-04-17 20:02:06 -04:00
|
|
|
lodCombo->addItem(QString::number(i));
|
|
|
|
|
|
|
|
reloadGearAppearance();
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
void MainWindow::calculate_bone(physis_Skeleton& skeleton, physis_Bone& bone, const physis_Bone* parent_bone) {
|
|
|
|
const glm::mat4 parent_matrix = parent_bone == nullptr ? glm::mat4(1.0f) : extraBone[parent_bone->index].localTransform;
|
2022-04-28 17:50:05 -04:00
|
|
|
|
|
|
|
glm::mat4 local = glm::mat4(1.0f);
|
|
|
|
local = glm::translate(local, glm::vec3(bone.position[0], bone.position[1], bone.position[2]));
|
|
|
|
local *= glm::mat4_cast(glm::quat(bone.rotation[3], bone.rotation[0], bone.rotation[1], bone.rotation[2]));
|
|
|
|
local = glm::scale(local, glm::vec3(bone.scale[0], bone.scale[1], bone.scale[2]));
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
extraBone[bone.index].localTransform = parent_matrix * local;
|
|
|
|
extraBone[bone.index].finalTransform = extraBone[bone.index].localTransform * extraBone[bone.index].inversePose;
|
2022-04-28 17:50:05 -04:00
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < skeleton.num_bones; i++) {
|
|
|
|
if(skeleton.bones[i].parent_bone != nullptr && strcmp(skeleton.bones[i].parent_bone->name, bone.name) == 0) {
|
|
|
|
calculate_bone(skeleton, skeleton.bones[i], &bone);
|
|
|
|
}
|
2022-04-28 17:50:05 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-17 20:02:06 -04:00
|
|
|
void MainWindow::reloadGearAppearance() {
|
|
|
|
loadedGear.renderModel = renderer->addModel(loadedGear.model, currentLod);
|
|
|
|
|
2022-08-11 17:53:56 -04:00
|
|
|
if(loadedGear.material.num_textures > 0) {
|
|
|
|
auto texture = physis_texture_parse(physis_gamedata_extract_file(&data, loadedGear.material.textures[0]));
|
|
|
|
|
|
|
|
loadedGear.renderTexture = renderer->addTexture(texture.width, texture.height, texture.rgba, texture.rgba_size);
|
|
|
|
|
|
|
|
loadedGear.renderModel.texture = &loadedGear.renderTexture;
|
|
|
|
}
|
|
|
|
|
2022-04-28 17:50:05 -04:00
|
|
|
calculate_bone(skeleton, *skeleton.root_bone, nullptr);
|
|
|
|
|
|
|
|
// we want to map the actual affected bones to bone ids
|
|
|
|
std::map<int, int> boneMapping;
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < loadedGear.model.num_affected_bones; i++) {
|
|
|
|
for(int k = 0; k < skeleton.num_bones; k++) {
|
|
|
|
if(strcmp(skeleton.bones[k].name, loadedGear.model.affected_bone_names[i]) == 0)
|
2022-04-28 17:50:05 -04:00
|
|
|
boneMapping[i] = k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-10 14:52:28 -04:00
|
|
|
for(int i = 0; i < loadedGear.model.num_affected_bones; i++) {
|
|
|
|
loadedGear.renderModel.boneData[i] = extraBone[boneMapping[i]].finalTransform;
|
2022-04-28 17:50:05 -04:00
|
|
|
}
|
|
|
|
|
2022-04-17 20:02:06 -04:00
|
|
|
#ifndef USE_STANDALONE_WINDOW
|
|
|
|
vkWindow->models = {loadedGear.renderModel};
|
|
|
|
#else
|
|
|
|
standaloneWindow->models = {loadedGear.renderModel};
|
|
|
|
#endif
|
|
|
|
}
|