/*!
* \brief Go through the scene nodes and load and transform all meshes them.
* \author Sascha Kaden
* \param[in] scene
* \param[in] node
* \param[in] transformation
* \param[out] vector of meshes
* \date 2017-05-09
*/
void getMeshes(const aiScene *scene, const aiNode *node, aiMatrix4x4 *trafo, std::vector<Mesh> &meshes, const bool useTrafo) {
aiMatrix4x4 prevTrafo;
prevTrafo = *trafo;
aiMultiplyMatrix4(trafo, &node->mTransformation);
for (size_t i = 0; i < node->mNumMeshes; ++i) {
Mesh mesh;
const aiMesh *aimesh = scene->mMeshes[node->mMeshes[i]];
for (size_t j = 0; j < aimesh->mNumVertices; ++j) {
aiVector3D vertex = aimesh->mVertices[j];
if (useTrafo)
aiTransformVecByMatrix4(&vertex, trafo);
mesh.vertices.emplace_back(vertex.x, vertex.y, vertex.z);
}
for (size_t j = 0; j < aimesh->mNumFaces; ++j) {
if (aimesh->mFaces[j].mNumIndices > 2) {
mesh.faces.emplace_back(aimesh->mFaces[j].mIndices[0], aimesh->mFaces[j].mIndices[1], aimesh->mFaces[j].mIndices[2]);
} else {
Logging::warning("Face array is to short", "CadProcessing");
}
}
meshes.push_back(mesh);
}
for (size_t i = 0; i < node->mNumChildren; ++i) {
getMeshes(scene, node->mChildren[i], trafo, meshes);
}
*trafo = prevTrafo;
}
void ModelRenderProcessor::deleteModelFromGpu(string modelPath) {
auto model = loader->getModelBy(modelPath);
auto materials = model->getMaterials();
for(auto& i : materials) {
auto program = loader->getProgramBy(i.getProgramName());
auto programName = program->getName();
if(!hasMaterialWithProgram(programName))
deleteProgramFromGpu(programName);
}
vector<Mesh3d>& meshes = model->getMeshes();
unordered_map<uint32_t, string> texturesToRemove;
for(auto& s : meshes) {
string mName = model->getUniqueMeshName(s);
deleteGeometryFromGpu(mName);
Texture2d& texture = model->getTextureBy(s);
texturesToRemove.emplace(s.getMaterialId(), texture.getPath());
}
for(auto& s : texturesToRemove) {
deleteTextureFromGpu(s.second);
}
}
bool KeyFrame::merge(const KeyFrame &o)
{
if(getMeshes().size() == 0)
{
meshes = o.getMeshes();
}
else
{
if(getMeshes().size() != o.getMeshes().size())
return false;
for(vector<Mesh*>::const_iterator iter=o.getMeshes().begin();
iter != o.getMeshes().end();
++iter)
{
meshes.push_back(*iter);
}
}
return true;
}
AScene3D *ASceneDecoder::createNewSceneObject()
{
DEBUG_OUT<<"ASceneDecoder::createNewSceneObject() starting...\n";
AScene3D *s=new AScene3D();
DEBUG_OUT<<"Meshes...\n";
s->setMeshes((AMesh3D **)allocArrayBigEnoughForList(getMeshes()));
s->setNumMeshes(buildArrayFromList((void **)s->getMeshes(),getMeshes()));
DEBUG_OUT<<"Lights...\n";
s->setLights((ALight3D **)allocArrayBigEnoughForList(getLights()));
s->setNumLights(buildArrayFromList((void **)s->getLights(),getLights()));
DEBUG_OUT<<"Cameras...\n";
s->setCameras((ACamera3D **)allocArrayBigEnoughForList(getCameras()));
s->setNumCameras(buildArrayFromList((void **)s->getCameras(),getCameras()));
//
//DEBUG_OUT<<"Sky...\n";
//theSky.surf=readFile->getTheSky()->surf;
//theSky.fRed=readFile->getTheSky()->fRed;
//theSky.fBlue=readFile->getTheSky()->fBlue;
//theSky.fGreen=readFile->getTheSky()->fGreen;
//DEBUG_OUT<<"Ground...\n";
//createGroundMesh(readFile->getTheGround());
DEBUG_OUT<<"Done.\n";
return s;
}
void ModelRenderProcessor::loadModelToGpu(string modelPath) {
auto model = loader->getModelBy(modelPath);
auto materials = model->getMaterials();
for(auto& i : materials) {
auto program = loader->getProgramBy(i.getProgramName());
auto programName = program->getName();
if(!hasMaterialWithProgram(programName))
loadProgramToGpu(programName, program);
}
vector<Mesh3d>& meshes = model->getMeshes();
for(auto& s : meshes) {
string meshName = model->getUniqueMeshName(s);
loadGeometryToGpu(meshName, s.getRawVertices(), s.getIndices());
Texture2d& texture = model->getTextureBy(s);
loadTextureToGpu(texture);
auto& buffer = meshToBuffer.at(meshName);
buffer.texture = textureToId.at(texture.getPath());
}
}
void ModelRenderProcessor::doStep(const StepData& stepData) {
auto sGConnector = graphics.lock();
if(!sGConnector)
throw WeakPtrException(EXCEPTION_INFO);
for(auto& i : idToObject) {
View& object = i.second;
object.doAnimationStep(stepData.stepMSec);
mat4 mvpMatrix = stepData.perspectiveView * object.getTransform();
auto model = loader->getModelBy(object.getPath());
vector<Mesh3d>& meshes = model->getMeshes();
for(auto& s : meshes) {
auto material = model->getMaterialBy(s);
auto programName = material.getProgramName();
auto programContext = nameToProgramContext.at(programName);
std::vector<IGraphicsConnector::ProgramParam> params;
IGraphicsConnector::ProgramParam mvp;
mvp.id = programContext->getLoc(programContext->getMvpBinding());
mvp.mat4 = std::make_shared<glm::mat4>(mvpMatrix);
params.push_back(mvp);
auto bonesData = prepareAnimationStep(object, s);
string meshName = model->getUniqueMeshName(s);
auto& buffer = meshToBuffer.at(meshName);
sGConnector->draw(buffer, programContext, params, bonesData);
}
}
StepData step = stepData;
step.extraData = &idToObject;
__super::doStep(step);
}
void KeyFrame::applySkin(const Material &material)
{
applySkinToModel(getMeshes(), material);
}
void ASE_Loader::Write(const char* filename)
{
int materialNum = mSceneObject->mMats.size();
SE_Material* materials = (SE_Material*)SE_Malloc(materialNum * sizeof(SE_Material));
SE_Object_Clear(materials, sizeof(materialNum * sizeof(SE_Material)));
int i;
for(i = 0 ; i < materialNum ; i++)
{
ASE_Material* srcm = &mSceneObject->mMats[i];
SE_Material* dstm = &materials[i];
COPY_MATERIAL(ambient);
COPY_MATERIAL(diffuse);
COPY_MATERIAL(specular);
SE_String_Init(&dstm->materialData.texturename, srcm->materialData.texName);
dstm->subMaterialNum = srcm->numsubmaterials;
if(srcm->numsubmaterials > 0)
{
dstm->subMaterialArray = (SE_MaterialData*)SE_Malloc(sizeof(SE_MaterialData) * dstm->subMaterialNum);
for(int j = 0 ; j < dstm->subMaterialNum ; j++)
{
SE_MaterialData* subdstm = &dstm->subMaterialArray[j];
ASE_MaterialData* subsrcm = &srcm->submaterials[j];
COPY_SUBMATERIAL(ambient);
COPY_SUBMATERIAL(diffuse);
COPY_SUBMATERIAL(specular);
SE_String_Init(&subdstm->texturename, subsrcm->texName);
}
}
}
int geomDataNum = mSceneObject->mGeomObjects.size();
SE_GeometryData* geomDataArray = (SE_GeometryData*)SE_Malloc(geomDataNum * sizeof(SE_GeometryData));
std::list<ASE_GeometryObject*>::iterator it;
i = 0;
for(it = mSceneObject->mGeomObjects.begin();
it != mSceneObject->mGeomObjects.end();
it++, i++)
{
ASE_GeometryObject* go = *it;
SE_GeometryData* dstgd = &geomDataArray[i];
ASE_Mesh* mesh = go->mesh;
SE_Object_Clear(dstgd, sizeof(SE_GeometryData));
dstgd->type = SE_TRIANGLES;
dstgd->vertexNum = mesh->numVertexes;
dstgd->vertexArray = (SE_Vector3f*)SE_Malloc(dstgd->vertexNum * sizeof(SE_Vector3f));
SE_Matrix3f rotate, rs;
SE_Matrix4f transformMatrix, invertTransformMatrix;
SE_Vector3f rotateAxis, translate, scale;
SE_Quat rotateQuat;
rotateAxis.x = go->rotateAxis[0];
rotateAxis.y = go->rotateAxis[1];
rotateAxis.z = go->rotateAxis[2];
translate.x = go->translate[0];
translate.y = go->translate[1];
translate.z = go->translate[2];
scale.x = go->scale[0];
scale.y = go->scale[1];
scale.z = go->scale[2];
SE_Quat_InitFromAngleAxis(go->rotateAngle, &rotateAxis, &rotateQuat);
SE_CreateTransformByRST(&rotateQuat, &scale, &translate, &transformMatrix);
SE_Mat4f_Inverse(&transformMatrix, &invertTransformMatrix);
int j;
for(j = 0 ; j < dstgd->vertexNum ; j++ )
{
SE_Vector4f v1, v2;
v1.x = mesh->vertexes[j].x;
v1.y = mesh->vertexes[j].y;
v1.z = mesh->vertexes[j].z;
v1.w = 1.0f;
SE_Mat4f_Map(&invertTransformMatrix, &v1, &v2);
SE_ASSERT(v2.w == 1.0f);
dstgd->vertexArray[j].x = v2.x;
dstgd->vertexArray[j].y = v2.y;
dstgd->vertexArray[j].z = v2.z;
/*
dstgd->vertexArray[j].x = mesh->vertexes[j].x;
dstgd->vertexArray[j].y = mesh->vertexes[j].y;
dstgd->vertexArray[j].z = mesh->vertexes[j].z;
*/
}
dstgd->ownVertexArray = 1;
dstgd->texVertexNum = mesh->numTVertexes;
dstgd->texVertexArray = (SE_Vector3f*)SE_Malloc(dstgd->texVertexNum * sizeof(SE_Vector3f));
for(j = 0 ; j < dstgd->texVertexNum ; j++)
{
dstgd->texVertexArray[j].x = mesh->tvertexes[j].s;
dstgd->texVertexArray[j].y = mesh->tvertexes[j].t;
dstgd->texVertexArray[j].z = 0;
}
dstgd->ownTexVertexArray = 1;
dstgd->faceNum = mesh->numFaces;
dstgd->faceArray = (SE_Face*)SE_Malloc(dstgd->faceNum * sizeof(SE_Face));
for(j = 0 ; j < dstgd->faceNum ; j++)
{
dstgd->faceArray[j].v[0] = mesh->faces[j].vi[0];
dstgd->faceArray[j].v[1] = mesh->faces[j].vi[1];
dstgd->faceArray[j].v[2] = mesh->faces[j].vi[2];
}
dstgd->ownFaceArray = 1;
if(mesh->tfaces)
{
dstgd->texFaceNum = mesh->numFaces;
dstgd->texFaceArray = (SE_Face*)SE_Malloc(dstgd->texFaceNum * sizeof(SE_Face));
for(j = 0 ; j < dstgd->texFaceNum ; j++)
{
dstgd->texFaceArray[j].v[0] = mesh->tfaces[j].vi[0];
dstgd->texFaceArray[j].v[1] = mesh->tfaces[j].vi[1];
dstgd->texFaceArray[j].v[2] = mesh->tfaces[j].vi[2];
}
dstgd->ownTexFaceArray = 1;
}
}
std::list<SE_Mesh*> seMeshs;
getMeshes(mSceneObject, seMeshs);
int meshNum = seMeshs.size();
FILE* fout = fopen(filename, "wb");
if(!fout)
return;
fwrite(&MAGIC, sizeof(int), 1, fout);
fwrite(&VERSION, sizeof(int), 1, fout);
fwrite(&COORDINATE, sizeof(int), 1, fout);
fwrite(&ENDIAN, sizeof(int), 1, fout);
fwrite(&materialNum, sizeof(int), 1, fout);
fwrite(&geomDataNum, sizeof(int), 1, fout);
fwrite(&meshNum, sizeof(int), 1, fout);
for(i = 0 ; i < materialNum ; i++)
{
LOGI("...write material\n");
fwrite(&MATERIAL_ID, sizeof(short), 1, fout);
SE_Material* m = &materials[i];
writeString(SE_String_GetData(&m->materialData.texturename), fout);
fwrite(&m->materialData.ambient.x, sizeof(float), 1, fout);
fwrite(&m->materialData.ambient.y, sizeof(float), 1, fout);
fwrite(&m->materialData.ambient.z, sizeof(float), 1, fout);
fwrite(&m->materialData.diffuse.x, sizeof(float), 1, fout);
fwrite(&m->materialData.diffuse.y, sizeof(float), 1, fout);
fwrite(&m->materialData.diffuse.z, sizeof(float), 1, fout);
fwrite(&m->materialData.specular.x, sizeof(float), 1, fout);
fwrite(&m->materialData.specular.y, sizeof(float), 1, fout);
fwrite(&m->materialData.specular.z, sizeof(float), 1, fout);
fwrite(&m->subMaterialNum , sizeof(int), 1, fout);
if(m->subMaterialNum > 0)
{
for(int j = 0 ; j < m->subMaterialNum ; j++)
{
SE_MaterialData* md = &m->subMaterialArray[j];
writeString(SE_String_GetData(&md->texturename), fout);
fwrite(&md->ambient.x, sizeof(float), 1, fout);
fwrite(&md->ambient.y, sizeof(float), 1, fout);
fwrite(&md->ambient.z, sizeof(float), 1, fout);
fwrite(&md->diffuse.x, sizeof(float), 1, fout);
fwrite(&md->diffuse.y, sizeof(float), 1, fout);
fwrite(&md->diffuse.z, sizeof(float), 1, fout);
fwrite(&md->specular.x, sizeof(float), 1, fout);
fwrite(&md->specular.y, sizeof(float), 1, fout);
fwrite(&md->specular.z, sizeof(float), 1, fout);
}
}
}
for(i = 0 ; i < geomDataNum ; i++)
{
LOGI("... write goem data\n");
fwrite(&GEOMOBJECT_ID, sizeof(short), 1, fout);
SE_GeometryData* gd = &geomDataArray[i];
fwrite(&gd->type, sizeof(int), 1, fout);
fwrite(&gd->vertexNum, sizeof(int), 1, fout);
fwrite(&gd->faceNum, sizeof(int), 1, fout);
fwrite(&gd->texVertexNum, sizeof(int), 1, fout);
fwrite(&gd->colorNum, sizeof(int), 1, fout);
int j;
for(j = 0 ; j < gd->vertexNum ; j++)
{
fwrite(&gd->vertexArray[j].x, sizeof(float), 1, fout);
fwrite(&gd->vertexArray[j].y, sizeof(float), 1, fout);
fwrite(&gd->vertexArray[j].z, sizeof(float), 1, fout);
}
for(j = 0 ; j < gd->faceNum ; j++)
{
fwrite(&gd->faceArray[j].v[0], sizeof(int), 1, fout);
fwrite(&gd->faceArray[j].v[1], sizeof(int), 1, fout);
fwrite(&gd->faceArray[j].v[2], sizeof(int), 1, fout);
}
if(gd->texVertexNum > 0)
{
for(j = 0 ; j < gd->texVertexNum ; j++)
{
fwrite(&gd->texVertexArray[j].x, sizeof(float), 1, fout);
fwrite(&gd->texVertexArray[j].y, sizeof(float), 1, fout);
fwrite(&gd->texVertexArray[j].z, sizeof(float), 1, fout);
}
for(j = 0 ; j < gd->faceNum ; j++)
{
fwrite(&gd->texFaceArray[j].v[0], sizeof(int), 1, fout);
fwrite(&gd->texFaceArray[j].v[1], sizeof(int), 1, fout);
fwrite(&gd->texFaceArray[j].v[2], sizeof(int), 1, fout);
}
}
if(gd->colorNum > 0)
{
for(j = 0 ; j < gd->colorNum ; j++)
{
fwrite(&gd->colorArray[j].x, sizeof(float), 1, fout);
fwrite(&gd->colorArray[j].y, sizeof(float), 1, fout);
fwrite(&gd->colorArray[j].z, sizeof(float), 1, fout);
}
}
}
i = 0;
std::list<SE_Mesh*>::iterator itMesh;
for(itMesh = seMeshs.begin() ; itMesh != seMeshs.end() ; itMesh++)
{
SE_Mesh* smesh = *itMesh;
LOGI("... write mesh id\n");
fwrite(&MESH_ID, sizeof(short), 1, fout);
fwrite(&smesh->geomDataIndex, sizeof(int), 1, fout);
fwrite(&smesh->materialIndex, sizeof(int), 1, fout);
fwrite(&smesh->wireframeColor.x, sizeof(float), 1, fout);
fwrite(&smesh->wireframeColor.y, sizeof(float), 1, fout);
fwrite(&smesh->wireframeColor.z, sizeof(float), 1, fout);
fwrite(&smesh->rotateAxis.x, sizeof(float), 1, fout);
fwrite(&smesh->rotateAxis.y, sizeof(float), 1, fout);
fwrite(&smesh->rotateAxis.z, sizeof(float), 1, fout);
fwrite(&smesh->rotateAngle, sizeof(float), 1, fout);
fwrite(&smesh->scaleAxis.x, sizeof(float), 1, fout);
fwrite(&smesh->scaleAxis.y, sizeof(float), 1, fout);
fwrite(&smesh->scaleAxis.z, sizeof(float), 1, fout);
fwrite(&smesh->scale.x, sizeof(float), 1, fout);
fwrite(&smesh->scale.y, sizeof(float), 1, fout);
fwrite(&smesh->scale.z, sizeof(float), 1, fout);
fwrite(&smesh->translate.x, sizeof(float), 1, fout);
fwrite(&smesh->translate.y, sizeof(float), 1, fout);
fwrite(&smesh->translate.z, sizeof(float), 1, fout);
writeString(SE_String_GetData(&smesh->name), fout);
fwrite(&smesh->subMeshNum, sizeof(int), 1, fout);
if(smesh->subMeshNum > 0)
{
LOGI("...submesh num = %d\n", smesh->subMeshNum);
int i;
for(i = 0 ; i < smesh->subMeshNum ; i++)
{
SE_SubMesh* submesh = &smesh->subMeshArray[i];
fwrite(&submesh->subMaterialIndex, sizeof(int), 1, fout);
fwrite(&submesh->faceList.num, sizeof(int), 1, fout);
int j;
for(j = 0 ; j < submesh->faceList.num ; j++)
{
fwrite(&submesh->faceList.faces[j], sizeof(int), 1, fout);
}
}
}
}
for(i = 0 ; i < materialNum ; i++)
{
if(materials[i].subMaterialNum > 0)
{
for(int j = 0 ; j < materials[i].subMaterialNum ; j++)
{
SE_String_Release(&materials[i].subMaterialArray[j].texturename);
}
SE_Free(materials[i].subMaterialArray);
}
SE_String_Release(&materials[i].materialData.texturename);
}
SE_Free(materials);
for(i = 0 ; i < geomDataNum ; i++)
{
SE_Free(geomDataArray[i].vertexArray);
SE_Free(geomDataArray[i].texVertexArray);
SE_Free(geomDataArray[i].faceArray);
SE_Free(geomDataArray[i].texFaceArray);
SE_Free(geomDataArray[i].colorArray);
}
SE_Free(geomDataArray);
for(itMesh = seMeshs.begin() ; itMesh != seMeshs.end() ; itMesh++)
{
SE_Mesh* mesh = *itMesh;
if(mesh->subMeshArray)
{
for(int j = 0 ; j < mesh->subMeshNum; j++)
{
SE_SubMesh* subMesh = &mesh->subMeshArray[j];
SE_Free(subMesh->faceList.faces);
}
SE_Free(mesh->subMeshArray);
}
SE_String_Release(&mesh->name);
SE_Free(*itMesh);
}
LOGI("write end\n");
fclose(fout);
}
Magic3D::TextData* Magic3D::Text::getText()
{
return static_cast<TextData*>(getMeshes()->at(0)->getData());
}
