Merge branch 'master' of git.rwth-aachen.de:carstenf/OpenGL

MeshViewerQt/Form Files/MainWindow.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindowClass</class>
+ <widget class="QMainWindow" name="MainWindowClass">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>600</width>
+    <height>400</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralWidget"/>
+  <widget class="QToolBar" name="mainToolBar">
+   <property name="movable">
+    <bool>false</bool>
+   </property>
+   <attribute name="toolBarArea">
+    <enum>TopToolBarArea</enum>
+   </attribute>
+   <attribute name="toolBarBreak">
+    <bool>false</bool>
+   </attribute>
+  </widget>
+  <widget class="QStatusBar" name="statusBar"/>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources>
+  <include location="../Resources/MainWindow.qrc"/>
+ </resources>
+ <connections/>
+</ui>

MeshViewerQt/Header/FileInterface.h

+#pragma once
+#include <fstream>
+#include <vector>
+#include <QMatrix4x4>
+
+//TODO: shouldn't be here
+enum ModelTyp {
+	null,
+	dynamicMesh,
+	cloth,
+	bone,
+	staticMesh,
+	shadowMesh = 6
+};
+
+struct BoundingBox {
+	float quaternion[4];
+	float center[3];
+	float extents[3];
+};
+
+struct Segment {
+	std::uint32_t textureIndex = 0;
+	float* vertex = nullptr;
+	float* uv = nullptr;
+	std::vector<std::vector<std::uint32_t>> polyIndices;	// indices into vertex array
+};
+
+struct Model {
+	std::string name			= "";
+	std::string parent			= "";
+	ModelTyp type				= null;	//TODO: should be removed
+	std::int32_t renderFlags	= -1;	//TODO: should be removed
+	QMatrix4x4 m4x4Translation;
+	std::vector<Segment*> segmList;
+};
+
+class FileInterface
+{
+public:
+	FileInterface(const char* path)
+		: m_vModels(new std::vector<Model*>)
+	{
+		//open file
+		m_fsMesh.open(path, std::ios::in | std::ios::binary);
+
+		if (!m_fsMesh.is_open())
+			throw std::invalid_argument(std::string("file not found: ") += path);
+	};
+
+	virtual ~FileInterface()
+	{
+		// close file
+		m_fsMesh.close(); 
+
+		//clean up
+		m_vTextureNames.clear();
+	};
+
+protected:
+	std::vector<Model*>* m_vModels;
+	std::fstream m_fsMesh;
+	std::vector<std::string> m_vTextureNames;
+	BoundingBox m_sceneBbox;
+
+	virtual void import() = 0;
+
+public:
+	virtual std::vector<Model*>* getModels() const { return m_vModels; };
+	virtual std::vector<std::string> getTextureNames() const { return m_vTextureNames; };
+	virtual BoundingBox getBoundingBox() const { return m_sceneBbox; };
+};
\ No newline at end of file

MeshViewerQt/Header/MainWindow.h

+#pragma once
+
+#include <QtWidgets/QMainWindow>
+#include "ui_MainWindow.h"
+
+class MainWindow : public QMainWindow
+{
+	Q_OBJECT
+
+public:
+	MainWindow(QWidget *parent = Q_NULLPTR);
+	~MainWindow();
+
+// Variables
+private:
+	Ui::MainWindowClass* ui;
+
+// Functions
+private:
+	void setupWindow();
+	void import(const char* path);
+
+// Slots
+private slots:
+	void openFile();
+	void aboutFile();
+	
+
+// Override Functions
+protected:
+	virtual void keyPressEvent(QKeyEvent * keyEvent) override final;
+};

MeshViewerQt/Header/MshFile.h

+#pragma once
+#include "FileInterface.h"
+
+
+struct ChunkHeader {
+	char name[5];
+	std::uint32_t size;
+	std::streampos position;
+};
+
+
+class MshFile : public FileInterface
+{
+public:
+	MshFile(const char* path);
+	~MshFile();
+
+private:
+	virtual void import() override final;
+
+	void loadChunks(std::list<ChunkHeader*> &destination, std::streampos start, const std::uint32_t length);
+
+	void analyseMsh2Chunks(std::list<ChunkHeader*> &chunkList);
+
+	void analyseMatdChunks(std::list<ChunkHeader*> &chunkList);
+
+	void analyseModlChunks(Model* dataDestination, std::list<ChunkHeader*> &chunkList);
+	void analyseGeomChunks(Model* dataDestination, std::list<ChunkHeader*> &chunkList);
+	void analyseSegmChunks(Model* dataDestination, std::list<ChunkHeader*> &chunkList);
+	void analyseClthChunks(Model* dataDestination, std::list<ChunkHeader*> &chunkList);
+
+	void readVertex(Segment* dataDestination, std::streampos position);
+	void readUV(Segment* dataDestination, std::streampos position);
+};
\ No newline at end of file

MeshViewerQt/Header/OpenGlViewer.h

+#pragma once
+#include <QOpenGLWidget>
+#include <QOpenGLFunctions>
+#include <QOpenGLBuffer>
+#include <QOPenGLVertexArrayObject>
+#include <QOpenGlShaderProgram>
+#include "..\Header\Texture.h"
+#include "..\Header\FileInterface.h"
+
+struct Vertex {
+	GLfloat position[3];
+	GLfloat uv[2];
+};
+
+struct TextureData {
+	bool alpha;
+	std::uint32_t width;
+	std::uint32_t height;
+	std::vector<std::uint8_t>* data;
+};
+
+class OpenGlViewer : public QOpenGLWidget, protected QOpenGLFunctions
+{
+	Q_OBJECT
+
+public:
+	OpenGlViewer(QWidget *parent);
+	~OpenGlViewer();
+
+private:
+// OpenGL ======================================
+	int m_uniformMVP;
+	GLuint m_oglTexture;
+	GLuint m_vertexBuffer;
+	QOpenGLVertexArrayObject m_vertexArray;
+	QOpenGLShaderProgram* m_program = nullptr;
+
+// Data ========================================
+	std::vector<Model*>* m_vModels		= nullptr;
+	std::vector<TextureData*>* m_vTextures	= nullptr;
+	BoundingBox m_sceneBoundings;
+
+// Transformation ==============================
+	float m_fRotX		= 0;
+	float m_fRotY		= 0;
+	float m_fRotZ		= 0;
+	float m_fTranX		= 0;
+	float m_fTranY		= 0;
+	float m_fTranZ		= 0;
+
+// Camera ======================================
+	float m_fFOV		= 45.0f;
+	float m_fMinView	= 0.1f;
+	float m_fMaxView	= 100.0f;
+
+private:
+	virtual void initializeGL() override final;
+	virtual void paintGL() override final;
+
+	void printContextInformation();
+	QMatrix4x4 getModelMatrix(unsigned int index) const;
+	QMatrix4x4 getMVPMatrix(unsigned int index) const;
+	void deleteData();
+
+public:
+	void setData(std::vector<Model*>* models, std::vector<TextureData*>* textures, BoundingBox bbox);
+};

MeshViewerQt/Header/Texture.h

+#pragma once
+#include <vector>
+
+
+class TextureTGA
+{
+public:
+	TextureTGA(const char* filePath);
+	~TextureTGA();
+
+private:
+	std::vector<std::uint8_t>* vui8Pixels;
+	std::uint32_t ui32BpP;
+	std::uint32_t ui32Width;
+	std::uint32_t ui32Height;
+
+public:
+	std::vector<std::uint8_t>* getData() const;
+	bool hasAlpha() const;
+	std::uint32_t getWidth() const;
+	std::uint32_t getHeight() const;
+};

MeshViewerQt/Header/defines.h

+#pragma once
+
+#define WINDOW_NAME					"Mesh Viewer"
+#define WINDOW_WIDTH				640
+#define WINDOW_HEIGHT				480
+
+#define DEFAULT_STATUS_MESSAGE		"Mesh Viewer pre alpha by Anakin"
+

MeshViewerQt/Resources/MainWindow.qrc

+<RCC>
+    <qresource prefix="/MainWindow">
+        <file>icon.ico</file>
+    </qresource>
+    <qresource prefix="/shaders">
+        <file>simple.frag</file>
+        <file>simple.vert</file>
+        <file>TextureShader.frag</file>
+        <file>TextureShader.vert</file>
+    </qresource>
+</RCC>

MeshViewerQt/Resources/TextureShader.frag

+#version 330
+
+// Input
+in vec2 UV;
+
+// Output
+out vec4 color;
+
+void main()
+{
+	color = {255,0,0};//texture(textureSampler, UV).rgb;
+}
\ No newline at end of file

MeshViewerQt/Resources/TextureShader.vert

+#version 330
+
+// Input vertex data, different for all executions of this shader
+layout(location = 0) in vec3 vertexPosition;
+layout(location = 1) in vec3 vertexUV;
+
+// Input that stay constant fpr the whole mesh
+uniform mat4 MVP;
+
+// Output
+out vec2 UV;
+
+void main()
+{
+	gl_Position = MVP * vec4(vertexPosition, 1);
+	UV = vertexUV;
+}
\ No newline at end of file

MeshViewerQt/Resources/simple.frag

+#version 330
+in vec4 vColor;
+out vec4 fColor;
+
+void main()
+{
+	fColor = vColor;
+}
\ No newline at end of file

MeshViewerQt/Resources/simple.vert

+#version 330
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec3 color;
+out vec4 vColor;
+
+void main()
+{
+	gl_Position = vec4(position, 1.0);
+	vColor = vec4(color, 1.0);
+}
\ No newline at end of file

MeshViewerQt/Source/MainWindow.cpp

+#include "..\Header\MainWindow.h"
+#include "..\Header\OpenGlViewer.h"
+#include "..\Header\MshFile.h"
+#include "..\Header\defines.h"
+#include <QKeyEvent>
+#include <QMessageBox>
+#include <QFileDialog>
+
+
+/////////////////////////////////////////////////////////////////////////
+// constructor/destructor
+
+MainWindow::MainWindow(QWidget *parent)
+	: QMainWindow(parent)
+	, ui (new Ui::MainWindowClass)
+{
+	setupWindow();
+}
+
+MainWindow::~MainWindow()
+{
+	delete ui;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// private functions
+
+void MainWindow::setupWindow()
+{
+	ui->setupUi(this);
+
+	this->setWindowTitle(WINDOW_NAME);
+	this->setWindowIcon(QIcon(":/MainWindow/icon.ico"));
+	this->resize(WINDOW_WIDTH, WINDOW_HEIGHT);
+
+	this->setCentralWidget(new OpenGlViewer(this));
+
+	ui->mainToolBar->addAction("Open File", this, &MainWindow::openFile);
+	ui->mainToolBar->addAction("File Info", this, &MainWindow::aboutFile);
+
+	ui->statusBar->showMessage(DEFAULT_STATUS_MESSAGE);
+}
+
+void MainWindow::import(const char * path)
+{
+	// variables
+	std::vector<Model*>* tmp_models = nullptr;
+	std::vector<TextureData*>* tmp_textures = new std::vector<TextureData*>;
+	std::vector<std::string> tmp_texNames;
+	BoundingBox tmp_bbox;
+
+	// model file
+	try
+	{
+		MshFile file(path);
+		tmp_models = file.getModels();
+		tmp_texNames = file.getTextureNames();
+		tmp_bbox = file.getBoundingBox();
+	}
+	catch (std::invalid_argument e)
+	{
+		QMessageBox msg(this);
+		msg.addButton(QMessageBox::Ok);
+		msg.setText(QString::fromStdString(e.what()));
+		msg.setIcon(QMessageBox::Critical);
+		msg.setWindowTitle("Open File Error");
+
+		msg.exec();
+		return;
+	}
+
+	// parth to texture
+	std::string tmp_path = path;
+	while (tmp_path.back() != '/' && tmp_path.back() != '\\')
+		tmp_path.pop_back();
+
+	// load all textures
+	for (auto& texIt : tmp_texNames)
+	{
+		TextureData* new_data = new TextureData;
+		try
+		{
+			TextureTGA tmp_texFile(std::string(tmp_path + texIt).c_str());
+
+			new_data->alpha = tmp_texFile.hasAlpha();
+			new_data->width = tmp_texFile.getWidth();
+			new_data->height = tmp_texFile.getHeight();
+			new_data->data = tmp_texFile.getData();
+		}
+		catch (std::invalid_argument e)
+		{
+			new_data->alpha = true;
+			new_data->width = 1;
+			new_data->height = 1;
+			new_data->data = new std::vector<std::uint8_t>({ 0, 0, 255, 255 });
+		}
+
+		tmp_textures->push_back(new_data);
+	}
+
+	// add a solid default color at the end (maybe there is an invalid index later)
+	TextureData* new_data = new TextureData;
+	new_data->alpha = true;
+	new_data->width = 1;
+	new_data->height = 1;
+	new_data->data = new std::vector<std::uint8_t>({ 0, 0, 255, 255 });
+	tmp_textures->push_back(new_data);
+
+	// clean up texture name list
+	tmp_texNames.clear();
+
+	// give the data to the viewer
+	OpenGlViewer* tmp_viewer = dynamic_cast<OpenGlViewer*>(centralWidget());
+	tmp_viewer->setData(tmp_models, tmp_textures, tmp_bbox);
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// private slots
+
+void MainWindow::openFile()
+{
+	QString fileName = QFileDialog::getOpenFileName(this, "Open File", "../Release/Msh", "Mesh (*.msh)");
+
+	import(fileName.toStdString().c_str());
+}
+
+void MainWindow::aboutFile()
+{
+	//TODO: Open Window with file information
+	QMessageBox* dialog = new QMessageBox(QMessageBox::Information, WINDOW_NAME, "File Info", QMessageBox::StandardButton::Close, this, Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint);
+	dialog->setDetailedText("This is the cool detailed text\n");
+	dialog->exec();
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// events
+
+void MainWindow::keyPressEvent(QKeyEvent * keyEvent)
+{
+	switch (keyEvent->key())
+	{
+	case Qt::Key::Key_Escape:
+		close();
+		break;
+	}
+
+	QMainWindow::keyPressEvent(keyEvent);
+}

MeshViewerQt/Source/Texture.cpp

+#include "Texture.h"
+#include <fstream>
+
+TextureTGA::TextureTGA(const char * filePath)
+{
+	// open the file
+	std::fstream fsPicture(filePath, std::ios::in | std::ios::binary);
+
+	if (!fsPicture.is_open())
+		throw std::invalid_argument(std::string("file not found: ") += filePath);
+
+	// read in the header
+	std::uint8_t ui8x18Header[19] = { 0 };
+	fsPicture.read(reinterpret_cast<char*>(&ui8x18Header), sizeof(ui8x18Header)-1);
+	
+	//get variables
+	vui8Pixels = new std::vector<std::uint8_t>;
+	bool bCompressed;
+	std::uint32_t ui32IDLength;
+	std::uint32_t ui32PicType;
+	std::uint32_t ui32PaletteLength;
+	std::uint32_t ui32Size;
+
+	// extract all information from header
+	ui32IDLength = ui8x18Header[0];
+	ui32PicType = ui8x18Header[2];
+	ui32PaletteLength = ui8x18Header[6] * 0x100 + ui8x18Header[5];
+	ui32Width = ui8x18Header[13] * 0x100 + ui8x18Header[12];
+	ui32Height = ui8x18Header[15] * 0x100 + ui8x18Header[14];
+	ui32BpP = ui8x18Header[16];
+
+	// calculate some more information
+	ui32Size = ui32Width * ui32Height * ui32BpP/8;
+	bCompressed = ui32PicType == 9 || ui32PicType == 10;
+	vui8Pixels->resize(ui32Size);
+
+	// jump to the data block
+	fsPicture.seekg(ui32IDLength + ui32PaletteLength, std::ios_base::cur);
+
+	// If not compressed 24 or 32 bit
+	if (ui32PicType == 2 && (ui32BpP == 24 || ui32BpP == 32))
+	{
+		fsPicture.read(reinterpret_cast<char*>(vui8Pixels->data()), ui32Size);
+	}
+	// else if compressed 24 or 32 bit
+	else if (ui32PicType == 10 && (ui32BpP == 24 || ui32BpP == 32))	// compressed
+	{
+		std::uint8_t tempChunkHeader;
+		std::uint8_t tempData[5];
+		unsigned int tempByteIndex = 0;
+
+		do {
+			fsPicture.read(reinterpret_cast<char*>(&tempChunkHeader), sizeof(tempChunkHeader));
+
+			if (tempChunkHeader >> 7)	// repeat count
+			{
+				// just use the first 7 bits
+				tempChunkHeader = (uint8_t(tempChunkHeader << 1) >> 1);
+
+				fsPicture.read(reinterpret_cast<char*>(&tempData), ui32BpP/8);
+
+				for (int i = 0; i <= tempChunkHeader; i++)
+				{
+					vui8Pixels->at(tempByteIndex++) = tempData[0];
+					vui8Pixels->at(tempByteIndex++) = tempData[1];
+					vui8Pixels->at(tempByteIndex++) = tempData[2];
+					if(ui32BpP == 32) vui8Pixels->at(tempByteIndex++) = tempData[3];
+				}
+			}
+			else						// data count
+			{
+				// just use the first 7 bits
+				tempChunkHeader = (uint8_t(tempChunkHeader << 1) >> 1);
+
+				for (int i = 0; i <= tempChunkHeader; i++)
+				{
+					fsPicture.read(reinterpret_cast<char*>(&tempData), ui32BpP/8);
+
+					vui8Pixels->at(tempByteIndex++) = tempData[0];
+					vui8Pixels->at(tempByteIndex++) = tempData[1];
+					vui8Pixels->at(tempByteIndex++) = tempData[2];
+					if (ui32BpP == 32) vui8Pixels->at(tempByteIndex++) = tempData[3];
+				}
+			}
+		} while (tempByteIndex < ui32Size);
+	}
+	// not useable format
+	else
+	{
+		fsPicture.close();
+		throw std::invalid_argument("Invaild File Format! Required 24 or 31 Bit Image.");
+	}
+
+	fsPicture.close();
+}
+
+TextureTGA::~TextureTGA()
+{
+}
+
+std::vector<std::uint8_t>* TextureTGA::getData() const
+{
+	return vui8Pixels;
+}
+
+bool TextureTGA::hasAlpha() const
+{
+	return ui32BpP == 32;
+}
+
+std::uint32_t TextureTGA::getWidth() const
+{
+	return ui32Width;
+}
+
+std::uint32_t TextureTGA::getHeight() const
+{
+	return ui32Height;
+}

MeshViewerQt/main.cpp

+#include "Header\MainWindow.h"
+#include <QtWidgets/QApplication>
+
+
+int startGUI(int argc, char* argv[])
+{
+	QApplication a(argc, argv);
+	MainWindow w;
+	w.show();
+	return a.exec();
+}
+
+int main(int argc, char *argv[])
+{
+	int exitstatus = startGUI(argc, argv);
+
+	return exitstatus;
+}