Update 'README.md'

Features:
- fixed overexposed specular bug,
- most settings are saved after each session
Bugs:
-nothing known

QtMeshViewer/Form Files/MainWindow.ui

@@ -19,7 +19,9 @@
   <property name="windowTitle">
    <string>MainWindow</string>
   </property>
-  <widget class="QWidget" name="centralWidget"/>
+  <widget class="QWidget" name="centralWidget">
+   <layout class="QHBoxLayout" name="horizontalLayout"/>
+  </widget>
   <widget class="QToolBar" name="mainToolBar">
    <property name="allowedAreas">
     <set>Qt::LeftToolBarArea|Qt::RightToolBarArea|Qt::TopToolBarArea</set>
@@ -32,6 +34,72 @@
    </attribute>
   </widget>
   <widget class="QStatusBar" name="statusBar"/>
+  <widget class="QDockWidget" name="dockWidget">
+   <property name="autoFillBackground">
+    <bool>false</bool>
+   </property>
+   <property name="features">
+    <set>QDockWidget::DockWidgetClosable|QDockWidget::DockWidgetFloatable</set>
+   </property>
+   <property name="allowedAreas">
+    <set>Qt::RightDockWidgetArea</set>
+   </property>
+   <property name="windowTitle">
+    <string>Asset library</string>
+   </property>
+   <attribute name="dockWidgetArea">
+    <number>2</number>
+   </attribute>
+   <widget class="QWidget" name="dockWidgetContents">
+    <layout class="QVBoxLayout" name="verticalLayout">
+     <property name="spacing">
+      <number>0</number>
+     </property>
+     <property name="leftMargin">
+      <number>0</number>
+     </property>
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <property name="rightMargin">
+      <number>0</number>
+     </property>
+     <property name="bottomMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <widget class="QTreeWidget" name="treeWidget">
+       <property name="showDropIndicator" stdset="0">
+        <bool>false</bool>
+       </property>
+       <property name="dragEnabled">
+        <bool>true</bool>
+       </property>
+       <property name="dragDropMode">
+        <enum>QAbstractItemView::DragOnly</enum>
+       </property>
+       <property name="selectionBehavior">
+        <enum>QAbstractItemView::SelectItems</enum>
+       </property>
+       <property name="verticalScrollMode">
+        <enum>QAbstractItemView::ScrollPerPixel</enum>
+       </property>
+       <property name="headerHidden">
+        <bool>true</bool>
+       </property>
+       <property name="expandsOnDoubleClick">
+        <bool>false</bool>
+       </property>
+       <column>
+        <property name="text">
+         <string notr="true">1</string>
+        </property>
+       </column>
+      </widget>
+     </item>
+    </layout>
+   </widget>
+  </widget>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources>

QtMeshViewer/Header/FileInterface.h

@@ -18,6 +18,9 @@ struct VertexData
 	QVector3D position;
 	QVector2D texCoord;
 	QVector3D vertexNormal;
+	QVector3D polygonNormal;
+	QVector3D tangent;
+	QVector3D bitangent;
 };
 
 struct Segment {
@@ -42,10 +45,10 @@ struct Material {
 	QString tx3d;
 	QOpenGLTexture* texture0 = Q_NULLPTR;
 	QOpenGLTexture* texture1 = Q_NULLPTR;
-	QVector4D specularColor = { 1.0, 1.0, 1.0, 1.0 };
+	QVector4D specularColor = { 0.1f, 0.1f, 0.1f, 1.0 };
 	QVector4D diffuseColor = { 1.0, 0.0, 0.0, 1.0 };
 	QVector4D ambientColor = { 1.0, 1.0, 1.0, 1.0 };
-	float shininess = 80;
+	float shininess = 1;
 	bool flags[8] = { false };
 	bool transparent = false;
 	quint8 rendertype = 0;

QtMeshViewer/Header/GeometryEngine.h

@@ -34,6 +34,7 @@ private:
 // functions
 private:
 	void clearData();
+	void setupPipeline(QOpenGLShaderProgram * program);
 
 public:
 	void drawGeometry(QOpenGLShaderProgram *program);

QtMeshViewer/Header/MainWindow.h

@@ -30,6 +30,8 @@ private:
 // functions
 private:
 	void setupWidgets();
+	void getAssetLibrary();
+	void searchMeshFiles(QString path);
 	void openFile();
 	void takeScreenShot();
 	void aboutTool();

QtMeshViewer/Header/OglViewerWidget.h

@@ -23,19 +23,19 @@ private:
 	QOpenGLShaderProgram m_program;
 	GeometryEngine *m_dataEngine;
 
-	QVector4D m_backgroundColorOn = { 0.02f, 0.02f, 0.02f, 1.0f };
-	QVector4D m_backgroundColorOff = { 0.5f, 0.8f, 1.0f, 1.0f };
+	QVector4D m_backgroundColorOn;
+	QVector4D m_backgroundColorOff;
 
-	bool m_wireframe = false;
-	bool m_lightOn = false;
-	bool m_backfaceCulling = false;
+	bool m_wireframe;
+	bool m_lightOn;
+	bool m_backfaceCulling;
 
 	struct {
-		QVector4D position = { 1,1,1,0 };
-		QVector3D intensities = { 1.0,1.0,1.0 };
-		float attenuationFactor = 0.0f;
-		float ambientCoefficient = 0.005f;
-		bool headlight = false;
+		QVector4D position;
+		QVector3D intensities;
+		float attenuationFactor;
+		float ambientCoefficient;
+		bool headlight;
 	} m_light;
 
 	struct {
@@ -51,6 +51,7 @@ private:
 
 // functions
 private:
+	void setDefaultValues();
 	void initShaders();
 	void resetView();
 	void updateLightPosition();
@@ -89,5 +90,10 @@ public slots:
 	void setHeadlight(bool value);
 	void setBackfaceCulling(bool value);
 
+// signals
+signals:
+	void lightChanged(bool value);
+
+
 };
 

QtMeshViewer/Header/SettingsManager.h

@@ -0,0 +1,72 @@
+#pragma once
+#include <QObject>
+#include <QFile>
+#include <QVector3D>
+#include <QVector4D>
+
+
+class SettingsManager : public QObject
+{
+	Q_OBJECT
+
+private:
+	SettingsManager(QObject *parent = Q_NULLPTR);
+
+public:
+	SettingsManager(SettingsManager const&) = delete;
+	void operator=(SettingsManager const&) = delete;
+
+	~SettingsManager();
+
+	static SettingsManager* getInstance(QObject *parent = Q_NULLPTR);
+
+// attributes
+private:
+	QFile file;
+
+	QVector3D m_bgColorOn = { 5, 5, 5 };
+	QVector3D m_bgColorOff = { 128, 204, 255 };
+	bool m_bfCulling = false;
+	bool m_light = false;
+
+	int m_lightType = 1;	// 1 = direct, 2 = point
+	QVector3D m_lightColor = { 255,255,255 };
+	float m_attenuation = 0.0f;
+	float m_ambient = 0.005f;
+	bool m_headlight = false;
+	bool m_autoColor = true;
+
+// functions
+private:
+	void readFromFile();
+	void writeToFile();
+
+public:
+	QVector3D getBgColorOn() const;
+	QVector3D getBgColorOff() const;
+	bool isBfCulling() const;
+	bool isLight() const;
+
+	int getLightType() const;
+	QVector3D getLightColor() const;
+	float getAttenuation() const;
+	float getAmbient() const;
+	bool isHeadlight() const;
+	bool isAutoColor() const;
+
+
+// slots
+public:
+	void setBgColorOn(QVector3D value);
+	void setBgColorOff(QVector3D value);
+	void setBfCulling(bool value);
+	void setLight(bool value);
+
+	void setLightType(int value);
+	void setLightColor(QVector3D value);
+	void setAttenuation(double value);
+	void setAmbient(double value);
+	void setHeadlight(bool value);
+	void setAutoColor(int value);
+
+};

QtMeshViewer/Header/SettingsWindow.h

@@ -9,7 +9,7 @@ class SettingsWindow : public QWidget
 	Q_OBJECT
 
 public:
-	SettingsWindow(QVector3D bgOffColor, QVector3D bgOnColor, QVector3D lightColor, bool autoColor, double ambCoef, double attFac, int lightType, QWidget * parent = Q_NULLPTR);
+	SettingsWindow(QWidget * parent = Q_NULLPTR);
 	~SettingsWindow();
 
 private:
@@ -33,5 +33,6 @@ signals:
 	void sendHeadlight(bool value);
 	void sendBackfaceCulling(bool value);
 	void sendZommSpeed(int percent);
+	void changeLightType(int value);
 	
 };

QtMeshViewer/Resources/fshader.glsl

@@ -4,16 +4,22 @@ precision mediump int;
 precision mediump float;
 #endif
 
-uniform mat3 n_matrix;
+uniform mat3 normalMatrix;
 uniform vec3 cameraPosition;
 
-uniform sampler2D texture;
-uniform float materialShininess;
-uniform vec3 materialSpecularColor;
+uniform sampler2D tx0;
+uniform sampler2D tx1;
 
-uniform bool b_transparent;
-uniform bool b_specular;
-uniform bool b_light;
+uniform struct Material {
+	float shininess;
+	vec3 specularColor;
+	bool isTransparent;
+	bool hasSpecularmap;
+	bool hasNormalmap;
+	bool isGlow;
+} material;
+
+uniform bool useLight;
 
 uniform struct Light {
 	vec4 position;
@@ -25,67 +31,96 @@ uniform struct Light {
 varying vec2 v_surfaceUV;
 varying vec3 v_surfacePosition;
 varying vec3 v_surfaceNormal;
+varying vec3 v_polyNorm;
+varying vec3 v_polyTan;
+varying vec3 v_polyBiTan;
 
 void main()
 {
-	if(b_light)
+	if(useLight && !material.isGlow)
 	{
-		// some values
-		vec3 normalWorld = normalize(n_matrix * v_surfaceNormal);
-
-		vec4 surfaceColor = vec4(texture2D(texture, v_surfaceUV));
+		// get the color and undo gamma correction
+		vec4 surfaceColor = vec4(texture2D(tx0, v_surfaceUV));
 		surfaceColor.rgb = pow(surfaceColor.rgb, vec3(2.2));
-		
-		vec3 surfaceToLight;
-		float attenuation;
-		// directional light
-		if(light.position.w == 0.0f)
-		{
-			surfaceToLight = normalize(light.position.xyz);
-		}
-		// point light
-		else
-		{
-			surfaceToLight = normalize(light.position.xyz - v_surfacePosition);
-		}
-		
-		float distanceToLight = length(light.position.xyz - v_surfacePosition);
-		attenuation = 1.0 / (1.0 + light.attenuationFactor * pow(distanceToLight, 2));
 
+		// attenutation depending on the distance to the light
+		float distanceToLight = length(light.position.xyz - v_surfacePosition);
+		float attenuation = 1.0 / (1.0 + light.attenuationFactor * pow(distanceToLight, 2));
+
+		// normal vector
+		vec3 normal = normalize(normalMatrix * v_surfaceNormal);
+
+		// direction from surface to light depending on the light type
+		vec3 surfaceToLight;
+		if(light.position.w == 0.0)		// directional light
+			surfaceToLight = normalize(light.position.xyz);
+		else							// point light
+			surfaceToLight = normalize(light.position.xyz - v_surfacePosition);
+
+		// direction from surface to camera
 		vec3 surfaceToCamera = normalize(cameraPosition - v_surfacePosition);
 
-		// ambient
+		// adjust the values if material has normal map
+		if(material.hasNormalmap)
+		{
+			vec3 surfaceTangent = normalize(normalMatrix * v_polyTan);
+			vec3 surfaceBitangent = normalize(normalMatrix * -v_polyBiTan);
+			vec3 surfaceNormal = normalize(normalMatrix * v_surfaceNormal);
+			mat3 tbn = transpose(mat3(surfaceTangent, surfaceBitangent, surfaceNormal));
+			normal = texture2D(tx1, v_surfaceUV).rgb;
+			normal = normalize(normal * 2.0 -1.0);
+			surfaceToLight = normalize(tbn * surfaceToLight);
+			surfaceToCamera = normalize(tbn * surfaceToCamera);
+		}
+
+
+	/////////////////////////////////////////////////////////////////////////////////////
+	// ambient component
+
 		vec3 ambient = light.ambientCoefficient * surfaceColor.rgb * light.intensities;
 
-		// diffuse
-		float diffuseCoefficient = max(0.0, dot(normalWorld, surfaceToLight));
+
+	/////////////////////////////////////////////////////////////////////////////////////
+	// diffuse component
+
+		float diffuseCoefficient = max(0.0, dot(normal, surfaceToLight));
 		vec3 diffuse = diffuseCoefficient * surfaceColor.rgb * light.intensities;
 
-		// specular
+
+	/////////////////////////////////////////////////////////////////////////////////////
+	// specular component
+
 		float specularCoefficient = 0.0;
 		if(diffuseCoefficient > 0.0)
-			specularCoefficient = pow(max(0.0, dot(surfaceToCamera, reflect(-surfaceToLight, normalWorld))), materialShininess);
-		vec3 specColor;
-		if(b_specular)
-			specColor = vec3(surfaceColor.a);
-		else
-			specColor = materialSpecularColor;
+			specularCoefficient = pow(max(0.0, dot(surfaceToCamera, reflect(-surfaceToLight, normal))), material.shininess);
+		
+		float specularWeight = 1;
+		if(material.hasSpecularmap)
+			specularWeight = surfaceColor.a;
+		vec3 specColor = specularWeight * 1/255 * material.specularColor;
+
 		vec3 specular = specularCoefficient * specColor * light.intensities;
 
-		// linear color before gamma correction)
+	/////////////////////////////////////////////////////////////////////////////////////
+	// linear color before gamma correction
 		vec3 linearColor = ambient + attenuation * (diffuse + specular);
 
-		// final color after gama correction
+	/////////////////////////////////////////////////////////////////////////////////////
+	// gama correction
 		vec3 gamma = vec3(1.0/2.2);
-		if(!b_transparent)
-			surfaceColor.a = 1.0f;
+
+		if(!material.isTransparent)
+			surfaceColor.a = 1.0;
+		
 		gl_FragColor = vec4(pow(linearColor, gamma), surfaceColor.a);
 	}
+	// don't use light
 	else
 	{
-		vec4 surfaceColor = vec4(texture2D(texture, v_surfaceUV));
-		if(!b_transparent)
-			surfaceColor.a = 1.0f;
+		vec4 surfaceColor = vec4(texture2D(tx0, v_surfaceUV));
+
+		if(!material.isTransparent)
+			surfaceColor.a = 1.0;
 
 		gl_FragColor = surfaceColor;
 	}

QtMeshViewer/Resources/vshader.glsl

@@ -4,26 +4,35 @@ precision mediump int;
 precision mediump float;
 #endif
 
-uniform mat4 vp_matrix;
-uniform mat4 norm_matrix;
-uniform mat4 m_matrix;
+uniform mat4 viewProjection;
+uniform mat4 normalizeModel;
+uniform mat4 modelMatrix;
 
 attribute vec4 a_position;
 attribute vec2 a_texcoord;
 attribute vec3 a_normal;
+attribute vec3 a_polyNorm;
+attribute vec3 a_polyTan;
+attribute vec3 a_polyBiTan;
 
 varying vec2 v_surfaceUV;
 varying vec3 v_surfacePosition;
 varying vec3 v_surfaceNormal;
+varying vec3 v_polyNorm;
+varying vec3 v_polyTan;
+varying vec3 v_polyBiTan;
 
 void main()
 {
 	// Calculate vertex position in screen space
-	gl_Position = vp_matrix * norm_matrix * m_matrix * a_position;
+	gl_Position = viewProjection * normalizeModel * modelMatrix * a_position;
 
 	// Pass data to fragment shader
 	// Value will be automatically interpolated to fragments inside polygon faces
 	v_surfaceUV = a_texcoord;
-	v_surfacePosition = vec3(norm_matrix * m_matrix * a_position);
+	v_surfacePosition = vec3(normalizeModel * modelMatrix * a_position);
 	v_surfaceNormal = a_normal;
+	v_polyNorm = a_polyNorm;
+	v_polyTan = a_polyTan;
+	v_polyBiTan = a_polyBiTan;
 }

QtMeshViewer/Source/GeometryEngine.cpp

@@ -5,7 +5,6 @@
 #include "..\Header\OutputDevice.h"
 #include <QRegExp>
 
-#include "..\Header\Profiler.h"
 
 /////////////////////////////////////////////////////////////////////////
 // constructor/destructor
@@ -52,26 +51,8 @@ void GeometryEngine::clearData()
 	m_drawList.clear();
 }
 
-void GeometryEngine::drawGeometry(QOpenGLShaderProgram *program)
+void GeometryEngine::setupPipeline(QOpenGLShaderProgram *program)
 {
-	if (!m_arrayBuf.isCreated() || !m_indexBuf.isCreated())
-		return;
-
-	// Setup
-	// Tell OpenGL which VBOs to use
-	m_arrayBuf.bind();
-	m_indexBuf.bind();
-
-	// Allways normalize by this
-	QMatrix4x4 normMatrix;
-	float maxExtent = std::max(std::max(m_boundings.extents[0], m_boundings.extents[1]), m_boundings.extents[2]);
-	normMatrix.scale(1 / maxExtent);
-	normMatrix.translate(-m_boundings.center[0], -m_boundings.center[1], -m_boundings.center[2]);
-	program->setUniformValue("norm_matrix", normMatrix);
-
-	// Allways use texture unit 0
-	program->setUniformValue("texture", 0);
-
 	// Offset for position
 	quintptr offset = 0;
 
@@ -88,50 +69,115 @@ void GeometryEngine::drawGeometry(QOpenGLShaderProgram *program)
 	program->enableAttributeArray(texcoordLocation);
 	program->setAttributeBuffer(texcoordLocation, GL_FLOAT, offset, 2, sizeof(VertexData));
 
-	//Offset for normal
+	//Offset for vertexNormal
 	offset += sizeof(QVector2D);
 
 	// Tell OpenGL programmable pipeline how to locate vertex normal data
-	int normLocation = program->attributeLocation("a_normal");
-	program->enableAttributeArray(normLocation);
-	program->setAttributeBuffer(normLocation, GL_FLOAT, offset, 3, sizeof(VertexData));
+	int vertNormLocation = program->attributeLocation("a_normal");
+	program->enableAttributeArray(vertNormLocation);
+	program->setAttributeBuffer(vertNormLocation, GL_FLOAT, offset, 3, sizeof(VertexData));
 
+	//Offset for polygonNormal
+	offset += sizeof(QVector3D);
+
+	// Tell OpenGL programmable pipeline how to locate polygon normal data
+	int polyNormLocation = program->attributeLocation("a_polyNorm");
+	program->enableAttributeArray(polyNormLocation);
+	program->setAttributeBuffer(polyNormLocation, GL_FLOAT, offset, 3, sizeof(VertexData));
+
+	//Offset for polygonTangent
+	offset += sizeof(QVector3D);
+
+	// Tell OpenGL programmable pipeline how to locate polygon tangent data
+	int polyTanLocation = program->attributeLocation("a_polyTan");
+	program->enableAttributeArray(polyTanLocation);
+	program->setAttributeBuffer(polyTanLocation, GL_FLOAT, offset, 3, sizeof(VertexData));
+
+	//Offset for polygonBitangent
+	offset += sizeof(QVector3D);
+
+	// Tell OpenGL programmable pipeline how to locate polygon bitangent data
+	int polyBiTanLocation = program->attributeLocation("a_polyBiTan");
+	program->enableAttributeArray(polyBiTanLocation);
+	program->setAttributeBuffer(polyBiTanLocation, GL_FLOAT, offset, 3, sizeof(VertexData));
+
+}
+
+void GeometryEngine::drawGeometry(QOpenGLShaderProgram *program)
+{
+	if (!m_arrayBuf.isCreated() || !m_indexBuf.isCreated())
+		return;
+
+	// Setup
+	// Tell OpenGL which VBOs to use
+	m_arrayBuf.bind();
+	m_indexBuf.bind();
+
+	// Allways normalize by this
+	QMatrix4x4 normMatrix;
+	float maxExtent = std::max(std::max(m_boundings.extents[0], m_boundings.extents[1]), m_boundings.extents[2]);
+	normMatrix.scale(1 / maxExtent);
+	normMatrix.translate(-m_boundings.center[0], -m_boundings.center[1], -m_boundings.center[2]);
+	program->setUniformValue("normalizeModel", normMatrix);
+
+	// Allways use texture unit 0 and 1
+	program->setUniformValue("tx0", 0);
+	program->setUniformValue("tx1", 1);
+
+	//setup the pipeline
+	setupPipeline(program);
+	
 	// Paint
 
 	for (auto& it : m_drawList)
 	{
 		bool tmp_transparent(false);
 		bool tmp_specular(false);
+		bool tmp_normalmap(false);
+		bool tmp_glow(false);
 		float shininess(0.0);
 		QVector3D specularColor;
 
 		// bind the correct texture
 		if (it.textureIndex < (unsigned)m_materials->size() && m_materials->at(it.textureIndex).texture0 != Q_NULLPTR)
 		{
-			m_materials->at(it.textureIndex).texture0->bind();
+			m_materials->at(it.textureIndex).texture0->bind(0);
 			tmp_transparent = m_materials->at(it.textureIndex).transparent;
 			tmp_specular = m_materials->at(it.textureIndex).flags[7];
 			shininess = m_materials->at(it.textureIndex).shininess;
 			specularColor = m_materials->at(it.textureIndex).specularColor.toVector3D();
+
+			if (m_materials->at(it.textureIndex).rendertype == 27 || m_materials->at(it.textureIndex).rendertype == 28)
+			{
+				if (m_materials->at(it.textureIndex).texture1 != Q_NULLPTR)
+				{
+					tmp_normalmap = true;
+					m_materials->at(it.textureIndex).texture1->bind(1);
+				}
+			}
+
+			if (m_materials->at(it.textureIndex).flags[0] || m_materials->at(it.textureIndex).flags[1] || m_materials->at(it.textureIndex).rendertype == 1)
+				tmp_glow = true;
 		}
 		else
 		{
-			m_defaultMaterial->texture0->bind();
+			m_defaultMaterial->texture0->bind(0);
 			tmp_transparent = m_defaultMaterial->transparent;
 		}
+
 		// Set model matrix
-		program->setUniformValue("m_matrix", it.modelMatrix);
+		program->setUniformValue("modelMatrix", it.modelMatrix);
 
 		// Set normal matrix
-		program->setUniformValue("n_matrix", (normMatrix * it.modelMatrix).normalMatrix());
-
-		// set some more values
-		program->setUniformValue("b_transparent", tmp_transparent);
-		program->setUniformValue("b_specular", tmp_specular);
+		program->setUniformValue("normalMatrix", (normMatrix * it.modelMatrix).normalMatrix());
 
 		// set some material attributes
-		program->setUniformValue("materialShininess", shininess);
-		program->setUniformValue("materialSpecularColor", specularColor);
+		program->setUniformValue("material.shininess", shininess);
+		program->setUniformValue("material.specularColor", specularColor);
+		program->setUniformValue("material.isTransparent", tmp_transparent);
+		program->setUniformValue("material.hasSpecularmap", tmp_specular);
+		program->setUniformValue("material.hasNormalmap", tmp_normalmap);
+		program->setUniformValue("material.isGlow", tmp_glow);
 
 		// Draw cube geometry using indices from VBO 1
 		glDrawElements(GL_TRIANGLES, it.size, GL_UNSIGNED_INT, (void*)(it.offset * sizeof(GLuint)));
@@ -141,7 +187,6 @@ void GeometryEngine::drawGeometry(QOpenGLShaderProgram *program)
 
 void GeometryEngine::loadFile(QString filePath)
 {
-	TIC("Start");
 	// cleanup old stuff and recreate buffers
 	clearData();
 	m_arrayBuf.create();
@@ -216,7 +261,5 @@ void GeometryEngine::loadFile(QString filePath)
 		clearData();
 		OutputDevice::getInstance()->print(QString(e.what()), 2);
 	}
-
-	TOC("End");
 }
 

QtMeshViewer/Source/MainWindow.cpp

@@ -49,6 +49,8 @@ MainWindow::MainWindow(QWidget *parent)
 	styleSheet.open(QIODevice::ReadOnly);
 	this->setStyleSheet(styleSheet.readAll());
 
+	getAssetLibrary();
+
 	printMessage("MeshViewer by Anakin", 0);
 }
 
@@ -161,6 +163,33 @@ void MainWindow::setupWidgets()
 
 }
 
+void MainWindow::getAssetLibrary()
+{
+	QTreeWidgetItem* item = new QTreeWidgetItem;
+	item->setData(0, Qt::DisplayRole, "Wuhu");
+	ui->treeWidget->addTopLevelItem(item);
+
+	searchMeshFiles("D:/workspaces/Visual Studio 2015/Projects/OpenGL/Release");
+
+}
+
+void MainWindow::searchMeshFiles(QString path)
+{
+	QDir directory(path);
+	directory.setNameFilters(QStringList("*.msh"));
+
+	QStringList childDirectories = directory.entryList(QDir::AllDirs | QDir::NoDotAndDotDot);
+
+	QStringList fileNames = directory.entryList(QDir::Files);
+
+	for (auto &it : childDirectories)
+		qDebug() << it;
+
+	for (auto &it : fileNames)
+		qDebug() << it;
+
+}
+
 void MainWindow::openFile()
 {
 	QString fileName = QFileDialog::getOpenFileName(this, "Open File", "", "Mesh (*.msh)");

QtMeshViewer/Source/MshFile.cpp

@@ -1,6 +1,7 @@
 #include "..\Header\MshFile.h"
 #include "..\Header\tga.h"
 #include "..\Header\OutputDevice.h"
+#include <QVector3D>
 
 
 // helper function to save data from file to any variable type
@@ -571,18 +572,106 @@ void MshFile::analyseSegmChunks(Model * dataDestination, QList<ChunkHeader*>& ch
 
 					if (tmp_buffer.size() == 5)
 					{
-						for (size_t i = 0; i < 3; i++)
-							new_segment->indices.push_back(tmp_buffer.takeFirst());
+						// calculate poylgon normal, tangent and bitangent
+						QVector3D vec1, vec2, norm, tan, bi;
+						QVector2D uv1, uv2;
+						float f;
+
+						vec1 = new_segment->vertices[tmp_buffer[0]].position - new_segment->vertices[tmp_buffer[1]].position;
+						vec2 = new_segment->vertices[tmp_buffer[0]].position - new_segment->vertices[tmp_buffer[2]].position;
+						uv1 = new_segment->vertices[tmp_buffer[0]].texCoord - new_segment->vertices[tmp_buffer[1]].texCoord;
+						uv2 = new_segment->vertices[tmp_buffer[0]].texCoord - new_segment->vertices[tmp_buffer[2]].texCoord;
+						f = 1.0f / (uv1.x() * uv2.y() - uv2.x() * uv1.y());
+
+						norm = QVector3D::crossProduct(vec1, vec2).normalized();
+
+						tan.setX(f * (uv2.y() * vec1.x() - uv1.y() * vec2.x()));
+						tan.setY(f * (uv2.y() * vec1.y() - uv1.y() * vec2.y()));
+						tan.setZ(f * (uv2.y() * vec1.z() - uv1.y() * vec2.z()));
+						tan.normalize();
+
+						bi.setX(f * (-uv2.x() * vec1.x() + uv1.x() * vec2.x()));
+						bi.setY(f * (-uv2.x() * vec1.y() + uv1.x() * vec2.y()));
+						bi.setZ(f * (-uv2.x() * vec1.z() + uv1.x() * vec2.z()));
+						bi.normalize();
+
+						for (int k = 0; k < 3; k++)
+						{
+							// polygon normal wasn't calculated before
+							if (new_segment->vertices[tmp_buffer[k]].polygonNormal == QVector3D(0, 0, 0))
+							{
+								new_segment->vertices[tmp_buffer[k]].polygonNormal = norm;
+								new_segment->vertices[tmp_buffer[k]].tangent = tan;
+								new_segment->vertices[tmp_buffer[k]].bitangent = bi;
+
+								new_segment->indices.push_back(tmp_buffer[k]);
+							}
+							// polygon normal already calculated so duplicate the vertex
+							else 
+							{
+								new_segment->vertices.push_back(new_segment->vertices[tmp_buffer[k]]);
+								new_segment->vertices.back().polygonNormal = norm;
+								new_segment->vertices.back().tangent = tan;
+								new_segment->vertices.back().bitangent = bi;
+								new_segment->indices.push_back(new_segment->vertices.size() - 1);
+							}
+						}
+						tmp_buffer.remove(0, 3);
 					}
 					else if (tmp_buffer.size() > 5)
 					{
 						unsigned int tmp_multiPolySize = tmp_buffer.size() - 2;
+
+						// calculate poylgon normal, tangent and bitangent
+						QVector3D vec1, vec2, norm, tan, bi;
+						QVector2D uv1, uv2;
+						float f;
+
+						vec1 = new_segment->vertices[tmp_buffer[0]].position - new_segment->vertices[tmp_buffer[1]].position;
+						vec2 = new_segment->vertices[tmp_buffer[0]].position - new_segment->vertices[tmp_buffer[2]].position;
+						uv1 = new_segment->vertices[tmp_buffer[0]].texCoord - new_segment->vertices[tmp_buffer[1]].texCoord;
+						uv2 = new_segment->vertices[tmp_buffer[0]].texCoord - new_segment->vertices[tmp_buffer[2]].texCoord;
+						f = 1.0f / (uv1.x() * uv2.y() - uv2.x() * uv1.y());
+
+						norm = QVector3D::crossProduct(vec1, vec2).normalized();
+
+						tan.setX(f * (uv2.y() * vec1.x() - uv1.y() * vec2.x()));
+						tan.setY(f * (uv2.y() * vec1.y() - uv1.y() * vec2.y()));
+						tan.setZ(f * (uv2.y() * vec1.z() - uv1.y() * vec2.z()));
+						tan.normalize();
+
+						bi.setX(f * (-uv2.x() * vec1.x() + uv1.x() * vec2.x()));
+						bi.setY(f * (-uv2.x() * vec1.y() + uv1.x() * vec2.y()));
+						bi.setZ(f * (-uv2.x() * vec1.z() + uv1.x() * vec2.z()));
+						bi.normalize();
+
 						// for every triangle of the multi polygon..
 						for (unsigned int tri = 0; tri < tmp_multiPolySize - 2; tri++)
+						{
 							// ..calculate the edge indices
 							for (int triEdge = 0; triEdge < 3; triEdge++)
-								new_segment->indices.push_back(tmp_buffer[(tri + triEdge - ((tri % 2) * (triEdge - 1) * 2))]);
+							{
+								int curIndi = tmp_buffer[(tri + triEdge - ((tri % 2) * (triEdge - 1) * 2))];
 
+								// polygon normal wasn't calculated before
+								if (new_segment->vertices[curIndi].polygonNormal == QVector3D(0, 0, 0))
+								{
+									new_segment->vertices[curIndi].polygonNormal = norm;
+									new_segment->vertices[curIndi].tangent = tan;
+									new_segment->vertices[curIndi].bitangent = bi;
+									new_segment->indices.push_back(curIndi);
+								}
+								// polygon normal already calculated so duplicate the vertex
+								else
+								{
+									new_segment->vertices.push_back(new_segment->vertices[curIndi]);
+									new_segment->vertices.back().polygonNormal = norm;
+									new_segment->vertices.back().tangent = tan;
+									new_segment->vertices.back().bitangent = bi;
+									new_segment->indices.push_back(new_segment->vertices.size() - 1);
+								}
+							}
+						}
 						tmp_buffer.remove(0, tmp_multiPolySize);
 					}
 
@@ -593,17 +682,106 @@ void MshFile::analyseSegmChunks(Model * dataDestination, QList<ChunkHeader*>& ch
 			// save the last polygon (no 2 high bit followed)
 			if (tmp_buffer.size() == 3)
 			{
-				for (size_t i = 0; i < 3; i++)
-					new_segment->indices.push_back(tmp_buffer.takeFirst());
+				// calculate poylgon normal, tangent and bitangent
+				QVector3D vec1, vec2, norm, tan, bi;
+				QVector2D uv1, uv2;
+				float f;
+
+				vec1 = new_segment->vertices[tmp_buffer[0]].position - new_segment->vertices[tmp_buffer[1]].position;
+				vec2 = new_segment->vertices[tmp_buffer[0]].position - new_segment->vertices[tmp_buffer[2]].position;
+				uv1 = new_segment->vertices[tmp_buffer[0]].texCoord - new_segment->vertices[tmp_buffer[1]].texCoord;
+				uv2 = new_segment->vertices[tmp_buffer[0]].texCoord - new_segment->vertices[tmp_buffer[2]].texCoord;
+				f = 1.0f / (uv1.x() * uv2.y() - uv2.x() * uv1.y());
+
+				norm = QVector3D::crossProduct(vec1, vec2).normalized();
+
+				tan.setX(f * (uv2.y() * vec1.x() - uv1.y() * vec2.x()));
+				tan.setY(f * (uv2.y() * vec1.y() - uv1.y() * vec2.y()));
+				tan.setZ(f * (uv2.y() * vec1.z() - uv1.y() * vec2.z()));
+				tan.normalize();
+
+				bi.setX(f * (-uv2.x() * vec1.x() + uv1.x() * vec2.x()));
+				bi.setY(f * (-uv2.x() * vec1.y() + uv1.x() * vec2.y()));
+				bi.setZ(f * (-uv2.x() * vec1.z() + uv1.x() * vec2.z()));
+				bi.normalize();
+
+				for (int k = 0; k < 3; k++)
+				{
+					// polygon normal wasn't calculated before
+					if (new_segment->vertices[tmp_buffer[k]].polygonNormal == QVector3D(0, 0, 0))
+					{
+						new_segment->vertices[tmp_buffer[k]].polygonNormal = norm;
+						new_segment->vertices[tmp_buffer[k]].tangent = tan;
+						new_segment->vertices[tmp_buffer[k]].bitangent = bi;
+
+						new_segment->indices.push_back(tmp_buffer[k]);
+					}
+					// polygon normal already calculated so duplicate the vertex
+					else
+					{
+						new_segment->vertices.push_back(new_segment->vertices[tmp_buffer[k]]);
+						new_segment->vertices.back().polygonNormal = norm;
+						new_segment->vertices.back().tangent = tan;
+						new_segment->vertices.back().bitangent = bi;
+						new_segment->indices.push_back(new_segment->vertices.size() - 1);
+					}
+				}
+				tmp_buffer.remove(0, 3);
 			}
 			else if (tmp_buffer.size() > 3)
 			{
 				unsigned int tmp_multiPolySize = tmp_buffer.size();
+
+				// calculate poylgon normal, tangent and bitangent
+				QVector3D vec1, vec2, norm, tan, bi;
+				QVector2D uv1, uv2;
+				float f;
+
+				vec1 = new_segment->vertices[tmp_buffer[0]].position - new_segment->vertices[tmp_buffer[1]].position;
+				vec2 = new_segment->vertices[tmp_buffer[0]].position - new_segment->vertices[tmp_buffer[2]].position;
+				uv1 = new_segment->vertices[tmp_buffer[0]].texCoord - new_segment->vertices[tmp_buffer[1]].texCoord;
+				uv2 = new_segment->vertices[tmp_buffer[0]].texCoord - new_segment->vertices[tmp_buffer[2]].texCoord;
+				f = 1.0f / (uv1.x() * uv2.y() - uv2.x() * uv1.y());
+
+				norm = QVector3D::crossProduct(vec1, vec2).normalized();
+
+				tan.setX(f * (uv2.y() * vec1.x() - uv1.y() * vec2.x()));
+				tan.setY(f * (uv2.y() * vec1.y() - uv1.y() * vec2.y()));
+				tan.setZ(f * (uv2.y() * vec1.z() - uv1.y() * vec2.z()));
+				tan.normalize();
+
+				bi.setX(f * (-uv2.x() * vec1.x() + uv1.x() * vec2.x()));
+				bi.setY(f * (-uv2.x() * vec1.y() + uv1.x() * vec2.y()));
+				bi.setZ(f * (-uv2.x() * vec1.z() + uv1.x() * vec2.z()));
+				bi.normalize();
+
 				// for every triangle of the multi polygon..
 				for (unsigned int tri = 0; tri < tmp_multiPolySize - 2; tri++)
+				{
 					// ..calculate the edge indices
 					for (int triEdge = 0; triEdge < 3; triEdge++)
-						new_segment->indices.push_back(tmp_buffer[(tri + triEdge - ((tri % 2) * (triEdge - 1) * 2))]);
+					{
+						int curIndi = tmp_buffer[(tri + triEdge - ((tri % 2) * (triEdge - 1) * 2))];
+
+						// polygon normal wasn't calculated before
+						if (new_segment->vertices[curIndi].polygonNormal == QVector3D(0, 0, 0))
+						{
+							new_segment->vertices[curIndi].polygonNormal = norm;
+							new_segment->vertices[curIndi].tangent = tan;
+							new_segment->vertices[curIndi].bitangent = bi;
+							new_segment->indices.push_back(curIndi);
+						}
+						// polygon normal already calculated so duplicate the vertex
+						else
+						{
+							new_segment->vertices.push_back(new_segment->vertices[curIndi]);
+							new_segment->vertices.back().polygonNormal = norm;
+							new_segment->vertices.back().tangent = tan;
+							new_segment->vertices.back().bitangent = bi;
+							new_segment->indices.push_back(new_segment->vertices.size() - 1);
+						}
+					}
+				}
 			}
 		}
 	}
@@ -662,12 +840,26 @@ void MshFile::analyseClthChunks(Model * dataDestination, QList<ChunkHeader*>& ch
 			m_file.read(F2V(tmp_size), sizeof(tmp_size));
 
 			// for every triangle..
-			for (unsigned int i = 0; i < tmp_size * 3; i++)
+			for (unsigned int i = 0; i < tmp_size; i++)
 			{
-				quint32 tmp_value;
-				m_file.read(F2V(tmp_value), sizeof(quint32));
+				quint32 tmp_value[3];
+				for (unsigned int j = 0; j < 3; j++)
+				{
+					m_file.read(F2V(tmp_value[j]), sizeof(quint32));
+					new_segment->indices.push_back((GLuint)tmp_value[j]);
+				}
 
-				new_segment->indices.push_back((GLuint)tmp_value);
+				QVector3D vec1, vec2, norm;
+
+				vec1 = new_segment->vertices[new_segment->indices[i * 3]].position - new_segment->vertices[new_segment->indices[i * 3 + 1]].position;
+				vec2 = new_segment->vertices[new_segment->indices[i * 3]].position - new_segment->vertices[new_segment->indices[i * 3 + 2]].position;
+				norm = QVector3D::crossProduct(vec1, vec2);
+
+				for (int k = 0; k < 3; k++)
+				{
+					new_segment->vertices[new_segment->indices[i * 3 + k]].vertexNormal += norm;
+					new_segment->vertices[new_segment->indices[i * 3 + k]].vertexNormal.normalize();
+				}
 			}
 		}
 	}
@@ -728,7 +920,7 @@ void MshFile::loadTexture(QOpenGLTexture *& destination, QString filepath, QStri
 	if (!loadSuccess)
 	{
 		OutputDevice::getInstance()->print("WARNING: texture not found or corrupted: " + filename, 1);
-		
+		//TODO: cloth use the wrong diffuse color. should be null
 		img = QImage(1, 1, QImage::Format_RGB32);
 		img.fill(QColor(m_materials->back().diffuseColor[0] * 255, m_materials->back().diffuseColor[1] * 255, m_materials->back().diffuseColor[2] * 255));
 		filename += " *";

QtMeshViewer/Source/OglViewerWidget.cpp

@@ -3,6 +3,7 @@
 #include "..\Header\FreeCamera.h"
 #include "..\Header\OrbitCamera.h"
 #include "..\Header\MoveCamera.h"
+#include "..\Header\SettingsManager.h"
 #include <QMouseEvent>
 #include <QDropEvent>
 #include <QMimeData>
@@ -24,7 +25,8 @@ OglViewerWidget::OglViewerWidget(QWidget *parent)
 	setAcceptDrops(true);
 
 	// settings window
-	m_settings = new SettingsWindow(m_backgroundColorOff.toVector3D() * 255, m_backgroundColorOn.toVector3D() * 255, m_light.intensities * 255, true, m_light.ambientCoefficient, m_light.attenuationFactor, 1, this);
+	setDefaultValues();
+	m_settings = new SettingsWindow(this);
 
 	connect(m_settings, &SettingsWindow::updateBGColorOff, this, &OglViewerWidget::setBGColorOff);
 	connect(m_settings, &SettingsWindow::updateBGColorOn, this, &OglViewerWidget::setBGColorOn);
@@ -52,6 +54,30 @@ OglViewerWidget::~OglViewerWidget()
 /////////////////////////////////////////////////////////////////////////
 // functions
 
+void OglViewerWidget::setDefaultValues()
+{
+	SettingsManager* sm = SettingsManager::getInstance(this);
+
+	m_backgroundColorOn = QVector4D(sm->getBgColorOn() / 255, 1.0f);
+	m_backgroundColorOff = QVector4D(sm->getBgColorOff() / 255, 1.0f);
+
+	m_wireframe = false;
+	m_lightOn = sm->isLight();
+	m_backfaceCulling = sm->isBfCulling();
+
+	if (sm->getLightType() == 1)	// directional
+		m_light.position = { 0.0,0.0,0.0,0.0 };
+	else						// point
+		m_light.position = { 0.0,0.0,0.0,1.0 };
+	m_light.intensities = sm->getLightColor() / 255;
+	m_light.attenuationFactor = sm->getAttenuation();
+	m_light.ambientCoefficient = sm->getAmbient();
+	m_light.headlight = sm->isHeadlight();
+
+	connect(this, &OglViewerWidget::lightChanged, sm, &SettingsManager::setLight);
+
+}
+
 void OglViewerWidget::initShaders()
 {
 	// Compile vertex shader
@@ -143,10 +169,10 @@ void OglViewerWidget::paintGL()
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 	// Set view-projection matrix
-	m_program.setUniformValue("vp_matrix", m_projection * m_camera->getMatrix());
+	m_program.setUniformValue("viewProjection", m_projection * m_camera->getMatrix());
 
 	// Set Light values
-	m_program.setUniformValue("b_light", m_lightOn);
+	m_program.setUniformValue("useLight", m_lightOn);
 	m_program.setUniformValue("light.position", m_light.position);
 	m_program.setUniformValue("light.intensities", m_light.intensities);
 	m_program.setUniformValue("light.attenuationFactor", m_light.attenuationFactor);
@@ -371,6 +397,8 @@ void OglViewerWidget::toggleLight()
 		m_backgroundColorOff[3] = 1.0;
 	}
 
+	emit lightChanged(m_lightOn);
+
 	update();
 }
 

QtMeshViewer/Source/SettingsManager.cpp

@@ -0,0 +1,222 @@
+#include "..\Header\SettingsManager.h"
+
+
+/////////////////////////////////////////////////////////////////////////
+// constructor/destructor
+
+SettingsManager::SettingsManager(QObject *parent)
+	: QObject(parent)
+{
+	file.setFileName("meshviewer.config");
+	readFromFile();
+}
+
+SettingsManager::~SettingsManager()
+{
+	writeToFile();
+}
+
+SettingsManager* SettingsManager::getInstance(QObject *parent)
+{
+	static SettingsManager* instance = new SettingsManager(parent);
+	return instance;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// functions
+
+void SettingsManager::readFromFile()
+{
+	if (file.open(QIODevice::ReadOnly))
+	{
+
+		QByteArray stream = file.readAll();
+		QList<QByteArray> lines = stream.split('\n');
+
+		for (auto& it : lines)
+		{
+			if (it.startsWith("<bgOn>"))
+			{
+				QList<QByteArray> values = it.right(it.size() - it.indexOf('>') - 1).split(';');
+
+				for (int i = 0; i < 3; i++)
+					m_bgColorOn[i] = values[i].toFloat();
+			}
+			else if (it.startsWith("<bgOff>"))
+			{
+				QList<QByteArray> values = it.right(it.size() - it.indexOf('>') - 1).split(';');
+
+				for (int i = 0; i < 3; i++)
+					m_bgColorOff[i] = values[i].toFloat();
+			}
+			else if (it.startsWith("<liCo>"))
+			{
+				QList<QByteArray> values = it.right(it.size() - it.indexOf('>') - 1).split(';');
+
+				for (int i = 0; i < 3; i++)
+					m_lightColor[i] = values[i].toFloat();
+			}
+			else if (it.startsWith("<bfCul>"))
+			{
+				m_bfCulling = it.right(it.size() - it.indexOf('>') - 1).toInt();
+			}
+			else if (it.startsWith("<liOn>"))
+			{
+				m_light = it.right(it.size() - it.indexOf('>') - 1).toInt();
+			}
+			else if (it.startsWith("<heLi>"))
+			{
+				m_headlight = it.right(it.size() - it.indexOf('>') - 1).toInt();
+			}
+			else if (it.startsWith("<auCo>"))
+			{
+				m_autoColor = it.right(it.size() - it.indexOf('>') - 1).toInt();
+			}
+			else if (it.startsWith("<liTy>"))
+			{
+				m_lightType = it.right(it.size() - it.indexOf('>') - 1).toInt();
+			}
+			else if (it.startsWith("<atFa>"))
+			{
+				m_attenuation = it.right(it.size() - it.indexOf('>') - 1).toFloat();
+			}
+			else if (it.startsWith("<amCo>"))
+			{
+				m_ambient = it.right(it.size() - it.indexOf('>') - 1).toFloat();
+			}
+
+		}
+		file.close();
+	}
+}
+
+void SettingsManager::writeToFile()
+{
+	file.open(QIODevice::WriteOnly);
+
+	file.write(QString("<bgOn>%1;%2;%3\n").arg(m_bgColorOn.x()).arg(m_bgColorOn.y()).arg(m_bgColorOn.z()).toUtf8());
+	file.write(QString("<bgOff>%1;%2;%3\n").arg(m_bgColorOff.x()).arg(m_bgColorOff.y()).arg(m_bgColorOff.z()).toUtf8());
+	file.write(QString("<liCo>%1;%2;%3\n").arg(m_lightColor.x()).arg(m_lightColor.y()).arg(m_lightColor.z()).toUtf8());
+
+	file.write(QString("<bfCul>%1\n").arg(m_bfCulling).toUtf8());
+	file.write(QString("<liOn>%1\n").arg(m_light).toUtf8());
+	file.write(QString("<heLi>%1\n").arg(m_headlight).toUtf8());
+	file.write(QString("<auCo>%1\n").arg(m_autoColor).toUtf8());
+
+	file.write(QString("<liTy>%1\n").arg(m_lightType).toUtf8());
+	file.write(QString("<atFa>%1\n").arg(m_attenuation).toUtf8());
+	file.write(QString("<amCo>%1\n").arg(m_ambient).toUtf8());
+
+	file.close();
+}
+
+// getter ///////////////////////////////////////////////////////////////
+
+QVector3D SettingsManager::getBgColorOn() const
+{
+	return m_bgColorOn;
+}
+
+QVector3D SettingsManager::getBgColorOff() const
+{
+	return m_bgColorOff;
+}
+
+bool SettingsManager::isBfCulling() const
+{
+	return m_bfCulling;
+}
+
+bool SettingsManager::isLight() const
+{
+	return m_light;
+}
+
+int SettingsManager::getLightType() const
+{
+	return m_lightType;
+}
+
+QVector3D SettingsManager::getLightColor() const
+{
+	return m_lightColor;
+}
+
+float SettingsManager::getAttenuation() const
+{
+	return m_attenuation;
+}
+
+float SettingsManager::getAmbient() const
+{
+	return m_ambient;
+}
+
+bool SettingsManager::isHeadlight() const
+{
+	return m_headlight;
+}
+
+bool SettingsManager::isAutoColor() const
+{
+	return m_autoColor;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// slots
+
+void SettingsManager::setBgColorOn(QVector3D value)
+{
+	m_bgColorOn = value;
+}
+
+void SettingsManager::setBgColorOff(QVector3D value)
+{
+	m_bgColorOff = value;
+}
+
+void SettingsManager::setBfCulling(bool value)
+{
+	m_bfCulling = value;
+}
+
+void SettingsManager::setLight(bool value)
+{
+	m_light = value;
+}
+
+void SettingsManager::setLightType(int value)
+{
+	m_lightType = value;
+}
+
+void SettingsManager::setLightColor(QVector3D value)
+{
+	m_lightColor = value;
+}
+
+void SettingsManager::setAttenuation(double value)
+{
+	m_attenuation = value;
+}
+
+void SettingsManager::setAmbient(double value)
+{
+	m_ambient = value;
+}
+
+void SettingsManager::setHeadlight(bool value)
+{
+	m_headlight = value;
+}
+
+void SettingsManager::setAutoColor(int value)
+{
+	if (value == 0)
+		m_autoColor = false;
+	else
+		m_autoColor = true;
+}
+

QtMeshViewer/Source/SettingsWindow.cpp

@@ -1,10 +1,11 @@
 #include "..\Header\SettingsWindow.h"
+#include "..\Header\SettingsManager.h"
 
 
 /////////////////////////////////////////////////////////////////////////
 // constructor/destructor
 
-SettingsWindow::SettingsWindow(QVector3D bgOffColor, QVector3D bgOnColor, QVector3D lightColor, bool autoColor, double ambCoef, double attFac, int lightType, QWidget * parent)
+SettingsWindow::SettingsWindow(QWidget * parent)
 	: QWidget(parent)
 	, ui(new Ui::SettingsWindow)
 {
@@ -15,24 +16,41 @@ SettingsWindow::SettingsWindow(QVector3D bgOffColor, QVector3D bgOnColor, QVecto
 	setupConnections();
 
 	// set default values
-	ui->lightOff_R_SB->setValue((int)bgOffColor[0]);
-	ui->lightOff_G_SB->setValue((int)bgOffColor[1]);
-	ui->lightOff_B_SB->setValue((int)bgOffColor[2]);
+	SettingsManager* sm = SettingsManager::getInstance(this);
 
-	ui->lightOn_R_SB->setValue((int)bgOnColor[0]);
-	ui->lightOn_G_SB->setValue((int)bgOnColor[1]);
-	ui->lightOn_B_SB->setValue((int)bgOnColor[2]);
+	ui->lightOff_R_SB->setValue((int)(sm->getBgColorOff()[0]));
+	ui->lightOff_G_SB->setValue((int)(sm->getBgColorOff()[1]));
+	ui->lightOff_B_SB->setValue((int)(sm->getBgColorOff()[2]));
 
-	ui->light_R_SB->setValue((int)lightColor[0]);
-	ui->light_G_SB->setValue((int)lightColor[1]);
-	ui->light_B_SB->setValue((int)lightColor[2]);
+	ui->lightOn_R_SB->setValue((int)(sm->getBgColorOn()[0]));
+	ui->lightOn_G_SB->setValue((int)(sm->getBgColorOn()[1]));
+	ui->lightOn_B_SB->setValue((int)(sm->getBgColorOn()[2]));
 
-	ui->ambCoef->setValue(ambCoef);
-	ui->attFac->setValue(attFac);
+	ui->light_R_SB->setValue((int)(sm->getLightColor()[0]));
+	ui->light_G_SB->setValue((int)(sm->getLightColor()[1]));
+	ui->light_B_SB->setValue((int)(sm->getLightColor()[2]));
 
-	ui->checkAutoColor->setChecked(autoColor);
-	if (lightType == 1)
+	ui->ambCoef->setValue(sm->getAmbient());
+	ui->attFac->setValue(sm->getAttenuation());
+
+	ui->checkBackfaceCulling->setChecked(sm->isBfCulling());
+	ui->checkAutoColor->setChecked(sm->isAutoColor());
+	ui->checkHeadlight->setChecked(sm->isHeadlight());
+
+	if (sm->getLightType() == 1)
 		ui->radioDirectLight->setChecked(true);
+	else
+		ui->radioPointLight->setChecked(true);
+
+	connect(this, &SettingsWindow::updateBGColorOff, sm, &SettingsManager::setBgColorOff);
+	connect(this, &SettingsWindow::updateBGColorOn, sm, &SettingsManager::setBgColorOn);
+	connect(this, &SettingsWindow::updateLightColor, sm, &SettingsManager::setLightColor);
+	connect(this, &SettingsWindow::updateAttFac, sm, &SettingsManager::setAttenuation);
+	connect(this, &SettingsWindow::updateAmbCoef, sm, &SettingsManager::setAmbient);
+	connect(this, &SettingsWindow::sendHeadlight, sm, &SettingsManager::setHeadlight);
+	connect(this, &SettingsWindow::sendBackfaceCulling, sm, &SettingsManager::setBfCulling);
+	connect(ui->checkAutoColor, &QCheckBox::stateChanged, sm, &SettingsManager::setAutoColor);
+	connect(this, &SettingsWindow::changeLightType, sm, &SettingsManager::setLightType);
 
 }
 
@@ -133,10 +151,12 @@ void SettingsWindow::radioToggled()
 	{
 		ui->attFac->setValue(0.0);
 		ui->attFac->setEnabled(false);
+		emit changeLightType(1);
 	}
 	else
 	{
 		ui->attFac->setEnabled(true);
+		emit changeLightType(2);
 	}
 }
 

README.md

@@ -1,3 +1,12 @@
+
+https://git.rwth-aachen.de/carstenf/OpenGL 
+
+Pulled from here as backup of work that I did under the develop branch. I hope to come back to this and port to Python using this as a reference for logic and how-to.
+
+Below is original README text.
+
+
+
 # MshViewer
 
 I started to learn OpenGL. Therefore i decided to implement a .msh viewer for SWBFII assets, since the old one
@@ -12,10 +21,4 @@ So far it is just me. If you wanna help me, let me know :D
 Feel free to use my code the way you like. But remember i used some public libraries. Make sure you read their
 licence, too.
 
-### To Do
-- normal map,
-- list all msh in a directory
-- glow/emissive
-- optional display bones, shadow, collision
-- change pose
-- animation
+