828 lines
20 KiB
C++
828 lines
20 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2012, 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 "TinyFormatter.h"
|
|
|
|
#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
|
|
|
|
// Define as 1 to get verbose logging.
|
|
#define OGRE_BINARY_SERIALIZER_DEBUG 0
|
|
|
|
namespace Assimp
|
|
{
|
|
namespace Ogre
|
|
{
|
|
|
|
const std::string VERSION_1_8 = "[MeshSerializer_v1.8]";
|
|
const unsigned short HEADER_CHUNK_ID = 0x1000;
|
|
const long MSTREAM_OVERHEAD_SIZE = sizeof(uint16_t) + sizeof(uint32_t);
|
|
|
|
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);
|
|
}
|
|
|
|
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)
|
|
DefaultLogger::get()->debug(Formatter::format() << MeshHeaderToString(static_cast<MeshChunkId>(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)
|
|
DefaultLogger::get()->debug(Formatter::format() << "Skipping " << numBytes << " bytes");
|
|
#endif
|
|
|
|
m_reader->IncPtr(numBytes);
|
|
}
|
|
|
|
Mesh *OgreBinarySerializer::ImportMesh(MemoryStreamReader *stream)
|
|
{
|
|
OgreBinarySerializer serializer(stream);
|
|
|
|
uint16_t id = serializer.ReadHeader(false);
|
|
if (id != HEADER_CHUNK_ID) {
|
|
throw DeadlyExportError("Invalid Ogre Mesh file header.");
|
|
}
|
|
|
|
/// @todo Check what we can actually support.
|
|
std::string version = serializer.ReadLine();
|
|
if (version != VERSION_1_8)
|
|
throw DeadlyExportError("Mesh version " + version + " not supported by this importer. Run OgreMeshUpgrader tool on the file and try again.");
|
|
|
|
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>();
|
|
|
|
DefaultLogger::get()->debug("Reading Mesh");
|
|
DefaultLogger::get()->debug(Formatter::format() << " - 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>();
|
|
|
|
DefaultLogger::get()->debug(Formatter::format() << "Reading SubMesh " << mesh->subMeshes.size());
|
|
DefaultLogger::get()->debug(Formatter::format() << " - Material: '" << submesh->materialRef << "'");
|
|
DefaultLogger::get()->debug(Formatter::format() << " - 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));
|
|
|
|
DefaultLogger::get()->debug(Formatter::format() << " - " << 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 = 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 wont 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(std::set<uint32_t>::const_iterator iter=influencedVertices.begin(), end=influencedVertices.end(); iter != end; ++iter)
|
|
{
|
|
const uint32_t vertexIndex = (*iter);
|
|
|
|
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 (VertexBoneAssignmentList::iterator baIter=vertexData->boneAssignments.begin(), baEnd=vertexData->boneAssignments.end(); baIter != baEnd; ++baIter)
|
|
{
|
|
if (baIter->vertexIndex == vertexIndex)
|
|
baIter->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;
|
|
uint16_t submeshIndex = 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(Formatter::format() << "Ogre Mesh does not include submesh " << submeshIndex << " referenced in M_SUBMESH_NAME_TABLE_ELEMENT. Invalid mesh file.");
|
|
}
|
|
|
|
submesh->name = ReadLine();
|
|
DefaultLogger::get()->debug(Formatter::format() << " - SubMesh " << submesh->index << " name '" << submesh->name << "'");
|
|
|
|
if (!AtEnd())
|
|
id = ReadHeader();
|
|
}
|
|
if (!AtEnd())
|
|
RollbackHeader();
|
|
}
|
|
}
|
|
|
|
void OgreBinarySerializer::ReadGeometry(VertexData *dest)
|
|
{
|
|
dest->count = Read<uint32_t>();
|
|
|
|
DefaultLogger::get()->debug(Formatter::format() << " - 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>();
|
|
|
|
DefaultLogger::get()->debug(Formatter::format() << " - 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));
|
|
|
|
DefaultLogger::get()->debug(Formatter::format() << " - 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 id = ReadHeader();
|
|
if (id != 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();
|
|
}
|
|
}
|
|
|
|
} // Ogre
|
|
} // Assimp
|
|
|
|
#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
|