mirror of
https://github.com/MihailRis/voxelcore.git
synced 2026-11-20 09:29:44 +00:00
337 lines
9.7 KiB
C++
337 lines
9.7 KiB
C++
#include "rigging.hpp"
|
|
|
|
#include <glm/ext/matrix_transform.hpp>
|
|
#include <glm/gtx/matrix_decompose.hpp>
|
|
|
|
#include "assets/Assets.hpp"
|
|
#include "coders/json.hpp"
|
|
#include "data/dv_util.hpp"
|
|
#include "graphics/commons/Model.hpp"
|
|
#include "graphics/render/ModelBatch.hpp"
|
|
|
|
using namespace rigging;
|
|
|
|
void ModelReference::refresh(const Assets& assets) {
|
|
if (updateFlag) {
|
|
model = assets.getShared<model::Model>(name);
|
|
updateFlag = false;
|
|
}
|
|
}
|
|
|
|
Bone::Bone(
|
|
size_t index,
|
|
std::string name,
|
|
std::string model,
|
|
std::vector<std::unique_ptr<Bone>> bones,
|
|
const glm::vec3& offset
|
|
)
|
|
: index(index),
|
|
name(std::move(name)),
|
|
bones(std::move(bones)),
|
|
offset(offset),
|
|
model({model, {}, true}) {
|
|
}
|
|
|
|
void Bone::setModel(const std::string& name) {
|
|
if (model.name == name) {
|
|
return;
|
|
}
|
|
model = {name, {}, true};
|
|
}
|
|
|
|
Skeleton::Skeleton(std::shared_ptr<const SkeletonConfig> config)
|
|
: config(config),
|
|
pose(config ? config->getBones().size() : 0),
|
|
calculated(config ? config->getBones().size() : 0),
|
|
flags(config ? config->getBones().size() : 0),
|
|
textures(),
|
|
modelOverrides(config ? config->getBones().size() : 0),
|
|
visible(true),
|
|
boneTints(config ? config->getBones().size() : 0, glm::vec4(1.0f)) {
|
|
if (config == nullptr) {
|
|
return;
|
|
}
|
|
const auto& bones = config->getBones();
|
|
for (size_t i = 0; i < bones.size(); i++) {
|
|
flags[i].visible = true;
|
|
}
|
|
}
|
|
|
|
dv::value Skeleton::serialize(bool saveTextures, bool savePose) const {
|
|
auto root = dv::object();
|
|
if (saveTextures) {
|
|
auto& map = root.object("textures");
|
|
for (auto& [slot, texture] : textures) {
|
|
map[slot] = texture;
|
|
}
|
|
}
|
|
if (savePose) {
|
|
auto& list = root.list("pose");
|
|
for (auto& mat : pose.matrices) {
|
|
list.add(dv::to_value(mat));
|
|
}
|
|
}
|
|
return root;
|
|
}
|
|
|
|
void Skeleton::deserialize(const dv::value& root) {
|
|
if (auto found = root.at("textures")) {
|
|
auto& texturesmap = *found;
|
|
for (auto& [slot, _] : texturesmap.asObject()) {
|
|
texturesmap.at(slot).get(textures[slot]);
|
|
}
|
|
}
|
|
if (auto found = root.at("pose")) {
|
|
auto& posearr = *found;
|
|
auto& matrices = pose.matrices;
|
|
for (size_t i = 0; i < std::min(matrices.size(), posearr.size()); i++) {
|
|
dv::get_mat(posearr[i], pose.matrices[i]);
|
|
}
|
|
}
|
|
boundsDirty = true;
|
|
}
|
|
|
|
void Skeleton::setConfig(std::shared_ptr<const SkeletonConfig> rigConfig) {
|
|
config = std::move(rigConfig);
|
|
|
|
int bonesCount = config ? config->getBones().size() : 0;
|
|
|
|
pose.matrices.resize(bonesCount, glm::mat4(1.0f));
|
|
calculated.matrices.resize(bonesCount, glm::mat4(1.0f));
|
|
|
|
modelOverrides.resize(bonesCount);
|
|
flags.resize(bonesCount);
|
|
boneTints.resize(bonesCount, glm::vec4(1.0f));
|
|
|
|
for (size_t i = 0; i < bonesCount; i++) {
|
|
flags[i].visible = true;
|
|
}
|
|
boundsDirty = true;
|
|
}
|
|
|
|
static void get_all_nodes(std::vector<Bone*>& nodes, Bone* node) {
|
|
nodes[node->getIndex()] = node;
|
|
for (auto& subnode : node->getBones()) {
|
|
get_all_nodes(nodes, subnode.get());
|
|
}
|
|
}
|
|
|
|
SkeletonConfig::SkeletonConfig(
|
|
const std::string& name, std::unique_ptr<Bone> root, size_t nodesCount
|
|
)
|
|
: name(name), root(std::move(root)), nodes(nodesCount) {
|
|
assert(this->root.get() != nullptr);
|
|
get_all_nodes(nodes, this->root.get());
|
|
}
|
|
|
|
size_t SkeletonConfig::update(
|
|
size_t index, Skeleton& skeleton, Bone* node, const glm::mat4& matrix
|
|
) const {
|
|
auto boneMatrix = skeleton.pose.matrices[index];
|
|
auto boneOffset = node->getOffset();
|
|
glm::mat4 baseMatrix(1.0f);
|
|
if (glm::length2(boneOffset) > 0.0f) {
|
|
baseMatrix = glm::translate(glm::mat4(1.0f), boneOffset);
|
|
}
|
|
skeleton.calculated.matrices[index] = matrix * baseMatrix * boneMatrix;
|
|
size_t count = 1;
|
|
for (auto& subnode : node->getBones()) {
|
|
count += update(
|
|
index + count,
|
|
skeleton,
|
|
subnode.get(),
|
|
skeleton.calculated.matrices[index]
|
|
);
|
|
}
|
|
return count;
|
|
}
|
|
|
|
static glm::mat4 build_matrix(
|
|
const glm::mat3& rot, const glm::vec3& pos, const glm::vec3& scale
|
|
) {
|
|
glm::mat4 combined(1.0f);
|
|
combined = glm::translate(combined, pos);
|
|
combined = combined * glm::mat4(rot);
|
|
combined = glm::scale(combined, scale);
|
|
return combined;
|
|
}
|
|
|
|
void SkeletonConfig::update(
|
|
Skeleton& skeleton,
|
|
const glm::mat3& rotation,
|
|
const glm::vec3& position,
|
|
const glm::vec3& scale
|
|
) const {
|
|
glm::vec3 pos = position;
|
|
const auto& interpolation = skeleton.interpolation;
|
|
if (interpolation.isEnabled() && interpolation.isRefreshed()) {
|
|
pos = interpolation.getCurrent();
|
|
}
|
|
glm::mat3 rot = rotation;
|
|
const auto& rotationInterpolation = skeleton.rotationInterpolation;
|
|
if (rotationInterpolation.isEnabled() && rotationInterpolation.isRefreshed()) {
|
|
rot = glm::mat3_cast(rotationInterpolation.getCurrent());
|
|
}
|
|
update(0, skeleton, root.get(), build_matrix(rot, pos, scale));
|
|
}
|
|
|
|
static float max_component(const glm::vec3& v) {
|
|
return glm::max(glm::abs(v.x), glm::max(glm::abs(v.y), glm::abs(v.z)));
|
|
}
|
|
|
|
static float farthest_corner_distance(
|
|
const glm::mat4& matrix, const AABB& aabb, const glm::vec3& origin
|
|
) {
|
|
glm::vec3 center = glm::vec3(matrix * glm::vec4(aabb.center(), 1.0f));
|
|
glm::vec3 halfSize = aabb.size() * 0.5f;
|
|
glm::vec3 extent = glm::abs(glm::vec3(matrix[0])) * halfSize.x +
|
|
glm::abs(glm::vec3(matrix[1])) * halfSize.y +
|
|
glm::abs(glm::vec3(matrix[2])) * halfSize.z;
|
|
return glm::length(glm::abs(center - origin) + extent);
|
|
}
|
|
|
|
void SkeletonConfig::processModels(
|
|
const Assets& assets,
|
|
Skeleton& skeleton,
|
|
const glm::vec3& position,
|
|
const glm::vec3& scale,
|
|
ModelBatch* batch,
|
|
ModelLightingMode lightingMode,
|
|
bool translucent
|
|
) const {
|
|
float radius = 0.0f;
|
|
bool pending = false;
|
|
for (size_t i = 0; i < nodes.size(); i++) {
|
|
auto* node = nodes[i];
|
|
if (!skeleton.flags[i].visible) {
|
|
continue;
|
|
}
|
|
node->model.refresh(assets);
|
|
auto model = node->model.model.lock(); // TODO: cache model pointer during frame
|
|
auto& modelOverride = skeleton.modelOverrides.at(i);
|
|
if (modelOverride.updateFlag) {
|
|
modelOverride.refresh(assets);
|
|
}
|
|
if (auto foundOverride = modelOverride.model.lock()) {
|
|
model = std::move(foundOverride);
|
|
}
|
|
if (model == nullptr) {
|
|
if (!node->model.name.empty()) {
|
|
node->model.updateFlag = true;
|
|
pending = true;
|
|
}
|
|
continue;
|
|
}
|
|
const auto& matrix = skeleton.calculated.matrices[i];
|
|
radius = glm::max(
|
|
radius, farthest_corner_distance(matrix, model->getBounds(), position)
|
|
);
|
|
if (batch == nullptr) {
|
|
continue;
|
|
}
|
|
batch->draw(
|
|
matrix,
|
|
skeleton.tint * skeleton.boneTints[i],
|
|
lightingMode == ModelLightingMode::SOLID
|
|
? position - glm::vec3(matrix * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f))
|
|
: glm::vec3(),
|
|
model,
|
|
&skeleton.textures,
|
|
translucent
|
|
);
|
|
}
|
|
float maxScale = max_component(scale);
|
|
skeleton.boundsRadius = maxScale > 0.0f ? radius / maxScale : radius;
|
|
skeleton.boundsDirty = pending;
|
|
}
|
|
|
|
void SkeletonConfig::render(
|
|
const Assets& assets,
|
|
ModelBatch& batch,
|
|
Skeleton& skeleton,
|
|
ModelLightingMode lightingMode,
|
|
const glm::mat3& rotation,
|
|
const glm::vec3& position,
|
|
const glm::vec3& scale,
|
|
bool translucent
|
|
) const {
|
|
if (skeleton.config->root == nullptr) {
|
|
return;
|
|
}
|
|
update(skeleton, rotation, position, scale);
|
|
|
|
if (!skeleton.visible) {
|
|
return;
|
|
}
|
|
processModels(
|
|
assets, skeleton, position, scale, &batch, lightingMode, translucent
|
|
);
|
|
}
|
|
|
|
void SkeletonConfig::updateBounds(
|
|
const Assets& assets,
|
|
Skeleton& skeleton,
|
|
const glm::mat3& rotation,
|
|
const glm::vec3& position,
|
|
const glm::vec3& scale
|
|
) const {
|
|
if (skeleton.config->root == nullptr) {
|
|
return;
|
|
}
|
|
update(skeleton, rotation, position, scale);
|
|
processModels(
|
|
assets,
|
|
skeleton,
|
|
position,
|
|
scale,
|
|
nullptr,
|
|
ModelLightingMode::SOLID,
|
|
false
|
|
);
|
|
}
|
|
|
|
const Bone* SkeletonConfig::find(std::string_view str) const {
|
|
for (size_t i = 0; i < nodes.size(); i++) {
|
|
auto* node = nodes[i];
|
|
if (node->getName() == str) {
|
|
return node;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static std::tuple<size_t, std::unique_ptr<Bone>> read_node(
|
|
const dv::value& root, size_t index
|
|
) {
|
|
std::string name;
|
|
std::string model;
|
|
root.at("name").get(name);
|
|
root.at("model").get(model);
|
|
glm::vec3 offset(0.0f);
|
|
dv::get_vec(root, "offset", offset);
|
|
|
|
std::vector<std::unique_ptr<Bone>> bones;
|
|
size_t count = 1;
|
|
if (auto found = root.at("nodes")) {
|
|
const auto& nodesList = *found;
|
|
for (const auto& map : nodesList) {
|
|
auto [subcount, subNode] = read_node(map, index + count);
|
|
count += subcount;
|
|
bones.push_back(std::move(subNode));
|
|
}
|
|
}
|
|
return {
|
|
count,
|
|
std::make_unique<Bone>(index, name, model, std::move(bones), offset)};
|
|
}
|
|
|
|
std::unique_ptr<SkeletonConfig> SkeletonConfig::parse(
|
|
std::string_view src, std::string_view file, std::string_view name
|
|
) {
|
|
auto root = json::parse(file, src);
|
|
const auto& rootNodeMap = root["root"];
|
|
auto [count, rootNode] = read_node(rootNodeMap, 0);
|
|
return std::make_unique<SkeletonConfig>(
|
|
std::string(name), std::move(rootNode), count
|
|
);
|
|
}
|