#include "rigging.hpp" #include #include #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(name); updateFlag = false; } } Bone::Bone( size_t index, std::string name, std::string model, std::vector> 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 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 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& 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 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> 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> 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(index, name, model, std::move(bones), offset)}; } std::unique_ptr 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( std::string(name), std::move(rootNode), count ); }