/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------

Copyright (c) 2006-2022, assimp team


All rights reserved.

Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the
following conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the assimp team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the assimp team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

----------------------------------------------------------------------
*/

#ifndef AI_OGRESTRUCTS_H_INC
#define AI_OGRESTRUCTS_H_INC

#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER

#include <assimp/MemoryIOWrapper.h>
#include <memory>
#include <assimp/mesh.h>
#include <map>
#include <vector>
#include <set>

struct aiNodeAnim;
struct aiAnimation;
struct aiNode;
struct aiMaterial;
struct aiScene;

/** @note Parts of this implementation, for example enums, deserialization constants and logic
    has been copied directly with minor modifications from the MIT licensed Ogre3D code base.
    See more from https://bitbucket.org/sinbad/ogre. */

namespace Assimp
{
namespace Ogre
{

// Forward decl
class Mesh;
class MeshXml;
class SubMesh;
class SubMeshXml;
class Skeleton;

#define OGRE_SAFE_DELETE(p) delete p; p=0;

// Typedefs
typedef Assimp::MemoryIOStream MemoryStream;
typedef std::shared_ptr<MemoryStream> MemoryStreamPtr;
typedef std::map<uint16_t, MemoryStreamPtr> VertexBufferBindings;

// Ogre Vertex Element
class VertexElement
{
public:
    /// Vertex element semantics, used to identify the meaning of vertex buffer contents
    enum Semantic {
        /// Position, 3 reals per vertex
        VES_POSITION = 1,
        /// Blending weights
        VES_BLEND_WEIGHTS = 2,
        /// Blending indices
        VES_BLEND_INDICES = 3,
        /// Normal, 3 reals per vertex
        VES_NORMAL = 4,
        /// Diffuse colours
        VES_DIFFUSE = 5,
        /// Specular colours
        VES_SPECULAR = 6,
        /// Texture coordinates
        VES_TEXTURE_COORDINATES = 7,
        /// Binormal (Y axis if normal is Z)
        VES_BINORMAL = 8,
        /// Tangent (X axis if normal is Z)
        VES_TANGENT = 9,
        /// The  number of VertexElementSemantic elements (note - the first value VES_POSITION is 1)
        VES_COUNT = 9
    };

    /// Vertex element type, used to identify the base types of the vertex contents
    enum Type
    {
        VET_FLOAT1 = 0,
        VET_FLOAT2 = 1,
        VET_FLOAT3 = 2,
        VET_FLOAT4 = 3,
        /// alias to more specific colour type - use the current rendersystem's colour packing
        VET_COLOUR = 4,
        VET_SHORT1 = 5,
        VET_SHORT2 = 6,
        VET_SHORT3 = 7,
        VET_SHORT4 = 8,
        VET_UBYTE4 = 9,
        /// D3D style compact colour
        VET_COLOUR_ARGB = 10,
        /// GL style compact colour
        VET_COLOUR_ABGR = 11,
        VET_DOUBLE1 = 12,
        VET_DOUBLE2 = 13,
        VET_DOUBLE3 = 14,
        VET_DOUBLE4 = 15,
        VET_USHORT1 = 16,
        VET_USHORT2 = 17,
        VET_USHORT3 = 18,
        VET_USHORT4 = 19,
        VET_INT1 = 20,
        VET_INT2 = 21,
        VET_INT3 = 22,
        VET_INT4 = 23,
        VET_UINT1 = 24,
        VET_UINT2 = 25,
        VET_UINT3 = 26,
        VET_UINT4 = 27
    };

    VertexElement();

    /// Size of the vertex element in bytes.
    size_t Size() const;

    /// Count of components in this element, eg. VET_FLOAT3 return 3.
    size_t ComponentCount() const;

    /// Type as string.
    std::string TypeToString();

    /// Semantic as string.
    std::string SemanticToString();

    static size_t TypeSize(Type type);
    static size_t ComponentCount(Type type);
    static std::string TypeToString(Type type);
    static std::string SemanticToString(Semantic semantic);

    uint16_t index;
    uint16_t source;
    uint16_t offset;
    Type type;
    Semantic semantic;
};
typedef std::vector<VertexElement> VertexElementList;

/// Ogre Vertex Bone Assignment
struct VertexBoneAssignment
{
    uint32_t vertexIndex;
    uint16_t boneIndex;
    float weight;
};
typedef std::vector<VertexBoneAssignment> VertexBoneAssignmentList;
typedef std::map<uint32_t, VertexBoneAssignmentList > VertexBoneAssignmentsMap;
typedef std::map<uint16_t, std::vector<aiVertexWeight> > AssimpVertexBoneWeightList;

// Ogre Vertex Data interface, inherited by the binary and XML implementations.
class IVertexData
{
public:
    IVertexData();

    /// Returns if bone assignments are available.
    bool HasBoneAssignments() const;

    /// Add vertex mapping from old to new index.
    void AddVertexMapping(uint32_t oldIndex, uint32_t newIndex);

    /// Returns re-mapped bone assignments.
    /** @note Uses mappings added via AddVertexMapping. */
    AssimpVertexBoneWeightList AssimpBoneWeights(size_t vertices);

    /// Returns a set of bone indexes that are referenced by bone assignments (weights).
    std::set<uint16_t> ReferencedBonesByWeights() const;

    /// Vertex count.
    uint32_t count;

    /// Bone assignments.
    VertexBoneAssignmentList boneAssignments;

private:
    void BoneAssignmentsForVertex(uint32_t currentIndex, uint32_t newIndex, VertexBoneAssignmentList &dest) const;

    std::map<uint32_t, std::vector<uint32_t> > vertexIndexMapping;
    VertexBoneAssignmentsMap boneAssignmentsMap;
};

// Ogre Vertex Data
class VertexData : public IVertexData
{
public:
    VertexData();
    ~VertexData();

    /// Releases all memory that this data structure owns.
    void Reset();

    /// Get vertex size for @c source.
    uint32_t VertexSize(uint16_t source) const;

    /// Get vertex buffer for @c source.
    MemoryStream *VertexBuffer(uint16_t source);

    /// Get vertex element for @c semantic for @c index.
    VertexElement *GetVertexElement(VertexElement::Semantic semantic, uint16_t index = 0);

    /// Vertex elements.
    VertexElementList vertexElements;

    /// Vertex buffers mapped to bind index.
    VertexBufferBindings vertexBindings;
};

// Ogre Index Data
class IndexData
{
public:
    IndexData();
    ~IndexData();

    /// Releases all memory that this data structure owns.
    void Reset();

    /// Index size in bytes.
    size_t IndexSize() const;

    /// Face size in bytes.
    size_t FaceSize() const;

    /// Index count.
    uint32_t count;

    /// Face count.
    uint32_t faceCount;

    /// If has 32-bit indexes.
    bool is32bit;

    /// Index buffer.
    MemoryStreamPtr buffer;
};

/// Ogre Pose
class Pose
{
public:
    struct Vertex
    {
        uint32_t index;
        aiVector3D offset;
        aiVector3D normal;
    };
    typedef std::map<uint32_t, Vertex> PoseVertexMap;

    Pose() : target(0), hasNormals(false) {}

    /// Name.
    std::string name;

    /// Target.
    uint16_t target;

    /// Does vertices map have normals.
    bool hasNormals;

    /// Vertex offset and normals.
    PoseVertexMap vertices;
};
typedef std::vector<Pose*> PoseList;

/// Ogre Pose Key Frame Ref
struct PoseRef
{
    uint16_t index;
    float influence;
};
typedef std::vector<PoseRef> PoseRefList;

/// Ogre Pose Key Frame
struct PoseKeyFrame
{
    /// Time position in the animation.
    float timePos;

    PoseRefList references;
};
typedef std::vector<PoseKeyFrame> PoseKeyFrameList;

/// Ogre Morph Key Frame
struct MorphKeyFrame
{
    /// Time position in the animation.
    float timePos;

    MemoryStreamPtr buffer;
};
typedef std::vector<MorphKeyFrame> MorphKeyFrameList;

/// Ogre animation key frame
struct TransformKeyFrame
{
    TransformKeyFrame();

    aiMatrix4x4 Transform();

    float timePos;

    aiQuaternion rotation;
    aiVector3D position;
    aiVector3D scale;
};
typedef std::vector<TransformKeyFrame> TransformKeyFrameList;

/// Ogre Animation Track
struct VertexAnimationTrack
{
    enum Type
    {
        /// No animation
        VAT_NONE = 0,
        /// Morph animation is made up of many interpolated snapshot keyframes
        VAT_MORPH = 1,
        /// Pose animation is made up of a single delta pose keyframe
        VAT_POSE = 2,
        /// Keyframe that has its on pos, rot and scale for a time position
        VAT_TRANSFORM = 3
    };

    VertexAnimationTrack();

    /// Convert to Assimp node animation.
    aiNodeAnim *ConvertToAssimpAnimationNode(Skeleton *skeleton);

    // Animation type.
    Type type;

    /// Vertex data target.
    /**  0 == shared geometry
        >0 == submesh index + 1 */
    uint16_t target;

    /// Only valid for VAT_TRANSFORM.
    std::string boneName;

    /// Only one of these will contain key frames, depending on the type enum.
    PoseKeyFrameList poseKeyFrames;
    MorphKeyFrameList morphKeyFrames;
    TransformKeyFrameList transformKeyFrames;
};
typedef std::vector<VertexAnimationTrack> VertexAnimationTrackList;

/// Ogre Animation
class Animation
{
public:
    explicit Animation(Skeleton *parent);
    explicit Animation(Mesh *parent);

    /// Returns the associated vertex data for a track in this animation.
    /** @note Only valid to call when parent Mesh is set. */
    VertexData *AssociatedVertexData(VertexAnimationTrack *track) const;

    /// Convert to Assimp animation.
    aiAnimation *ConvertToAssimpAnimation();

    /// Parent mesh.
    /** @note Set only when animation is read from a mesh. */
    Mesh *parentMesh;

    /// Parent skeleton.
    /** @note Set only when animation is read from a skeleton. */
    Skeleton *parentSkeleton;

    /// Animation name.
    std::string name;

    /// Base animation name.
    std::string baseName;

    /// Length in seconds.
    float length;

    /// Base animation key time.
    float baseTime;

    /// Animation tracks.
    VertexAnimationTrackList tracks;
};
typedef std::vector<Animation*> AnimationList;

/// Ogre Bone
class Bone
{
public:
    Bone();

    /// Returns if this bone is parented.
    bool IsParented() const;

    /// Parent index as uint16_t. Internally int32_t as -1 means unparented.
    uint16_t ParentId() const;

    /// Add child bone.
    void AddChild(Bone *bone);

    /// Calculates the world matrix for bone and its children.
    void CalculateWorldMatrixAndDefaultPose(Skeleton *skeleton);

    /// Convert to Assimp node (animation nodes).
    aiNode *ConvertToAssimpNode(Skeleton *parent, aiNode *parentNode = nullptr);

    /// Convert to Assimp bone (mesh bones).
    aiBone *ConvertToAssimpBone(Skeleton *parent, const std::vector<aiVertexWeight> &boneWeights);

    uint16_t id;
    std::string name;

    Bone *parent;
    int32_t parentId;
    std::vector<uint16_t> children;

    aiVector3D position;
    aiQuaternion rotation;
    aiVector3D scale;

    aiMatrix4x4 worldMatrix;
    aiMatrix4x4 defaultPose;
};
typedef std::vector<Bone*> BoneList;

/// Ogre Skeleton
class Skeleton
{
public:
    enum BlendMode
    {
        /// Animations are applied by calculating a weighted average of all animations
        ANIMBLEND_AVERAGE = 0,
        /// Animations are applied by calculating a weighted cumulative total
        ANIMBLEND_CUMULATIVE = 1
    };

    Skeleton();
    ~Skeleton();

    /// Releases all memory that this data structure owns.
    void Reset();

    /// Returns unparented root bones.
    BoneList RootBones() const;

    /// Returns number of unparented root bones.
    size_t NumRootBones() const;

    /// Get bone by name.
    Bone *BoneByName(const std::string &name) const;

    /// Get bone by id.
    Bone *BoneById(uint16_t id) const;

    BoneList bones;
    AnimationList animations;

    /// @todo Take blend mode into account, but where?
    BlendMode blendMode;
};

/// Ogre Sub Mesh interface, inherited by the binary and XML implementations.
class ISubMesh
{
public:
    /// @note Full list of Ogre types, not all of them are supported and exposed to Assimp.
    enum OperationType
    {
        /// A list of points, 1 vertex per point
        OT_POINT_LIST = 1,
        /// A list of lines, 2 vertices per line
        OT_LINE_LIST = 2,
        /// A strip of connected lines, 1 vertex per line plus 1 start vertex
        OT_LINE_STRIP = 3,
        /// A list of triangles, 3 vertices per triangle
        OT_TRIANGLE_LIST = 4,
        /// A strip of triangles, 3 vertices for the first triangle, and 1 per triangle after that
        OT_TRIANGLE_STRIP = 5,
        /// A fan of triangles, 3 vertices for the first triangle, and 1 per triangle after that
        OT_TRIANGLE_FAN = 6
    };

    ISubMesh();

    /// SubMesh index.
    unsigned int index;

    /// SubMesh name.
    std::string name;

    /// Material used by this submesh.
    std::string materialRef;

    /// Texture alias information.
    std::string textureAliasName;
    std::string textureAliasRef;

    /// Assimp scene material index used by this submesh.
    /** -1 if no material or material could not be imported. */
    int materialIndex;

    /// If submesh uses shared geometry from parent mesh.
    bool usesSharedVertexData;

    /// Operation type.
    OperationType operationType;
};

/// Ogre SubMesh
class SubMesh : public ISubMesh
{
public:
    SubMesh();
    ~SubMesh();

    /// Releases all memory that this data structure owns.
    /** @note Vertex and index data contains shared ptrs
        that are freed automatically. In practice the ref count
        should be 0 after this reset. */
    void Reset();

    /// Convert to Assimp mesh.
    aiMesh *ConvertToAssimpMesh(Mesh *parent);

    /// Vertex data.
    VertexData *vertexData;

    /// Index data.
    IndexData *indexData;
};
typedef std::vector<SubMesh*> SubMeshList;

/// Ogre Mesh
class Mesh
{
public:
    /// Constructor.
    Mesh();

    /// Destructor.
    ~Mesh();

    /// Releases all memory that this data structure owns.
    void Reset();

    /// Returns number of subMeshes.
    size_t NumSubMeshes() const;

    /// Returns submesh for @c index.
    SubMesh *GetSubMesh( size_t index) const;

    /// Convert mesh to Assimp scene.
    void ConvertToAssimpScene(aiScene* dest);

    /// Mesh has skeletal animations.
    bool hasSkeletalAnimations;

    /// Skeleton reference.
    std::string skeletonRef;

    /// Skeleton.
    Skeleton *skeleton;

    /// Vertex data
    VertexData *sharedVertexData;

    /// Sub meshes.
    SubMeshList subMeshes;

    /// Animations
    AnimationList animations;

    /// Poses
    PoseList poses;
};

/// Ogre XML Vertex Data
class VertexDataXml : public IVertexData
{
public:
    VertexDataXml();

    bool HasPositions() const;
    bool HasNormals() const;
    bool HasTangents() const;
    bool HasUvs() const;
    size_t NumUvs() const;

    std::vector<aiVector3D> positions;
    std::vector<aiVector3D> normals;
    std::vector<aiVector3D> tangents;
    std::vector<std::vector<aiVector3D> > uvs;
};

/// Ogre XML Index Data
class IndexDataXml
{
public:
    IndexDataXml() : faceCount(0) {}

    /// Face count.
    uint32_t faceCount;

    std::vector<aiFace> faces;
};

/// Ogre XML SubMesh
class SubMeshXml : public ISubMesh
{
public:
    SubMeshXml();
    ~SubMeshXml();

    /// Releases all memory that this data structure owns.
    void Reset();

    aiMesh *ConvertToAssimpMesh(MeshXml *parent);

    IndexDataXml *indexData;
    VertexDataXml *vertexData;
};
typedef std::vector<SubMeshXml*> SubMeshXmlList;

/// Ogre XML Mesh
class MeshXml
{
public:
    MeshXml();
    ~MeshXml();

    /// Releases all memory that this data structure owns.
    void Reset();

    /// Returns number of subMeshes.
    size_t NumSubMeshes() const;

    /// Returns submesh for @c index.
    SubMeshXml *GetSubMesh(uint16_t index) const;

    /// Convert mesh to Assimp scene.
    void ConvertToAssimpScene(aiScene* dest);

    /// Skeleton reference.
    std::string skeletonRef;

    /// Skeleton.
    Skeleton *skeleton;

    /// Vertex data
    VertexDataXml *sharedVertexData;

    /// Sub meshes.
    SubMeshXmlList subMeshes;
};

} // Ogre
} // Assimp

#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
#endif // AI_OGRESTRUCTS_H_INC
