assimp/tools/assimp_qt_viewer/glview.cpp

1162 lines
38 KiB
C++

/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2018, 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.
---------------------------------------------------------------------------
*/
#include "glview.hpp"
// Header files, Qt.
#include <QTime>
// Header files, OpenGL.
#if defined(__APPLE__)
# include <OpenGL/glu.h>
#else
# include <GL/glu.h>
#endif
// Header files, DevIL.
// Header files, Assimp.
#include <assimp/DefaultLogger.hpp>
#define STB_IMAGE_IMPLEMENTATION
#include "contrib/stb_image/stb_image.h"
CGLView::SHelper_Mesh::SHelper_Mesh(const size_t pQuantity_Point, const size_t pQuantity_Line, const size_t pQuantity_Triangle, const SBBox& pBBox)
: Quantity_Point(pQuantity_Point)
, Quantity_Line(pQuantity_Line)
, Quantity_Triangle(pQuantity_Triangle)
, BBox(pBBox) {
Index_Point = pQuantity_Point ? new GLuint[pQuantity_Point * 1] : nullptr;
Index_Line = pQuantity_Line ? new GLuint[pQuantity_Line * 2] : nullptr;
Index_Triangle = pQuantity_Triangle ? new GLuint[pQuantity_Triangle * 3] : nullptr;
}
CGLView::SHelper_Mesh::~SHelper_Mesh() {
delete [] Index_Point;
delete [] Index_Line;
delete [] Index_Triangle;
}
void CGLView::SHelper_Camera::SetDefault() {
Position.Set(0, 0, 0);
Target.Set(0, 0, -1);
Rotation_AroundCamera = aiMatrix4x4();
Rotation_Scene = aiMatrix4x4();
Translation_ToScene.Set(0, 0, 2);
}
static void set_float4(float f[4], float a, float b, float c, float d) {
f[0] = a;
f[1] = b;
f[2] = c;
f[3] = d;
}
static void color4_to_float4(const aiColor4D *c, float f[4]) {
f[0] = c->r;
f[1] = c->g;
f[2] = c->b;
f[3] = c->a;
}
void CGLView::Material_Apply(const aiMaterial* pMaterial) {
GLfloat tcol[4];
aiColor4D taicol;
unsigned int max;
int ret1, ret2;
int texture_index = 0;
aiString texture_path;
///TODO: cache materials
// Disable color material because glMaterial is used.
glDisable(GL_COLOR_MATERIAL);///TODO: cache
// Set texture. If assigned.
if(AI_SUCCESS == pMaterial->GetTexture(aiTextureType_DIFFUSE, texture_index, &texture_path)) {
//bind texture
unsigned int texture_ID = mTexture_IDMap.value(texture_path.data, 0);
glBindTexture(GL_TEXTURE_2D, texture_ID);
}
//
// Set material parameters from scene or default values.
//
// Diffuse
set_float4(tcol, 0.8f, 0.8f, 0.8f, 1.0f);
if ( AI_SUCCESS == aiGetMaterialColor( pMaterial, AI_MATKEY_COLOR_DIFFUSE, &taicol )) {
color4_to_float4( &taicol, tcol );
}
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, tcol);
// Specular
set_float4(tcol, 0.0f, 0.0f, 0.0f, 1.0f);
if ( AI_SUCCESS == aiGetMaterialColor( pMaterial, AI_MATKEY_COLOR_SPECULAR, &taicol )) {
color4_to_float4( &taicol, tcol );
}
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, tcol);
// Ambient
set_float4(tcol, 0.2f, 0.2f, 0.2f, 1.0f);
if ( AI_SUCCESS == aiGetMaterialColor( pMaterial, AI_MATKEY_COLOR_AMBIENT, &taicol )) {
color4_to_float4( &taicol, tcol );
}
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, tcol);
// Emission
set_float4(tcol, 0.0f, 0.0f, 0.0f, 1.0f);
if(AI_SUCCESS == aiGetMaterialColor(pMaterial, AI_MATKEY_COLOR_EMISSIVE, &taicol)) color4_to_float4(&taicol, tcol);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, tcol);
// Shininess
ai_real shininess, strength;
max = 1;
ret1 = aiGetMaterialFloatArray(pMaterial, AI_MATKEY_SHININESS, &shininess, &max);
// Shininess strength
max = 1;
ret2 = aiGetMaterialFloatArray(pMaterial, AI_MATKEY_SHININESS_STRENGTH, &strength, &max);
if((ret1 == AI_SUCCESS) && (ret2 == AI_SUCCESS)) {
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength);///TODO: cache
} else {
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f);///TODO: cache
set_float4(tcol, 0.0f, 0.0f, 0.0f, 0.0f);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, tcol);
}
// Fill mode
GLenum fill_mode;
int wireframe;
max = 1;
if(AI_SUCCESS == aiGetMaterialIntegerArray(pMaterial, AI_MATKEY_ENABLE_WIREFRAME, &wireframe, &max))
fill_mode = wireframe ? GL_LINE : GL_FILL;
else
fill_mode = GL_FILL;
glPolygonMode(GL_FRONT_AND_BACK, fill_mode);///TODO: cache
// Fill side
int two_sided;
max = 1;
if((AI_SUCCESS == aiGetMaterialIntegerArray(pMaterial, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided)///TODO: cache
glDisable(GL_CULL_FACE);
else
glEnable(GL_CULL_FACE);
}
void CGLView::Matrix_NodeToRoot(const aiNode* pNode, aiMatrix4x4& pOutMatrix)
{
const aiNode* node_cur;
std::list<aiMatrix4x4> mat_list;
pOutMatrix = aiMatrix4x4();
// starting walk from current element to root
node_cur = pNode;
if(node_cur != nullptr)
{
do
{
// if cur_node is group then store group transformation matrix in list.
mat_list.push_back(node_cur->mTransformation);
node_cur = node_cur->mParent;
} while(node_cur != nullptr);
}
// multiply all matrices in reverse order
for ( std::list<aiMatrix4x4>::reverse_iterator rit = mat_list.rbegin(); rit != mat_list.rend(); rit++)
{
pOutMatrix = pOutMatrix * (*rit);
}
}
void CGLView::ImportTextures(const QString& scenePath) {
auto LoadTexture = [&](const QString& pFileName) -> bool ///TODO: IME texture mode, operation.
{
GLuint id_ogl_texture;// OpenGL texture ID.
if(!pFileName.startsWith(AI_EMBEDDED_TEXNAME_PREFIX))
{
QString basepath = scenePath.left(scenePath.lastIndexOf('/') + 1);// path with '/' at the end.
QString fileloc = (basepath + pFileName);
fileloc.replace('\\', "/");
int x, y, n;
unsigned char *data = stbi_load(fileloc.toLocal8Bit(), &x, &y, &n, STBI_rgb_alpha );
if ( nullptr == data ) {
LogError(QString("Couldn't load Image: %1").arg(fileloc));
return false;
}
// Convert every colour component into unsigned byte. If your image contains alpha channel you can replace IL_RGB with IL_RGBA.
glGenTextures(1, &id_ogl_texture);// Texture ID generation.
mTexture_IDMap[pFileName] = id_ogl_texture;// save texture ID for filename in map
glBindTexture(GL_TEXTURE_2D, id_ogl_texture);// Binding of texture ID.
// Redefine standard texture values
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);// We will use linear interpolation for magnification filter.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);// We will use linear interpolation for minifying filter.
glTexImage2D(GL_TEXTURE_2D, 0, n, x, y, 0, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, data );// Texture specification.
stbi_image_free(data);
// Cleanup
}
else
{
struct SPixel_Description
{
const char* FormatHint;
const GLint Image_InternalFormat;
const GLint Pixel_Format;
};
constexpr SPixel_Description Pixel_Description[] = {
{"rgba8880", GL_RGB, GL_RGB},
{"rgba8888", GL_RGBA, GL_RGBA}
};
constexpr size_t Pixel_Description_Count = sizeof(Pixel_Description) / sizeof(SPixel_Description);
size_t idx_description;
// Get texture index.
bool ok;
size_t idx_texture = pFileName.right(strlen(AI_EMBEDDED_TEXNAME_PREFIX)).toULong(&ok);
if(!ok)
{
LogError("Can not get index of the embedded texture from path in material.");
return false;
}
// Create alias for conveniance.
const aiTexture& als = *mScene->mTextures[idx_texture];
if(als.mHeight == 0)// Compressed texture.
{
LogError("IME: compressed embedded textures are not implemented.");
}
else
{
ok = false;
for(size_t idx = 0; idx < Pixel_Description_Count; idx++)
{
if(als.CheckFormat(Pixel_Description[idx].FormatHint))
{
idx_description = idx;
ok = true;
break;
}
}
if(!ok)
{
LogError(QString("Unsupported format hint for embedded texture: [%1]").arg(als.achFormatHint));
return false;
}
glGenTextures(1, &id_ogl_texture);// Texture ID generation.
mTexture_IDMap[pFileName] = id_ogl_texture;// save texture ID for filename in map
glBindTexture(GL_TEXTURE_2D, id_ogl_texture);// Binding of texture ID.
// Redefine standard texture values
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);// We will use linear interpolation for magnification filter.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);// We will use linear interpolation for minifying filter.
// Texture specification.
glTexImage2D(GL_TEXTURE_2D, 0, Pixel_Description[idx_description].Image_InternalFormat, als.mWidth, als.mHeight, 0,
Pixel_Description[idx_description].Pixel_Format, GL_UNSIGNED_BYTE, (uint8_t*)als.pcData);
}// if(als.mHeight == 0) else
}// if(!filename.startsWith(AI_EMBEDDED_TEXNAME_PREFIX)) else
return true;
};// auto LoadTexture = [&](const aiString& pPath)
if(mScene == nullptr)
{
LogError("Trying to load textures for empty scene.");
return;
}
//
// Load textures.
//
// Get textures file names and number of textures.
for(size_t idx_material = 0; idx_material < mScene->mNumMaterials; idx_material++) {
int idx_texture = 0;
aiString path;
do {
if (mScene->mMaterials[ idx_material ]->GetTexture( aiTextureType_DIFFUSE, idx_texture, &path ) != AI_SUCCESS) {
break;
}
LoadTexture(QString(path.C_Str()));
idx_texture++;
} while(true);
}// for(size_t idx_material = 0; idx_material < mScene->mNumMaterials; idx_material++)
// Textures list is empty, exit.
if(mTexture_IDMap.empty()) {
LogInfo("No textures for import.");
}
}
void CGLView::BBox_GetForNode(const aiNode& pNode, const aiMatrix4x4& pParent_TransformationMatrix, SBBox& pNodeBBox, bool& pFirstAssign)
{
aiMatrix4x4 mat_trans = pParent_TransformationMatrix * pNode.mTransformation;
// Check if node has meshes
for(size_t idx_idx_mesh = 0; idx_idx_mesh < pNode.mNumMeshes; idx_idx_mesh++)
{
size_t idx_mesh;
SBBox bbox_local;
aiVector3D bbox_vertices[8];
idx_mesh = pNode.mMeshes[idx_idx_mesh];
// Get vertices of mesh BBox
BBox_GetVertices(mHelper_Mesh[idx_mesh]->BBox, bbox_vertices);
// Transform vertices
for(size_t idx_vert = 0; idx_vert < 8; idx_vert++) bbox_vertices[idx_vert] *= mat_trans;
// And create BBox for transformed mesh
BBox_GetFromVertices(bbox_vertices, 8, bbox_local);
if(!pFirstAssign)
{
BBox_Extend(bbox_local, pNodeBBox);
}
else
{
pFirstAssign = false;
pNodeBBox = bbox_local;
}
}// for(size_t idx_idx_mesh = 0; idx_idx_mesh < pNode.mNumMeshes; idx_idx_mesh++)
for(size_t idx_node = 0; idx_node < pNode.mNumChildren; idx_node++)
{
BBox_GetForNode(*pNode.mChildren[idx_node], mat_trans, pNodeBBox, pFirstAssign);
}
}
void CGLView::BBox_Extend(const SBBox& pChild, SBBox& pParent)
{
// search minimal...
AssignIfLesser(&pParent.Minimum.x, pChild.Minimum.x);
AssignIfLesser(&pParent.Minimum.y, pChild.Minimum.y);
AssignIfLesser(&pParent.Minimum.z, pChild.Minimum.z);
// and maximal values
AssignIfGreater(&pParent.Maximum.x, pChild.Maximum.x);
AssignIfGreater(&pParent.Maximum.y, pChild.Maximum.y);
AssignIfGreater(&pParent.Maximum.z, pChild.Maximum.z);
}
void CGLView::BBox_GetVertices(const SBBox& pBBox, aiVector3D pVertex[8])
{
pVertex[0] = pBBox.Minimum;
pVertex[1].Set(pBBox.Minimum.x, pBBox.Minimum.y, pBBox.Maximum.z);
pVertex[2].Set(pBBox.Minimum.x, pBBox.Maximum.y, pBBox.Maximum.z);
pVertex[3].Set(pBBox.Minimum.x, pBBox.Maximum.y, pBBox.Minimum.z);
pVertex[4].Set(pBBox.Maximum.x, pBBox.Minimum.y, pBBox.Minimum.z);
pVertex[5].Set(pBBox.Maximum.x, pBBox.Minimum.y, pBBox.Maximum.z);
pVertex[6] = pBBox.Maximum;
pVertex[7].Set(pBBox.Maximum.x, pBBox.Maximum.y, pBBox.Minimum.z);
}
void CGLView::BBox_GetFromVertices(const aiVector3D* pVertices, const size_t pVerticesQuantity, SBBox& pBBox)
{
if(pVerticesQuantity == 0)
{
pBBox.Maximum.Set(0, 0, 0);
pBBox.Minimum.Set(0, 0, 0);
return;
}
// Assign first values.
pBBox.Minimum = pVertices[0];
pBBox.Maximum = pVertices[0];
for(size_t idx_vert = 1; idx_vert < pVerticesQuantity; idx_vert++)
{
const ai_real x = pVertices[idx_vert].x;
const ai_real y = pVertices[idx_vert].y;
const ai_real z = pVertices[idx_vert].z;
// search minimal...
AssignIfLesser(&pBBox.Minimum.x, x);
AssignIfLesser(&pBBox.Minimum.y, y);
AssignIfLesser(&pBBox.Minimum.z, z);
// and maximal values
AssignIfGreater(&pBBox.Maximum.x, x);
AssignIfGreater(&pBBox.Maximum.y, y);
AssignIfGreater(&pBBox.Maximum.z, z);
}
}
void CGLView::LogInfo(const QString& pMessage) {
Assimp::DefaultLogger::get()->info(pMessage.toStdString());
}
void CGLView::LogError(const QString& pMessage) {
Assimp::DefaultLogger::get()->error(pMessage.toStdString());
}
void CGLView::Draw_Node(const aiNode* pNode) {
aiMatrix4x4 mat_node = pNode->mTransformation;
// Apply node transformation matrix.
mat_node.Transpose();
glPushMatrix();
#ifdef ASSIMP_DOUBLE_PRECISION
glMultMatrixd((GLdouble*)mat_node[0]);
#else
glMultMatrixf((GLfloat*)&mat_node);
#endif // ASSIMP_DOUBLE_PRECISION
// Draw all meshes assigned to this node
for(size_t idx_mesh_arr = 0; idx_mesh_arr < pNode->mNumMeshes; idx_mesh_arr++) Draw_Mesh(pNode->mMeshes[idx_mesh_arr]);
// Draw all children nodes
for(size_t idx_node = 0; idx_node < pNode->mNumChildren; idx_node++) Draw_Node(pNode->mChildren[idx_node]);
// Restore transformation matrix.
glPopMatrix();
}
void CGLView::Draw_Mesh(const size_t pMesh_Index)
{
// Check argument
if(pMesh_Index >= mHelper_Mesh_Quantity) return;
aiMesh& mesh_cur = *mScene->mMeshes[pMesh_Index];
if(!mesh_cur.HasPositions()) return;// Nothing to draw.
// If mesh use material then apply it
if(mScene->HasMaterials()) Material_Apply(mScene->mMaterials[mesh_cur.mMaterialIndex]);
//
// Vertices array
//
glEnableClientState(GL_VERTEX_ARRAY);
#if ASSIMP_DOUBLE_PRECISION
glVertexPointer(3, GL_DOUBLE, 0, mesh_cur.mVertices);
#else
glVertexPointer(3, GL_FLOAT, 0, mesh_cur.mVertices);
#endif // ASSIMP_DOUBLE_PRECISION
if(mesh_cur.HasVertexColors(0))
{
glEnable(GL_COLOR_MATERIAL);///TODO: cache
glEnableClientState(GL_COLOR_ARRAY);
#ifdef ASSIMP_DOUBLE_PRECISION
glColorPointer(4, GL_DOUBLE, 0, mesh_cur.mColors[0]);
#else
glColorPointer(4, GL_FLOAT, 0, mesh_cur.mColors[0]);
#endif // ASSIMP_DOUBLE_PRECISION
}
//
// Texture coordinates array
//
if(mesh_cur.HasTextureCoords(0))
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
#ifdef ASSIMP_DOUBLE_PRECISION
glTexCoordPointer(2, GL_DOUBLE, sizeof(aiVector3D), mesh_cur.mTextureCoords[0]);
#else
glTexCoordPointer(2, GL_FLOAT, sizeof(aiVector3D), mesh_cur.mTextureCoords[0]);
#endif // ASSIMP_DOUBLE_PRECISION
}
//
// Normals array
//
if(mesh_cur.HasNormals())
{
glEnableClientState(GL_NORMAL_ARRAY);
#ifdef ASSIMP_DOUBLE_PRECISION
glNormalPointer(GL_DOUBLE, 0, mesh_cur.mNormals);
#else
glNormalPointer(GL_FLOAT, 0, mesh_cur.mNormals);
#endif // ASSIMP_DOUBLE_PRECISION
}
//
// Draw arrays
//
SHelper_Mesh& helper_cur = *mHelper_Mesh[pMesh_Index];
if(helper_cur.Quantity_Triangle > 0) glDrawElements(GL_TRIANGLES, helper_cur.Quantity_Triangle * 3, GL_UNSIGNED_INT, helper_cur.Index_Triangle);
if(helper_cur.Quantity_Line > 0) glDrawElements(GL_LINES,helper_cur.Quantity_Line * 2, GL_UNSIGNED_INT, helper_cur.Index_Line);
if(helper_cur.Quantity_Point > 0) glDrawElements(GL_POINTS, helper_cur.Quantity_Point, GL_UNSIGNED_INT, helper_cur.Index_Point);
//
// Clean up
//
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
void CGLView::Draw_BBox(const SBBox& pBBox)
{
aiVector3D vertex[8];
BBox_GetVertices(pBBox, vertex);
// Draw
if(mLightingEnabled) glDisable(GL_LIGHTING);///TODO: display list
glEnable(GL_COLOR_MATERIAL);
glBindTexture(GL_TEXTURE_1D, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_3D, 0);
const QColor c_w(Qt::white);
glColor3f(c_w.redF(), c_w.greenF(), c_w.blueF());
glBegin(GL_LINE_STRIP);
# ifdef ASSIMP_DOUBLE_PRECISION
glVertex3dv(&vertex[0][0]), glVertex3dv(&vertex[1][0]), glVertex3dv(&vertex[2][0]), glVertex3dv(&vertex[3][0]), glVertex3dv(&vertex[0][0]);// "Minimum" side.
glVertex3dv(&vertex[4][0]), glVertex3dv(&vertex[5][0]), glVertex3dv(&vertex[6][0]), glVertex3dv(&vertex[7][0]), glVertex3dv(&vertex[4][0]);// Edge and "maximum" side.
# else
glVertex3fv(&vertex[0][0]), glVertex3fv(&vertex[1][0]), glVertex3fv(&vertex[2][0]), glVertex3fv(&vertex[3][0]), glVertex3fv(&vertex[0][0]);// "Minimum" side.
glVertex3fv(&vertex[4][0]), glVertex3fv(&vertex[5][0]), glVertex3fv(&vertex[6][0]), glVertex3fv(&vertex[7][0]), glVertex3fv(&vertex[4][0]);// Edge and "maximum" side.
# endif // ASSIMP_DOUBLE_PRECISION
glEnd();
glBegin(GL_LINES);
# ifdef ASSIMP_DOUBLE_PRECISION
glVertex3dv(&vertex[1][0]), glVertex3dv(&vertex[5][0]);
glVertex3dv(&vertex[2][0]), glVertex3dv(&vertex[6][0]);
glVertex3dv(&vertex[3][0]), glVertex3dv(&vertex[7][0]);
# else
glVertex3fv(&vertex[1][0]), glVertex3fv(&vertex[5][0]);
glVertex3fv(&vertex[2][0]), glVertex3fv(&vertex[6][0]);
glVertex3fv(&vertex[3][0]), glVertex3fv(&vertex[7][0]);
# endif // ASSIMP_DOUBLE_PRECISION
glEnd();
glDisable(GL_COLOR_MATERIAL);
if(mLightingEnabled) glEnable(GL_LIGHTING);
}
void CGLView::Enable_Textures(const bool pEnable) {
if(pEnable) {
glEnable(GL_TEXTURE_1D);
glEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_3D);
} else {
glDisable(GL_TEXTURE_1D);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_3D);
}
}
void CGLView::initializeGL() {
mGLContext_Current = true;
initializeOpenGLFunctions();
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_TEXTURE_2D);
glEnable( GL_MULTISAMPLE );
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glDisable(GL_COLOR_MATERIAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
}
void CGLView::resizeGL(int width, int height) {
mCamera_Viewport_AspectRatio = (GLdouble)width / height;
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(mCamera_FOVY, mCamera_Viewport_AspectRatio, 1.0, 100000.0);///TODO: znear/zfar depend on scene size.
}
void CGLView::drawCoordSystem() {
// Disable lighting. Colors must be bright and colorful)
if ( mLightingEnabled ) glDisable( GL_LIGHTING );///TODO: display list
// For same reason - disable textures.
glBindTexture(GL_TEXTURE_1D, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_3D, 0);
glEnable(GL_COLOR_MATERIAL);
glBegin(GL_LINES);
// X, -X
glColor3f(1.0f, 0.0f, 0.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(100000.0, 0.0, 0.0);
glColor3f(0.5f, 0.5f, 1.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(-100000.0, 0.0, 0.0);
// Y, -Y
glColor3f(0.0f, 1.0f, 0.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 100000.0, 0.0);
glColor3f(1.0f, 0.0f, 1.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, -100000.0, 0.0);
// Z, -Z
glColor3f(0.0f, 0.0f, 1.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 0.0, 100000.0);
glColor3f(1.0f, 1.0f, 0.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 0.0, -100000.0);
glColor3f(1.0f, 1.0f, 1.0f);
glEnd();
// Restore previous state of lighting.
if (mLightingEnabled) {
glEnable( GL_LIGHTING );
}
}
void CGLView::paintGL() {
QTime time_paintbegin;
time_paintbegin = QTime::currentTime();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Apply current camera transformations.
#if ASSIMP_DOUBLE_PRECISION
glMultMatrixd((GLdouble*)&mHelper_Camera.Rotation_AroundCamera);
glTranslated(-mHelper_Camera.Translation_ToScene.x, -mHelper_Camera.Translation_ToScene.y, -mHelper_Camera.Translation_ToScene.z);
glMultMatrixd((GLdouble*)&mHelper_Camera.Rotation_Scene);
#else
glMultMatrixf((GLfloat*)&mHelper_Camera.Rotation_AroundCamera);
glTranslatef(-mHelper_Camera.Translation_ToScene.x, -mHelper_Camera.Translation_ToScene.y, -mHelper_Camera.Translation_ToScene.z);
glMultMatrixf((GLfloat*)&mHelper_Camera.Rotation_Scene);
#endif // ASSIMP_DOUBLE_PRECISION
// Coordinate system
if ( mScene_AxesEnabled ) {
drawCoordSystem();
}
glDisable(GL_COLOR_MATERIAL);
// Scene
if(mScene != nullptr) {
Draw_Node(mScene->mRootNode);
// Scene BBox
if (mScene_DrawBBox) {
Draw_BBox( mScene_BBox );
}
}
emit Paint_Finished((size_t) time_paintbegin.msecsTo(QTime::currentTime()), mHelper_Camera.Translation_ToScene.Length());
}
CGLView::CGLView( QWidget *pParent )
: QOpenGLWidget( pParent )
, mGLContext_Current( false ) {
// set initial view
mHelper_CameraDefault.SetDefault();
Camera_Set( 0 );
}
CGLView::~CGLView() {
FreeScene();
}
void CGLView::FreeScene() {
// Set scene to null and after that \ref paintGL will not try to render it.
mScene = nullptr;
// Clean helper objects.
if(mHelper_Mesh != nullptr)
{
for(size_t idx_mesh = 0; idx_mesh < mHelper_Mesh_Quantity; idx_mesh++) delete mHelper_Mesh[idx_mesh];
delete [] mHelper_Mesh;
mHelper_Mesh = nullptr;
}
mHelper_Mesh_Quantity = 0;
// Delete textures
const int id_tex_size = mTexture_IDMap.size();
if(id_tex_size)
{
GLuint* id_tex = new GLuint[id_tex_size];
QMap<QString, GLuint>::iterator it = mTexture_IDMap.begin();
for(int idx = 0; idx < id_tex_size; idx++, it++)
{
id_tex[idx] = it.value();
}
glDeleteTextures(id_tex_size, id_tex);
mTexture_IDMap.clear();
delete [] id_tex;
}
}
void CGLView::SetScene(const aiScene *pScene, const QString& pScenePath) {
FreeScene();// Clear old data
// Why checking here, not at begin of function. Because old scene may not exist at know. So, need cleanup.
if (pScene == nullptr) {
return;
}
mScene = pScene;// Copy pointer of new scene.
//
// Meshes
//
// Create helper objects for meshes. This allow to render meshes as OpenGL arrays.
if(mScene->HasMeshes())
{
// Create mesh helpers array.
mHelper_Mesh_Quantity = mScene->mNumMeshes;
mHelper_Mesh = new SHelper_Mesh*[mScene->mNumMeshes];
// Walk through the meshes and extract needed data and, also calculate BBox.
for(size_t idx_mesh = 0; idx_mesh < mScene->mNumMeshes; idx_mesh++)
{
aiMesh& mesh_cur = *mScene->mMeshes[idx_mesh];
//
// Calculate BBox
//
SBBox mesh_bbox;
BBox_GetFromVertices(mesh_cur.mVertices, mesh_cur.mNumVertices, mesh_bbox);
//
// Create vertices indices arrays splitted by primitive type.
//
size_t indcnt_p = 0;// points quantity
size_t indcnt_l = 0;// lines quantity
size_t indcnt_t = 0;// triangles quantity
if(mesh_cur.HasFaces())
{
// Usual way: all faces are triangles
if(mesh_cur.mPrimitiveTypes == aiPrimitiveType_TRIANGLE)
{
indcnt_t = mesh_cur.mNumFaces;
}
else
{
// Calculate count of primitives by types.
for(size_t idx_face = 0; idx_face < mesh_cur.mNumFaces; idx_face++)
{
if(mesh_cur.mFaces[idx_face].mNumIndices == 3)
indcnt_t++;
else if(mesh_cur.mFaces[idx_face].mNumIndices == 2)
indcnt_l++;
else if(mesh_cur.mFaces[idx_face].mNumIndices == 1)
indcnt_p++;
}
}// if(mesh_cur.mPrimitiveTypes == aiPrimitiveType_TRIANGLE) else
// Create helper
mHelper_Mesh[idx_mesh] = new SHelper_Mesh(indcnt_p, indcnt_l, indcnt_t, mesh_bbox);
// Fill indices arrays
indcnt_p = 0, indcnt_l = 0, indcnt_t = 0;// Reuse variables as indices
for(size_t idx_face = 0; idx_face < mesh_cur.mNumFaces; idx_face++)
{
if(mesh_cur.mFaces[idx_face].mNumIndices == 3)
{
mHelper_Mesh[idx_mesh]->Index_Triangle[indcnt_t++] = mesh_cur.mFaces[idx_face].mIndices[0];
mHelper_Mesh[idx_mesh]->Index_Triangle[indcnt_t++] = mesh_cur.mFaces[idx_face].mIndices[1];
mHelper_Mesh[idx_mesh]->Index_Triangle[indcnt_t++] = mesh_cur.mFaces[idx_face].mIndices[2];
}
else if(mesh_cur.mFaces[idx_face].mNumIndices == 2)
{
mHelper_Mesh[idx_mesh]->Index_Line[indcnt_l++] = mesh_cur.mFaces[idx_face].mIndices[0];
mHelper_Mesh[idx_mesh]->Index_Line[indcnt_l++] = mesh_cur.mFaces[idx_face].mIndices[1];
}
else if(mesh_cur.mFaces[idx_face].mNumIndices == 1)
{
mHelper_Mesh[idx_mesh]->Index_Point[indcnt_p++] = mesh_cur.mFaces[idx_face].mIndices[0];
}
}// for(size_t idx_face = 0; idx_face < mesh_cur.mNumFaces; idx_face++)
}// if(mesh_cur.HasFaces())
else
{
// If mesh has no faces then vertices can be just points set.
indcnt_p = mesh_cur.mNumVertices;
// Create helper
mHelper_Mesh[idx_mesh] = new SHelper_Mesh(indcnt_p, 0, 0, mesh_bbox);
// Fill indices arrays
for(size_t idx = 0; idx < indcnt_p; idx++) mHelper_Mesh[idx_mesh]->Index_Point[idx] = idx;
}// if(mesh_cur.HasFaces()) else
}// for(size_t idx_mesh = 0; idx_mesh < mScene->mNumMeshes; idx_mesh++)
}// if(mScene->HasMeshes())
//
// Scene BBox
//
// For calculating right BBox we must walk through all nodes and apply transformation to meshes BBoxes
if(mHelper_Mesh_Quantity > 0)
{
bool first_assign = true;
aiMatrix4x4 mat_root;
BBox_GetForNode(*mScene->mRootNode, mat_root, mScene_BBox, first_assign);
mScene_Center = mScene_BBox.Maximum + mScene_BBox.Minimum;
mScene_Center /= 2;
}
else
{
mScene_BBox = {{0, 0, 0}, {0, 0, 0}};
mScene_Center = {0, 0, 0};
}// if(mHelper_Mesh_Count > 0) else
//
// Textures
//
ImportTextures(pScenePath);
//
// Light sources
//
Lighting_Enable();
// If scene has no lights then enable default
if(!mScene->HasLights())
{
const GLfloat col_amb[4] = { 0.2, 0.2, 0.2, 1.0 };
SLightParameters lp;
lp.Type = aiLightSource_POINT;
lp.Ambient.r = col_amb[0], lp.Ambient.g = col_amb[1], lp.Ambient.b = col_amb[2], lp.Ambient.a = col_amb[3];
lp.Diffuse = { 1.0, 1.0, 1.0, 1.0 };
lp.Specular = lp.Diffuse;
lp.For.Point.Position = mScene_Center;
lp.For.Point.Attenuation_Constant = 1;
lp.For.Point.Attenuation_Linear = 0;
lp.For.Point.Attenuation_Quadratic = 0;
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col_amb);
Lighting_EditSource(0, lp);
emit SceneObject_LightSource("_default");// Light source will be enabled in signal handler.
}
else
{
for(size_t idx_light = 0; idx_light < mScene->mNumLights; idx_light++)
{
SLightParameters lp;
QString name;
const aiLight& light_cur = *mScene->mLights[idx_light];
auto col3_to_col4 = [](const aiColor3D& pCol3) -> aiColor4D { return aiColor4D(pCol3.r, pCol3.g, pCol3.b, 1.0); };
///TODO: find light source node and apply all transformations
// General properties
name = light_cur.mName.C_Str();
lp.Ambient = col3_to_col4(light_cur.mColorAmbient);
lp.Diffuse = col3_to_col4(light_cur.mColorDiffuse);
lp.Specular = col3_to_col4(light_cur.mColorSpecular);
lp.Type = light_cur.mType;
// Depend on type properties
switch(light_cur.mType)
{
case aiLightSource_DIRECTIONAL:
lp.For.Directional.Direction = light_cur.mDirection;
break;
case aiLightSource_POINT:
lp.For.Point.Position = light_cur.mPosition;
lp.For.Point.Attenuation_Constant = light_cur.mAttenuationConstant;
lp.For.Point.Attenuation_Linear = light_cur.mAttenuationLinear;
lp.For.Point.Attenuation_Quadratic = light_cur.mAttenuationQuadratic;
break;
case aiLightSource_SPOT:
lp.For.Spot.Position = light_cur.mPosition;
lp.For.Spot.Direction = light_cur.mDirection;
lp.For.Spot.Attenuation_Constant = light_cur.mAttenuationConstant;
lp.For.Spot.Attenuation_Linear = light_cur.mAttenuationLinear;
lp.For.Spot.Attenuation_Quadratic = light_cur.mAttenuationQuadratic;
lp.For.Spot.CutOff = light_cur.mAngleOuterCone;
break;
case aiLightSource_AMBIENT:
lp.For.Point.Position = light_cur.mPosition, lp.For.Point.Attenuation_Constant = 1, lp.For.Point.Attenuation_Linear = 0, lp.For.Point.Attenuation_Quadratic = 0;
name.append("_unsup_ambient");
break;
case aiLightSource_AREA:
lp.For.Point.Position = light_cur.mPosition, lp.For.Point.Attenuation_Constant = 1, lp.For.Point.Attenuation_Linear = 0, lp.For.Point.Attenuation_Quadratic = 0;
name.append("_unsup_area");
break;
case aiLightSource_UNDEFINED:
lp.For.Point.Position = light_cur.mPosition, lp.For.Point.Attenuation_Constant = 1, lp.For.Point.Attenuation_Linear = 0, lp.For.Point.Attenuation_Quadratic = 0;
name.append("_unsup_undefined");
break;
default:
lp.For.Point.Position = light_cur.mPosition, lp.For.Point.Attenuation_Constant = 1, lp.For.Point.Attenuation_Linear = 0, lp.For.Point.Attenuation_Quadratic = 0;
name.append("_unsupported_invalid");
break;
}// switch(light_cur.mType)
// Add light source
// Use index if name is empty.
if (name.isEmpty()) {
name += QString( "%1" ).arg( idx_light );
}
Lighting_EditSource(idx_light, lp);
emit SceneObject_LightSource(name);// Light source will be enabled in signal handler.
}// for(size_t idx_light = 0; idx_light < mScene->mNumLights; idx_light++)
}// if(!mScene->HasLights()) else
//
// Cameras
//
if(!mScene->HasCameras())
{
mCamera_DefaultAdded = true;
mHelper_CameraDefault.SetDefault();
// Calculate distance from camera to scene. Distance must be enoguh for that viewport contain whole scene.
const GLfloat tg_angle = tan(mCamera_FOVY / 2);
GLfloat val_x = ((mScene_BBox.Maximum.x - mScene_BBox.Minimum.x) / 2) / (mCamera_Viewport_AspectRatio * tg_angle);
GLfloat val_y = ((mScene_BBox.Maximum.y - mScene_BBox.Minimum.y) / 2) / tg_angle;
GLfloat val_step = val_x;
AssignIfGreater(val_step, val_y);
mHelper_CameraDefault.Translation_ToScene.Set(mScene_Center.x, mScene_Center.y, val_step + mScene_BBox.Maximum.z);
emit SceneObject_Camera("_default");
}
else
{
mCamera_DefaultAdded = false;
for(size_t idx_cam = 0; idx_cam < mScene->mNumCameras; idx_cam++)
{
emit SceneObject_Camera(mScene->mCameras[idx_cam]->mName.C_Str());
}
}// if(!mScene->HasCameras()) else
}
void CGLView::Lighting_Enable() {
mLightingEnabled = true;
glEnable(GL_LIGHTING);
}
void CGLView::Lighting_Disable() {
glDisable( GL_LIGHTING );
mLightingEnabled = false;
}
void CGLView::Lighting_EditSource(const size_t pLightNumber, const SLightParameters& pLightParameters)
{
const size_t light_num = GL_LIGHT0 + pLightNumber;
GLfloat farr[4];
if(pLightNumber >= GL_MAX_LIGHTS) return;///TODO: return value;
// Ambient color
farr[0] = pLightParameters.Ambient.r;
farr[1] = pLightParameters.Ambient.g;
farr[2] = pLightParameters.Ambient.b;
farr[3] = pLightParameters.Ambient.a;
glLightfv(light_num, GL_AMBIENT, farr);
// Diffuse color
farr[0] = pLightParameters.Diffuse.r;
farr[1] = pLightParameters.Diffuse.g;
farr[2] = pLightParameters.Diffuse.b;
farr[3] = pLightParameters.Diffuse.a;
glLightfv(light_num, GL_DIFFUSE, farr);
// Specular color
farr[0] = pLightParameters.Specular.r;
farr[1] = pLightParameters.Specular.g;
farr[2] = pLightParameters.Specular.b;
farr[3] = pLightParameters.Specular.a;
glLightfv(light_num, GL_SPECULAR, farr);
// Other parameters
switch(pLightParameters.Type)
{
case aiLightSource_DIRECTIONAL:
// Direction
farr[0] = pLightParameters.For.Directional.Direction.x, farr[1] = pLightParameters.For.Directional.Direction.y;
farr[2] = pLightParameters.For.Directional.Direction.z; farr[3] = 0;
glLightfv(light_num, GL_POSITION, farr);
break;
case aiLightSource_POINT:
// Position
farr[0] = pLightParameters.For.Point.Position.x, farr[1] = pLightParameters.For.Point.Position.y;
farr[2] = pLightParameters.For.Point.Position.z; farr[3] = 1;
glLightfv(light_num, GL_POSITION, farr);
// Attenuation
glLightf(light_num, GL_CONSTANT_ATTENUATION, pLightParameters.For.Point.Attenuation_Constant);
glLightf(light_num, GL_LINEAR_ATTENUATION, pLightParameters.For.Point.Attenuation_Linear);
glLightf(light_num, GL_QUADRATIC_ATTENUATION, pLightParameters.For.Point.Attenuation_Quadratic);
glLightf(light_num, GL_SPOT_CUTOFF, 180.0);
break;
case aiLightSource_SPOT:
// Position
farr[0] = pLightParameters.For.Spot.Position.x, farr[1] = pLightParameters.For.Spot.Position.y, farr[2] = pLightParameters.For.Spot.Position.z; farr[3] = 1;
glLightfv(light_num, GL_POSITION, farr);
// Attenuation
glLightf(light_num, GL_CONSTANT_ATTENUATION, pLightParameters.For.Spot.Attenuation_Constant);
glLightf(light_num, GL_LINEAR_ATTENUATION, pLightParameters.For.Spot.Attenuation_Linear);
glLightf(light_num, GL_QUADRATIC_ATTENUATION, pLightParameters.For.Spot.Attenuation_Quadratic);
// Spot specific
farr[0] = pLightParameters.For.Spot.Direction.x, farr[1] = pLightParameters.For.Spot.Direction.y, farr[2] = pLightParameters.For.Spot.Direction.z; farr[3] = 0;
glLightfv(light_num, GL_SPOT_DIRECTION, farr);
glLightf(light_num, GL_SPOT_CUTOFF, pLightParameters.For.Spot.CutOff);
break;
default:// For unknown light source types use point source.
// Position
farr[0] = pLightParameters.For.Point.Position.x, farr[1] = pLightParameters.For.Point.Position.y;
farr[2] = pLightParameters.For.Point.Position.z; farr[3] = 1;
glLightfv(light_num, GL_POSITION, farr);
// Attenuation
glLightf(light_num, GL_CONSTANT_ATTENUATION, 1);
glLightf(light_num, GL_LINEAR_ATTENUATION, 0);
glLightf(light_num, GL_QUADRATIC_ATTENUATION, 0);
glLightf(light_num, GL_SPOT_CUTOFF, 180.0);
break;
}// switch(pLightParameters.Type)
}
void CGLView::Lighting_EnableSource(const size_t pLightNumber) {
if(pLightNumber >= GL_MAX_LIGHTS) return;///TODO: return value;
glEnable(GL_LIGHT0 + pLightNumber);
}
void CGLView::Lighting_DisableSource(const size_t pLightNumber)
{
if(pLightNumber >= GL_MAX_LIGHTS) return;///TODO: return value;
glDisable(GL_LIGHT0 + pLightNumber);
}
void CGLView::Camera_Set(const size_t pCameraNumber)
{
SHelper_Camera& hcam = mHelper_Camera;// reference with short name for conveniance.
aiVector3D up;
if(mCamera_DefaultAdded || (pCameraNumber >= mScene->mNumCameras))// If default camera used then 'pCameraNumber' doesn't matter.
{
// Transformation parameters
hcam = mHelper_CameraDefault;
up.Set(0, 1, 0);
}
else
{
const aiCamera& camera_cur = *mScene->mCameras[pCameraNumber];
const aiNode* camera_node;
aiMatrix4x4 camera_mat;
aiQuaternion camera_quat_rot;
aiVector3D camera_tr;
up = camera_cur.mUp;
//
// Try to get real coordinates of the camera.
//
// Find node
camera_node = mScene->mRootNode->FindNode(camera_cur.mName);
if(camera_node != nullptr) Matrix_NodeToRoot(camera_node, camera_mat);
hcam.Position = camera_cur.mLookAt;
hcam.Target = camera_cur.mPosition;
hcam.Rotation_AroundCamera = aiMatrix4x4(camera_quat_rot.GetMatrix());
hcam.Rotation_AroundCamera.Transpose();
// get components of transformation matrix.
camera_mat.DecomposeNoScaling(camera_quat_rot, camera_tr);
hcam.Rotation_Scene = aiMatrix4x4();
hcam.Translation_ToScene = camera_tr;
}
// Load identity matrix - travel to world begin.
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Set camera and update picture
gluLookAt(hcam.Position.x, hcam.Position.y, hcam.Position.z, hcam.Target.x, hcam.Target.y, hcam.Target.z, up.x, up.y, up.z);
}
void CGLView::Camera_RotateScene(const GLfloat pAngle_X, const GLfloat pAngle_Y, const GLfloat pAngle_Z, const aiMatrix4x4* pMatrix_Rotation_Initial) {
auto deg2rad = [](const GLfloat pDegree) -> GLfloat {
return pDegree * AI_MATH_PI / 180.0f;
};
aiMatrix4x4 mat_rot;
mat_rot.FromEulerAnglesXYZ(deg2rad(pAngle_X), deg2rad(pAngle_Y), deg2rad(pAngle_Z));
if(pMatrix_Rotation_Initial != nullptr)
mHelper_Camera.Rotation_Scene = *pMatrix_Rotation_Initial * mat_rot;
else
mHelper_Camera.Rotation_Scene *= mat_rot;
}
void CGLView::Camera_Rotate(const GLfloat pAngle_X, const GLfloat pAngle_Y, const GLfloat pAngle_Z, const aiMatrix4x4* pMatrix_Rotation_Initial)
{
auto deg2rad = [](const GLfloat pDegree) -> GLfloat { return pDegree * AI_MATH_PI / 180.0; };
aiMatrix4x4 mat_rot;
mat_rot.FromEulerAnglesXYZ(deg2rad(pAngle_X), deg2rad(pAngle_Y), deg2rad(pAngle_Z));
if(pMatrix_Rotation_Initial != nullptr)
mHelper_Camera.Rotation_AroundCamera = *pMatrix_Rotation_Initial * mat_rot;
else
mHelper_Camera.Rotation_AroundCamera *= mat_rot;
}
void CGLView::Camera_Translate(const GLfloat pTranslate_X, const GLfloat pTranslate_Y, const GLfloat pTranslate_Z)
{
aiVector3D vect_tr(pTranslate_X, pTranslate_Y, pTranslate_Z);
vect_tr *= mHelper_Camera.Rotation_AroundCamera;
mHelper_Camera.Translation_ToScene += vect_tr;
}
void CGLView::Camera_Matrix(aiMatrix4x4& pRotation_Camera, aiMatrix4x4& pRotation_Scene, aiVector3D& pTranslation_Camera)
{
pRotation_Camera = mHelper_Camera.Rotation_AroundCamera;
pRotation_Scene = mHelper_Camera.Rotation_Scene;
pTranslation_Camera = mHelper_Camera.Translation_ToScene;
}