GltfScenePopulator.hpp

#pragma once
#ifndef KJY_ANIM_ENGINE_GLTF_SCENE_POPULATOR_HPP_
#define KJY_ANIM_ENGINE_GLTF_SCENE_POPULATOR_HPP_

#include "GltfCommon.h"
#include "world/Entities/TypicalEntities.inl"
#include <world/Scene.hpp>

/* TinyGltf objects don't contain that much so duplicating them shouldn't
 * involve to much overhead */
template<typename T>
struct AugmentedGltfObject : public T{
    AugmentedGltfObject(int index, const T& t) : original_index(index), T(t) {}
    int original_index = -1;
};

typedef AugmentedGltfObject<tinygltf::Node> AugNode;


struct GltfPoseKeyframeSequence{
    std::string owner;
    int target_node;
    std::string path;
    PoseKeyframeSequence sequence;
};

struct GltfAnimation{
    std::string name;
    std::vector<GltfPoseKeyframeSequence> channels;
    bool start_enabled = true;
    bool should_loop = false;
};

class ExtrasExtension; 

/* TODO list:
 *    1. Support multiple scenes and non-default scenes.
 *    6. Shape keys
 */
class GltfScenePopulator{
 public:
    GltfScenePopulator(Scene* scene, const tinygltf::Model& model, const std::string& source_name = std::string());

    void populate();

    void addExtension(ExtrasExtension* aExtension) {mExtensions.push_back(aExtension);}

    static bool node_has_pose(const tinygltf::Node& node);
    static Pose get_node_pose(const tinygltf::Node& node);

    const std::map<int, Entity*>& getGltfnodesToEntites() const {return(gltfnodes_to_entites);}
    const std::map<int, MeshEntity*>& getGltfmeshToMeshes() const {return(gltfmesh_to_meshes);}
    const std::map<int, Skeleton*>& getGltfskinsToSkeletons() const {return(gltfskins_to_skeletons);}
    const std::map<int, Bone*>& getGltfnodeToBones() const {return(gltfnode_to_bones);}
    const std::map<int, GltfMetallicRoughness*>& getGltfmaterialsToMaterials() const {return(gltfmaterials_to_materials);}
    const std::map<int, SimpleTexture2D>& getGltftexturesToTextures() const {return(gltftextures_to_textures);}
    const std::unordered_map<std::string, GltfAnimation>& getGltfanimToAnimations() const {return(gltfanim_to_animations);}
    const std::unordered_map<std::string, GltfAnimation>& getSkeletonIsolatedAnimations() const {return(skeleton_isolated_animations);}
    
    /* Get the root entity of all content loaded from glTF file */
    EmptyEntity* sceneRoot();

 protected:
    friend class ExtrasExtension; 

    Entity* traverse_node(int node_index, Entity* parent = nullptr);
    BaseCameraEntity* process_camera_entity(const AugNode& node);
    SkinnedMeshEntity* process_skinned_mesh_entity(const AugNode& node);
    SolidMeshEntity* process_mesh_entity(const AugNode& node);
    Skeleton* construct_skeleton_from_skin(int skin_index);
    void process_animation(const tinygltf::Animation& animation);
    void populate_scene_animators();
    void process_pose_animation_channel(const tinygltf::AnimationChannel& channel, const tinygltf::AnimationSampler& sampler, GltfPoseKeyframeSequence& output_sequence);
    GltfPoseKeyframeSequence process_animation_channel(const tinygltf::AnimationChannel& channel, const tinygltf::AnimationSampler& sampler);
    GltfMetallicRoughness* process_metallic_roughness_material(int material_index);
    SimpleTexture2D process_texture(int texture_index);
    void isolate_bone_animations(const GltfAnimation& animation, const std::vector<Bone*>& touched_bones);
    Skeleton* find_bone_skeleton(Bone* bone);

    void printInfo(const std::string& info);
    void printWarning(const std::string& info);

    std::vector<ExtrasExtension*> mExtensions;

    Scene* _scene = nullptr;
    EmptyEntity* scene_root = nullptr;
    const tinygltf::Model& _asset;
    const std::string _source_identifier;

    std::map<int, Entity*> gltfnodes_to_entites;
    std::map<int, MeshEntity*> gltfmesh_to_meshes;
    std::map<int, Skeleton*> gltfskins_to_skeletons;
    std::map<int, Bone*> gltfnode_to_bones;
    std::map<int, GltfMetallicRoughness*> gltfmaterials_to_materials;
    std::map<int, SimpleTexture2D> gltftextures_to_textures;
    std::unordered_map<std::string, GltfAnimation> gltfanim_to_animations;
    std::unordered_map<std::string, GltfAnimation> skeleton_isolated_animations;

    std::map<int, BaseCameraEntity*> gltfcam_to_camera_entity; // TODO
    // std::map<int, Light*> gltflight_to_lights; // TODO
    // std::map<int, GltfMetallicRoughness> converted_materials; // TODO
    // std::map<int, SimpleTexture2D> gltftex_to_textures; // TODO
};

enum class GltfLoadStep {
    TRAVERSE_NODE = 0,
    PROCESS_MESH_ENT,
    PROCESS_SKIN_MESH_ENT,
    PROCESS_CAMERA_ENT,
    PROCESS_ANIM,
    PROCESS_PBRMAT,
    PROCESS_TEX,
    _GLTF_LOAD_STEP_TOTAL
};

enum class ExtensionResultHint{
    CONTINUE = 0,
    FINISH_NOW,
    DISCARD
};

class ExtrasExtension 
{
 public:
    virtual ExtensionResultHint preProcessSceneCallback(GltfScenePopulator& aPopulator, const tinygltf::Scene& aSceneIn, Scene* aSceneOut) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postProcessSceneCallback(GltfScenePopulator& aPopulator, const tinygltf::Scene& aSceneIn, Scene* aSceneOut) {return ExtensionResultHint::CONTINUE;}

    virtual ExtensionResultHint preTraverseNodeCallback(GltfScenePopulator& aPopulator, const AugNode& aNode, Entity* aParent, Entity*& aResult) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postTraverseNodeCallback(GltfScenePopulator& aPopulator, const AugNode& aNode, Entity* aParent, Entity*& aResult) {return ExtensionResultHint::CONTINUE;}

    virtual ExtensionResultHint preProcessMeshEntityCallback(GltfScenePopulator& aPopulator, const AugNode& aNode, SolidMeshEntity*& aMesh) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postProcessMeshEntityCallback(GltfScenePopulator& aPopulator, const AugNode& aNode, SolidMeshEntity*& aMesh) {return ExtensionResultHint::CONTINUE;}

    virtual ExtensionResultHint preProcessSkinMeshEntityCallback(GltfScenePopulator& aPopulator, const AugNode& aNode, SkinnedMeshEntity*& aSkin) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postProcessSkinMeshEntityCallback(GltfScenePopulator& aPopulator, const AugNode& aNode, SkinnedMeshEntity*& aSkin) {return ExtensionResultHint::CONTINUE;}

    virtual ExtensionResultHint preProcessCameraEntityCallback(GltfScenePopulator& aPopulator, const AugNode& aNode, LookAtCamera*& aCamera) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postProcessCameraEntityCallback(GltfScenePopulator& aPopulator, const AugNode& aNode, LookAtCamera*& aCamera) {return ExtensionResultHint::CONTINUE;}

    virtual ExtensionResultHint preProcessAnimationCallback(GltfScenePopulator& aPopulator, const tinygltf::Animation& aAnimIn, std::vector<Bone*>& aTouchedBones, GltfAnimation& aAnimResult) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postProcessAnimationCallback(GltfScenePopulator& aPopulator, const tinygltf::Animation& aAnimIn, std::vector<Bone*>& aTouchedBones, GltfAnimation& aAnimResult) {return ExtensionResultHint::CONTINUE;}

    virtual ExtensionResultHint preProcessPbrMaterialCallback(GltfScenePopulator& aPopulator, const tinygltf::Material& aMaterialIn, GltfMetallicRoughness*& aMaterialOut) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postProcessPbrMaterialCallback(GltfScenePopulator& aPopulator, const tinygltf::Material& aMaterialIn, GltfMetallicRoughness*& aMaterialOut) {return ExtensionResultHint::CONTINUE;}

    virtual ExtensionResultHint preProcessTextureCallback(GltfScenePopulator& aPopulator, const tinygltf::Texture& aTexture, const tinygltf::Image& aImage, SimpleTexture2D& aTextureOut) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postProcessTextureCallback(GltfScenePopulator& aPopulator, const tinygltf::Texture& aTexture, const tinygltf::Image& aImage, SimpleTexture2D& aTextureOut) {return ExtensionResultHint::CONTINUE;}

    virtual ExtensionResultHint preProcessPopulateAnimatorsCallback(GltfScenePopulator& aPopulator, std::unordered_map<std::string, GltfAnimation>& aAnimationsIn, Scene* aSceneOut) {return ExtensionResultHint::CONTINUE;}
    virtual ExtensionResultHint postProcessPopulateAnimatorsCallback(GltfScenePopulator& aPopulator, std::unordered_map<std::string, GltfAnimation>& aAnimationsIn, Scene* aSceneOut) {return ExtensionResultHint::CONTINUE;}

 protected:
    static const tinygltf::Model& getAsset(const GltfScenePopulator& aPopulator) {
        return(aPopulator._asset);
    }
};


#endif