void GLModel::AddMaterials(aiMaterial** materials, unsigned int numMaterials)
{
this->materials->resize(numMaterials);
for ( unsigned int i = 0; i < numMaterials; ++i )
{
aiMaterial &material = *(materials[i]);
aiColor3D ambient(0.0f, 0.0f, 0.0f);
aiColor3D diffuse(0.0f, 0.0f, 0.0f);
aiColor3D specular(0.0f, 0.0f, 0.0f);
float shininess = 10.0f;
float intensity = 1.0f;
float diffuseBlend = 1.0f;
std::cout<<"diffuseBlend "<<diffuseBlend<<std::endl;
aiString name;
material.Get(AI_MATKEY_COLOR_DIFFUSE, diffuse);
material.Get(AI_MATKEY_COLOR_AMBIENT, ambient);
material.Get(AI_MATKEY_COLOR_SPECULAR, specular);
material.Get(AI_MATKEY_SHININESS, shininess);
material.Get(AI_MATKEY_TEXBLEND_DIFFUSE(0), diffuseBlend);
material.Get(AI_MATKEY_SHININESS_STRENGTH, intensity);
material.Get(AI_MATKEY_NAME, name);
Material mat;
mat.diffuse = glm::vec4(diffuse.r, diffuse.g, diffuse.b, 1.0f);
mat.ambient = glm::vec4(ambient.r, ambient.g, ambient.b, 1.0f);
mat.specular = glm::vec4(specular.r, specular.g, specular.b, 1.0f);
mat.shininess = shininess / 5.0f;
mat.intensity = 1.0f + intensity;
mat.diffuseBlend = diffuseBlend;
//int numTextures = material.GetTextureCount(aiTextureType_DIFFUSE);
aiString texPath;
this->textures->resize(this->textures->size() + 1 + 1);
if ( material.Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE,0), texPath) == AI_SUCCESS )
{
std::string location;
if( this->path == "./")
location = this->path + texPath.data;
else
location = this->path + "/" + texPath.data;
std::cout << "Texture at " << location << std::endl;
GLTexture texture(name.C_Str(), GL_TEXTURE_2D, location.c_str());
if (!texture.Load())
{
printf("Error loading texture '%s'\n", location.c_str());
}
this->textures->at(i) = std::pair<bool, GLTexture>(true, texture);
}
if(std::string(name.C_Str()) != std::string("DefaultMaterial") || numMaterials == 1)
this->materials->at(i) = std::pair<aiString, Material>(name, mat);
}
}
void CAssParser::FindTextures(
S3DModel* model,
const aiScene* scene,
const LuaTable& modelTable,
const std::string& modelPath,
const std::string& modelName
) {
// Assign textures
// The S3O texture handler uses two textures.
// The first contains diffuse color (RGB) and teamcolor (A)
// The second contains glow (R), reflectivity (G) and 1-bit Alpha (A).
// 1. try to find by name (lowest prioriy)
if (model->tex1.empty()) model->tex1 = FindTextureByRegex("unittextures/", modelName); // high priority
if (model->tex1.empty()) model->tex1 = FindTextureByRegex("unittextures/", modelName + "1");
if (model->tex2.empty()) model->tex2 = FindTextureByRegex("unittextures/", modelName + "2");
if (model->tex1.empty()) model->tex1 = FindTextureByRegex(modelPath, "tex1");
if (model->tex2.empty()) model->tex2 = FindTextureByRegex(modelPath, "tex2");
if (model->tex1.empty()) model->tex1 = FindTextureByRegex(modelPath, "diffuse");
if (model->tex2.empty()) model->tex2 = FindTextureByRegex(modelPath, "glow"); // low priority
// 2. gather model-defined textures of first material (medium priority)
if (scene->mNumMaterials > 0) {
const unsigned int texTypes[] = {
aiTextureType_SPECULAR,
aiTextureType_UNKNOWN,
aiTextureType_DIFFUSE,
/*
// TODO: support these too (we need to allow constructing tex1 & tex2 from several sources)
aiTextureType_EMISSIVE,
aiTextureType_HEIGHT,
aiTextureType_NORMALS,
aiTextureType_SHININESS,
aiTextureType_OPACITY,
*/
};
for (unsigned int n = 0; n < (sizeof(texTypes) / sizeof(texTypes[0])); n++) {
aiString textureFile;
if (scene->mMaterials[0]->Get(AI_MATKEY_TEXTURE(texTypes[n], 0), textureFile) != aiReturn_SUCCESS)
continue;
assert(textureFile.length > 0);
model->tex1 = FindTexture(textureFile.data, modelPath, model->tex1);
}
}
// 3. try to load from metafile (highest priority)
model->tex1 = FindTexture(modelTable.GetString("tex1", ""), modelPath, model->tex1);
model->tex2 = FindTexture(modelTable.GetString("tex2", ""), modelPath, model->tex2);
model->invertTexYAxis = modelTable.GetBool("fliptextures", true); // Flip texture upside down
model->invertTexAlpha = modelTable.GetBool("invertteamcolor", true); // Reverse teamcolor levels
}
void CAssParser::FindTextures(
S3DModel* model,
const aiScene* scene,
const LuaTable& modelTable,
const std::string& modelPath,
const std::string& modelName
) {
// 1. try to find by name (lowest priority)
model->texs[0] = FindTextureByRegex("unittextures/", modelName);
if (model->texs[0].empty()) model->texs[0] = FindTextureByRegex("unittextures/", modelName + "1");
if (model->texs[1].empty()) model->texs[1] = FindTextureByRegex("unittextures/", modelName + "2");
if (model->texs[0].empty()) model->texs[0] = FindTextureByRegex(modelPath, "tex1");
if (model->texs[1].empty()) model->texs[1] = FindTextureByRegex(modelPath, "tex2");
if (model->texs[0].empty()) model->texs[0] = FindTextureByRegex(modelPath, "diffuse");
if (model->texs[1].empty()) model->texs[1] = FindTextureByRegex(modelPath, "glow"); // lowest-priority name
// 2. gather model-defined textures of first material (medium priority)
if (scene->mNumMaterials > 0) {
constexpr unsigned int texTypes[] = {
aiTextureType_SPECULAR,
aiTextureType_UNKNOWN,
aiTextureType_DIFFUSE,
/*
// TODO: support these too (we need to allow constructing tex1 & tex2 from several sources)
aiTextureType_EMISSIVE,
aiTextureType_HEIGHT,
aiTextureType_NORMALS,
aiTextureType_SHININESS,
aiTextureType_OPACITY,
*/
};
for (unsigned int texType: texTypes) {
aiString textureFile;
if (scene->mMaterials[0]->Get(AI_MATKEY_TEXTURE(texType, 0), textureFile) != aiReturn_SUCCESS)
continue;
assert(textureFile.length > 0);
model->texs[0] = FindTexture(textureFile.data, modelPath, model->texs[0]);
}
}
// 3. try to load from metafile (highest priority)
model->texs[0] = FindTexture(modelTable.GetString("tex1", ""), modelPath, model->texs[0]);
model->texs[1] = FindTexture(modelTable.GetString("tex2", ""), modelPath, model->texs[1]);
}
void CVK::Node::load(std::string path)
{
// load a scene with ASSIMP
Assimp::Importer importer;
const aiScene* scene = importer.ReadFile(path, aiProcess_GenSmoothNormals | aiProcess_Triangulate);
if(scene)
printf("SUCCESS: Loaded Model from Path: \"%s\"\n", path.c_str());
else
{
printf("ERROR: Loading failed from Path: \"%s\"\n", path.c_str());
return;
}
std::vector<CVK::Material*> materials;
// load all materials in this file
for(unsigned int i=0; i < scene->mNumMaterials; i++)
{
aiMaterial* mat = scene->mMaterials[i];
aiColor3D diffColor (0.f,0.f,0.f);
mat->Get(AI_MATKEY_COLOR_DIFFUSE, diffColor);
aiColor3D specColor (0.f,0.f,0.f);
mat->Get(AI_MATKEY_COLOR_SPECULAR, specColor);
float shininess = 0.0f;
mat->Get(AI_MATKEY_SHININESS, shininess);
glm::vec3 diffuseColor(diffColor.r, diffColor.g, diffColor.b);
glm::vec3 specularColor(specColor.r, specColor.g, specColor.b);
aiString fileName; // filename
mat->Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0), fileName);
std::string s = path.substr(0, path.rfind("/")) + "/";
s += fileName.data;
//materials.push_back(new CVK::Material(glm::vec3(0.0,1.0,0.0), glm::vec3(0.0,0.0,1.0), 10));
if (fileName.length>0)
materials.push_back(new CVK::Material( const_cast<char*> ( s.c_str() ), 1.f, 1.f, specularColor, shininess));
//should set kd and ks!!
else
materials.push_back(new CVK::Material(diffuseColor, specularColor, shininess));
}
// load all meshes in this file
for(unsigned int i=0; i < scene->mNumMeshes; i++)
{
aiMesh* mesh = scene->mMeshes[i];
CVK::Geometry* geometry = new CVK::Geometry();
// load geometry information of the current mesh
for(unsigned int vCount = 0; vCount < mesh->mNumVertices; vCount++)
{
// vertices
aiVector3D v = mesh->mVertices[vCount];
geometry->getVertices()->push_back( glm::vec4(v.x, v.y, v.z, 1.0f));
// normals
if (mesh->HasNormals())
{
v = mesh->mNormals[vCount];
geometry->getNormals()->push_back( glm::vec3(v.x, v.y, v.z));
}
// texture coordinates
if (mesh->HasTextureCoords(0))
{
v = mesh->mTextureCoords[0][vCount];
geometry->getUVs()->push_back( glm::vec2(v.x, v.y));
}
}
for(unsigned int fCount = 0; fCount < mesh->mNumFaces; fCount++)
{
aiFace f = mesh->mFaces[fCount];
// index numbers
for(unsigned int iCount = 0; iCount < f.mNumIndices; iCount++)
{
geometry->getIndex()->push_back(f.mIndices[iCount]);
}
}
geometry->createBuffers();
// new child node with the geometry and a connection to material
CVK::Node* child = new CVK::Node();
child->setGeometry(geometry);
child->setMaterial(materials[mesh->mMaterialIndex]);
addChild(child);
}
}
bool Model::LoadAssimp(const char *filename)
{
Assimp::Importer importer;
// remove unused data
importer.SetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS,
aiComponent_COLORS | aiComponent_LIGHTS | aiComponent_CAMERAS);
// max triangles and vertices per mesh, splits above this threshold
importer.SetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, INT_MAX);
importer.SetPropertyInteger(AI_CONFIG_PP_SLM_VERTEX_LIMIT, 0xfffe); // avoid the primitive restart index
// remove points and lines
importer.SetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_POINT | aiPrimitiveType_LINE);
const aiScene *scene = importer.ReadFile(filename,
aiProcess_CalcTangentSpace |
aiProcess_JoinIdenticalVertices |
aiProcess_Triangulate |
aiProcess_RemoveComponent |
aiProcess_GenSmoothNormals |
aiProcess_SplitLargeMeshes |
aiProcess_ValidateDataStructure |
//aiProcess_ImproveCacheLocality | // handled by optimizePostTransform()
aiProcess_RemoveRedundantMaterials |
aiProcess_SortByPType |
aiProcess_FindInvalidData |
aiProcess_GenUVCoords |
aiProcess_TransformUVCoords |
aiProcess_OptimizeMeshes |
aiProcess_OptimizeGraph);
if (scene == nullptr)
return false;
if (scene->HasTextures())
{
// embedded textures...
}
if (scene->HasAnimations())
{
// todo
}
m_Header.materialCount = scene->mNumMaterials;
m_pMaterial = new Material [m_Header.materialCount];
memset(m_pMaterial, 0, sizeof(Material) * m_Header.materialCount);
for (unsigned int materialIndex = 0; materialIndex < scene->mNumMaterials; materialIndex++)
{
const aiMaterial *srcMat = scene->mMaterials[materialIndex];
Material *dstMat = m_pMaterial + materialIndex;
aiColor3D diffuse(1.0f, 1.0f, 1.0f);
aiColor3D specular(1.0f, 1.0f, 1.0f);
aiColor3D ambient(1.0f, 1.0f, 1.0f);
aiColor3D emissive(0.0f, 0.0f, 0.0f);
aiColor3D transparent(1.0f, 1.0f, 1.0f);
float opacity = 1.0f;
float shininess = 0.0f;
float specularStrength = 1.0f;
aiString texDiffusePath;
aiString texSpecularPath;
aiString texEmissivePath;
aiString texNormalPath;
aiString texLightmapPath;
aiString texReflectionPath;
srcMat->Get(AI_MATKEY_COLOR_DIFFUSE, diffuse);
srcMat->Get(AI_MATKEY_COLOR_SPECULAR, specular);
srcMat->Get(AI_MATKEY_COLOR_AMBIENT, ambient);
srcMat->Get(AI_MATKEY_COLOR_EMISSIVE, emissive);
srcMat->Get(AI_MATKEY_COLOR_TRANSPARENT, transparent);
srcMat->Get(AI_MATKEY_OPACITY, opacity);
srcMat->Get(AI_MATKEY_SHININESS, shininess);
srcMat->Get(AI_MATKEY_SHININESS_STRENGTH, specularStrength);
srcMat->Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0), texDiffusePath);
srcMat->Get(AI_MATKEY_TEXTURE(aiTextureType_SPECULAR, 0), texSpecularPath);
srcMat->Get(AI_MATKEY_TEXTURE(aiTextureType_EMISSIVE, 0), texEmissivePath);
srcMat->Get(AI_MATKEY_TEXTURE(aiTextureType_NORMALS, 0), texNormalPath);
srcMat->Get(AI_MATKEY_TEXTURE(aiTextureType_LIGHTMAP, 0), texLightmapPath);
srcMat->Get(AI_MATKEY_TEXTURE(aiTextureType_REFLECTION, 0), texReflectionPath);
dstMat->diffuse = Vector3(diffuse.r, diffuse.g, diffuse.b);
dstMat->specular = Vector3(specular.r, specular.g, specular.b);
dstMat->ambient = Vector3(ambient.r, ambient.g, ambient.b);
dstMat->emissive = Vector3(emissive.r, emissive.g, emissive.b);
dstMat->transparent = Vector3(transparent.r, transparent.g, transparent.b);
dstMat->opacity = opacity;
dstMat->shininess = shininess;
dstMat->specularStrength = specularStrength;
char *pRem = nullptr;
strncpy_s(dstMat->texDiffusePath, "models/", Material::maxTexPath - 1);
strncat_s(dstMat->texDiffusePath, texDiffusePath.C_Str(), Material::maxTexPath - 1);
pRem = strrchr(dstMat->texDiffusePath, '.');
while (pRem != nullptr && *pRem != 0) *(pRem++) = 0; // remove extension
strncpy_s(dstMat->texSpecularPath, "models/", Material::maxTexPath - 1);
strncat_s(dstMat->texSpecularPath, texSpecularPath.C_Str(), Material::maxTexPath - 1);
pRem = strrchr(dstMat->texSpecularPath, '.');
while (pRem != nullptr && *pRem != 0) *(pRem++) = 0; // remove extension
strncpy_s(dstMat->texEmissivePath, "models/", Material::maxTexPath - 1);
strncat_s(dstMat->texEmissivePath, texEmissivePath.C_Str(), Material::maxTexPath - 1);
pRem = strrchr(dstMat->texEmissivePath, '.');
while (pRem != nullptr && *pRem != 0) *(pRem++) = 0; // remove extension
strncpy_s(dstMat->texNormalPath, "models/", Material::maxTexPath - 1);
strncat_s(dstMat->texNormalPath, texNormalPath.C_Str(), Material::maxTexPath - 1);
pRem = strrchr(dstMat->texNormalPath, '.');
while (pRem != nullptr && *pRem != 0) *(pRem++) = 0; // remove extension
strncpy_s(dstMat->texLightmapPath, "models/", Material::maxTexPath - 1);
strncat_s(dstMat->texLightmapPath, texLightmapPath.C_Str(), Material::maxTexPath - 1);
pRem = strrchr(dstMat->texLightmapPath, '.');
while (pRem != nullptr && *pRem != 0) *(pRem++) = 0; // remove extension
strncpy_s(dstMat->texReflectionPath, "models/", Material::maxTexPath - 1);
strncat_s(dstMat->texReflectionPath, texReflectionPath.C_Str(), Material::maxTexPath - 1);
pRem = strrchr(dstMat->texReflectionPath, '.');
while (pRem != nullptr && *pRem != 0) *(pRem++) = 0; // remove extension
aiString matName;
srcMat->Get(AI_MATKEY_NAME, matName);
strncpy_s(dstMat->name, matName.C_Str(), Material::maxMaterialName - 1);
}
m_Header.meshCount = scene->mNumMeshes;
m_pMesh = new Mesh [m_Header.meshCount];
memset(m_pMesh, 0, sizeof(Mesh) * m_Header.meshCount);
// first pass, count everything
for (unsigned int meshIndex = 0; meshIndex < scene->mNumMeshes; meshIndex++)
{
const aiMesh *srcMesh = scene->mMeshes[meshIndex];
Mesh *dstMesh = m_pMesh + meshIndex;
assert(srcMesh->mPrimitiveTypes == aiPrimitiveType_TRIANGLE);
dstMesh->materialIndex = srcMesh->mMaterialIndex;
// just store everything as float. Can quantize in Model::optimize()
dstMesh->attribsEnabled |= attrib_mask_position;
dstMesh->attrib[attrib_position].offset = dstMesh->vertexStride;
dstMesh->attrib[attrib_position].normalized = 0;
dstMesh->attrib[attrib_position].components = 3;
dstMesh->attrib[attrib_position].format = attrib_format_float;
dstMesh->vertexStride += sizeof(float) * 3;
dstMesh->attribsEnabled |= attrib_mask_texcoord0;
dstMesh->attrib[attrib_texcoord0].offset = dstMesh->vertexStride;
dstMesh->attrib[attrib_texcoord0].normalized = 0;
dstMesh->attrib[attrib_texcoord0].components = 2;
dstMesh->attrib[attrib_texcoord0].format = attrib_format_float;
dstMesh->vertexStride += sizeof(float) * 2;
dstMesh->attribsEnabled |= attrib_mask_normal;
dstMesh->attrib[attrib_normal].offset = dstMesh->vertexStride;
dstMesh->attrib[attrib_normal].normalized = 0;
dstMesh->attrib[attrib_normal].components = 3;
dstMesh->attrib[attrib_normal].format = attrib_format_float;
dstMesh->vertexStride += sizeof(float) * 3;
dstMesh->attribsEnabled |= attrib_mask_tangent;
dstMesh->attrib[attrib_tangent].offset = dstMesh->vertexStride;
dstMesh->attrib[attrib_tangent].normalized = 0;
dstMesh->attrib[attrib_tangent].components = 3;
dstMesh->attrib[attrib_tangent].format = attrib_format_float;
dstMesh->vertexStride += sizeof(float) * 3;
dstMesh->attribsEnabled |= attrib_mask_bitangent;
dstMesh->attrib[attrib_bitangent].offset = dstMesh->vertexStride;
dstMesh->attrib[attrib_bitangent].normalized = 0;
dstMesh->attrib[attrib_bitangent].components = 3;
dstMesh->attrib[attrib_bitangent].format = attrib_format_float;
dstMesh->vertexStride += sizeof(float) * 3;
// depth-only
dstMesh->attribsEnabledDepth |= attrib_mask_position;
dstMesh->attribDepth[attrib_position].offset = dstMesh->vertexStrideDepth;
dstMesh->attribDepth[attrib_position].normalized = 0;
dstMesh->attribDepth[attrib_position].components = 3;
dstMesh->attribDepth[attrib_position].format = attrib_format_float;
dstMesh->vertexStrideDepth += sizeof(float) * 3;
// color rendering
dstMesh->vertexDataByteOffset = m_Header.vertexDataByteSize;
dstMesh->vertexCount = srcMesh->mNumVertices;
dstMesh->indexDataByteOffset = m_Header.indexDataByteSize;
dstMesh->indexCount = srcMesh->mNumFaces * 3;
m_Header.vertexDataByteSize += dstMesh->vertexStride * dstMesh->vertexCount;
m_Header.indexDataByteSize += sizeof(uint16_t) * dstMesh->indexCount;
// depth-only rendering
dstMesh->vertexDataByteOffsetDepth = m_Header.vertexDataByteSizeDepth;
dstMesh->vertexCountDepth = srcMesh->mNumVertices;
m_Header.vertexDataByteSizeDepth += dstMesh->vertexStrideDepth * dstMesh->vertexCountDepth;
}
// allocate storage
m_pVertexData = new unsigned char [m_Header.vertexDataByteSize];
m_pIndexData = new unsigned char [m_Header.indexDataByteSize];
m_pVertexDataDepth = new unsigned char [m_Header.vertexDataByteSizeDepth];
m_pIndexDataDepth = new unsigned char [m_Header.indexDataByteSize];
// second pass, fill in vertex and index data
for (unsigned int meshIndex = 0; meshIndex < scene->mNumMeshes; meshIndex++)
{
const aiMesh *srcMesh = scene->mMeshes[meshIndex];
Mesh *dstMesh = m_pMesh + meshIndex;
float *dstPos = (float*)(m_pVertexData + dstMesh->vertexDataByteOffset + dstMesh->attrib[attrib_position].offset);
float *dstTexcoord0 = (float*)(m_pVertexData + dstMesh->vertexDataByteOffset + dstMesh->attrib[attrib_texcoord0].offset);
float *dstNormal = (float*)(m_pVertexData + dstMesh->vertexDataByteOffset + dstMesh->attrib[attrib_normal].offset);
float *dstTangent = (float*)(m_pVertexData + dstMesh->vertexDataByteOffset + dstMesh->attrib[attrib_tangent].offset);
float *dstBitangent = (float*)(m_pVertexData + dstMesh->vertexDataByteOffset + dstMesh->attrib[attrib_bitangent].offset);
float *dstPosDepth = (float*)(m_pVertexDataDepth + dstMesh->vertexDataByteOffsetDepth + dstMesh->attribDepth[attrib_position].offset);
for (unsigned int v = 0; v < dstMesh->vertexCount; v++)
{
if (srcMesh->mVertices)
{
dstPos[0] = srcMesh->mVertices[v].x;
dstPos[1] = srcMesh->mVertices[v].y;
dstPos[2] = srcMesh->mVertices[v].z;
dstPosDepth[0] = srcMesh->mVertices[v].x;
dstPosDepth[1] = srcMesh->mVertices[v].y;
dstPosDepth[2] = srcMesh->mVertices[v].z;
}
else
{
// no position? That's kind of bad.
assert(0);
}
dstPos = (float*)((unsigned char*)dstPos + dstMesh->vertexStride);
dstPosDepth = (float*)((unsigned char*)dstPosDepth + dstMesh->vertexStrideDepth);
if (srcMesh->mTextureCoords[0])
{
dstTexcoord0[0] = srcMesh->mTextureCoords[0][v].x;
dstTexcoord0[1] = srcMesh->mTextureCoords[0][v].y;
}
else
{
dstTexcoord0[0] = 0.0f;
dstTexcoord0[1] = 0.0f;
}
dstTexcoord0 = (float*)((unsigned char*)dstTexcoord0 + dstMesh->vertexStride);
if (srcMesh->mNormals)
{
dstNormal[0] = srcMesh->mNormals[v].x;
dstNormal[1] = srcMesh->mNormals[v].y;
dstNormal[2] = srcMesh->mNormals[v].z;
}
else
{
// Assimp should generate normals if they are missing, according to the postprocessing flag specified on load,
// so we should never get here.
assert(0);
}
dstNormal = (float*)((unsigned char*)dstNormal + dstMesh->vertexStride);
if (srcMesh->mTangents)
{
dstTangent[0] = srcMesh->mTangents[v].x;
dstTangent[1] = srcMesh->mTangents[v].y;
dstTangent[2] = srcMesh->mTangents[v].z;
}
else
{
// TODO: generate tangents/bitangents if missing
dstTangent[0] = 1.0f;
dstTangent[1] = 0.0f;
dstTangent[2] = 0.0f;
}
dstTangent = (float*)((unsigned char*)dstTangent + dstMesh->vertexStride);
if (srcMesh->mBitangents)
{
dstBitangent[0] = srcMesh->mBitangents[v].x;
dstBitangent[1] = srcMesh->mBitangents[v].y;
dstBitangent[2] = srcMesh->mBitangents[v].z;
}
else
{
// TODO: generate tangents/bitangents if missing
dstBitangent[0] = 0.0f;
dstBitangent[1] = 1.0f;
dstBitangent[2] = 0.0f;
}
dstBitangent = (float*)((unsigned char*)dstBitangent + dstMesh->vertexStride);
}
uint16_t *dstIndex = (uint16_t*)(m_pIndexData + dstMesh->indexDataByteOffset);
uint16_t *dstIndexDepth = (uint16_t*)(m_pIndexDataDepth + dstMesh->indexDataByteOffset);
for (unsigned int f = 0; f < srcMesh->mNumFaces; f++)
{
assert(srcMesh->mFaces[f].mNumIndices == 3);
*dstIndex++ = srcMesh->mFaces[f].mIndices[0];
*dstIndex++ = srcMesh->mFaces[f].mIndices[1];
*dstIndex++ = srcMesh->mFaces[f].mIndices[2];
*dstIndexDepth++ = srcMesh->mFaces[f].mIndices[0];
*dstIndexDepth++ = srcMesh->mFaces[f].mIndices[1];
*dstIndexDepth++ = srcMesh->mFaces[f].mIndices[2];
}
}
ComputeAllBoundingBoxes();
return true;
}
// -----------------------------------------------------------------------------------
// Implementation of the assimp info utility to print basic file info
int Assimp_Info (const char* const* params, unsigned int num)
{
if (num < 1) {
printf("assimp info: Invalid number of arguments. "
"See \'assimp info --help\'\n");
return 1;
}
// --help
if (!strcmp( params[0],"-h")||!strcmp( params[0],"--help")||!strcmp( params[0],"-?") ) {
printf("%s",AICMD_MSG_INFO_HELP_E);
return 0;
}
// asssimp info <file> [-r]
if (num < 1) {
printf("assimp info: Invalid number of arguments. "
"See \'assimp info --help\'\n");
return 1;
}
const std::string in = std::string(params[0]);
// do maximum post-processing unless -r was specified
ImportData import;
import.ppFlags = num>1&&(!strcmp(params[1],"--raw")||!strcmp(params[1],"-r")) ? 0
: aiProcessPreset_TargetRealtime_MaxQuality;
// import the main model
import.log = true;
import.showLog = true;
const aiScene* scene = ImportModel(import,in);
if (!scene) {
printf("assimp info: Unable to load input file %s\n",
in.c_str());
return 5;
}
aiMemoryInfo mem;
globalImporter->GetMemoryRequirements(mem);
static const char* format_string =
"Memory consumption: %i B\n"
"Nodes: %i\n"
"Maximum depth %i\n"
"Meshes: %i\n"
"Animations: %i\n"
"Textures (embed.): %i\n"
"Materials: %i\n"
"Cameras: %i\n"
"Lights: %i\n"
"Vertices: %i\n"
"Faces: %i\n"
"Bones: %i\n"
"Animation Channels: %i\n"
"Primitive Types: %s\n"
"Average faces/mesh %i\n"
"Average verts/mesh %i\n"
"Minimum point (%f %f %f)\n"
"Maximum point (%f %f %f)\n"
"Center point (%f %f %f)\n"
;
aiVector3D special_points[3];
FindSpecialPoints(scene,special_points);
printf(format_string,
mem.total,
CountNodes(scene->mRootNode),
GetMaxDepth(scene->mRootNode),
scene->mNumMeshes,
scene->mNumAnimations,
scene->mNumTextures,
scene->mNumMaterials,
scene->mNumCameras,
scene->mNumLights,
CountVertices(scene),
CountFaces(scene),
CountBones(scene),
CountAnimChannels(scene),
FindPTypes(scene).c_str(),
GetAvgFacePerMesh(scene),
GetAvgVertsPerMesh(scene),
special_points[0][0],special_points[0][1],special_points[0][2],
special_points[1][0],special_points[1][1],special_points[1][2],
special_points[2][0],special_points[2][1],special_points[2][2]
)
;
unsigned int total=0;
for(unsigned int i = 0;i < scene->mNumMaterials; ++i) {
aiString name;
if (AI_SUCCESS==aiGetMaterialString(scene->mMaterials[i],AI_MATKEY_NAME,&name)) {
printf("%s\n \'%s\'",(total++?"":"\nNamed Materials:" ),name.data);
}
}
if(total) {
printf("\n");
}
total=0;
for(unsigned int i = 0;i < scene->mNumMaterials; ++i) {
aiString name;
static const aiTextureType types[] = {
aiTextureType_NONE,
aiTextureType_DIFFUSE,
aiTextureType_SPECULAR,
aiTextureType_AMBIENT,
aiTextureType_EMISSIVE,
aiTextureType_HEIGHT,
aiTextureType_NORMALS,
aiTextureType_SHININESS,
aiTextureType_OPACITY,
aiTextureType_DISPLACEMENT,
aiTextureType_LIGHTMAP,
aiTextureType_REFLECTION,
aiTextureType_UNKNOWN
};
for(unsigned int type = 0; type < sizeof(types)/sizeof(types[0]); ++type) {
for(unsigned int idx = 0;AI_SUCCESS==aiGetMaterialString(scene->mMaterials[i],
AI_MATKEY_TEXTURE(types[type],idx),&name); ++idx) {
printf("%s\n \'%s\'",(total++?"":"\nTexture Refs:" ),name.data);
}
}
}
if(total) {
printf("\n");
}
total=0;
for(unsigned int i = 0;i < scene->mNumAnimations; ++i) {
if (scene->mAnimations[i]->mName.length) {
printf("%s\n \'%s\'",(total++?"":"\nNamed Animations:" ),scene->mAnimations[i]->mName.data);
}
}
if(total) {
printf("\n");
}
printf("\nNode hierarchy:\n");
unsigned int cline=0;
PrintHierarchy(scene->mRootNode,20,1000,cline);
printf("\n");
return 0;
}
void CAssParser::FindTextures(S3DModel* model, const aiScene* scene, const LuaTable& metaTable, const std::string& modelFilePath)
{
const std::string modelPath = FileSystem::GetDirectory(modelFilePath);
const std::string modelName = FileSystem::GetBasename(modelFilePath);
// Assign textures
// The S3O texture handler uses two textures.
// The first contains diffuse color (RGB) and teamcolor (A)
// The second contains glow (R), reflectivity (G) and 1-bit Alpha (A).
// gather model defined textures
if (scene->mNumMaterials > 0) {
const aiMaterial* mat = scene->mMaterials[0]; //only check first material
//FIXME support these too (we need to allow to construct tex1 & tex2 from several sources)
/*aiTextureType_EMISSIVE
aiTextureType_HEIGHT
aiTextureType_NORMALS
aiTextureType_SHININESS
aiTextureType_OPACITY*/
aiString textureFile;
mat->Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0), textureFile);
if (strcmp(textureFile.C_Str(), "") == 0) model->tex1 = textureFile.C_Str();
textureFile.Clear();
mat->Get(AI_MATKEY_TEXTURE(aiTextureType_UNKNOWN, 0), textureFile);
if (strcmp(textureFile.C_Str(), "") == 0) model->tex1 = textureFile.C_Str();
textureFile.Clear();
mat->Get(AI_MATKEY_TEXTURE(aiTextureType_SPECULAR, 0), textureFile);
if (strcmp(textureFile.C_Str(), "") == 0) model->tex1 = textureFile.C_Str();
textureFile.Clear();
}
// try to load from metafile
model->tex1 = metaTable.GetString("tex1", model->tex1);
model->tex2 = metaTable.GetString("tex2", model->tex2);
// try to find by name
if (model->tex1.empty()) {
const std::vector<std::string>& files = CFileHandler::FindFiles("unittextures/", modelName + ".*");
if (!files.empty()) {
model->tex1 = FileSystem::GetFilename(files[0]);
}
}
if (model->tex2.empty()) {
const std::vector<std::string>& files = CFileHandler::FindFiles("unittextures/", modelName + "2.*");
if (!files.empty()) {
model->tex2 = FileSystem::GetFilename(files[0]);
}
}
// last chance for primary texture
if (model->tex1.empty()) {
const std::vector<std::string>& files = CFileHandler::FindFiles(modelPath, "diffuse.*");
if (!files.empty()) {
model->tex1 = FileSystem::GetFilename(files[0]);
}
}
// correct filepath?
if (!CFileHandler::FileExists(model->tex1, SPRING_VFS_ZIP)) {
if (CFileHandler::FileExists("unittextures/" + model->tex1, SPRING_VFS_ZIP)) {
model->tex1 = "unittextures/" + model->tex1;
} else if (CFileHandler::FileExists(modelPath + model->tex1, SPRING_VFS_ZIP)) {
model->tex1 = modelPath + model->tex1;
}
}
if (!CFileHandler::FileExists(model->tex2, SPRING_VFS_ZIP)) {
if (CFileHandler::FileExists("unittextures/" + model->tex2, SPRING_VFS_ZIP)) {
model->tex2 = "unittextures/" + model->tex2;
} else if (CFileHandler::FileExists(modelPath + model->tex2, SPRING_VFS_ZIP)) {
model->tex2 = modelPath + model->tex2;
}
}
model->flipTexY = metaTable.GetBool("fliptextures", true); // Flip texture upside down
model->invertTexAlpha = metaTable.GetBool("invertteamcolor", true); // Reverse teamcolor levels
}
// -----------------------------------------------------------------------------------
// Implementation of the assimp info utility to print basic file info
int Assimp_Info(const aiScene* scene, Assimp::Importer *globalImporter)
{
aiMemoryInfo mem;
globalImporter->GetMemoryRequirements(mem);
static const char* format_string =
"Memory consumption: %i B\n"
"Nodes: %i\n"
"Maximum depth %i\n"
"Meshes: %i\n"
"Animations: %i\n"
"Textures (embed.): %i\n"
"Materials: %i\n"
"Cameras: %i\n"
"Lights: %i\n"
"Vertices: %i\n"
"Faces: %i\n"
"Bones: %i\n"
"Animation Channels: %i\n"
"Primitive Types: %s\n"
"Average faces/mesh %i\n"
"Average verts/mesh %i\n"
"Minimum point (%f %f %f)\n"
"Maximum point (%f %f %f)\n"
"Center point (%f %f %f)\n"
;
aiVector3D special_points[3];
FindSpecialPoints(scene, special_points);
fprintf(stderr, format_string,
mem.total,
CountNodes(scene->mRootNode),
GetMaxDepth(scene->mRootNode),
scene->mNumMeshes,
scene->mNumAnimations,
scene->mNumTextures,
scene->mNumMaterials,
scene->mNumCameras,
scene->mNumLights,
CountVertices(scene),
CountFaces(scene),
CountBones(scene),
CountAnimChannels(scene),
FindPTypes(scene).c_str(),
GetAvgFacePerMesh(scene),
GetAvgVertsPerMesh(scene),
special_points[0][0], special_points[0][1], special_points[0][2],
special_points[1][0], special_points[1][1], special_points[1][2],
special_points[2][0], special_points[2][1], special_points[2][2]
)
;
#define FULLLOG
#ifdef FULLLOG
unsigned int total = 0;
for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
aiString name;
if (AI_SUCCESS == aiGetMaterialString(scene->mMaterials[i], AI_MATKEY_NAME, &name)) {
fprintf(stderr, "%s\n \'%s\'", (total++ ? "" : "\nNamed Materials:"), name.data);
}
}
if (total) {
fprintf(stderr, "\n");
}
total = 0;
for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
aiString name;
static const aiTextureType types[] = {
aiTextureType_NONE,
aiTextureType_DIFFUSE,
aiTextureType_SPECULAR,
aiTextureType_AMBIENT,
aiTextureType_EMISSIVE,
aiTextureType_HEIGHT,
aiTextureType_NORMALS,
aiTextureType_SHININESS,
aiTextureType_OPACITY,
aiTextureType_DISPLACEMENT,
aiTextureType_LIGHTMAP,
aiTextureType_REFLECTION,
aiTextureType_UNKNOWN
};
for (unsigned int type = 0; type < sizeof(types) / sizeof(types[0]); ++type) {
for (unsigned int idx = 0; AI_SUCCESS == aiGetMaterialString(scene->mMaterials[i],
AI_MATKEY_TEXTURE(types[type], idx), &name); ++idx) {
fprintf(stderr, "%s\n \'%s\'", (total++ ? "" : "\nTexture Refs:"), name.data);
}
}
}
if (total) {
fprintf(stderr, "\n");
}
total = 0;
for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
if (scene->mAnimations[i]->mName.length) {
fprintf(stderr, "%s\n \'%s\'", (total++ ? "" : "\nNamed Animations:"), scene->mAnimations[i]->mName.data);
}
}
if (total) {
fprintf(stderr, "\n");
}
/*
fprintf(stderr, "\nNode hierarchy:\n");
unsigned int cline = 0;
PrintHierarchy(scene->mRootNode, 20, 1000, cline);
*/
#endif
fprintf(stderr, "\n");
return 0;
}
