1206 lines
34 KiB
C++
1206 lines
34 KiB
C++
/*
|
|
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 ASSIMP_BUILD_NO_OGRE_IMPORTER
|
|
|
|
#include "OgreStructs.h"
|
|
#include "TinyFormatter.h"
|
|
#include <assimp/scene.h>
|
|
#include <assimp/DefaultLogger.hpp>
|
|
#include "Exceptional.h"
|
|
|
|
|
|
namespace Assimp
|
|
{
|
|
namespace Ogre
|
|
{
|
|
|
|
// VertexElement
|
|
|
|
VertexElement::VertexElement() :
|
|
index(0),
|
|
source(0),
|
|
offset(0),
|
|
type(VET_FLOAT1),
|
|
semantic(VES_POSITION)
|
|
{
|
|
}
|
|
|
|
size_t VertexElement::Size() const
|
|
{
|
|
return TypeSize(type);
|
|
}
|
|
|
|
size_t VertexElement::ComponentCount() const
|
|
{
|
|
return ComponentCount(type);
|
|
}
|
|
|
|
size_t VertexElement::ComponentCount(Type type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case VET_COLOUR:
|
|
case VET_COLOUR_ABGR:
|
|
case VET_COLOUR_ARGB:
|
|
case VET_FLOAT1:
|
|
case VET_DOUBLE1:
|
|
case VET_SHORT1:
|
|
case VET_USHORT1:
|
|
case VET_INT1:
|
|
case VET_UINT1:
|
|
return 1;
|
|
case VET_FLOAT2:
|
|
case VET_DOUBLE2:
|
|
case VET_SHORT2:
|
|
case VET_USHORT2:
|
|
case VET_INT2:
|
|
case VET_UINT2:
|
|
return 2;
|
|
case VET_FLOAT3:
|
|
case VET_DOUBLE3:
|
|
case VET_SHORT3:
|
|
case VET_USHORT3:
|
|
case VET_INT3:
|
|
case VET_UINT3:
|
|
return 3;
|
|
case VET_FLOAT4:
|
|
case VET_DOUBLE4:
|
|
case VET_SHORT4:
|
|
case VET_USHORT4:
|
|
case VET_INT4:
|
|
case VET_UINT4:
|
|
case VET_UBYTE4:
|
|
return 4;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t VertexElement::TypeSize(Type type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case VET_COLOUR:
|
|
case VET_COLOUR_ABGR:
|
|
case VET_COLOUR_ARGB:
|
|
return sizeof(unsigned int);
|
|
case VET_FLOAT1:
|
|
return sizeof(float);
|
|
case VET_FLOAT2:
|
|
return sizeof(float)*2;
|
|
case VET_FLOAT3:
|
|
return sizeof(float)*3;
|
|
case VET_FLOAT4:
|
|
return sizeof(float)*4;
|
|
case VET_DOUBLE1:
|
|
return sizeof(double);
|
|
case VET_DOUBLE2:
|
|
return sizeof(double)*2;
|
|
case VET_DOUBLE3:
|
|
return sizeof(double)*3;
|
|
case VET_DOUBLE4:
|
|
return sizeof(double)*4;
|
|
case VET_SHORT1:
|
|
return sizeof(short);
|
|
case VET_SHORT2:
|
|
return sizeof(short)*2;
|
|
case VET_SHORT3:
|
|
return sizeof(short)*3;
|
|
case VET_SHORT4:
|
|
return sizeof(short)*4;
|
|
case VET_USHORT1:
|
|
return sizeof(unsigned short);
|
|
case VET_USHORT2:
|
|
return sizeof(unsigned short)*2;
|
|
case VET_USHORT3:
|
|
return sizeof(unsigned short)*3;
|
|
case VET_USHORT4:
|
|
return sizeof(unsigned short)*4;
|
|
case VET_INT1:
|
|
return sizeof(int);
|
|
case VET_INT2:
|
|
return sizeof(int)*2;
|
|
case VET_INT3:
|
|
return sizeof(int)*3;
|
|
case VET_INT4:
|
|
return sizeof(int)*4;
|
|
case VET_UINT1:
|
|
return sizeof(unsigned int);
|
|
case VET_UINT2:
|
|
return sizeof(unsigned int)*2;
|
|
case VET_UINT3:
|
|
return sizeof(unsigned int)*3;
|
|
case VET_UINT4:
|
|
return sizeof(unsigned int)*4;
|
|
case VET_UBYTE4:
|
|
return sizeof(unsigned char)*4;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
std::string VertexElement::TypeToString()
|
|
{
|
|
return TypeToString(type);
|
|
}
|
|
|
|
std::string VertexElement::TypeToString(Type type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case VET_COLOUR: return "COLOUR";
|
|
case VET_COLOUR_ABGR: return "COLOUR_ABGR";
|
|
case VET_COLOUR_ARGB: return "COLOUR_ARGB";
|
|
case VET_FLOAT1: return "FLOAT1";
|
|
case VET_FLOAT2: return "FLOAT2";
|
|
case VET_FLOAT3: return "FLOAT3";
|
|
case VET_FLOAT4: return "FLOAT4";
|
|
case VET_DOUBLE1: return "DOUBLE1";
|
|
case VET_DOUBLE2: return "DOUBLE2";
|
|
case VET_DOUBLE3: return "DOUBLE3";
|
|
case VET_DOUBLE4: return "DOUBLE4";
|
|
case VET_SHORT1: return "SHORT1";
|
|
case VET_SHORT2: return "SHORT2";
|
|
case VET_SHORT3: return "SHORT3";
|
|
case VET_SHORT4: return "SHORT4";
|
|
case VET_USHORT1: return "USHORT1";
|
|
case VET_USHORT2: return "USHORT2";
|
|
case VET_USHORT3: return "USHORT3";
|
|
case VET_USHORT4: return "USHORT4";
|
|
case VET_INT1: return "INT1";
|
|
case VET_INT2: return "INT2";
|
|
case VET_INT3: return "INT3";
|
|
case VET_INT4: return "INT4";
|
|
case VET_UINT1: return "UINT1";
|
|
case VET_UINT2: return "UINT2";
|
|
case VET_UINT3: return "UINT3";
|
|
case VET_UINT4: return "UINT4";
|
|
case VET_UBYTE4: return "UBYTE4";
|
|
}
|
|
return "Uknown_VertexElement::Type";
|
|
}
|
|
|
|
std::string VertexElement::SemanticToString()
|
|
{
|
|
return SemanticToString(semantic);
|
|
}
|
|
|
|
std::string VertexElement::SemanticToString(Semantic semantic)
|
|
{
|
|
switch(semantic)
|
|
{
|
|
case VES_POSITION: return "POSITION";
|
|
case VES_BLEND_WEIGHTS: return "BLEND_WEIGHTS";
|
|
case VES_BLEND_INDICES: return "BLEND_INDICES";
|
|
case VES_NORMAL: return "NORMAL";
|
|
case VES_DIFFUSE: return "DIFFUSE";
|
|
case VES_SPECULAR: return "SPECULAR";
|
|
case VES_TEXTURE_COORDINATES: return "TEXTURE_COORDINATES";
|
|
case VES_BINORMAL: return "BINORMAL";
|
|
case VES_TANGENT: return "TANGENT";
|
|
}
|
|
return "Uknown_VertexElement::Semantic";
|
|
}
|
|
|
|
// IVertexData
|
|
|
|
IVertexData::IVertexData() :
|
|
count(0)
|
|
{
|
|
}
|
|
|
|
bool IVertexData::HasBoneAssignments() const
|
|
{
|
|
return !boneAssignments.empty();
|
|
}
|
|
|
|
void IVertexData::AddVertexMapping(uint32_t oldIndex, uint32_t newIndex)
|
|
{
|
|
BoneAssignmentsForVertex(oldIndex, newIndex, boneAssignmentsMap[newIndex]);
|
|
vertexIndexMapping[oldIndex].push_back(newIndex);
|
|
}
|
|
|
|
void IVertexData::BoneAssignmentsForVertex(uint32_t currentIndex, uint32_t newIndex, VertexBoneAssignmentList &dest) const
|
|
{
|
|
for (const auto &boneAssign : boneAssignments)
|
|
{
|
|
if (boneAssign.vertexIndex == currentIndex)
|
|
{
|
|
VertexBoneAssignment a = boneAssign;
|
|
a.vertexIndex = newIndex;
|
|
dest.push_back(a);
|
|
}
|
|
}
|
|
}
|
|
|
|
AssimpVertexBoneWeightList IVertexData::AssimpBoneWeights(size_t vertices)
|
|
{
|
|
AssimpVertexBoneWeightList weights;
|
|
for(size_t vi=0; vi<vertices; ++vi)
|
|
{
|
|
VertexBoneAssignmentList &vertexWeights = boneAssignmentsMap[static_cast<unsigned int>(vi)];
|
|
for (VertexBoneAssignmentList::const_iterator iter=vertexWeights.begin(), end=vertexWeights.end();
|
|
iter!=end; ++iter)
|
|
{
|
|
std::vector<aiVertexWeight> &boneWeights = weights[iter->boneIndex];
|
|
boneWeights.push_back(aiVertexWeight(static_cast<unsigned int>(vi), iter->weight));
|
|
}
|
|
}
|
|
return weights;
|
|
}
|
|
|
|
std::set<uint16_t> IVertexData::ReferencedBonesByWeights() const
|
|
{
|
|
std::set<uint16_t> referenced;
|
|
for (const auto &boneAssign : boneAssignments)
|
|
{
|
|
referenced.insert(boneAssign.boneIndex);
|
|
}
|
|
return referenced;
|
|
}
|
|
|
|
// VertexData
|
|
|
|
VertexData::VertexData()
|
|
{
|
|
}
|
|
|
|
VertexData::~VertexData()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void VertexData::Reset()
|
|
{
|
|
// Releases shared ptr memory streams.
|
|
vertexBindings.clear();
|
|
vertexElements.clear();
|
|
}
|
|
|
|
uint32_t VertexData::VertexSize(uint16_t source) const
|
|
{
|
|
uint32_t size = 0;
|
|
for(const auto &element : vertexElements)
|
|
{
|
|
if (element.source == source)
|
|
size += static_cast<uint32_t>(element.Size());
|
|
}
|
|
return size;
|
|
}
|
|
|
|
MemoryStream *VertexData::VertexBuffer(uint16_t source)
|
|
{
|
|
if (vertexBindings.find(source) != vertexBindings.end())
|
|
return vertexBindings[source].get();
|
|
return 0;
|
|
}
|
|
|
|
VertexElement *VertexData::GetVertexElement(VertexElement::Semantic semantic, uint16_t index)
|
|
{
|
|
for(auto & element : vertexElements)
|
|
{
|
|
if (element.semantic == semantic && element.index == index)
|
|
return &element;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// VertexDataXml
|
|
|
|
VertexDataXml::VertexDataXml()
|
|
{
|
|
}
|
|
|
|
bool VertexDataXml::HasPositions() const
|
|
{
|
|
return !positions.empty();
|
|
}
|
|
|
|
bool VertexDataXml::HasNormals() const
|
|
{
|
|
return !normals.empty();
|
|
}
|
|
|
|
bool VertexDataXml::HasTangents() const
|
|
{
|
|
return !tangents.empty();
|
|
}
|
|
|
|
bool VertexDataXml::HasUvs() const
|
|
{
|
|
return !uvs.empty();
|
|
}
|
|
|
|
size_t VertexDataXml::NumUvs() const
|
|
{
|
|
return uvs.size();
|
|
}
|
|
|
|
// IndexData
|
|
|
|
IndexData::IndexData() :
|
|
count(0),
|
|
faceCount(0),
|
|
is32bit(false)
|
|
{
|
|
}
|
|
|
|
IndexData::~IndexData()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void IndexData::Reset()
|
|
{
|
|
// Release shared ptr memory stream.
|
|
buffer.reset();
|
|
}
|
|
|
|
size_t IndexData::IndexSize() const
|
|
{
|
|
return (is32bit ? sizeof(uint32_t) : sizeof(uint16_t));
|
|
}
|
|
|
|
size_t IndexData::FaceSize() const
|
|
{
|
|
return IndexSize() * 3;
|
|
}
|
|
|
|
// Mesh
|
|
|
|
Mesh::Mesh()
|
|
: hasSkeletalAnimations(false)
|
|
, skeleton(NULL)
|
|
, sharedVertexData(NULL)
|
|
, subMeshes()
|
|
, animations()
|
|
, poses()
|
|
{
|
|
}
|
|
|
|
Mesh::~Mesh()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void Mesh::Reset()
|
|
{
|
|
OGRE_SAFE_DELETE(skeleton)
|
|
OGRE_SAFE_DELETE(sharedVertexData)
|
|
|
|
for(auto &mesh : subMeshes) {
|
|
OGRE_SAFE_DELETE(mesh)
|
|
}
|
|
subMeshes.clear();
|
|
for(auto &anim : animations) {
|
|
OGRE_SAFE_DELETE(anim)
|
|
}
|
|
animations.clear();
|
|
for(auto &pose : poses) {
|
|
OGRE_SAFE_DELETE(pose)
|
|
}
|
|
poses.clear();
|
|
}
|
|
|
|
size_t Mesh::NumSubMeshes() const
|
|
{
|
|
return subMeshes.size();
|
|
}
|
|
|
|
SubMesh *Mesh::GetSubMesh( size_t index ) const
|
|
{
|
|
for ( size_t i = 0; i < subMeshes.size(); ++i ) {
|
|
if ( subMeshes[ i ]->index == index ) {
|
|
return subMeshes[ i ];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Mesh::ConvertToAssimpScene(aiScene* dest)
|
|
{
|
|
if ( nullptr == dest ) {
|
|
return;
|
|
}
|
|
|
|
// Setup
|
|
dest->mNumMeshes = static_cast<unsigned int>(NumSubMeshes());
|
|
dest->mMeshes = new aiMesh*[dest->mNumMeshes];
|
|
|
|
// Create root node
|
|
dest->mRootNode = new aiNode();
|
|
dest->mRootNode->mNumMeshes = dest->mNumMeshes;
|
|
dest->mRootNode->mMeshes = new unsigned int[dest->mRootNode->mNumMeshes];
|
|
|
|
// Export meshes
|
|
for(size_t i=0; i<dest->mNumMeshes; ++i) {
|
|
dest->mMeshes[i] = subMeshes[i]->ConvertToAssimpMesh(this);
|
|
dest->mRootNode->mMeshes[i] = static_cast<unsigned int>(i);
|
|
}
|
|
|
|
// Export skeleton
|
|
if (skeleton)
|
|
{
|
|
// Bones
|
|
if (!skeleton->bones.empty())
|
|
{
|
|
BoneList rootBones = skeleton->RootBones();
|
|
dest->mRootNode->mNumChildren = static_cast<unsigned int>(rootBones.size());
|
|
dest->mRootNode->mChildren = new aiNode*[dest->mRootNode->mNumChildren];
|
|
|
|
for(size_t i=0, len=rootBones.size(); i<len; ++i)
|
|
{
|
|
dest->mRootNode->mChildren[i] = rootBones[i]->ConvertToAssimpNode(skeleton, dest->mRootNode);
|
|
}
|
|
}
|
|
|
|
// Animations
|
|
if (!skeleton->animations.empty())
|
|
{
|
|
dest->mNumAnimations = static_cast<unsigned int>(skeleton->animations.size());
|
|
dest->mAnimations = new aiAnimation*[dest->mNumAnimations];
|
|
|
|
for(size_t i=0, len=skeleton->animations.size(); i<len; ++i)
|
|
{
|
|
dest->mAnimations[i] = skeleton->animations[i]->ConvertToAssimpAnimation();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ISubMesh
|
|
|
|
ISubMesh::ISubMesh() :
|
|
index(0),
|
|
materialIndex(-1),
|
|
usesSharedVertexData(false),
|
|
operationType(OT_POINT_LIST)
|
|
{
|
|
}
|
|
|
|
// SubMesh
|
|
|
|
SubMesh::SubMesh() :
|
|
vertexData(0),
|
|
indexData(new IndexData())
|
|
{
|
|
}
|
|
|
|
SubMesh::~SubMesh()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void SubMesh::Reset()
|
|
{
|
|
OGRE_SAFE_DELETE(vertexData)
|
|
OGRE_SAFE_DELETE(indexData)
|
|
}
|
|
|
|
aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
|
|
{
|
|
if (operationType != OT_TRIANGLE_LIST) {
|
|
throw DeadlyImportError(Formatter::format() << "Only mesh operation type OT_TRIANGLE_LIST is supported. Found " << operationType);
|
|
}
|
|
|
|
aiMesh *dest = new aiMesh();
|
|
dest->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
|
|
|
|
if (!name.empty())
|
|
dest->mName = name;
|
|
|
|
// Material index
|
|
if (materialIndex != -1)
|
|
dest->mMaterialIndex = materialIndex;
|
|
|
|
// Pick source vertex data from shader geometry or from internal geometry.
|
|
VertexData *src = (!usesSharedVertexData ? vertexData : parent->sharedVertexData);
|
|
|
|
VertexElement *positionsElement = src->GetVertexElement(VertexElement::VES_POSITION);
|
|
VertexElement *normalsElement = src->GetVertexElement(VertexElement::VES_NORMAL);
|
|
VertexElement *uv1Element = src->GetVertexElement(VertexElement::VES_TEXTURE_COORDINATES, 0);
|
|
VertexElement *uv2Element = src->GetVertexElement(VertexElement::VES_TEXTURE_COORDINATES, 1);
|
|
|
|
// Sanity checks
|
|
if (!positionsElement) {
|
|
throw DeadlyImportError("Failed to import Ogre VertexElement::VES_POSITION. Mesh does not have vertex positions!");
|
|
} else if (positionsElement->type != VertexElement::VET_FLOAT3) {
|
|
throw DeadlyImportError("Ogre Mesh position vertex element type != VertexElement::VET_FLOAT3. This is not supported.");
|
|
} else if (normalsElement && normalsElement->type != VertexElement::VET_FLOAT3) {
|
|
throw DeadlyImportError("Ogre Mesh normal vertex element type != VertexElement::VET_FLOAT3. This is not supported.");
|
|
}
|
|
|
|
// Faces
|
|
dest->mNumFaces = indexData->faceCount;
|
|
dest->mFaces = new aiFace[dest->mNumFaces];
|
|
|
|
// Assimp required unique vertices, we need to convert from Ogres shared indexing.
|
|
size_t uniqueVertexCount = dest->mNumFaces * 3;
|
|
dest->mNumVertices = static_cast<unsigned int>(uniqueVertexCount);
|
|
dest->mVertices = new aiVector3D[dest->mNumVertices];
|
|
|
|
// Source streams
|
|
MemoryStream *positions = src->VertexBuffer(positionsElement->source);
|
|
MemoryStream *normals = (normalsElement ? src->VertexBuffer(normalsElement->source) : 0);
|
|
MemoryStream *uv1 = (uv1Element ? src->VertexBuffer(uv1Element->source) : 0);
|
|
MemoryStream *uv2 = (uv2Element ? src->VertexBuffer(uv2Element->source) : 0);
|
|
|
|
// Element size
|
|
const size_t sizePosition = positionsElement->Size();
|
|
const size_t sizeNormal = (normalsElement ? normalsElement->Size() : 0);
|
|
const size_t sizeUv1 = (uv1Element ? uv1Element->Size() : 0);
|
|
const size_t sizeUv2 = (uv2Element ? uv2Element->Size() : 0);
|
|
|
|
// Vertex width
|
|
const size_t vWidthPosition = src->VertexSize(positionsElement->source);
|
|
const size_t vWidthNormal = (normalsElement ? src->VertexSize(normalsElement->source) : 0);
|
|
const size_t vWidthUv1 = (uv1Element ? src->VertexSize(uv1Element->source) : 0);
|
|
const size_t vWidthUv2 = (uv2Element ? src->VertexSize(uv2Element->source) : 0);
|
|
|
|
bool boneAssignments = src->HasBoneAssignments();
|
|
|
|
// Prepare normals
|
|
if (normals)
|
|
dest->mNormals = new aiVector3D[dest->mNumVertices];
|
|
|
|
// Prepare UVs, ignoring incompatible UVs.
|
|
if (uv1)
|
|
{
|
|
if (uv1Element->type == VertexElement::VET_FLOAT2 || uv1Element->type == VertexElement::VET_FLOAT3)
|
|
{
|
|
dest->mNumUVComponents[0] = static_cast<unsigned int>(uv1Element->ComponentCount());
|
|
dest->mTextureCoords[0] = new aiVector3D[dest->mNumVertices];
|
|
}
|
|
else
|
|
{
|
|
DefaultLogger::get()->warn(Formatter::format() << "Ogre imported UV0 type " << uv1Element->TypeToString() << " is not compatible with Assimp. Ignoring UV.");
|
|
uv1 = 0;
|
|
}
|
|
}
|
|
if (uv2)
|
|
{
|
|
if (uv2Element->type == VertexElement::VET_FLOAT2 || uv2Element->type == VertexElement::VET_FLOAT3)
|
|
{
|
|
dest->mNumUVComponents[1] = static_cast<unsigned int>(uv2Element->ComponentCount());
|
|
dest->mTextureCoords[1] = new aiVector3D[dest->mNumVertices];
|
|
}
|
|
else
|
|
{
|
|
DefaultLogger::get()->warn(Formatter::format() << "Ogre imported UV0 type " << uv2Element->TypeToString() << " is not compatible with Assimp. Ignoring UV.");
|
|
uv2 = 0;
|
|
}
|
|
}
|
|
|
|
aiVector3D *uv1Dest = (uv1 ? dest->mTextureCoords[0] : 0);
|
|
aiVector3D *uv2Dest = (uv2 ? dest->mTextureCoords[1] : 0);
|
|
|
|
MemoryStream *faces = indexData->buffer.get();
|
|
for (size_t fi=0, isize=indexData->IndexSize(), fsize=indexData->FaceSize();
|
|
fi<dest->mNumFaces; ++fi)
|
|
{
|
|
// Source Ogre face
|
|
aiFace ogreFace;
|
|
ogreFace.mNumIndices = 3;
|
|
ogreFace.mIndices = new unsigned int[3];
|
|
|
|
faces->Seek(fi * fsize, aiOrigin_SET);
|
|
if (indexData->is32bit)
|
|
{
|
|
faces->Read(&ogreFace.mIndices[0], isize, 3);
|
|
}
|
|
else
|
|
{
|
|
uint16_t iout = 0;
|
|
for (size_t ii=0; ii<3; ++ii)
|
|
{
|
|
faces->Read(&iout, isize, 1);
|
|
ogreFace.mIndices[ii] = static_cast<unsigned int>(iout);
|
|
}
|
|
}
|
|
|
|
// Destination Assimp face
|
|
aiFace &face = dest->mFaces[fi];
|
|
face.mNumIndices = 3;
|
|
face.mIndices = new unsigned int[3];
|
|
|
|
const size_t pos = fi * 3;
|
|
for (size_t v=0; v<3; ++v)
|
|
{
|
|
const size_t newIndex = pos + v;
|
|
|
|
// Write face index
|
|
face.mIndices[v] = static_cast<unsigned int>(newIndex);
|
|
|
|
// Ogres vertex index to ref into the source buffers.
|
|
const size_t ogreVertexIndex = ogreFace.mIndices[v];
|
|
src->AddVertexMapping(static_cast<uint32_t>(ogreVertexIndex), static_cast<uint32_t>(newIndex));
|
|
|
|
// Position
|
|
positions->Seek((vWidthPosition * ogreVertexIndex) + positionsElement->offset, aiOrigin_SET);
|
|
positions->Read(&dest->mVertices[newIndex], sizePosition, 1);
|
|
|
|
// Normal
|
|
if (normals)
|
|
{
|
|
normals->Seek((vWidthNormal * ogreVertexIndex) + normalsElement->offset, aiOrigin_SET);
|
|
normals->Read(&dest->mNormals[newIndex], sizeNormal, 1);
|
|
}
|
|
// UV0
|
|
if (uv1 && uv1Dest)
|
|
{
|
|
uv1->Seek((vWidthUv1 * ogreVertexIndex) + uv1Element->offset, aiOrigin_SET);
|
|
uv1->Read(&uv1Dest[newIndex], sizeUv1, 1);
|
|
uv1Dest[newIndex].y = (uv1Dest[newIndex].y * -1) + 1; // Flip UV from Ogre to Assimp form
|
|
}
|
|
// UV1
|
|
if (uv2 && uv2Dest)
|
|
{
|
|
uv2->Seek((vWidthUv2 * ogreVertexIndex) + uv2Element->offset, aiOrigin_SET);
|
|
uv2->Read(&uv2Dest[newIndex], sizeUv2, 1);
|
|
uv2Dest[newIndex].y = (uv2Dest[newIndex].y * -1) + 1; // Flip UV from Ogre to Assimp form
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bones and bone weights
|
|
if (parent->skeleton && boneAssignments)
|
|
{
|
|
AssimpVertexBoneWeightList weights = src->AssimpBoneWeights(dest->mNumVertices);
|
|
std::set<uint16_t> referencedBones = src->ReferencedBonesByWeights();
|
|
|
|
dest->mNumBones = static_cast<unsigned int>(referencedBones.size());
|
|
dest->mBones = new aiBone*[dest->mNumBones];
|
|
|
|
size_t assimpBoneIndex = 0;
|
|
for(std::set<uint16_t>::const_iterator rbIter=referencedBones.begin(), rbEnd=referencedBones.end(); rbIter != rbEnd; ++rbIter, ++assimpBoneIndex)
|
|
{
|
|
Bone *bone = parent->skeleton->BoneById((*rbIter));
|
|
dest->mBones[assimpBoneIndex] = bone->ConvertToAssimpBone(parent->skeleton, weights[bone->id]);
|
|
}
|
|
}
|
|
|
|
return dest;
|
|
}
|
|
|
|
// MeshXml
|
|
|
|
MeshXml::MeshXml() :
|
|
skeleton(0),
|
|
sharedVertexData(0)
|
|
{
|
|
}
|
|
|
|
MeshXml::~MeshXml()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void MeshXml::Reset()
|
|
{
|
|
OGRE_SAFE_DELETE(skeleton)
|
|
OGRE_SAFE_DELETE(sharedVertexData)
|
|
|
|
for(auto &mesh : subMeshes) {
|
|
OGRE_SAFE_DELETE(mesh)
|
|
}
|
|
subMeshes.clear();
|
|
}
|
|
|
|
size_t MeshXml::NumSubMeshes() const
|
|
{
|
|
return subMeshes.size();
|
|
}
|
|
|
|
SubMeshXml *MeshXml::GetSubMesh(uint16_t index) const
|
|
{
|
|
for(size_t i=0; i<subMeshes.size(); ++i)
|
|
if (subMeshes[i]->index == index)
|
|
return subMeshes[i];
|
|
return 0;
|
|
}
|
|
|
|
void MeshXml::ConvertToAssimpScene(aiScene* dest)
|
|
{
|
|
// Setup
|
|
dest->mNumMeshes = static_cast<unsigned int>(NumSubMeshes());
|
|
dest->mMeshes = new aiMesh*[dest->mNumMeshes];
|
|
|
|
// Create root node
|
|
dest->mRootNode = new aiNode();
|
|
dest->mRootNode->mNumMeshes = dest->mNumMeshes;
|
|
dest->mRootNode->mMeshes = new unsigned int[dest->mRootNode->mNumMeshes];
|
|
|
|
// Export meshes
|
|
for(size_t i=0; i<dest->mNumMeshes; ++i)
|
|
{
|
|
dest->mMeshes[i] = subMeshes[i]->ConvertToAssimpMesh(this);
|
|
dest->mRootNode->mMeshes[i] = static_cast<unsigned int>(i);
|
|
}
|
|
|
|
// Export skeleton
|
|
if (skeleton)
|
|
{
|
|
// Bones
|
|
if (!skeleton->bones.empty())
|
|
{
|
|
BoneList rootBones = skeleton->RootBones();
|
|
dest->mRootNode->mNumChildren = static_cast<unsigned int>(rootBones.size());
|
|
dest->mRootNode->mChildren = new aiNode*[dest->mRootNode->mNumChildren];
|
|
|
|
for(size_t i=0, len=rootBones.size(); i<len; ++i)
|
|
{
|
|
dest->mRootNode->mChildren[i] = rootBones[i]->ConvertToAssimpNode(skeleton, dest->mRootNode);
|
|
}
|
|
}
|
|
|
|
// Animations
|
|
if (!skeleton->animations.empty())
|
|
{
|
|
dest->mNumAnimations = static_cast<unsigned int>(skeleton->animations.size());
|
|
dest->mAnimations = new aiAnimation*[dest->mNumAnimations];
|
|
|
|
for(size_t i=0, len=skeleton->animations.size(); i<len; ++i)
|
|
{
|
|
dest->mAnimations[i] = skeleton->animations[i]->ConvertToAssimpAnimation();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// SubMeshXml
|
|
|
|
SubMeshXml::SubMeshXml() :
|
|
indexData(new IndexDataXml()),
|
|
vertexData(0)
|
|
{
|
|
}
|
|
|
|
SubMeshXml::~SubMeshXml()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void SubMeshXml::Reset()
|
|
{
|
|
OGRE_SAFE_DELETE(indexData)
|
|
OGRE_SAFE_DELETE(vertexData)
|
|
}
|
|
|
|
aiMesh *SubMeshXml::ConvertToAssimpMesh(MeshXml *parent)
|
|
{
|
|
aiMesh *dest = new aiMesh();
|
|
dest->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
|
|
|
|
if (!name.empty())
|
|
dest->mName = name;
|
|
|
|
// Material index
|
|
if (materialIndex != -1)
|
|
dest->mMaterialIndex = materialIndex;
|
|
|
|
// Faces
|
|
dest->mNumFaces = indexData->faceCount;
|
|
dest->mFaces = new aiFace[dest->mNumFaces];
|
|
|
|
// Assimp required unique vertices, we need to convert from Ogres shared indexing.
|
|
size_t uniqueVertexCount = dest->mNumFaces * 3;
|
|
dest->mNumVertices = static_cast<unsigned int>(uniqueVertexCount);
|
|
dest->mVertices = new aiVector3D[dest->mNumVertices];
|
|
|
|
VertexDataXml *src = (!usesSharedVertexData ? vertexData : parent->sharedVertexData);
|
|
bool boneAssignments = src->HasBoneAssignments();
|
|
bool normals = src->HasNormals();
|
|
size_t uvs = src->NumUvs();
|
|
|
|
// Prepare normals
|
|
if (normals)
|
|
dest->mNormals = new aiVector3D[dest->mNumVertices];
|
|
|
|
// Prepare UVs
|
|
for(size_t uvi=0; uvi<uvs; ++uvi)
|
|
{
|
|
dest->mNumUVComponents[uvi] = 2;
|
|
dest->mTextureCoords[uvi] = new aiVector3D[dest->mNumVertices];
|
|
}
|
|
|
|
for (size_t fi=0; fi<dest->mNumFaces; ++fi)
|
|
{
|
|
// Source Ogre face
|
|
aiFace &ogreFace = indexData->faces[fi];
|
|
|
|
// Destination Assimp face
|
|
aiFace &face = dest->mFaces[fi];
|
|
face.mNumIndices = 3;
|
|
face.mIndices = new unsigned int[3];
|
|
|
|
const size_t pos = fi * 3;
|
|
for (size_t v=0; v<3; ++v)
|
|
{
|
|
const size_t newIndex = pos + v;
|
|
|
|
// Write face index
|
|
face.mIndices[v] = static_cast<unsigned int>(newIndex);
|
|
|
|
// Ogres vertex index to ref into the source buffers.
|
|
const size_t ogreVertexIndex = ogreFace.mIndices[v];
|
|
src->AddVertexMapping(static_cast<uint32_t>(ogreVertexIndex), static_cast<uint32_t>(newIndex));
|
|
|
|
// Position
|
|
dest->mVertices[newIndex] = src->positions[ogreVertexIndex];
|
|
|
|
// Normal
|
|
if (normals)
|
|
dest->mNormals[newIndex] = src->normals[ogreVertexIndex];
|
|
|
|
// UVs
|
|
for(size_t uvi=0; uvi<uvs; ++uvi)
|
|
{
|
|
aiVector3D *uvDest = dest->mTextureCoords[uvi];
|
|
std::vector<aiVector3D> &uvSrc = src->uvs[uvi];
|
|
uvDest[newIndex] = uvSrc[ogreVertexIndex];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bones and bone weights
|
|
if (parent->skeleton && boneAssignments)
|
|
{
|
|
AssimpVertexBoneWeightList weights = src->AssimpBoneWeights(dest->mNumVertices);
|
|
std::set<uint16_t> referencedBones = src->ReferencedBonesByWeights();
|
|
|
|
dest->mNumBones = static_cast<unsigned int>(referencedBones.size());
|
|
dest->mBones = new aiBone*[dest->mNumBones];
|
|
|
|
size_t assimpBoneIndex = 0;
|
|
for(std::set<uint16_t>::const_iterator rbIter=referencedBones.begin(), rbEnd=referencedBones.end(); rbIter != rbEnd; ++rbIter, ++assimpBoneIndex)
|
|
{
|
|
Bone *bone = parent->skeleton->BoneById((*rbIter));
|
|
dest->mBones[assimpBoneIndex] = bone->ConvertToAssimpBone(parent->skeleton, weights[bone->id]);
|
|
}
|
|
}
|
|
|
|
return dest;
|
|
}
|
|
|
|
// Animation
|
|
|
|
Animation::Animation(Skeleton *parent) :
|
|
parentMesh(NULL),
|
|
parentSkeleton(parent),
|
|
length(0.0f),
|
|
baseTime(-1.0f)
|
|
{
|
|
}
|
|
|
|
Animation::Animation(Mesh *parent) :
|
|
parentMesh(parent),
|
|
parentSkeleton(0),
|
|
length(0.0f),
|
|
baseTime(-1.0f)
|
|
{
|
|
}
|
|
|
|
VertexData *Animation::AssociatedVertexData(VertexAnimationTrack *track) const
|
|
{
|
|
if (!parentMesh)
|
|
return 0;
|
|
|
|
bool sharedGeom = (track->target == 0);
|
|
if (sharedGeom)
|
|
return parentMesh->sharedVertexData;
|
|
else
|
|
return parentMesh->GetSubMesh(track->target-1)->vertexData;
|
|
}
|
|
|
|
aiAnimation *Animation::ConvertToAssimpAnimation()
|
|
{
|
|
aiAnimation *anim = new aiAnimation();
|
|
anim->mName = name;
|
|
anim->mDuration = static_cast<double>(length);
|
|
anim->mTicksPerSecond = 1.0;
|
|
|
|
// Tracks
|
|
if (!tracks.empty())
|
|
{
|
|
anim->mNumChannels = static_cast<unsigned int>(tracks.size());
|
|
anim->mChannels = new aiNodeAnim*[anim->mNumChannels];
|
|
|
|
for(size_t i=0, len=tracks.size(); i<len; ++i)
|
|
{
|
|
anim->mChannels[i] = tracks[i].ConvertToAssimpAnimationNode(parentSkeleton);
|
|
}
|
|
}
|
|
return anim;
|
|
}
|
|
|
|
// Skeleton
|
|
|
|
Skeleton::Skeleton() :
|
|
bones(),
|
|
animations(),
|
|
blendMode(ANIMBLEND_AVERAGE)
|
|
{
|
|
}
|
|
|
|
Skeleton::~Skeleton()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void Skeleton::Reset()
|
|
{
|
|
for(auto &bone : bones) {
|
|
OGRE_SAFE_DELETE(bone)
|
|
}
|
|
bones.clear();
|
|
for(auto &anim : animations) {
|
|
OGRE_SAFE_DELETE(anim)
|
|
}
|
|
animations.clear();
|
|
}
|
|
|
|
BoneList Skeleton::RootBones() const
|
|
{
|
|
BoneList rootBones;
|
|
for(BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter)
|
|
{
|
|
if (!(*iter)->IsParented())
|
|
rootBones.push_back((*iter));
|
|
}
|
|
return rootBones;
|
|
}
|
|
|
|
size_t Skeleton::NumRootBones() const
|
|
{
|
|
size_t num = 0;
|
|
for(BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter)
|
|
{
|
|
if (!(*iter)->IsParented())
|
|
num++;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
Bone *Skeleton::BoneByName(const std::string &name) const
|
|
{
|
|
for(BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter)
|
|
{
|
|
if ((*iter)->name == name)
|
|
return (*iter);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Bone *Skeleton::BoneById(uint16_t id) const
|
|
{
|
|
for(BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter)
|
|
{
|
|
if ((*iter)->id == id)
|
|
return (*iter);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Bone
|
|
|
|
Bone::Bone() :
|
|
id(0),
|
|
parent(0),
|
|
parentId(-1),
|
|
scale(1.0f, 1.0f, 1.0f)
|
|
{
|
|
}
|
|
|
|
bool Bone::IsParented() const
|
|
{
|
|
return (parentId != -1 && parent != 0);
|
|
}
|
|
|
|
uint16_t Bone::ParentId() const
|
|
{
|
|
return static_cast<uint16_t>(parentId);
|
|
}
|
|
|
|
void Bone::AddChild(Bone *bone)
|
|
{
|
|
if (!bone)
|
|
return;
|
|
if (bone->IsParented())
|
|
throw DeadlyImportError("Attaching child Bone that is already parented: " + bone->name);
|
|
|
|
bone->parent = this;
|
|
bone->parentId = id;
|
|
children.push_back(bone->id);
|
|
}
|
|
|
|
void Bone::CalculateWorldMatrixAndDefaultPose(Skeleton *skeleton)
|
|
{
|
|
if (!IsParented())
|
|
worldMatrix = aiMatrix4x4(scale, rotation, position).Inverse();
|
|
else
|
|
worldMatrix = aiMatrix4x4(scale, rotation, position).Inverse() * parent->worldMatrix;
|
|
|
|
defaultPose = aiMatrix4x4(scale, rotation, position);
|
|
|
|
// Recursively for all children now that the parent matrix has been calculated.
|
|
for (auto boneId : children)
|
|
{
|
|
Bone *child = skeleton->BoneById(boneId);
|
|
if (!child) {
|
|
throw DeadlyImportError(Formatter::format() << "CalculateWorldMatrixAndDefaultPose: Failed to find child bone " << boneId << " for parent " << id << " " << name);
|
|
}
|
|
child->CalculateWorldMatrixAndDefaultPose(skeleton);
|
|
}
|
|
}
|
|
|
|
aiNode *Bone::ConvertToAssimpNode(Skeleton *skeleton, aiNode *parentNode)
|
|
{
|
|
// Bone node
|
|
aiNode* node = new aiNode(name);
|
|
node->mParent = parentNode;
|
|
node->mTransformation = defaultPose;
|
|
|
|
// Children
|
|
if (!children.empty())
|
|
{
|
|
node->mNumChildren = static_cast<unsigned int>(children.size());
|
|
node->mChildren = new aiNode*[node->mNumChildren];
|
|
|
|
for(size_t i=0, len=children.size(); i<len; ++i)
|
|
{
|
|
Bone *child = skeleton->BoneById(children[i]);
|
|
if (!child) {
|
|
throw DeadlyImportError(Formatter::format() << "ConvertToAssimpNode: Failed to find child bone " << children[i] << " for parent " << id << " " << name);
|
|
}
|
|
node->mChildren[i] = child->ConvertToAssimpNode(skeleton, node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
|
|
aiBone *Bone::ConvertToAssimpBone(Skeleton * /*parent*/, const std::vector<aiVertexWeight> &boneWeights)
|
|
{
|
|
aiBone *bone = new aiBone();
|
|
bone->mName = name;
|
|
bone->mOffsetMatrix = worldMatrix;
|
|
|
|
if (!boneWeights.empty())
|
|
{
|
|
bone->mNumWeights = static_cast<unsigned int>(boneWeights.size());
|
|
bone->mWeights = new aiVertexWeight[boneWeights.size()];
|
|
memcpy(bone->mWeights, &boneWeights[0], boneWeights.size() * sizeof(aiVertexWeight));
|
|
}
|
|
|
|
return bone;
|
|
}
|
|
|
|
// VertexAnimationTrack
|
|
|
|
VertexAnimationTrack::VertexAnimationTrack() :
|
|
type(VAT_NONE),
|
|
target(0)
|
|
{
|
|
}
|
|
|
|
aiNodeAnim *VertexAnimationTrack::ConvertToAssimpAnimationNode(Skeleton *skeleton)
|
|
{
|
|
if (boneName.empty() || type != VAT_TRANSFORM) {
|
|
throw DeadlyImportError("VertexAnimationTrack::ConvertToAssimpAnimationNode: Cannot convert track that has no target bone name or is not type of VAT_TRANSFORM");
|
|
}
|
|
|
|
aiNodeAnim *nodeAnim = new aiNodeAnim();
|
|
nodeAnim->mNodeName = boneName;
|
|
|
|
Bone *bone = skeleton->BoneByName(boneName);
|
|
if (!bone) {
|
|
throw DeadlyImportError("VertexAnimationTrack::ConvertToAssimpAnimationNode: Failed to find bone " + boneName + " from parent Skeleton");
|
|
}
|
|
|
|
// Keyframes
|
|
size_t numKeyframes = transformKeyFrames.size();
|
|
|
|
nodeAnim->mPositionKeys = new aiVectorKey[numKeyframes];
|
|
nodeAnim->mRotationKeys = new aiQuatKey[numKeyframes];
|
|
nodeAnim->mScalingKeys = new aiVectorKey[numKeyframes];
|
|
nodeAnim->mNumPositionKeys = static_cast<unsigned int>(numKeyframes);
|
|
nodeAnim->mNumRotationKeys = static_cast<unsigned int>(numKeyframes);
|
|
nodeAnim->mNumScalingKeys = static_cast<unsigned int>(numKeyframes);
|
|
|
|
for(size_t kfi=0; kfi<numKeyframes; ++kfi)
|
|
{
|
|
TransformKeyFrame &kfSource = transformKeyFrames[kfi];
|
|
|
|
// Calculate the complete transformation from world space to bone space
|
|
aiVector3D pos; aiQuaternion rot; aiVector3D scale;
|
|
|
|
aiMatrix4x4 finalTransform = bone->defaultPose * kfSource.Transform();
|
|
finalTransform.Decompose(scale, rot, pos);
|
|
|
|
double t = static_cast<double>(kfSource.timePos);
|
|
nodeAnim->mPositionKeys[kfi].mTime = t;
|
|
nodeAnim->mRotationKeys[kfi].mTime = t;
|
|
nodeAnim->mScalingKeys[kfi].mTime = t;
|
|
|
|
nodeAnim->mPositionKeys[kfi].mValue = pos;
|
|
nodeAnim->mRotationKeys[kfi].mValue = rot;
|
|
nodeAnim->mScalingKeys[kfi].mValue = scale;
|
|
}
|
|
|
|
return nodeAnim;
|
|
}
|
|
|
|
// TransformKeyFrame
|
|
|
|
TransformKeyFrame::TransformKeyFrame() :
|
|
timePos(0.0f),
|
|
scale(1.0f, 1.0f, 1.0f)
|
|
{
|
|
}
|
|
|
|
aiMatrix4x4 TransformKeyFrame::Transform()
|
|
{
|
|
return aiMatrix4x4(scale, rotation, position);
|
|
}
|
|
|
|
} // Ogre
|
|
} // Assimp
|
|
|
|
#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
|