| /* |
| Open Asset Import Library (assimp) |
| ---------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, 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_OGREBINARYSERIALIZER_H_INC |
| #define AI_OGREBINARYSERIALIZER_H_INC |
| |
| #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER |
| |
| #include "OgreStructs.h" |
| #include "StreamReader.h" |
| |
| namespace Assimp |
| { |
| namespace Ogre |
| { |
| |
| typedef Assimp::StreamReaderLE MemoryStreamReader; |
| typedef std::shared_ptr<MemoryStreamReader> MemoryStreamReaderPtr; |
| |
| class OgreBinarySerializer |
| { |
| public: |
| /// Imports mesh and returns the result. |
| /** @note Fatal unrecoverable errors will throw a DeadlyImportError. */ |
| static Mesh *ImportMesh(MemoryStreamReader *reader); |
| |
| /// Imports skeleton to @c mesh into Mesh::skeleton. |
| /** If mesh does not have a skeleton reference or the skeleton file |
| cannot be found it is not a fatal DeadlyImportError. |
| @return If skeleton import was successful. */ |
| static bool ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh); |
| static bool ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh); |
| |
| private: |
| enum AssetMode |
| { |
| AM_Mesh, |
| AM_Skeleton |
| }; |
| |
| OgreBinarySerializer(MemoryStreamReader *reader, AssetMode mode) : |
| m_currentLen(0), |
| m_reader(reader), |
| assetMode(mode) |
| { |
| } |
| |
| static MemoryStreamReaderPtr OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename); |
| |
| // Header |
| |
| uint16_t ReadHeader(bool readLen = true); |
| void RollbackHeader(); |
| |
| // Mesh |
| |
| void ReadMesh(Mesh *mesh); |
| void ReadMeshLodInfo(Mesh *mesh); |
| void ReadMeshSkeletonLink(Mesh *mesh); |
| void ReadMeshBounds(Mesh *mesh); |
| void ReadMeshExtremes(Mesh *mesh); |
| |
| void ReadSubMesh(Mesh *mesh); |
| void ReadSubMeshNames(Mesh *mesh); |
| void ReadSubMeshOperation(SubMesh *submesh); |
| void ReadSubMeshTextureAlias(SubMesh *submesh); |
| |
| void ReadBoneAssignment(VertexData *dest); |
| |
| void ReadGeometry(VertexData *dest); |
| void ReadGeometryVertexDeclaration(VertexData *dest); |
| void ReadGeometryVertexElement(VertexData *dest); |
| void ReadGeometryVertexBuffer(VertexData *dest); |
| |
| void ReadEdgeList(Mesh *mesh); |
| void ReadPoses(Mesh *mesh); |
| void ReadPoseVertices(Pose *pose); |
| |
| void ReadAnimations(Mesh *mesh); |
| void ReadAnimation(Animation *anim); |
| void ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *track); |
| |
| void NormalizeBoneWeights(VertexData *vertexData) const; |
| |
| // Skeleton |
| |
| void ReadSkeleton(Skeleton *skeleton); |
| |
| void ReadBone(Skeleton *skeleton); |
| void ReadBoneParent(Skeleton *skeleton); |
| |
| void ReadSkeletonAnimation(Skeleton *skeleton); |
| void ReadSkeletonAnimationTrack(Skeleton *skeleton, Animation *dest); |
| void ReadSkeletonAnimationKeyFrame(VertexAnimationTrack *dest); |
| void ReadSkeletonAnimationLink(Skeleton *skeleton); |
| |
| // Reader utils |
| bool AtEnd() const; |
| |
| template<typename T> |
| inline T Read(); |
| |
| void ReadBytes(char *dest, size_t numBytes); |
| void ReadBytes(uint8_t *dest, size_t numBytes); |
| void ReadBytes(void *dest, size_t numBytes); |
| uint8_t *ReadBytes(size_t numBytes); |
| |
| void ReadVector(aiVector3D &vec); |
| void ReadQuaternion(aiQuaternion &quat); |
| |
| std::string ReadString(size_t len); |
| std::string ReadLine(); |
| |
| void SkipBytes(size_t numBytes); |
| |
| uint32_t m_currentLen; |
| MemoryStreamReader *m_reader; |
| |
| AssetMode assetMode; |
| }; |
| |
| enum MeshChunkId |
| { |
| M_HEADER = 0x1000, |
| // char* version : Version number check |
| M_MESH = 0x3000, |
| // bool skeletallyAnimated // important flag which affects h/w buffer policies |
| // Optional M_GEOMETRY chunk |
| M_SUBMESH = 0x4000, |
| // char* materialName |
| // bool useSharedVertices |
| // unsigned int indexCount |
| // bool indexes32Bit |
| // unsigned int* faceVertexIndices (indexCount) |
| // OR |
| // unsigned short* faceVertexIndices (indexCount) |
| // M_GEOMETRY chunk (Optional: present only if useSharedVertices = false) |
| M_SUBMESH_OPERATION = 0x4010, // optional, trilist assumed if missing |
| // unsigned short operationType |
| M_SUBMESH_BONE_ASSIGNMENT = 0x4100, |
| // Optional bone weights (repeating section) |
| // unsigned int vertexIndex; |
| // unsigned short boneIndex; |
| // float weight; |
| // Optional chunk that matches a texture name to an alias |
| // a texture alias is sent to the submesh material to use this texture name |
| // instead of the one in the texture unit with a matching alias name |
| M_SUBMESH_TEXTURE_ALIAS = 0x4200, // Repeating section |
| // char* aliasName; |
| // char* textureName; |
| |
| M_GEOMETRY = 0x5000, // NB this chunk is embedded within M_MESH and M_SUBMESH |
| // unsigned int vertexCount |
| M_GEOMETRY_VERTEX_DECLARATION = 0x5100, |
| M_GEOMETRY_VERTEX_ELEMENT = 0x5110, // Repeating section |
| // unsigned short source; // buffer bind source |
| // unsigned short type; // VertexElementType |
| // unsigned short semantic; // VertexElementSemantic |
| // unsigned short offset; // start offset in buffer in bytes |
| // unsigned short index; // index of the semantic (for colours and texture coords) |
| M_GEOMETRY_VERTEX_BUFFER = 0x5200, // Repeating section |
| // unsigned short bindIndex; // Index to bind this buffer to |
| // unsigned short vertexSize; // Per-vertex size, must agree with declaration at this index |
| M_GEOMETRY_VERTEX_BUFFER_DATA = 0x5210, |
| // raw buffer data |
| M_MESH_SKELETON_LINK = 0x6000, |
| // Optional link to skeleton |
| // char* skeletonName : name of .skeleton to use |
| M_MESH_BONE_ASSIGNMENT = 0x7000, |
| // Optional bone weights (repeating section) |
| // unsigned int vertexIndex; |
| // unsigned short boneIndex; |
| // float weight; |
| M_MESH_LOD = 0x8000, |
| // Optional LOD information |
| // string strategyName; |
| // unsigned short numLevels; |
| // bool manual; (true for manual alternate meshes, false for generated) |
| M_MESH_LOD_USAGE = 0x8100, |
| // Repeating section, ordered in increasing depth |
| // NB LOD 0 (full detail from 0 depth) is omitted |
| // LOD value - this is a distance, a pixel count etc, based on strategy |
| // float lodValue; |
| M_MESH_LOD_MANUAL = 0x8110, |
| // Required if M_MESH_LOD section manual = true |
| // String manualMeshName; |
| M_MESH_LOD_GENERATED = 0x8120, |
| // Required if M_MESH_LOD section manual = false |
| // Repeating section (1 per submesh) |
| // unsigned int indexCount; |
| // bool indexes32Bit |
| // unsigned short* faceIndexes; (indexCount) |
| // OR |
| // unsigned int* faceIndexes; (indexCount) |
| M_MESH_BOUNDS = 0x9000, |
| // float minx, miny, minz |
| // float maxx, maxy, maxz |
| // float radius |
| |
| // Added By DrEvil |
| // optional chunk that contains a table of submesh indexes and the names of |
| // the sub-meshes. |
| M_SUBMESH_NAME_TABLE = 0xA000, |
| // Subchunks of the name table. Each chunk contains an index & string |
| M_SUBMESH_NAME_TABLE_ELEMENT = 0xA100, |
| // short index |
| // char* name |
| // Optional chunk which stores precomputed edge data |
| M_EDGE_LISTS = 0xB000, |
| // Each LOD has a separate edge list |
| M_EDGE_LIST_LOD = 0xB100, |
| // unsigned short lodIndex |
| // bool isManual // If manual, no edge data here, loaded from manual mesh |
| // bool isClosed |
| // unsigned long numTriangles |
| // unsigned long numEdgeGroups |
| // Triangle* triangleList |
| // unsigned long indexSet |
| // unsigned long vertexSet |
| // unsigned long vertIndex[3] |
| // unsigned long sharedVertIndex[3] |
| // float normal[4] |
| |
| M_EDGE_GROUP = 0xB110, |
| // unsigned long vertexSet |
| // unsigned long triStart |
| // unsigned long triCount |
| // unsigned long numEdges |
| // Edge* edgeList |
| // unsigned long triIndex[2] |
| // unsigned long vertIndex[2] |
| // unsigned long sharedVertIndex[2] |
| // bool degenerate |
| // Optional poses section, referred to by pose keyframes |
| M_POSES = 0xC000, |
| M_POSE = 0xC100, |
| // char* name (may be blank) |
| // unsigned short target // 0 for shared geometry, |
| // 1+ for submesh index + 1 |
| // bool includesNormals [1.8+] |
| M_POSE_VERTEX = 0xC111, |
| // unsigned long vertexIndex |
| // float xoffset, yoffset, zoffset |
| // float xnormal, ynormal, znormal (optional, 1.8+) |
| // Optional vertex animation chunk |
| M_ANIMATIONS = 0xD000, |
| M_ANIMATION = 0xD100, |
| // char* name |
| // float length |
| M_ANIMATION_BASEINFO = 0xD105, |
| // [Optional] base keyframe information (pose animation only) |
| // char* baseAnimationName (blank for self) |
| // float baseKeyFrameTime |
| M_ANIMATION_TRACK = 0xD110, |
| // unsigned short type // 1 == morph, 2 == pose |
| // unsigned short target // 0 for shared geometry, |
| // 1+ for submesh index + 1 |
| M_ANIMATION_MORPH_KEYFRAME = 0xD111, |
| // float time |
| // bool includesNormals [1.8+] |
| // float x,y,z // repeat by number of vertices in original geometry |
| M_ANIMATION_POSE_KEYFRAME = 0xD112, |
| // float time |
| M_ANIMATION_POSE_REF = 0xD113, // repeat for number of referenced poses |
| // unsigned short poseIndex |
| // float influence |
| // Optional submesh extreme vertex list chink |
| M_TABLE_EXTREMES = 0xE000 |
| // unsigned short submesh_index; |
| // float extremes [n_extremes][3]; |
| }; |
| |
| /* |
| static std::string MeshHeaderToString(MeshChunkId id) |
| { |
| switch(id) |
| { |
| case M_HEADER: return "HEADER"; |
| case M_MESH: return "MESH"; |
| case M_SUBMESH: return "SUBMESH"; |
| case M_SUBMESH_OPERATION: return "SUBMESH_OPERATION"; |
| case M_SUBMESH_BONE_ASSIGNMENT: return "SUBMESH_BONE_ASSIGNMENT"; |
| case M_SUBMESH_TEXTURE_ALIAS: return "SUBMESH_TEXTURE_ALIAS"; |
| case M_GEOMETRY: return "GEOMETRY"; |
| case M_GEOMETRY_VERTEX_DECLARATION: return "GEOMETRY_VERTEX_DECLARATION"; |
| case M_GEOMETRY_VERTEX_ELEMENT: return "GEOMETRY_VERTEX_ELEMENT"; |
| case M_GEOMETRY_VERTEX_BUFFER: return "GEOMETRY_VERTEX_BUFFER"; |
| case M_GEOMETRY_VERTEX_BUFFER_DATA: return "GEOMETRY_VERTEX_BUFFER_DATA"; |
| case M_MESH_SKELETON_LINK: return "MESH_SKELETON_LINK"; |
| case M_MESH_BONE_ASSIGNMENT: return "MESH_BONE_ASSIGNMENT"; |
| case M_MESH_LOD: return "MESH_LOD"; |
| case M_MESH_LOD_USAGE: return "MESH_LOD_USAGE"; |
| case M_MESH_LOD_MANUAL: return "MESH_LOD_MANUAL"; |
| case M_MESH_LOD_GENERATED: return "MESH_LOD_GENERATED"; |
| case M_MESH_BOUNDS: return "MESH_BOUNDS"; |
| case M_SUBMESH_NAME_TABLE: return "SUBMESH_NAME_TABLE"; |
| case M_SUBMESH_NAME_TABLE_ELEMENT: return "SUBMESH_NAME_TABLE_ELEMENT"; |
| case M_EDGE_LISTS: return "EDGE_LISTS"; |
| case M_EDGE_LIST_LOD: return "EDGE_LIST_LOD"; |
| case M_EDGE_GROUP: return "EDGE_GROUP"; |
| case M_POSES: return "POSES"; |
| case M_POSE: return "POSE"; |
| case M_POSE_VERTEX: return "POSE_VERTEX"; |
| case M_ANIMATIONS: return "ANIMATIONS"; |
| case M_ANIMATION: return "ANIMATION"; |
| case M_ANIMATION_BASEINFO: return "ANIMATION_BASEINFO"; |
| case M_ANIMATION_TRACK: return "ANIMATION_TRACK"; |
| case M_ANIMATION_MORPH_KEYFRAME: return "ANIMATION_MORPH_KEYFRAME"; |
| case M_ANIMATION_POSE_KEYFRAME: return "ANIMATION_POSE_KEYFRAME"; |
| case M_ANIMATION_POSE_REF: return "ANIMATION_POSE_REF"; |
| case M_TABLE_EXTREMES: return "TABLE_EXTREMES"; |
| } |
| return "Unknown_MeshChunkId"; |
| } |
| */ |
| |
| enum SkeletonChunkId |
| { |
| SKELETON_HEADER = 0x1000, |
| // char* version : Version number check |
| SKELETON_BLENDMODE = 0x1010, // optional |
| // unsigned short blendmode : SkeletonAnimationBlendMode |
| SKELETON_BONE = 0x2000, |
| // Repeating section defining each bone in the system. |
| // Bones are assigned indexes automatically based on their order of declaration |
| // starting with 0. |
| // char* name : name of the bone |
| // unsigned short handle : handle of the bone, should be contiguous & start at 0 |
| // Vector3 position : position of this bone relative to parent |
| // Quaternion orientation : orientation of this bone relative to parent |
| // Vector3 scale : scale of this bone relative to parent |
| SKELETON_BONE_PARENT = 0x3000, |
| // Record of the parent of a single bone, used to build the node tree |
| // Repeating section, listed in Bone Index order, one per Bone |
| // unsigned short handle : child bone |
| // unsigned short parentHandle : parent bone |
| SKELETON_ANIMATION = 0x4000, |
| // A single animation for this skeleton |
| // char* name : Name of the animation |
| // float length : Length of the animation in seconds |
| SKELETON_ANIMATION_BASEINFO = 0x4010, |
| // [Optional] base keyframe information |
| // char* baseAnimationName (blank for self) |
| // float baseKeyFrameTime |
| SKELETON_ANIMATION_TRACK = 0x4100, |
| // A single animation track (relates to a single bone) |
| // Repeating section (within SKELETON_ANIMATION) |
| // unsigned short boneIndex : Index of bone to apply to |
| SKELETON_ANIMATION_TRACK_KEYFRAME = 0x4110, |
| // A single keyframe within the track |
| // Repeating section |
| // float time : The time position (seconds) |
| // Quaternion rotate : Rotation to apply at this keyframe |
| // Vector3 translate : Translation to apply at this keyframe |
| // Vector3 scale : Scale to apply at this keyframe |
| SKELETON_ANIMATION_LINK = 0x5000 |
| // Link to another skeleton, to re-use its animations |
| // char* skeletonName : name of skeleton to get animations from |
| // float scale : scale to apply to trans/scale keys |
| }; |
| |
| /* |
| static std::string SkeletonHeaderToString(SkeletonChunkId id) |
| { |
| switch(id) |
| { |
| case SKELETON_HEADER: return "HEADER"; |
| case SKELETON_BLENDMODE: return "BLENDMODE"; |
| case SKELETON_BONE: return "BONE"; |
| case SKELETON_BONE_PARENT: return "BONE_PARENT"; |
| case SKELETON_ANIMATION: return "ANIMATION"; |
| case SKELETON_ANIMATION_BASEINFO: return "ANIMATION_BASEINFO"; |
| case SKELETON_ANIMATION_TRACK: return "ANIMATION_TRACK"; |
| case SKELETON_ANIMATION_TRACK_KEYFRAME: return "ANIMATION_TRACK_KEYFRAME"; |
| case SKELETON_ANIMATION_LINK: return "ANIMATION_LINK"; |
| } |
| return "Unknown_SkeletonChunkId"; |
| } |
| */ |
| } // Ogre |
| } // Assimp |
| |
| #endif // ASSIMP_BUILD_NO_OGRE_IMPORTER |
| #endif // AI_OGREBINARYSERIALIZER_H_INC |
