configRecomputeNormals = (pImp->GetPropertyInteger(

AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS, 1) ?

true :

false);

noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;

aiScene *pScene, IOSystem *pIOHandler) {

std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));

// Check whether we can read from the file

if (file == nullptr) {

throw DeadlyImportError("Failed to open ASE file ", pFile, ".");

}

// Allocate storage and copy the contents of the file to a memory buffer

std::vector<char> mBuffer2;

TextFileToBuffer(file.get(), mBuffer2);

const size_t fileSize = mBuffer2.size();

this->mBuffer = &mBuffer2[0];

this->pcScene = pScene;

// ------------------------------------------------------------------

// Guess the file format by looking at the extension

// ASC is considered to be the older format 110,

// ASE is the actual version 200 (that is currently written by max)

// ------------------------------------------------------------------

unsigned int defaultFormat;

std::string::size_type s = pFile.length() - 1;

switch (pFile.c_str()[s]) {

case 'C':

case 'c':

defaultFormat = AI_ASE_OLD_FILE_FORMAT;

break;

default:

defaultFormat = AI_ASE_NEW_FILE_FORMAT;

};

// Construct an ASE parser and parse the file

ASE::Parser parser(mBuffer, fileSize, defaultFormat);

mParser = &parser;

mParser->Parse();

//------------------------------------------------------------------

// Check whether we god at least one mesh. If we did - generate

// materials and copy meshes.

// ------------------------------------------------------------------

if (!mParser->m_vMeshes.empty()) {

// If absolutely no material has been loaded from the file

// we need to generate a default material

GenerateDefaultMaterial();

// process all meshes

bool tookNormals = false;

std::vector<aiMesh *> avOutMeshes;

avOutMeshes.reserve(mParser->m_vMeshes.size() * 2);

for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) {

if ((*i).bSkip) {

continue;

}

BuildUniqueRepresentation(*i);

// Need to generate proper vertex normals if necessary

if (GenerateNormals(*i)) {

tookNormals = true;

}

// Convert all meshes to aiMesh objects

ConvertMeshes(*i, avOutMeshes);

}

if (tookNormals) {

ASSIMP_LOG_DEBUG("ASE: Taking normals from the file. Use "

"the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you "

"experience problems");

}

// Now build the output mesh list. Remove dummies

pScene->mNumMeshes = (unsigned int)avOutMeshes.size();

aiMesh **pp = pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];

for (std::vector<aiMesh *>::const_iterator i = avOutMeshes.begin(); i != avOutMeshes.end(); ++i) {

if (!(*i)->mNumFaces) {

continue;

}

*pp++ = *i;

}

pScene->mNumMeshes = (unsigned int)(pp - pScene->mMeshes);

// Build final material indices (remove submaterials and setup

// the final list)

BuildMaterialIndices();

}

// ------------------------------------------------------------------

// Copy all scene graph nodes - lights, cameras, dummies and meshes

// into one huge list.

//------------------------------------------------------------------

std::vector<BaseNode *> nodes;

nodes.reserve(mParser->m_vMeshes.size() + mParser->m_vLights.size() + mParser->m_vCameras.size() + mParser->m_vDummies.size());

// Lights

for (auto &light : mParser->m_vLights)

nodes.push_back(&light);

// Cameras

for (auto &camera : mParser->m_vCameras)

nodes.push_back(&camera);

// Meshes

for (auto &mesh : mParser->m_vMeshes)

nodes.push_back(&mesh);

// Dummies

for (auto &dummy : mParser->m_vDummies)

nodes.push_back(&dummy);

// build the final node graph

BuildNodes(nodes);

// build output animations

BuildAnimations(nodes);

// build output cameras

BuildCameras();

// build output lights

BuildLights();

// ------------------------------------------------------------------

// If we have no meshes use the SkeletonMeshBuilder helper class

// to build a mesh for the animation skeleton

// FIXME: very strange results

// ------------------------------------------------------------------

if (!pScene->mNumMeshes) {

pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;

if (!noSkeletonMesh) {

SkeletonMeshBuilder skeleton(pScene);

}

}

ai_assert(nullptr != mParser);

bool bHas = false;

for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) {

if ((*i).bSkip) continue;

if (ASE::Face::DEFAULT_MATINDEX == (*i).iMaterialIndex) {

(*i).iMaterialIndex = (unsigned int)mParser->m_vMaterials.size();

bHas = true;

}

}

if (bHas || mParser->m_vMaterials.empty()) {

// add a simple material without submaterials to the parser's list

mParser->m_vMaterials.emplace_back(AI_DEFAULT_MATERIAL_NAME);

ASE::Material &mat = mParser->m_vMaterials.back();

mat.mDiffuse = aiColor3D(0.6f, 0.6f, 0.6f);

mat.mSpecular = aiColor3D(1.0f, 1.0f, 1.0f);

mat.mAmbient = aiColor3D(0.05f, 0.05f, 0.05f);

mat.mShading = Discreet3DS::Gouraud;

}

// check whether we have at least one mesh which has animations

std::vector<ASE::BaseNode *>::const_iterator i = nodes.begin();

unsigned int iNum = 0;

for (; i != nodes.end(); ++i) {

// TODO: Implement Bezier & TCB support

if ((*i)->mAnim.mPositionType != ASE::Animation::TRACK) {

ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "

"This is not supported.");

}

if ((*i)->mAnim.mRotationType != ASE::Animation::TRACK) {

ASSIMP_LOG_WARN("ASE: Rotation controller uses Bezier/TCB keys. "

"This is not supported.");

}

if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK) {

ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "

"This is not supported.");

}

// We compare against 1 here - firstly one key is not

// really an animation and secondly MAX writes dummies

// that represent the node transformation.

if ((*i)->mAnim.akeyPositions.size() > 1 || (*i)->mAnim.akeyRotations.size() > 1 || (*i)->mAnim.akeyScaling.size() > 1) {

++iNum;

}

if ((*i)->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan((*i)->mTargetPosition.x)) {

++iNum;

}

}

if (iNum) {

// Generate a new animation channel and setup everything for it

pcScene->mNumAnimations = 1;

pcScene->mAnimations = new aiAnimation *[1];

aiAnimation *pcAnim = pcScene->mAnimations[0] = new aiAnimation();

pcAnim->mNumChannels = iNum;

pcAnim->mChannels = new aiNodeAnim *[iNum];

pcAnim->mTicksPerSecond = mParser->iFrameSpeed * mParser->iTicksPerFrame;

iNum = 0;

// Now iterate through all meshes and collect all data we can find

for (i = nodes.begin(); i != nodes.end(); ++i) {

ASE::BaseNode *me = *i;

if (me->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan(me->mTargetPosition.x)) {

// Generate an extra channel for the camera/light target.

// BuildNodes() does also generate an extra node, named

// <baseName>.Target.

aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();

nd->mNodeName.Set(me->mName + ".Target");

// Allocate the key array and fill it

nd->mNumPositionKeys = (unsigned int)me->mTargetAnim.akeyPositions.size();

nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];

::memcpy(nd->mPositionKeys, &me->mTargetAnim.akeyPositions[0],

nd->mNumPositionKeys * sizeof(aiVectorKey));

}

if (me->mAnim.akeyPositions.size() > 1 || me->mAnim.akeyRotations.size() > 1 || me->mAnim.akeyScaling.size() > 1) {

// Begin a new node animation channel for this node

aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();

nd->mNodeName.Set(me->mName);

// copy position keys

if (me->mAnim.akeyPositions.size() > 1) {

// Allocate the key array and fill it

nd->mNumPositionKeys = (unsigned int)me->mAnim.akeyPositions.size();

nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];

::memcpy(nd->mPositionKeys, &me->mAnim.akeyPositions[0],

nd->mNumPositionKeys * sizeof(aiVectorKey));

}

// copy rotation keys

if (me->mAnim.akeyRotations.size() > 1) {

// Allocate the key array and fill it

nd->mNumRotationKeys = (unsigned int)me->mAnim.akeyRotations.size();

nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];

// --------------------------------------------------------------------

// Rotation keys are offsets to the previous keys.

// We have the quaternion representations of all

// of them, so we just need to concatenate all

// (unit-length) quaternions to get the absolute

// rotations.

// Rotation keys are ABSOLUTE for older files

// --------------------------------------------------------------------

aiQuaternion cur;

for (unsigned int a = 0; a < nd->mNumRotationKeys; ++a) {

aiQuatKey q = me->mAnim.akeyRotations[a];

if (mParser->iFileFormat > 110) {

cur = (a ? cur * q.mValue : q.mValue);

q.mValue = cur.Normalize();

}

nd->mRotationKeys[a] = q;

// need this to get to Assimp quaternion conventions

nd->mRotationKeys[a].mValue.w *= -1.f;

}

}

// copy scaling keys

if (me->mAnim.akeyScaling.size() > 1) {

// Allocate the key array and fill it

nd->mNumScalingKeys = (unsigned int)me->mAnim.akeyScaling.size();

nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];

::memcpy(nd->mScalingKeys, &me->mAnim.akeyScaling[0],

nd->mNumScalingKeys * sizeof(aiVectorKey));

}

}

}

}

if (!mParser->m_vCameras.empty()) {

pcScene->mNumCameras = (unsigned int)mParser->m_vCameras.size();

pcScene->mCameras = new aiCamera *[pcScene->mNumCameras];

for (unsigned int i = 0; i < pcScene->mNumCameras; ++i) {

aiCamera *out = pcScene->mCameras[i] = new aiCamera();

ASE::Camera &in = mParser->m_vCameras[i];

// copy members

out->mClipPlaneFar = in.mFar;

out->mClipPlaneNear = (in.mNear ? in.mNear : 0.1f);

out->mHorizontalFOV = in.mFOV;

out->mName.Set(in.mName);

}

}

if (!mParser->m_vLights.empty()) {

pcScene->mNumLights = (unsigned int)mParser->m_vLights.size();

pcScene->mLights = new aiLight *[pcScene->mNumLights];

for (unsigned int i = 0; i < pcScene->mNumLights; ++i) {

aiLight *out = pcScene->mLights[i] = new aiLight();

ASE::Light &in = mParser->m_vLights[i];

// The direction is encoded in the transformation matrix of the node.

// In 3DS MAX the light source points into negative Z direction if

// the node transformation is the identity.

out->mDirection = aiVector3D(0.f, 0.f, -1.f);

out->mName.Set(in.mName);

switch (in.mLightType) {

case ASE::Light::TARGET:

out->mType = aiLightSource_SPOT;

out->mAngleInnerCone = AI_DEG_TO_RAD(in.mAngle);

out->mAngleOuterCone = (in.mFalloff ? AI_DEG_TO_RAD(in.mFalloff) : out->mAngleInnerCone);

break;

case ASE::Light::DIRECTIONAL:

out->mType = aiLightSource_DIRECTIONAL;

break;

default:

//case ASE::Light::OMNI:

out->mType = aiLightSource_POINT;

break;

};

out->mColorDiffuse = out->mColorSpecular = in.mColor * in.mIntensity;

}

}

for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {

// Get the name of the mesh (the mesh instance has been temporarily stored in the third vertex color)

const aiMesh *pcMesh = pcScene->mMeshes[i];

const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2];

if (mesh == snode) {

++node->mNumMeshes;

}

}

if (node->mNumMeshes) {

node->mMeshes = new unsigned int[node->mNumMeshes];

for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes; ++i) {

const aiMesh *pcMesh = pcScene->mMeshes[i];

const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2];

if (mesh == snode) {

node->mMeshes[p++] = i;

// Transform all vertices of the mesh back into their local space ->

// at the moment they are pretransformed

aiMatrix4x4 m = mesh->mTransform;

m.Inverse();

aiVector3D *pvCurPtr = pcMesh->mVertices;

const aiVector3D *pvEndPtr = pvCurPtr + pcMesh->mNumVertices;

while (pvCurPtr != pvEndPtr) {

*pvCurPtr = m * (*pvCurPtr);

pvCurPtr++;

}

// Do the same for the normal vectors, if we have them.

// As always, inverse transpose.

if (pcMesh->mNormals) {

aiMatrix3x3 m3 = aiMatrix3x3(mesh->mTransform);

m3.Transpose();

pvCurPtr = pcMesh->mNormals;

pvEndPtr = pvCurPtr + pcMesh->mNumVertices;

while (pvCurPtr != pvEndPtr) {

*pvCurPtr = m3 * (*pvCurPtr);

pvCurPtr++;

}

}

}

}

}

const aiMatrix4x4 &mat) {

const size_t len = name.size();

ai_assert(4 <= AI_MAX_NUMBER_OF_COLOR_SETS);

// Receives child nodes for the pcParent node

std::vector<aiNode *> apcNodes;

// Now iterate through all nodes in the scene and search for one

// which has *us* as parent.

for (std::vector<BaseNode *>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {

const BaseNode *snode = *it;

if (!name.empty()) {

if (len != snode->mParent.length() || name != snode->mParent.c_str()) {

continue;

}

} else if (snode->mParent.length()) {

continue;

}

(*it)->mProcessed = true;

// Allocate a new node and add it to the output data structure

apcNodes.push_back(new aiNode);

aiNode *node = apcNodes.back();

node->mName.Set((snode->mName.length() ? snode->mName.c_str() : "Unnamed_Node"));

node->mParent = pcParent;

// Setup the transformation matrix of the node

aiMatrix4x4 mParentAdjust = mat;

mParentAdjust.Inverse();

node->mTransformation = mParentAdjust * snode->mTransform;

// Add sub nodes - prevent stack overflow due to recursive parenting

if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName) {

AddNodes(nodes, node, node->mName.C_Str(), snode->mTransform);

}

// Further processing depends on the type of the node

if (snode->mType == ASE::BaseNode::Mesh) {

// If the type of this node is "Mesh" we need to search

// the list of output meshes in the data structure for

// all those that belonged to this node once. This is

// slightly inconvinient here and a better solution should

// be used when this code is refactored next.

AddMeshes(snode, node);

} else if (is_not_qnan(snode->mTargetPosition.x)) {

// If this is a target camera or light we generate a small

// child node which marks the position of the camera

// target (the direction information is contained in *this*

// node's animation track but the exact target position

// would be lost otherwise)

if (!node->mNumChildren) {

node->mChildren = new aiNode *[1];

}

aiNode *nd = new aiNode();

nd->mName.Set(snode->mName + ".Target");

nd->mTransformation.a4 = snode->mTargetPosition.x - snode->mTransform.a4;

nd->mTransformation.b4 = snode->mTargetPosition.y - snode->mTransform.b4;

nd->mTransformation.c4 = snode->mTargetPosition.z - snode->mTransform.c4;

nd->mParent = node;

// The .Target node is always the first child node

for (unsigned int m = 0; m < node->mNumChildren; ++m)

node->mChildren[m + 1] = node->mChildren[m];

node->mChildren[0] = nd;

node->mNumChildren++;

// What we did is so great, it is at least worth a debug message

ASSIMP_LOG_VERBOSE_DEBUG("ASE: Generating separate target node (", snode->mName, ")");

}

}

// Allocate enough space for the child nodes

// We allocate one slot more in case this is a target camera/light

pcParent->mNumChildren = (unsigned int)apcNodes.size();

if (pcParent->mNumChildren) {

pcParent->mChildren = new aiNode *[apcNodes.size() + 1 /* PLUS ONE !!! */];

// now build all nodes for our nice new children

for (unsigned int p = 0; p < apcNodes.size(); ++p)

pcParent->mChildren[p] = apcNodes[p];

}

return;

ai_assert(nullptr != pcScene);

// allocate the one and only root node

aiNode *root = pcScene->mRootNode = new aiNode();

root->mName.Set("<ASERoot>");

// Setup the coordinate system transformation

pcScene->mRootNode->mNumChildren = 1;

pcScene->mRootNode->mChildren = new aiNode *[1];

aiNode *ch = pcScene->mRootNode->mChildren[0] = new aiNode();

ch->mParent = root;

// Change the transformation matrix of all nodes

for (BaseNode *node : nodes) {

aiMatrix4x4 &m = node->mTransform;

m.Transpose(); // row-order vs column-order

}

// add all nodes

static const std::string none = "";

AddNodes(nodes, ch, none);

// now iterate through al nodes and find those that have not yet

// been added to the nodegraph (= their parent could not be recognized)

std::vector<const BaseNode *> aiList;

for (std::vector<BaseNode *>::iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {

if ((*it)->mProcessed) {

continue;

}

// check whether our parent is known

bool bKnowParent = false;

// search the list another time, starting *here* and try to find out whether

// there is a node that references *us* as a parent

for (std::vector<BaseNode *>::const_iterator it2 = nodes.begin(); it2 != end; ++it2) {

if (it2 == it) {

continue;

}

if ((*it2)->mName == (*it)->mParent) {

bKnowParent = true;

break;

}

}

if (!bKnowParent) {

aiList.push_back(*it);

}

}

// Are there any orphaned nodes?

if (!aiList.empty()) {

std::vector<aiNode *> apcNodes;

apcNodes.reserve(aiList.size() + pcScene->mRootNode->mNumChildren);

for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren; ++i)

apcNodes.push_back(pcScene->mRootNode->mChildren[i]);

delete[] pcScene->mRootNode->mChildren;

for (std::vector<const BaseNode *>::/*const_*/ iterator i = aiList.begin(); i != aiList.end(); ++i) {

const ASE::BaseNode *src = *i;

// The parent is not known, so we can assume that we must add

// this node to the root node of the whole scene

aiNode *pcNode = new aiNode();

pcNode->mParent = pcScene->mRootNode;

pcNode->mName.Set(src->mName);

AddMeshes(src, pcNode);

AddNodes(nodes, pcNode, pcNode->mName.data);

apcNodes.push_back(pcNode);

}

// Regenerate our output array

pcScene->mRootNode->mChildren = new aiNode *[apcNodes.size()];

for (unsigned int i = 0; i < apcNodes.size(); ++i)

pcScene->mRootNode->mChildren[i] = apcNodes[i];

pcScene->mRootNode->mNumChildren = (unsigned int)apcNodes.size();

}

// Reset the third color set to nullptr - we used this field to store a temporary pointer

for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i)

pcScene->mMeshes[i]->mColors[2] = nullptr;

// The root node should not have at least one child or the file is valid

if (!pcScene->mRootNode->mNumChildren) {

throw DeadlyImportError("ASE: No nodes loaded. The file is either empty or corrupt");

}

// Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system

pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,

0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);

// allocate output storage

std::vector<aiVector3D> mPositions;

std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];

std::vector<aiColor4D> mVertexColors;

std::vector<aiVector3D> mNormals;

std::vector<BoneVertex> mBoneVertices;

unsigned int iSize = (unsigned int)mesh.mFaces.size() * 3;

mPositions.resize(iSize);

// optional texture coordinates

for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {

if (!mesh.amTexCoords[i].empty()) {

amTexCoords[i].resize(iSize);

}

}

// optional vertex colors

if (!mesh.mVertexColors.empty()) {

mVertexColors.resize(iSize);

}

// optional vertex normals (vertex normals can simply be copied)

if (!mesh.mNormals.empty()) {

mNormals.resize(iSize);

}

// bone vertices. There is no need to change the bone list

if (!mesh.mBoneVertices.empty()) {

mBoneVertices.resize(iSize);

}

// iterate through all faces in the mesh

unsigned int iCurrent = 0, fi = 0;

for (std::vector<ASE::Face>::iterator i = mesh.mFaces.begin(); i != mesh.mFaces.end(); ++i, ++fi) {

for (unsigned int n = 0; n < 3; ++n, ++iCurrent) {

const uint32_t curIndex = (*i).mIndices[n];

if (curIndex >= mesh.mPositions.size()) {

throw DeadlyImportError("ASE: Invalid vertex index in face ", fi, ".");

}

mPositions[iCurrent] = mesh.mPositions[(*i).mIndices[n]];

// add texture coordinates

for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {

if (mesh.amTexCoords[c].empty()) break;

amTexCoords[c][iCurrent] = mesh.amTexCoords[c][(*i).amUVIndices[c][n]];

}

// add vertex colors

if (!mesh.mVertexColors.empty()) {

mVertexColors[iCurrent] = mesh.mVertexColors[(*i).mColorIndices[n]];

}

// add normal vectors

if (!mesh.mNormals.empty()) {

mNormals[iCurrent] = mesh.mNormals[fi * 3 + n];

mNormals[iCurrent].Normalize();

}

// handle bone vertices

if ((*i).mIndices[n] < mesh.mBoneVertices.size()) {

// (sometimes this will cause bone verts to be duplicated

// however, I' quite sure Schrompf' JoinVerticesStep

// will fix that again ...)

mBoneVertices[iCurrent] = mesh.mBoneVertices[(*i).mIndices[n]];

}

(*i).mIndices[n] = iCurrent;

}

}

// replace the old arrays

mesh.mNormals = mNormals;

mesh.mPositions = mPositions;

mesh.mVertexColors = mVertexColors;

for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c)

mesh.amTexCoords[c] = amTexCoords[c];

// Setup the texture name

aiString tex;

tex.Set(texture.mMapName);

mat.AddProperty(&tex, AI_MATKEY_TEXTURE(type, 0));

// Setup the texture blend factor

if (is_not_qnan(texture.mTextureBlend))

mat.AddProperty<ai_real>(&texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type, 0));

// Setup texture UV transformations

mat.AddProperty<ai_real>(&texture.mOffsetU, 5, AI_MATKEY_UVTRANSFORM(type, 0));

// LARGE TODO: Much code her is copied from 3DS ... join them maybe?

// Allocate the output material

mat.pcInstance = new aiMaterial();

// At first add the base ambient color of the

// scene to the material

mat.mAmbient.r += mParser->m_clrAmbient.r;

mat.mAmbient.g += mParser->m_clrAmbient.g;

mat.mAmbient.b += mParser->m_clrAmbient.b;

aiString name;

name.Set(mat.mName);

mat.pcInstance->AddProperty(&name, AI_MATKEY_NAME);

// material colors

mat.pcInstance->AddProperty(&mat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);

mat.pcInstance->AddProperty(&mat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);

mat.pcInstance->AddProperty(&mat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);

mat.pcInstance->AddProperty(&mat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);

// shininess

if (0.0f != mat.mSpecularExponent && 0.0f != mat.mShininessStrength) {

mat.pcInstance->AddProperty(&mat.mSpecularExponent, 1, AI_MATKEY_SHININESS);

mat.pcInstance->AddProperty(&mat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);

}

// If there is no shininess, we can disable phong lighting

else if (D3DS::Discreet3DS::Metal == mat.mShading ||

D3DS::Discreet3DS::Phong == mat.mShading ||

D3DS::Discreet3DS::Blinn == mat.mShading) {

mat.mShading = D3DS::Discreet3DS::Gouraud;

}

// opacity

mat.pcInstance->AddProperty<ai_real>(&mat.mTransparency, 1, AI_MATKEY_OPACITY);

// Two sided rendering?

if (mat.mTwoSided) {

int i = 1;

mat.pcInstance->AddProperty<int>(&i, 1, AI_MATKEY_TWOSIDED);

}

// shading mode

aiShadingMode eShading = aiShadingMode_NoShading;

switch (mat.mShading) {

case D3DS::Discreet3DS::Flat:

eShading = aiShadingMode_Flat;

break;

case D3DS::Discreet3DS::Phong:

eShading = aiShadingMode_Phong;

break;

case D3DS::Discreet3DS::Blinn:

eShading = aiShadingMode_Blinn;

break;

// I don't know what "Wire" shading should be,

// assume it is simple lambertian diffuse (L dot N) shading

case D3DS::Discreet3DS::Wire: {

// set the wireframe flag

unsigned int iWire = 1;

mat.pcInstance->AddProperty<int>((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME);

}

// fallthrough

case D3DS::Discreet3DS::Gouraud:

eShading = aiShadingMode_Gouraud;

break;

case D3DS::Discreet3DS::Metal:

eShading = aiShadingMode_CookTorrance;

break;

}

mat.pcInstance->AddProperty<int>((int *)&eShading, 1, AI_MATKEY_SHADING_MODEL);

// DIFFUSE texture

if (mat.sTexDiffuse.mMapName.length() > 0)

CopyASETexture(*mat.pcInstance, mat.sTexDiffuse, aiTextureType_DIFFUSE);

// SPECULAR texture

if (mat.sTexSpecular.mMapName.length() > 0)

CopyASETexture(*mat.pcInstance, mat.sTexSpecular, aiTextureType_SPECULAR);

// AMBIENT texture

if (mat.sTexAmbient.mMapName.length() > 0)

CopyASETexture(*mat.pcInstance, mat.sTexAmbient, aiTextureType_AMBIENT);

// OPACITY texture

if (mat.sTexOpacity.mMapName.length() > 0)

CopyASETexture(*mat.pcInstance, mat.sTexOpacity, aiTextureType_OPACITY);

// EMISSIVE texture

if (mat.sTexEmissive.mMapName.length() > 0)

CopyASETexture(*mat.pcInstance, mat.sTexEmissive, aiTextureType_EMISSIVE);

// BUMP texture

if (mat.sTexBump.mMapName.length() > 0)

CopyASETexture(*mat.pcInstance, mat.sTexBump, aiTextureType_HEIGHT);

// SHININESS texture

if (mat.sTexShininess.mMapName.length() > 0)

CopyASETexture(*mat.pcInstance, mat.sTexShininess, aiTextureType_SHININESS);

// store the name of the material itself, too

if (mat.mName.length() > 0) {

aiString tex;

tex.Set(mat.mName);

mat.pcInstance->AddProperty(&tex, AI_MATKEY_NAME);

}

return;

// validate the material index of the mesh

if (mesh.iMaterialIndex >= mParser->m_vMaterials.size()) {

mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size() - 1;

ASSIMP_LOG_WARN("Material index is out of range");

}

// If the material the mesh is assigned to consists of submeshes, split it

if (!mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials.empty()) {

std::vector<ASE::Material> vSubMaterials = mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials;

std::vector<unsigned int> *aiSplit = new std::vector<unsigned int>[vSubMaterials.size()];

// build a list of all faces per sub-material

for (unsigned int i = 0; i < mesh.mFaces.size(); ++i) {

// check range

if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) {

ASSIMP_LOG_WARN("Submaterial index is out of range");

// use the last material instead

aiSplit[vSubMaterials.size() - 1].push_back(i);

} else

aiSplit[mesh.mFaces[i].iMaterial].push_back(i);

}

// now generate submeshes

for (unsigned int p = 0; p < vSubMaterials.size(); ++p) {

if (!aiSplit[p].empty()) {

aiMesh *p_pcOut = new aiMesh();

p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;

// let the sub material index

p_pcOut->mMaterialIndex = p;

// we will need this material

mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials[p].bNeed = true;

// store the real index here ... color channel 3

p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex;

// store a pointer to the mesh in color channel 2

p_pcOut->mColors[2] = (aiColor4D *)&mesh;

avOutMeshes.push_back(p_pcOut);

// convert vertices

p_pcOut->mNumVertices = (unsigned int)aiSplit[p].size() * 3;

p_pcOut->mNumFaces = (unsigned int)aiSplit[p].size();

// receive output vertex weights

std::vector<std::pair<unsigned int, float>> *avOutputBones = nullptr;

if (!mesh.mBones.empty()) {

avOutputBones = new std::vector<std::pair<unsigned int, float>>[mesh.mBones.size()];

}

// allocate enough storage for faces

p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces];

unsigned int iBase = 0, iIndex;

if (p_pcOut->mNumVertices) {

p_pcOut->mVertices = new aiVector3D[p_pcOut->mNumVertices];

p_pcOut->mNormals = new aiVector3D[p_pcOut->mNumVertices];

for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {

iIndex = aiSplit[p][q];

p_pcOut->mFaces[q].mIndices = new unsigned int[3];

p_pcOut->mFaces[q].mNumIndices = 3;

for (unsigned int t = 0; t < 3; ++t, ++iBase) {

const uint32_t iIndex2 = mesh.mFaces[iIndex].mIndices[t];

p_pcOut->mVertices[iBase] = mesh.mPositions[iIndex2];

p_pcOut->mNormals[iBase] = mesh.mNormals[iIndex2];

// convert bones, if existing

if (!mesh.mBones.empty()) {

ai_assert(avOutputBones);

// check whether there is a vertex weight for this vertex index

if (iIndex2 < mesh.mBoneVertices.size()) {

for (std::vector<std::pair<int, float>>::const_iterator

blubb = mesh.mBoneVertices[iIndex2].mBoneWeights.begin();

blubb != mesh.mBoneVertices[iIndex2].mBoneWeights.end(); ++blubb) {

// NOTE: illegal cases have already been filtered out

avOutputBones[(*blubb).first].emplace_back(

iBase, (*blubb).second);

}

}

}

p_pcOut->mFaces[q].mIndices[t] = iBase;

}

}

}

// convert texture coordinates (up to AI_MAX_NUMBER_OF_TEXTURECOORDS sets supported)