SkeletalMesh.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "Assets/Material.h"
#include "Asset.h"
#include "Vertex.h"
#include "Constants.h"
 
#include "Graphics/Graphics.h"
#include "Graphics/GraphicsTypes.h"
#include "Graphics/GraphicsConstants.h"
 
#include "Maths.h"
 
#if EDITOR
#include <assimp/scene.h>
#endif
 
struct Bone
{
    std::string mName;
    int32_t mIndex = -1;
    int32_t mParentIndex = -1;
    glm::mat4 mOffsetMatrix = { };
    glm::mat4 mInvOffsetMatrix = { };
};
 
struct PositionKey
{
    float mTime = 0.0f;
    glm::vec3 mValue = {};
};
 
struct RotationKey
{
    float mTime = 0.0f;
    glm::quat mValue = {};
};
 
struct ScaleKey
{
    float mTime = 0.0f;
    glm::vec3 mValue = {};
};
 
struct AnimEventKey
{
    float mTime = 0.0f;
    glm::vec3 mValue = {};
};
 
struct AnimEventTrack
{
    std::string mName;
    std::vector<AnimEventKey> mEventKeys;
};
 
struct AnimEvent
{
    SkeletalMesh3D* mNode = nullptr;
    std::string mName;
    std::string mAnimation;
    float mTime = 0.0f;
    glm::vec3 mValue = {};
};
 
struct Channel
{
    int32_t mBoneIndex = -1;
    std::vector<PositionKey> mPositionKeys;
    std::vector<RotationKey> mRotationKeys;
    std::vector<ScaleKey> mScaleKeys;
};
 
struct Animation
{
    std::string mName;
    float mDuration = 0.0f;
    float mTicksPerSecond = 0.0f;
    std::vector<Channel> mChannels;
    std::vector<AnimEventTrack> mEventTracks;
};
 
// Contiguous range inside the SkeletalMesh's shared vertex/index buffers
// that should be drawn with its own material. One section per source aiMesh
// when the mesh was imported with "combineMeshes".
struct SkeletalMeshSection
{
    std::string mName;
    uint32_t mFirstIndex = 0;
    uint32_t mIndexCount = 0;
    uint32_t mBaseVertex = 0;
    uint32_t mVertexCount = 0;
    MaterialRef mMaterial;
};
 
// A named attachment point on the skeleton: a bone plus a constant local offset.
// Authored once per rig so props (swords, shields, muzzle flashes) get consistent
// placement without every instance hand-tuning its own transform.
//
// Keyed by bone NAME rather than index, like BoneMaskAsset, so re-importing a mesh
// with a different bone order doesn't silently relocate everything attached to it.
struct MeshSocket
{
    std::string mName;
    std::string mBoneName;
    glm::vec3 mPosition = { 0.0f, 0.0f, 0.0f };
    glm::vec3 mRotation = { 0.0f, 0.0f, 0.0f };     // euler degrees
    glm::vec3 mScale = { 1.0f, 1.0f, 1.0f };
};
 
class POLYPHASE_API SkeletalMesh : public Asset
{
public:
 
    DECLARE_ASSET(SkeletalMesh, Asset);
 
    SkeletalMesh();
    ~SkeletalMesh();
 
    SkeletalMeshResource* GetResource();
 
    // Asset Interface
    virtual void LoadStream(Stream& stream, Platform platform) override;
    virtual void SaveStream(Stream& stream, Platform platform) override;
    virtual void Create() override;
    virtual void Destroy() override;
    virtual bool Import(const std::string& path, ImportOptions* options) override;
    virtual void GatherProperties(std::vector<Property>& outProps) override;
    virtual glm::vec4 GetTypeColor() override;
    virtual const char* GetTypeName() override;
    virtual const char* GetTypeImportExt() override;
 
    class Material* GetMaterial();
    void SetMaterial(class Material* newMaterial);
 
    // Multi-section accessors. A legacy single-material mesh appears as one
    // implicit section named "Default" covering the entire index range.
    uint32_t GetNumSections() const;
    const SkeletalMeshSection& GetSection(uint32_t index) const;
    SkeletalMeshSection& GetSectionMutable(uint32_t index);
    class Material* GetSectionMaterial(uint32_t index) const;
    void SetSectionMaterial(uint32_t index, class Material* material);
    int32_t FindSectionIndex(const std::string& name) const;
    const std::vector<SkeletalMeshSection>& GetSections() const;
 
    uint32_t GetNumIndices();
    uint32_t GetNumFaces();
    uint32_t GetNumVertices();
 
    const IndexType* GetIndices() const;
 
    int32_t FindBoneIndex(const std::string& name) const;
    const std::vector<Bone>& GetBones() const;
    const Bone& GetBone(int32_t index) const;
    uint32_t GetNumBones() const;
 
    // Named attachment points. See MeshSocket.
    uint32_t GetNumSockets() const;
    const MeshSocket& GetSocket(uint32_t index) const;
    MeshSocket& GetSocketMutable(uint32_t index);
    const std::vector<MeshSocket>& GetSockets() const;
    int32_t FindSocketIndex(const std::string& name) const;
    // Returns the index of the added socket. The name is uniquified if it collides.
    uint32_t AddSocket(const MeshSocket& socket);
    void RemoveSocket(uint32_t index);
    // The socket's constant offset relative to its bone, as a matrix.
    glm::mat4 GetSocketLocalMatrix(uint32_t index) const;
 
    glm::mat4 GetInvRootTransform() const;
 
    const std::vector<Animation>& GetAnimations() const;
    const Animation* GetAnimation(const char* name);
 
    // Get length of animation in seconds
    float GetAnimationDuration(const char* name);
 
    const std::vector<VertexSkinned>& GetVertices() const;
 
    void FinalizeBoneTransforms(std::vector<glm::mat4>& inoutTransforms);
 
    void CopyBindPose(std::vector<glm::mat4>& outTransforms);
 
    // Decomposed local-bind TRS, cached in InitBindPose. Used by
    // SkeletalMesh3D's blend loop to seed bones from bind pose before
    // accumulating animation layers, so masked-out bones in lower slots
    // and unmasked bones in upper slots both blend against a known pose.
    const glm::vec3& GetBindPosePos(int32_t boneIndex) const;
    const glm::quat& GetBindPoseRot(int32_t boneIndex) const;
    const glm::vec3& GetBindPoseScale(int32_t boneIndex) const;
 
    // Mark every bone in [rootIndex, descendants...] in outBitset (size = numBones).
    // Exploits the parent-before-child DFS order produced by SetupBoneHierarchy.
    void GatherDescendants(int32_t rootIndex, std::vector<uint8_t>& outBitset, bool includeRoot = true) const;
 
    // Resolve an include/exclude subtree spec into a per-bone bitset. Unknown
    // bone names are skipped (caller logs). selfOnly = include only the named
    // bones without recursing.
    void GatherSubtreeBoneSet(
        const std::vector<std::string>& includes,
        const std::vector<std::string>& excludes,
        bool selfOnly,
        std::vector<uint8_t>& outBitset) const;
 
    Bounds GetBounds() const;
    AABB GetAABB() const;
    // Exact bind-pose box from the vertices, without the Bounds Scale
    // padding GetAABB() applies. Use for placement/fitting, not culling.
    AABB GetBindPoseAABB() const { return mAABB; }
 
    const glm::mat4 GetBindPoseMatrix(int32_t boneIndex) const;
 
    SkeletalMesh* GetAnimationLookupMesh();
    void SetAnimationLookupMesh(SkeletalMesh* lookupMesh);
 
    static bool HandlePropChange(Datum* datum, uint32_t index, const void* newValue);
 
private:
 
    void InitBindPose();
    void ComputeBounds();
 
    MaterialRef mMaterial;
    SkeletalMeshRef mAnimationLookupMesh;
    uint32_t mNumVertices;
    uint32_t mNumIndices;
    uint32_t mNumUvMaps;
 
    std::vector<Bone> mBones;
    std::vector<Animation> mAnimations;
    std::vector<VertexSkinned> mVertices;
    std::vector<SkeletalMeshSection> mSections;
    std::vector<MeshSocket> mSockets;
 
    glm::mat4 mInvRootTransform;
    std::vector<glm::mat4> mBindPoseMatrices;
    // Decomposed local-bind TRS, parallel to mBindPoseMatrices. Populated by
    // InitBindPose. Zero-sized while bones haven't been initialised.
    std::vector<glm::vec3> mBindPoseDecompPos;
    std::vector<glm::quat> mBindPoseDecompRot;
    std::vector<glm::vec3> mBindPoseDecompScale;
    std::vector<IndexType> mIndices;
 
    Bounds mBounds;
 
    // Bind-pose AABB derived from vertex positions in ComputeBounds().
    // Intentionally NOT serialized -- Create() recomputes bounds on every load.
    AABB mAABB;
 
    float mBoundsScale = 1.1f;
 
    // Graphics Resource
    SkeletalMeshResource mResource;
 
#if EDITOR
public:
    void Create(const aiScene& scene,
        const aiMesh& meshData,
        std::vector<Material>* materials = nullptr);
 
    void SetupBoneHierarchy(
        const aiNode& node,
        const aiMesh& meshData,
        std::vector<uint8_t>& boneIndices,
        std::vector<float>& boneWeights,
        int32_t parentBoneIndex);
 
    void SetupAnimations(const aiScene& scene);
    void SetupResource(const aiMesh& meshData,
        const std::vector<float>& boneWeights,
        const std::vector<uint8_t>& boneIndices);
 
    void CreateCombined(const aiScene& scene,
        const std::vector<const aiMesh*>& renderMeshes);
#endif // EDITOR
};