/* ---------------------------------------------------------------------------- */
void recursive_render (const struct aiScene *sc, const struct aiNode* nd)
{
unsigned int i;
unsigned int n = 0, t;
struct aiMatrix4x4 m = nd->mTransformation;
/* update transform */
aiTransposeMatrix4(&m);
glPushMatrix();
glMultMatrixf((float*)&m);
/* draw all meshes assigned to this node */
for (; n < nd->mNumMeshes; ++n) {
const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
apply_material(sc->mMaterials[mesh->mMaterialIndex]);
if(mesh->mNormals == NULL) {
glDisable(GL_LIGHTING);
} else {
glEnable(GL_LIGHTING);
}
for (t = 0; t < mesh->mNumFaces; ++t) {
const struct aiFace* face = &mesh->mFaces[t];
GLenum face_mode;
switch(face->mNumIndices) {
case 1: face_mode = GL_POINTS; break;
case 2: face_mode = GL_LINES; break;
case 3: face_mode = GL_TRIANGLES; break;
default: face_mode = GL_POLYGON; break;
}
glBegin(face_mode);
for(i = 0; i < face->mNumIndices; i++) {
int index = face->mIndices[i];
if(mesh->mColors[0] != NULL)
glColor4fv((GLfloat*)&mesh->mColors[0][index]);
if(mesh->mNormals != NULL)
glNormal3fv(&mesh->mNormals[index].x);
glVertex3fv(&mesh->mVertices[index].x);
}
glEnd();
}
}
/* draw all children */
for (n = 0; n < nd->mNumChildren; ++n) {
recursive_render(sc, nd->mChildren[n]);
}
glPopMatrix();
}
/* private */ void
mainwindow::_create_actions()
{
_action_exit = new QAction(tr("Exit"), this);
_action_loadfile = new QAction(tr("Open"), this);
_action_addfile = new QAction(tr("Add"), this);
// menu
connect(_action_exit, SIGNAL( triggered()), this, SLOT( close_window() ));
connect(_action_loadfile, SIGNAL( triggered()), this, SLOT( openfile() ));
connect(_action_addfile, SIGNAL( triggered()), this, SLOT( addfile() ));
connect(_button_recompile, SIGNAL( released() ), _glwindow, SLOT( recompile() ));
connect(_button_set_spheremap, SIGNAL( released() ), _glwindow, SLOT( load_spheremap() ));
connect(_addfile_button, SIGNAL(released()), this, SLOT(addfile()));
connect(_deletefile_button, SIGNAL(released()), this, SLOT(deletefiles()));
connect(_checkbox_spheremap, SIGNAL( stateChanged(int) ), _glwindow, SLOT( spheremapping(int) ));
connect(_checkbox_fxaa, SIGNAL( stateChanged(int) ), _glwindow, SLOT( fxaa(int) ));
connect(_checkbox_pretessellation, SIGNAL(stateChanged(int)), _glwindow, SLOT(enable_pretessellation(int)));
connect(_checkbox_vsync, SIGNAL( stateChanged(int) ), _glwindow, SLOT( vsync(int) ));
connect(_checkbox_culling, SIGNAL(stateChanged(int)), _glwindow, SLOT( backface_culling(int)));
connect(_checkbox_counting, SIGNAL(stateChanged(int)), _glwindow, SLOT( enable_counter(int)));
connect(_checkbox_tritesselation, SIGNAL(stateChanged(int)), _glwindow, SLOT(enable_triangular_tesselation(int)));
connect(_checkbox_holefilling, SIGNAL(stateChanged(int)), _glwindow, SLOT(holefilling(int)));
connect(_checkbox_conservative_rasterization, SIGNAL(stateChanged(int)), _glwindow, SLOT(conservative_rasterization(int)));
connect(_combobox_antialiasing, SIGNAL(currentIndexChanged(int)), this, SLOT(antialiasing()));
connect(_combobox_trimming, SIGNAL(currentIndexChanged(int)), this, SLOT(trimming()));
connect(_combobox_rendering, SIGNAL(currentIndexChanged(int)), this, SLOT(rendering()));
connect(_combobox_fillmode, SIGNAL(currentIndexChanged(int)), this, SLOT(fillmode()));
connect(_combobox_preclassification, SIGNAL(currentIndexChanged(int)), this, SLOT(preclassification()));
connect(_slider_trim_max_bisections, SIGNAL(valueChanged(int)), _glwindow, SLOT(trim_max_bisections(int)));
connect(_slider_trim_error_tolerance, SIGNAL(valueChanged(float)), _glwindow, SLOT(trim_error_tolerance(float)));
connect(_slider_tesselation_max_pixel_error, SIGNAL(valueChanged(float)), _glwindow, SLOT(tesselation_max_pixel_error(float)));
connect(_slider_tesselation_max_object_error, SIGNAL(valueChanged(float)), _glwindow, SLOT(tesselation_max_geometric_error(float)));
connect(_slider_raycasting_max_iterations, SIGNAL(valueChanged(int)), _glwindow, SLOT(raycasting_max_iterations(int)));
connect(_slider_raycasting_error_tolerance, SIGNAL(valueChanged(float)), _glwindow, SLOT(raycasting_error_tolerance(float)));
connect(_current_specular, SIGNAL(released()), this, SLOT(set_specular()));
connect(_current_diffuse, SIGNAL(released()), this, SLOT(set_diffuse()));
connect(_current_ambient, SIGNAL(released()), this, SLOT(set_ambient()));
connect(_current_shininess, SIGNAL(valueChanged(float)), this, SLOT(set_shininess(float)));
connect(_current_opacity, SIGNAL(valueChanged(float)), this, SLOT(set_opacity(float)));
connect(_material_apply, SIGNAL(released()), this, SLOT(apply_material()));
_file_menu->addSeparator();
_file_menu->addAction (_action_loadfile);
_file_menu->addAction (_action_addfile);
_file_menu->addAction (_action_exit);
}
void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float scale)
{
unsigned int i;
unsigned int n=0, t;
aiMatrix4x4 m = nd->mTransformation;
m.Scaling(aiVector3D(scale, scale, scale), m);
// update transform
m.Transpose();
glPushMatrix();
glMultMatrixf((float*)&m);
// draw all meshes assigned to this node
for (; n < nd->mNumMeshes; ++n)
{
const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
apply_material(sc->mMaterials[mesh->mMaterialIndex]);
if(mesh->mNormals == NULL)
{
glDisable(GL_LIGHTING);
}
else
{
glEnable(GL_LIGHTING);
}
if(mesh->mColors[0] != NULL)
{
glEnable(GL_COLOR_MATERIAL);
}
else
{
glDisable(GL_COLOR_MATERIAL);
}
for (t = 0; t < mesh->mNumFaces; ++t) {
const struct aiFace* face = &mesh->mFaces[t];
GLenum face_mode;
switch(face->mNumIndices)
{
case 1: face_mode = GL_POINTS; break;
case 2: face_mode = GL_LINES; break;
case 3: face_mode = GL_TRIANGLES; break;
default: face_mode = GL_POLYGON; break;
}
glBegin(face_mode);
for(i = 0; i < face->mNumIndices; i++) // go through all vertices in face
{
int vertexIndex = face->mIndices[i]; // get group index for current index
if(mesh->mColors[0] != NULL)
Color4f(&mesh->mColors[0][vertexIndex]);
if(mesh->mNormals != NULL)
if(mesh->HasTextureCoords(0)) //HasTextureCoords(texture_coordinates_set)
{
glTexCoord2f(mesh->mTextureCoords[0][vertexIndex].x, 1 - mesh->mTextureCoords[0][vertexIndex].y); //mTextureCoords[channel][vertex]
}
glNormal3fv(&mesh->mNormals[vertexIndex].x);
glVertex3fv(&mesh->mVertices[vertexIndex].x);
}
glEnd();
}
}
// draw all children
for (n = 0; n < nd->mNumChildren; ++n)
{
recursive_render(sc, nd->mChildren[n], scale);
}
glPopMatrix();
}
void AssimpSimpleModelLoader::recursive_render (const aiScene *sc, const aiNode* nd)
{
unsigned int i;
unsigned int n = 0, t;
aiMatrix4x4 m = nd->mTransformation;
// Debug
// printf("Node name: %s\n",nd->mName.data);
// update transform
aiTransposeMatrix4(&m);
glPushMatrix();
glMultMatrixf((float*)&m);
// draw all meshes assigned to this node
for (; n < nd->mNumMeshes; ++n) {
const aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]];
// Debug
// printf("--------------->Drawing MESH with this name: %s\n",mesh->mName.data);
apply_material(sc->mMaterials[mesh->mMaterialIndex]);
if(mesh->mNormals == NULL) {
glDisable(GL_LIGHTING);
} else {
glEnable(GL_LIGHTING);
}
// Texture UV
if(mesh->HasTextureCoords(0))
glEnable(GL_TEXTURE_2D);
else
glDisable(GL_TEXTURE_2D);
if(mesh->mColors[0] != NULL)
{
glEnable(GL_COLOR_MATERIAL);
}
else
{
glDisable(GL_COLOR_MATERIAL);
}
for (t = 0; t < mesh->mNumFaces; ++t) {
const aiFace* face = &mesh->mFaces[t];
GLenum face_mode;
switch(face->mNumIndices) {
case 1: face_mode = GL_POINTS; break;
case 2: face_mode = GL_LINES; break;
case 3: face_mode = GL_TRIANGLES; break;
default: face_mode = GL_POLYGON; break;
}
glBegin(face_mode);
for(i = 0; i < face->mNumIndices; i++) {
int index = face->mIndices[i];
if(mesh->mColors[0] != NULL)
glColor4fv((GLfloat*)&mesh->mColors[0][index]);
if(mesh->mNormals != NULL) {
glNormal3fv(&mesh->mNormals[index].x);
if(mesh->HasTextureCoords(0)) //HasTextureCoords(texture_coordinates_set)
{
glTexCoord2f(mesh->mTextureCoords[0][index].x, 1 - mesh->mTextureCoords[0][index].y); //mTextureCoords[channel][vertex]
}
}
glVertex3fv(&mesh->mVertices[index].x);
}
glEnd();
}
}
// draw all children
for (n = 0; n < nd->mNumChildren; ++n) {
recursive_render(sc, nd->mChildren[n]);
}
glPopMatrix();
}
void Model3D::recursive_render(const struct aiScene *sc, const struct aiNode* nd) {
int i;
unsigned int n = 0, t;
struct aiMatrix4x4 m = nd->mTransformation;
// update transform
aiTransposeMatrix4(&m);
glPushMatrix();
glMultMatrixf((float*) &m);
// draw all meshes assigned to this node
for (; n < nd->mNumMeshes; ++n) {
const struct aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]];
if (n < texturesAndPaths.size())
glBindTexture(GL_TEXTURE_2D, texturesAndPaths[n].hTexture);
apply_material(sc->mMaterials[mesh->mMaterialIndex]);
if (mesh->mNormals == NULL
)
glDisable(GL_LIGHTING);
else
glEnable(GL_LIGHTING);
if (mesh->mColors[0] != NULL
)
glEnable(GL_COLOR_MATERIAL);
else
glDisable(GL_COLOR_MATERIAL);
for (t = 0; t < mesh->mNumFaces; ++t) {
const struct aiFace* face = &mesh->mFaces[t];
GLenum face_mode;
switch (face->mNumIndices) {
case 1:
face_mode = GL_POINTS;
break;
case 2:
face_mode = GL_LINES;
break;
case 3:
face_mode = GL_TRIANGLES;
break;
default:
face_mode = GL_POLYGON;
break;
}
glBegin(face_mode);
for (i = 0; i < face->mNumIndices; i++) {
int index = face->mIndices[i];
if (mesh->mColors[0] != NULL
)
Color4f(&mesh->mColors[0][index]);
if (mesh->mNormals != NULL
)
glNormal3fv(&mesh->mNormals[index].x);
if (mesh->HasTextureCoords(0))
glTexCoord2f(mesh->mTextureCoords[0][index].x, mesh->mTextureCoords[0][index].y);
glVertex3fv(&mesh->mVertices[index].x);
}
glEnd();
}
}
// draw all children
for (n = 0; n < nd->mNumChildren; ++n)
recursive_render(sc, nd->mChildren[n]);
glPopMatrix();
}
