/*

Open Asset Import Library (assimp)

----------------------------------------------------------------------

Copyright (c) 2006-2025, 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