assimp/tools/assimp_qt_viewer/glview.cpp

/// \file   glview.cpp
/// \brief  OpenGL visualisation. Implementation file.
/// \author smal.root@gmail.com
/// \date   2016

#include "glview.hpp"

// Header files, OpenGL.
#include <GL/glu.h>

// Header files, DevIL.
#include <il.h>

// Header files, Assimp.
#include <assimp/DefaultLogger.hpp>

#ifndef __unused
	#define __unused	__attribute__((unused))
#endif // __unused

/**********************************/
/********** SHelper_Mesh **********/
/**********************************/

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()
{
	if(Index_Point != nullptr) delete [] Index_Point;
	if(Index_Line != nullptr) delete [] Index_Line;
	if(Index_Triangle != nullptr) delete [] Index_Triangle;
}

/**********************************/
/********** SHelper_Mesh **********/
/**********************************/

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);
}

/**********************************/
/************ CGLView *************/
/**********************************/

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;

    auto 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; };
    auto 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; };

	///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
	float 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& pScenePath)
{
    auto LoadTexture = [&](const QString& pFileName) -> bool ///TODO: IME texture mode, operation.
    {
        ILboolean success;
        GLuint id_ogl_texture;// OpenGL texture ID.

	    if(!pFileName.startsWith(AI_EMBEDDED_TEXNAME_PREFIX))
	    {
		    ILuint id_image;// DevIL image ID.
		    QString basepath = pScenePath.left(pScenePath.lastIndexOf('/') + 1);// path with '/' at the end.
		    QString fileloc = (basepath + pFileName);

		    fileloc.replace('\\', "/");
		    ilGenImages(1, &id_image);// Generate DevIL image ID.
		    ilBindImage(id_image);
		    success = ilLoadImage(fileloc.toLocal8Bit());
		    if(!success)
		    {
			    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.
		    success = ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
		    if(!success)
		    {
			    LogError("Couldn't convert image.");

			    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.
		    glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0,
						    ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData());// Texture specification.

		    //Cleanup
		    ilDeleteImages(1, &id_image);// Because we have already copied image data into texture data we can release memory used by image.
	    }
	    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;
	}

	// Before calling ilInit() version should be checked.
	if(ilGetInteger(IL_VERSION_NUM) < IL_VERSION)
	{
		LogError("Wrong DevIL version.");

		return;
	}

	ilInit();// Initialization of DevIL.
	//
	// 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.size() == 0)
	{
		LogInfo("No textures for import.");

		return;
	}
}

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 GLfloat x = pVertices[idx_vert].x;
		const GLfloat y = pVertices[idx_vert].y;
		const GLfloat 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);
	}
}

/********************************************************************/
/************************ Logging functions *************************/
/********************************************************************/

void CGLView::LogInfo(const QString& pMessage)
{
	Assimp::DefaultLogger::get()->info(pMessage.toStdString());
}

void CGLView::LogError(const QString& pMessage)
{
	Assimp::DefaultLogger::get()->error(pMessage.toStdString());
}

/********************************************************************/
/************************** Draw functions **************************/
/********************************************************************/

void CGLView::Draw_Node(const aiNode* pNode)
{
    aiMatrix4x4 mat_node = pNode->mTransformation;

	// Apply node transformation matrix.
	mat_node.Transpose();
	glPushMatrix();
	glMultMatrixf((GLfloat*)&mat_node);
	// 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);
	glVertexPointer(3, GL_FLOAT, 0, mesh_cur.mVertices);

	if(mesh_cur.HasVertexColors(0))
	{
		glEnable(GL_COLOR_MATERIAL);///TODO: cache
		glEnableClientState(GL_COLOR_ARRAY);
		glColorPointer(4, GL_FLOAT, 0, mesh_cur.mColors[0]);
	}

	//
	// Texture coordinates array
	//
	if(mesh_cur.HasTextureCoords(0))
	{
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		glTexCoordPointer(2, GL_FLOAT, sizeof(aiVector3D), mesh_cur.mTextureCoords[0]);
	}

	//
	// Normals array
	//
	if(mesh_cur.HasNormals())
	{
		glEnableClientState(GL_NORMAL_ARRAY);
		glNormalPointer(GL_FLOAT, 0, mesh_cur.mNormals);
	}

	//
	// 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);
	qglColor(QColor(Qt::white));
	glBegin(GL_LINE_STRIP);
		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.
	glEnd();
	glBegin(GL_LINES);
		glVertex3fv(&vertex[1][0]), glVertex3fv(&vertex[5][0]);
		glVertex3fv(&vertex[2][0]), glVertex3fv(&vertex[6][0]);
		glVertex3fv(&vertex[3][0]), glVertex3fv(&vertex[7][0]);
	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);
	}
}

/********************************************************************/
/*********************** Overrided functions ************************/
/********************************************************************/

void CGLView::initializeGL()
{
	qglClearColor(Qt::gray);
	glShadeModel(GL_SMOOTH);

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_NORMALIZE);
	glEnable(GL_TEXTURE_2D);

	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 pWidth, int pHeight)
{
	mCamera_Viewport_AspectRatio = (GLdouble)pWidth / pHeight;
	glViewport(0, 0, pWidth, pHeight);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(mCamera_FOVY, mCamera_Viewport_AspectRatio, 1.0, 100000.0);///TODO: znear/zfar depend on scene size.
}

void CGLView::drawCoordSystem() {
    glBindTexture(GL_TEXTURE_1D, 0);
    glBindTexture(GL_TEXTURE_2D, 0);
    glBindTexture(GL_TEXTURE_3D, 0);
    glEnable(GL_COLOR_MATERIAL);
    glBegin(GL_LINES);
    // X, -X
    qglColor(QColor(Qt::red)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(100000.0, 0.0, 0.0);
    qglColor(QColor(Qt::cyan)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(-100000.0, 0.0, 0.0);
    // Y, -Y
    qglColor(QColor(Qt::green)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 100000.0, 0.0);
    qglColor(QColor(Qt::magenta)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, -100000.0, 0.0);
    // Z, -Z
    qglColor(QColor(Qt::blue)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 0.0, 100000.0);
    qglColor(QColor(Qt::yellow)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 0.0, -100000.0);
    glEnd();
}

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.
	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);
	// Coordinate system
    if ( mLightingEnabled ) {
        glDisable( GL_LIGHTING );///TODO: display list
    }
    drawCoordSystem();

	glDisable(GL_COLOR_MATERIAL);
	if(mLightingEnabled) glEnable(GL_LIGHTING);

	// 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());
}

/********************************************************************/
/********************** Constructor/Destructor **********************/
/********************************************************************/

CGLView::CGLView(QWidget *pParent)
	: QGLWidget(QGLFormat(QGL::DoubleBuffer | QGL::DepthBuffer), pParent)
{
	static_assert(sizeof(GLfloat) == sizeof(ai_real), "ai_real in Assimp must be equal to GLfloat/float.");///TODO: may be templates can be used.

	// set initial view
	mHelper_CameraDefault.SetDefault();
	Camera_Set(0);
}

CGLView::~CGLView()
{
	FreeScene();
}

/********************************************************************/
/********************* Scene control functions **********************/
/********************************************************************/

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 splited 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
			if(name.isEmpty()) name += QString("%1").arg(idx_light);// Use index if name is empty.

			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
}

/********************************************************************/
/******************** Lighting control functions ********************/
/********************************************************************/

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;

	glLightfv(light_num, GL_AMBIENT, &pLightParameters.Ambient.r);// Ambient color
	glLightfv(light_num, GL_DIFFUSE, &pLightParameters.Diffuse.r);// Diffuse color
	glLightfv(light_num, GL_SPECULAR, &pLightParameters.Specular.r);// Specular color
	// Other parameters
	switch(pLightParameters.Type)
	{
		case aiLightSource_DIRECTIONAL:
			// Direction
			farr[0] = pLightParameters.For.Directional.Direction.x, farr[2] = 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[2] = 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[2] = 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[2] = 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[2] = 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);
}

/********************************************************************/
/******************** Cameras control functions *********************/
/********************************************************************/

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)
{
auto deg2rad = [](const GLfloat pDegree) -> GLfloat { return pDegree * M_PI / 180.0; };

	aiMatrix4x4 mat_rot;

	mat_rot.FromEulerAnglesXYZ(deg2rad(pAngle_X), deg2rad(pAngle_Y), deg2rad(pAngle_Z));
	mHelper_Camera.Rotation_Scene *= mat_rot;
}

void CGLView::Camera_Rotate(const GLfloat pAngle_X, const GLfloat pAngle_Y, const GLfloat pAngle_Z)
{
auto deg2rad = [](const GLfloat pDegree) -> GLfloat { return pDegree * M_PI / 180.0; };

	aiMatrix4x4 mat_rot;

	mat_rot.FromEulerAnglesXYZ(deg2rad(pAngle_X), deg2rad(pAngle_Y), deg2rad(pAngle_Z));
	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;
}