974 lines
31 KiB
C++
974 lines
31 KiB
C++
/*
|
|
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.
|
|
|
|
----------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "OgreBinarySerializer.h"
|
|
#include "OgreParsingUtils.h"
|
|
#include "OgreXmlSerializer.h"
|
|
|
|
#include <assimp/TinyFormatter.h>
|
|
#include <assimp/DefaultLogger.hpp>
|
|
|
|
#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
|
|
|
|
// Define as 1 to get verbose logging.
|
|
#define OGRE_BINARY_SERIALIZER_DEBUG 0
|
|
|
|
namespace Assimp {
|
|
namespace Ogre {
|
|
|
|
static constexpr auto MESH_VERSION_1_8 = "[MeshSerializer_v1.8]";
|
|
static constexpr auto SKELETON_VERSION_1_8 = "[Serializer_v1.80]";
|
|
static constexpr auto SKELETON_VERSION_1_1 = "[Serializer_v1.10]";
|
|
|
|
const unsigned short HEADER_CHUNK_ID = 0x1000;
|
|
|
|
const long MSTREAM_OVERHEAD_SIZE = sizeof(uint16_t) + sizeof(uint32_t);
|
|
const long MSTREAM_BONE_SIZE_WITHOUT_SCALE = MSTREAM_OVERHEAD_SIZE + sizeof(unsigned short) + (sizeof(float) * 7);
|
|
const long MSTREAM_KEYFRAME_SIZE_WITHOUT_SCALE = MSTREAM_OVERHEAD_SIZE + (sizeof(float) * 8);
|
|
|
|
template <>
|
|
inline bool OgreBinarySerializer::Read<bool>() {
|
|
return (m_reader->GetU1() > 0);
|
|
}
|
|
|
|
template <>
|
|
inline char OgreBinarySerializer::Read<char>() {
|
|
return static_cast<char>(m_reader->GetU1());
|
|
}
|
|
|
|
template <>
|
|
inline uint8_t OgreBinarySerializer::Read<uint8_t>() {
|
|
return m_reader->GetU1();
|
|
}
|
|
|
|
template <>
|
|
inline uint16_t OgreBinarySerializer::Read<uint16_t>() {
|
|
return m_reader->GetU2();
|
|
}
|
|
|
|
template <>
|
|
inline uint32_t OgreBinarySerializer::Read<uint32_t>() {
|
|
return m_reader->GetU4();
|
|
}
|
|
|
|
template <>
|
|
inline float OgreBinarySerializer::Read<float>() {
|
|
return m_reader->GetF4();
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadBytes(char *dest, size_t numBytes) {
|
|
ReadBytes(static_cast<void *>(dest), numBytes);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadBytes(uint8_t *dest, size_t numBytes) {
|
|
ReadBytes(static_cast<void *>(dest), numBytes);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadBytes(void *dest, size_t numBytes) {
|
|
m_reader->CopyAndAdvance(dest, numBytes);
|
|
}
|
|
|
|
uint8_t *OgreBinarySerializer::ReadBytes(size_t numBytes) {
|
|
uint8_t *bytes = new uint8_t[numBytes];
|
|
ReadBytes(bytes, numBytes);
|
|
return bytes;
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadVector(aiVector3D &vec) {
|
|
m_reader->CopyAndAdvance(&vec.x, sizeof(float) * 3);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadQuaternion(aiQuaternion &quat) {
|
|
float temp[4];
|
|
m_reader->CopyAndAdvance(temp, sizeof(float) * 4);
|
|
quat.x = temp[0];
|
|
quat.y = temp[1];
|
|
quat.z = temp[2];
|
|
quat.w = temp[3];
|
|
}
|
|
|
|
bool OgreBinarySerializer::AtEnd() const {
|
|
return (m_reader->GetRemainingSize() == 0);
|
|
}
|
|
|
|
std::string OgreBinarySerializer::ReadString(size_t len) {
|
|
std::string str;
|
|
str.resize(len);
|
|
ReadBytes(&str[0], len);
|
|
return str;
|
|
}
|
|
|
|
std::string OgreBinarySerializer::ReadLine() {
|
|
std::string str;
|
|
while (!AtEnd()) {
|
|
char c = Read<char>();
|
|
if (c == '\n')
|
|
break;
|
|
str += c;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
uint16_t OgreBinarySerializer::ReadHeader(bool readLen) {
|
|
uint16_t id = Read<uint16_t>();
|
|
if (readLen)
|
|
m_currentLen = Read<uint32_t>();
|
|
|
|
#if (OGRE_BINARY_SERIALIZER_DEBUG == 1)
|
|
if (id != HEADER_CHUNK_ID) {
|
|
ASSIMP_LOG_DEBUG((assetMode == AM_Mesh ? MeshHeaderToString(static_cast<MeshChunkId>(id)) : SkeletonHeaderToString(static_cast<SkeletonChunkId>(id))));
|
|
}
|
|
#endif
|
|
|
|
return id;
|
|
}
|
|
|
|
void OgreBinarySerializer::RollbackHeader() {
|
|
m_reader->IncPtr(-MSTREAM_OVERHEAD_SIZE);
|
|
}
|
|
|
|
void OgreBinarySerializer::SkipBytes(size_t numBytes) {
|
|
#if (OGRE_BINARY_SERIALIZER_DEBUG == 1)
|
|
ASSIMP_LOG_VERBOSE_DEBUG("Skipping ", numBytes, " bytes");
|
|
#endif
|
|
|
|
m_reader->IncPtr(numBytes);
|
|
}
|
|
|
|
// Mesh
|
|
|
|
Mesh *OgreBinarySerializer::ImportMesh(MemoryStreamReader *stream) {
|
|
OgreBinarySerializer serializer(stream, OgreBinarySerializer::AM_Mesh);
|
|
|
|
uint16_t id = serializer.ReadHeader(false);
|
|
if (id != HEADER_CHUNK_ID) {
|
|
throw DeadlyImportError("Invalid Ogre Mesh file header.");
|
|
}
|
|
|
|
/// @todo Check what we can actually support.
|
|
std::string version = serializer.ReadLine();
|
|
if (version != MESH_VERSION_1_8) {
|
|
throw DeadlyImportError("Mesh version ", version, " not supported by this importer. Run OgreMeshUpgrader tool on the file and try again.",
|
|
" Supported versions: ", MESH_VERSION_1_8);
|
|
}
|
|
|
|
Mesh *mesh = new Mesh();
|
|
while (!serializer.AtEnd()) {
|
|
id = serializer.ReadHeader();
|
|
switch (id) {
|
|
case M_MESH: {
|
|
serializer.ReadMesh(mesh);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return mesh;
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadMesh(Mesh *mesh) {
|
|
mesh->hasSkeletalAnimations = Read<bool>();
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG("Reading Mesh");
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - Skeletal animations: ", mesh->hasSkeletalAnimations ? "true" : "false");
|
|
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() &&
|
|
(id == M_GEOMETRY ||
|
|
id == M_SUBMESH ||
|
|
id == M_MESH_SKELETON_LINK ||
|
|
id == M_MESH_BONE_ASSIGNMENT ||
|
|
id == M_MESH_LOD ||
|
|
id == M_MESH_BOUNDS ||
|
|
id == M_SUBMESH_NAME_TABLE ||
|
|
id == M_EDGE_LISTS ||
|
|
id == M_POSES ||
|
|
id == M_ANIMATIONS ||
|
|
id == M_TABLE_EXTREMES)) {
|
|
switch (id) {
|
|
case M_GEOMETRY: {
|
|
mesh->sharedVertexData = new VertexData();
|
|
ReadGeometry(mesh->sharedVertexData);
|
|
break;
|
|
}
|
|
case M_SUBMESH: {
|
|
ReadSubMesh(mesh);
|
|
break;
|
|
}
|
|
case M_MESH_SKELETON_LINK: {
|
|
ReadMeshSkeletonLink(mesh);
|
|
break;
|
|
}
|
|
case M_MESH_BONE_ASSIGNMENT: {
|
|
ReadBoneAssignment(mesh->sharedVertexData);
|
|
break;
|
|
}
|
|
case M_MESH_LOD: {
|
|
ReadMeshLodInfo(mesh);
|
|
break;
|
|
}
|
|
case M_MESH_BOUNDS: {
|
|
ReadMeshBounds(mesh);
|
|
break;
|
|
}
|
|
case M_SUBMESH_NAME_TABLE: {
|
|
ReadSubMeshNames(mesh);
|
|
break;
|
|
}
|
|
case M_EDGE_LISTS: {
|
|
ReadEdgeList(mesh);
|
|
break;
|
|
}
|
|
case M_POSES: {
|
|
ReadPoses(mesh);
|
|
break;
|
|
}
|
|
case M_ANIMATIONS: {
|
|
ReadAnimations(mesh);
|
|
break;
|
|
}
|
|
case M_TABLE_EXTREMES: {
|
|
ReadMeshExtremes(mesh);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
|
|
NormalizeBoneWeights(mesh->sharedVertexData);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadMeshLodInfo(Mesh *mesh) {
|
|
// Assimp does not acknowledge LOD levels as far as I can see it. This info is just skipped.
|
|
// @todo Put this stuff to scene/mesh custom properties. If manual mesh the app can use the information.
|
|
ReadLine(); // strategy name
|
|
uint16_t numLods = Read<uint16_t>();
|
|
bool manual = Read<bool>();
|
|
|
|
/// @note Main mesh is considered as LOD 0, start from index 1.
|
|
for (size_t i = 1; i < numLods; ++i) {
|
|
uint16_t id = ReadHeader();
|
|
if (id != M_MESH_LOD_USAGE) {
|
|
throw DeadlyImportError("M_MESH_LOD does not contain a M_MESH_LOD_USAGE for each LOD level");
|
|
}
|
|
|
|
m_reader->IncPtr(sizeof(float)); // user value
|
|
|
|
if (manual) {
|
|
id = ReadHeader();
|
|
if (id != M_MESH_LOD_MANUAL) {
|
|
throw DeadlyImportError("Manual M_MESH_LOD_USAGE does not contain M_MESH_LOD_MANUAL");
|
|
}
|
|
|
|
ReadLine(); // manual mesh name (ref to another mesh)
|
|
} else {
|
|
for (size_t si = 0, silen = mesh->NumSubMeshes(); si < silen; ++si) {
|
|
id = ReadHeader();
|
|
if (id != M_MESH_LOD_GENERATED) {
|
|
throw DeadlyImportError("Generated M_MESH_LOD_USAGE does not contain M_MESH_LOD_GENERATED");
|
|
}
|
|
|
|
uint32_t indexCount = Read<uint32_t>();
|
|
bool is32bit = Read<bool>();
|
|
|
|
if (indexCount > 0) {
|
|
uint32_t len = indexCount * (is32bit ? sizeof(uint32_t) : sizeof(uint16_t));
|
|
m_reader->IncPtr(len);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadMeshSkeletonLink(Mesh *mesh) {
|
|
mesh->skeletonRef = ReadLine();
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadMeshBounds(Mesh * /*mesh*/) {
|
|
// Skip bounds, not compatible with Assimp.
|
|
// 2x float vec3 + 1x float sphere radius
|
|
SkipBytes(sizeof(float) * 7);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadMeshExtremes(Mesh * /*mesh*/) {
|
|
// Skip extremes, not compatible with Assimp.
|
|
size_t numBytes = m_currentLen - MSTREAM_OVERHEAD_SIZE;
|
|
SkipBytes(numBytes);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadBoneAssignment(VertexData *dest) {
|
|
if (!dest) {
|
|
throw DeadlyImportError("Cannot read bone assignments, vertex data is null.");
|
|
}
|
|
|
|
VertexBoneAssignment ba;
|
|
ba.vertexIndex = Read<uint32_t>();
|
|
ba.boneIndex = Read<uint16_t>();
|
|
ba.weight = Read<float>();
|
|
|
|
dest->boneAssignments.push_back(ba);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSubMesh(Mesh *mesh) {
|
|
uint16_t id = 0;
|
|
|
|
SubMesh *submesh = new SubMesh();
|
|
submesh->materialRef = ReadLine();
|
|
submesh->usesSharedVertexData = Read<bool>();
|
|
|
|
submesh->indexData->count = Read<uint32_t>();
|
|
submesh->indexData->faceCount = static_cast<uint32_t>(submesh->indexData->count / 3);
|
|
submesh->indexData->is32bit = Read<bool>();
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG("Reading SubMesh ", mesh->subMeshes.size());
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - Material: '", submesh->materialRef, "'");
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - Uses shared geometry: ", submesh->usesSharedVertexData ? "true" : "false");
|
|
|
|
// Index buffer
|
|
if (submesh->indexData->count > 0) {
|
|
uint32_t numBytes = submesh->indexData->count * (submesh->indexData->is32bit ? sizeof(uint32_t) : sizeof(uint16_t));
|
|
uint8_t *indexBuffer = ReadBytes(numBytes);
|
|
submesh->indexData->buffer = MemoryStreamPtr(new Assimp::MemoryIOStream(indexBuffer, numBytes, true));
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - ", submesh->indexData->faceCount,
|
|
" faces from ", submesh->indexData->count, (submesh->indexData->is32bit ? " 32bit" : " 16bit"),
|
|
" indexes of ", numBytes, " bytes");
|
|
}
|
|
|
|
// Vertex buffer if not referencing the shared geometry
|
|
if (!submesh->usesSharedVertexData) {
|
|
id = ReadHeader();
|
|
if (id != M_GEOMETRY) {
|
|
throw DeadlyImportError("M_SUBMESH does not contain M_GEOMETRY, but shader geometry is set to false");
|
|
}
|
|
|
|
submesh->vertexData = new VertexData();
|
|
ReadGeometry(submesh->vertexData);
|
|
}
|
|
|
|
// Bone assignment, submesh operation and texture aliases
|
|
if (!AtEnd()) {
|
|
id = ReadHeader();
|
|
while (!AtEnd() &&
|
|
(id == M_SUBMESH_OPERATION ||
|
|
id == M_SUBMESH_BONE_ASSIGNMENT ||
|
|
id == M_SUBMESH_TEXTURE_ALIAS)) {
|
|
switch (id) {
|
|
case M_SUBMESH_OPERATION: {
|
|
ReadSubMeshOperation(submesh);
|
|
break;
|
|
}
|
|
case M_SUBMESH_BONE_ASSIGNMENT: {
|
|
ReadBoneAssignment(submesh->vertexData);
|
|
break;
|
|
}
|
|
case M_SUBMESH_TEXTURE_ALIAS: {
|
|
ReadSubMeshTextureAlias(submesh);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
|
|
NormalizeBoneWeights(submesh->vertexData);
|
|
|
|
submesh->index = static_cast<unsigned int>(mesh->subMeshes.size());
|
|
mesh->subMeshes.push_back(submesh);
|
|
}
|
|
|
|
void OgreBinarySerializer::NormalizeBoneWeights(VertexData *vertexData) const {
|
|
if (!vertexData || vertexData->boneAssignments.empty())
|
|
return;
|
|
|
|
std::set<uint32_t> influencedVertices;
|
|
for (VertexBoneAssignmentList::const_iterator baIter = vertexData->boneAssignments.begin(), baEnd = vertexData->boneAssignments.end(); baIter != baEnd; ++baIter) {
|
|
influencedVertices.insert(baIter->vertexIndex);
|
|
}
|
|
|
|
/** Normalize bone weights.
|
|
Some exporters won't care if the sum of all bone weights
|
|
for a single vertex equals 1 or not, so validate here. */
|
|
const float epsilon = 0.05f;
|
|
for (const uint32_t vertexIndex : influencedVertices) {
|
|
float sum = 0.0f;
|
|
for (VertexBoneAssignmentList::const_iterator baIter = vertexData->boneAssignments.begin(), baEnd = vertexData->boneAssignments.end(); baIter != baEnd; ++baIter) {
|
|
if (baIter->vertexIndex == vertexIndex)
|
|
sum += baIter->weight;
|
|
}
|
|
if ((sum < (1.0f - epsilon)) || (sum > (1.0f + epsilon))) {
|
|
for (auto &boneAssign : vertexData->boneAssignments) {
|
|
if (boneAssign.vertexIndex == vertexIndex)
|
|
boneAssign.weight /= sum;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSubMeshOperation(SubMesh *submesh) {
|
|
submesh->operationType = static_cast<SubMesh::OperationType>(Read<uint16_t>());
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSubMeshTextureAlias(SubMesh *submesh) {
|
|
submesh->textureAliasName = ReadLine();
|
|
submesh->textureAliasRef = ReadLine();
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSubMeshNames(Mesh *mesh) {
|
|
uint16_t id = 0;
|
|
|
|
if (!AtEnd()) {
|
|
id = ReadHeader();
|
|
while (!AtEnd() && id == M_SUBMESH_NAME_TABLE_ELEMENT) {
|
|
uint16_t submeshIndex = Read<uint16_t>();
|
|
SubMesh *submesh = mesh->GetSubMesh(submeshIndex);
|
|
if (!submesh) {
|
|
throw DeadlyImportError("Ogre Mesh does not include submesh ", submeshIndex, " referenced in M_SUBMESH_NAME_TABLE_ELEMENT. Invalid mesh file.");
|
|
}
|
|
|
|
submesh->name = ReadLine();
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - SubMesh ", submesh->index, " name '", submesh->name, "'");
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadGeometry(VertexData *dest) {
|
|
dest->count = Read<uint32_t>();
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - Reading geometry of ", dest->count, " vertices");
|
|
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() &&
|
|
(id == M_GEOMETRY_VERTEX_DECLARATION ||
|
|
id == M_GEOMETRY_VERTEX_BUFFER)) {
|
|
switch (id) {
|
|
case M_GEOMETRY_VERTEX_DECLARATION: {
|
|
ReadGeometryVertexDeclaration(dest);
|
|
break;
|
|
}
|
|
case M_GEOMETRY_VERTEX_BUFFER: {
|
|
ReadGeometryVertexBuffer(dest);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadGeometryVertexDeclaration(VertexData *dest) {
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() && id == M_GEOMETRY_VERTEX_ELEMENT) {
|
|
ReadGeometryVertexElement(dest);
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadGeometryVertexElement(VertexData *dest) {
|
|
VertexElement element;
|
|
element.source = Read<uint16_t>();
|
|
element.type = static_cast<VertexElement::Type>(Read<uint16_t>());
|
|
element.semantic = static_cast<VertexElement::Semantic>(Read<uint16_t>());
|
|
element.offset = Read<uint16_t>();
|
|
element.index = Read<uint16_t>();
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - Vertex element ", element.SemanticToString(), " of type ",
|
|
element.TypeToString(), " index=", element.index, " source=", element.source);
|
|
|
|
dest->vertexElements.push_back(element);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadGeometryVertexBuffer(VertexData *dest) {
|
|
uint16_t bindIndex = Read<uint16_t>();
|
|
uint16_t vertexSize = Read<uint16_t>();
|
|
|
|
uint16_t id = ReadHeader();
|
|
if (id != M_GEOMETRY_VERTEX_BUFFER_DATA)
|
|
throw DeadlyImportError("M_GEOMETRY_VERTEX_BUFFER_DATA not found in M_GEOMETRY_VERTEX_BUFFER");
|
|
|
|
if (dest->VertexSize(bindIndex) != vertexSize)
|
|
throw DeadlyImportError("Vertex buffer size does not agree with vertex declaration in M_GEOMETRY_VERTEX_BUFFER");
|
|
|
|
size_t numBytes = dest->count * vertexSize;
|
|
uint8_t *vertexBuffer = ReadBytes(numBytes);
|
|
dest->vertexBindings[bindIndex] = MemoryStreamPtr(new Assimp::MemoryIOStream(vertexBuffer, numBytes, true));
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - Read vertex buffer for source ", bindIndex, " of ", numBytes, " bytes");
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadEdgeList(Mesh * /*mesh*/) {
|
|
// Assimp does not acknowledge LOD levels as far as I can see it. This info is just skipped.
|
|
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() && id == M_EDGE_LIST_LOD) {
|
|
m_reader->IncPtr(sizeof(uint16_t)); // lod index
|
|
bool manual = Read<bool>();
|
|
|
|
if (!manual) {
|
|
m_reader->IncPtr(sizeof(uint8_t));
|
|
uint32_t numTriangles = Read<uint32_t>();
|
|
uint32_t numEdgeGroups = Read<uint32_t>();
|
|
|
|
size_t skipBytes = (sizeof(uint32_t) * 8 + sizeof(float) * 4) * numTriangles;
|
|
m_reader->IncPtr(skipBytes);
|
|
|
|
for (size_t i = 0; i < numEdgeGroups; ++i) {
|
|
uint16_t curId = ReadHeader();
|
|
if (curId != M_EDGE_GROUP)
|
|
throw DeadlyImportError("M_EDGE_GROUP not found in M_EDGE_LIST_LOD");
|
|
|
|
m_reader->IncPtr(sizeof(uint32_t) * 3);
|
|
uint32_t numEdges = Read<uint32_t>();
|
|
for (size_t j = 0; j < numEdges; ++j) {
|
|
m_reader->IncPtr(sizeof(uint32_t) * 6 + sizeof(uint8_t));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadPoses(Mesh *mesh) {
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() && id == M_POSE) {
|
|
Pose *pose = new Pose();
|
|
pose->name = ReadLine();
|
|
pose->target = Read<uint16_t>();
|
|
pose->hasNormals = Read<bool>();
|
|
|
|
ReadPoseVertices(pose);
|
|
|
|
mesh->poses.push_back(pose);
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadPoseVertices(Pose *pose) {
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() && id == M_POSE_VERTEX) {
|
|
Pose::Vertex v;
|
|
v.index = Read<uint32_t>();
|
|
ReadVector(v.offset);
|
|
if (pose->hasNormals)
|
|
ReadVector(v.normal);
|
|
|
|
pose->vertices[v.index] = v;
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadAnimations(Mesh *mesh) {
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() && id == M_ANIMATION) {
|
|
Animation *anim = new Animation(mesh);
|
|
anim->name = ReadLine();
|
|
anim->length = Read<float>();
|
|
|
|
ReadAnimation(anim);
|
|
|
|
mesh->animations.push_back(anim);
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadAnimation(Animation *anim) {
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
if (id == M_ANIMATION_BASEINFO) {
|
|
anim->baseName = ReadLine();
|
|
anim->baseTime = Read<float>();
|
|
|
|
// Advance to first track
|
|
id = ReadHeader();
|
|
}
|
|
|
|
while (!AtEnd() && id == M_ANIMATION_TRACK) {
|
|
VertexAnimationTrack track;
|
|
track.type = static_cast<VertexAnimationTrack::Type>(Read<uint16_t>());
|
|
track.target = Read<uint16_t>();
|
|
|
|
ReadAnimationKeyFrames(anim, &track);
|
|
|
|
anim->tracks.push_back(track);
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *track) {
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() &&
|
|
(id == M_ANIMATION_MORPH_KEYFRAME ||
|
|
id == M_ANIMATION_POSE_KEYFRAME)) {
|
|
if (id == M_ANIMATION_MORPH_KEYFRAME) {
|
|
MorphKeyFrame kf;
|
|
kf.timePos = Read<float>();
|
|
bool hasNormals = Read<bool>();
|
|
|
|
size_t vertexCount = anim->AssociatedVertexData(track)->count;
|
|
size_t vertexSize = sizeof(float) * (hasNormals ? 6 : 3);
|
|
size_t numBytes = vertexCount * vertexSize;
|
|
|
|
uint8_t *morphBuffer = ReadBytes(numBytes);
|
|
kf.buffer = MemoryStreamPtr(new Assimp::MemoryIOStream(morphBuffer, numBytes, true));
|
|
|
|
track->morphKeyFrames.push_back(kf);
|
|
} else if (id == M_ANIMATION_POSE_KEYFRAME) {
|
|
PoseKeyFrame kf;
|
|
kf.timePos = Read<float>();
|
|
|
|
if (!AtEnd()) {
|
|
id = ReadHeader();
|
|
while (!AtEnd() && id == M_ANIMATION_POSE_REF) {
|
|
PoseRef pr;
|
|
pr.index = Read<uint16_t>();
|
|
pr.influence = Read<float>();
|
|
kf.references.push_back(pr);
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
|
|
track->poseKeyFrames.push_back(kf);
|
|
}
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
// Skeleton
|
|
|
|
bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh) {
|
|
if (!mesh || mesh->skeletonRef.empty())
|
|
return false;
|
|
|
|
// Highly unusual to see in read world cases but support
|
|
// binary mesh referencing a XML skeleton file.
|
|
if (EndsWith(mesh->skeletonRef, ".skeleton.xml", false)) {
|
|
OgreXmlSerializer::ImportSkeleton(pIOHandler, mesh);
|
|
return false;
|
|
}
|
|
|
|
MemoryStreamReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef);
|
|
if (!reader)
|
|
return false;
|
|
|
|
Skeleton *skeleton = new Skeleton();
|
|
OgreBinarySerializer serializer(reader.get(), OgreBinarySerializer::AM_Skeleton);
|
|
serializer.ReadSkeleton(skeleton);
|
|
mesh->skeleton = skeleton;
|
|
return true;
|
|
}
|
|
|
|
bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh) {
|
|
if (!mesh || mesh->skeletonRef.empty())
|
|
return false;
|
|
|
|
MemoryStreamReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef);
|
|
if (!reader.get())
|
|
return false;
|
|
|
|
Skeleton *skeleton = new Skeleton();
|
|
OgreBinarySerializer serializer(reader.get(), OgreBinarySerializer::AM_Skeleton);
|
|
serializer.ReadSkeleton(skeleton);
|
|
mesh->skeleton = skeleton;
|
|
return true;
|
|
}
|
|
|
|
MemoryStreamReaderPtr OgreBinarySerializer::OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename) {
|
|
if (!EndsWith(filename, ".skeleton", false)) {
|
|
ASSIMP_LOG_ERROR("Imported Mesh is referencing to unsupported '", filename, "' skeleton file.");
|
|
return MemoryStreamReaderPtr();
|
|
}
|
|
|
|
if (!pIOHandler->Exists(filename)) {
|
|
ASSIMP_LOG_ERROR("Failed to find skeleton file '", filename, "' that is referenced by imported Mesh.");
|
|
return MemoryStreamReaderPtr();
|
|
}
|
|
|
|
IOStream *f = pIOHandler->Open(filename, "rb");
|
|
if (!f) {
|
|
throw DeadlyImportError("Failed to open skeleton file ", filename);
|
|
}
|
|
|
|
return MemoryStreamReaderPtr(new MemoryStreamReader(f));
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSkeleton(Skeleton *skeleton) {
|
|
uint16_t id = ReadHeader(false);
|
|
if (id != HEADER_CHUNK_ID) {
|
|
throw DeadlyImportError("Invalid Ogre Skeleton file header.");
|
|
}
|
|
|
|
// This deserialization supports both versions of the skeleton spec
|
|
std::string version = ReadLine();
|
|
if (version != SKELETON_VERSION_1_8 && version != SKELETON_VERSION_1_1) {
|
|
throw DeadlyImportError("Skeleton version ", version, " not supported by this importer.",
|
|
" Supported versions: ", SKELETON_VERSION_1_8, " and ", SKELETON_VERSION_1_1);
|
|
}
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG("Reading Skeleton");
|
|
|
|
bool firstBone = true;
|
|
bool firstAnim = true;
|
|
|
|
while (!AtEnd()) {
|
|
id = ReadHeader();
|
|
switch (id) {
|
|
case SKELETON_BLENDMODE: {
|
|
skeleton->blendMode = static_cast<Skeleton::BlendMode>(Read<uint16_t>());
|
|
break;
|
|
}
|
|
case SKELETON_BONE: {
|
|
if (firstBone) {
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - Bones");
|
|
firstBone = false;
|
|
}
|
|
|
|
ReadBone(skeleton);
|
|
break;
|
|
}
|
|
case SKELETON_BONE_PARENT: {
|
|
ReadBoneParent(skeleton);
|
|
break;
|
|
}
|
|
case SKELETON_ANIMATION: {
|
|
if (firstAnim) {
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" - Animations");
|
|
firstAnim = false;
|
|
}
|
|
|
|
ReadSkeletonAnimation(skeleton);
|
|
break;
|
|
}
|
|
case SKELETON_ANIMATION_LINK: {
|
|
ReadSkeletonAnimationLink(skeleton);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Calculate bone matrices for root bones. Recursively calculates their children.
|
|
for (size_t i = 0, len = skeleton->bones.size(); i < len; ++i) {
|
|
Bone *bone = skeleton->bones[i];
|
|
if (!bone->IsParented())
|
|
bone->CalculateWorldMatrixAndDefaultPose(skeleton);
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadBone(Skeleton *skeleton) {
|
|
Bone *bone = new Bone();
|
|
bone->name = ReadLine();
|
|
bone->id = Read<uint16_t>();
|
|
|
|
// Pos and rot
|
|
ReadVector(bone->position);
|
|
ReadQuaternion(bone->rotation);
|
|
|
|
// Scale (optional)
|
|
if (m_currentLen > MSTREAM_BONE_SIZE_WITHOUT_SCALE)
|
|
ReadVector(bone->scale);
|
|
|
|
// Bone indexes need to start from 0 and be contiguous
|
|
if (bone->id != skeleton->bones.size()) {
|
|
throw DeadlyImportError("Ogre Skeleton bone indexes not contiguous. Error at bone index ", bone->id);
|
|
}
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" ", bone->id, " ", bone->name);
|
|
|
|
skeleton->bones.push_back(bone);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadBoneParent(Skeleton *skeleton) {
|
|
uint16_t childId = Read<uint16_t>();
|
|
uint16_t parentId = Read<uint16_t>();
|
|
|
|
Bone *child = skeleton->BoneById(childId);
|
|
Bone *parent = skeleton->BoneById(parentId);
|
|
|
|
if (child && parent)
|
|
parent->AddChild(child);
|
|
else
|
|
throw DeadlyImportError("Failed to find bones for parenting: Child id ", childId, " for parent id ", parentId);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSkeletonAnimation(Skeleton *skeleton) {
|
|
Animation *anim = new Animation(skeleton);
|
|
anim->name = ReadLine();
|
|
anim->length = Read<float>();
|
|
|
|
if (!AtEnd()) {
|
|
uint16_t id = ReadHeader();
|
|
if (id == SKELETON_ANIMATION_BASEINFO) {
|
|
anim->baseName = ReadLine();
|
|
anim->baseTime = Read<float>();
|
|
|
|
// Advance to first track
|
|
id = ReadHeader();
|
|
}
|
|
|
|
while (!AtEnd() && id == SKELETON_ANIMATION_TRACK) {
|
|
ReadSkeletonAnimationTrack(skeleton, anim);
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
|
|
skeleton->animations.push_back(anim);
|
|
|
|
ASSIMP_LOG_VERBOSE_DEBUG(" ", anim->name, " (", anim->length, " sec, ", anim->tracks.size(), " tracks)");
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSkeletonAnimationTrack(Skeleton * /*skeleton*/, Animation *dest) {
|
|
uint16_t boneId = Read<uint16_t>();
|
|
Bone *bone = dest->parentSkeleton->BoneById(boneId);
|
|
if (!bone) {
|
|
throw DeadlyImportError("Cannot read animation track, target bone ", boneId, " not in target Skeleton");
|
|
}
|
|
|
|
VertexAnimationTrack track;
|
|
track.type = VertexAnimationTrack::VAT_TRANSFORM;
|
|
track.boneName = bone->name;
|
|
|
|
uint16_t id = ReadHeader();
|
|
while (!AtEnd() && id == SKELETON_ANIMATION_TRACK_KEYFRAME) {
|
|
ReadSkeletonAnimationKeyFrame(&track);
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
|
|
dest->tracks.push_back(track);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSkeletonAnimationKeyFrame(VertexAnimationTrack *dest) {
|
|
TransformKeyFrame keyframe;
|
|
keyframe.timePos = Read<float>();
|
|
|
|
// Rot and pos
|
|
ReadQuaternion(keyframe.rotation);
|
|
ReadVector(keyframe.position);
|
|
|
|
// Scale (optional)
|
|
if (m_currentLen > MSTREAM_KEYFRAME_SIZE_WITHOUT_SCALE)
|
|
ReadVector(keyframe.scale);
|
|
|
|
dest->transformKeyFrames.push_back(keyframe);
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadSkeletonAnimationLink(Skeleton * /*skeleton*/) {
|
|
// Skip bounds, not compatible with Assimp.
|
|
ReadLine(); // skeleton name
|
|
SkipBytes(sizeof(float) * 3); // scale
|
|
}
|
|
|
|
} // namespace Ogre
|
|
} // namespace Assimp
|
|
|
|
#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
|