/*
---------------------------------------------------------------------------
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;
}