1 files changed, 696 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/Ogre/OgreStructs.h b/src/mesh/assimp-master/code/AssetLib/Ogre/OgreStructs.h
new file mode 100644
index 0000000..be9ffa0
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Ogre/OgreStructs.h
@@ -0,0 +1,696 @@
+/*
+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 = 0);
+
+    /// 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