current revision

ui/map/3D/gl/GLTriangles.h

@@ -0,0 +1,223 @@
+#ifndef GLTRIANGLES_H
+#define GLTRIANGLES_H
+
+#include <QOpenGLFunctions>
+#include "GL.h"
+#include "GLHelper.h"
+
+#include <type_traits>
+#include <Indoor/geo/Point3.h>
+
+template <typename T> class GLTriangles : protected QOpenGLFunctions {
+
+private:
+
+	QOpenGLBuffer arrayBuf;
+	QOpenGLBuffer indexBuf;
+	QOpenGLTexture* textures[4];
+
+	std::vector<T> vertices;
+	std::vector<GLuint> indices;
+
+public:
+
+	/** ctor */
+	GLTriangles() : arrayBuf(QOpenGLBuffer::VertexBuffer), indexBuf(QOpenGLBuffer::IndexBuffer), textures() {
+		;
+	}
+
+	/** dtor */
+	~GLTriangles() {
+
+		arrayBuf.destroy();
+		indexBuf.destroy();
+
+		for (int i = 0; i < 4; ++i) {delete textures[i];}
+
+	}
+
+	/** set the to-be-used texture */
+	void setTexture(const int slot, const QString& textureFile) {
+
+		const QImage img(textureFile);
+		if (img.width() <= 0) {throw "error";}
+
+		QOpenGLTexture* texture = new QOpenGLTexture(img);
+		texture->setMinificationFilter(QOpenGLTexture::Linear);
+		texture->setMagnificationFilter(QOpenGLTexture::Linear);
+		texture->setWrapMode(QOpenGLTexture::Repeat);
+		texture->generateMipMaps();
+		textures[slot] = texture;
+
+	}
+
+	void setDiffuse(const QString& textureFile) {
+		setTexture(0, textureFile);
+	}
+
+	void setNormalMap(const QString& textureFile) {
+		setTexture(1, textureFile);
+	}
+
+	/** add a new face to this element */
+	void addFace(const T& vnt1, const T& vnt2, const T& vnt3) {
+		addFace(vnt1, vnt2, vnt3, 0);
+	}
+
+	/** add a new face to this element */
+	void addFaceCCW(const T& vnt1, const T& vnt2, const T& vnt3) {
+		addFace(vnt1, vnt2, vnt3, 1);
+	}
+
+	/** add a new face to this element */
+	void addFaceCW(const T& vnt1, const T& vnt2, const T& vnt3) {
+		addFace(vnt1, vnt2, vnt3, 2);
+	}
+
+	/** add a new quad to this element */
+	void addQuadCCW(const T& vnt1, const T& vnt2, const T& vnt3, const T& vnt4) {
+		addFace(vnt1, vnt2, vnt3, 1);
+		addFace(vnt3, vnt4, vnt1, 1);
+	}
+
+	/** add a new quad to this element */
+	void addQuadCW(const T& vnt1, const T& vnt2, const T& vnt3, const T& vnt4) {
+		addFace(vnt1, vnt2, vnt3, 2);
+		addFace(vnt3, vnt4, vnt1, 2);
+	}
+
+	/** add a new quad to this element */
+	void addQuad(const T& vnt1, const T& vnt2, const T& vnt3, const T& vnt4) {
+		addFace(vnt1, vnt2, vnt3, 0);
+		addFace(vnt3, vnt4, vnt1, 0);
+	}
+
+	/** build the underlying buffers */
+	void build() {
+
+		initializeOpenGLFunctions();
+
+		// Transfer vertex data to VBO 0
+		arrayBuf.create();
+		arrayBuf.bind();
+		arrayBuf.allocate(vertices.data(), vertices.size() * sizeof(vertices[0]));
+
+		// Transfer index data to VBO 1
+		indexBuf.create();
+		indexBuf.bind();
+		indexBuf.allocate(indices.data(), indices.size() * sizeof(indices[0]));
+
+	}
+
+	void rebuild() {
+		if (indexBuf.isCreated()) {indexBuf.destroy();}
+		if (arrayBuf.isCreated()) {arrayBuf.destroy();}
+		build();
+	}
+
+	void clear() {
+		indices.clear();
+		vertices.clear();
+	}
+
+	/** render the element */
+	void render(QOpenGLShaderProgram* program) {
+
+		// nothing to-do?
+		if (indices.empty()) {return;}
+
+		// Tell OpenGL which VBOs to use
+		arrayBuf.bind();
+		indexBuf.bind();
+
+		for (int i = 0; i < 4; ++i) {
+			if (textures[i]) { textures[i]->bind(i); }
+		}
+
+		// vertices
+		int vertLoc = program->attributeLocation("a_position");
+		program->enableAttributeArray(vertLoc);
+		program->setAttributeBuffer(vertLoc, GL_FLOAT, vertices[0].getVertOffset(), 3, sizeof(vertices[0]));
+
+		// Tell OpenGL programmable pipeline how to locate vertex texture coordinate data
+		if (T::hasNormal()) {
+			int normLoc = program->attributeLocation("a_normal");
+			program->enableAttributeArray(normLoc);
+			program->setAttributeBuffer(normLoc, GL_FLOAT, vertices[0].getNormOffset(), 3, sizeof(vertices[0]));
+		}
+
+		if (T::hasTexCoord()) {
+			int texcoordLocation = program->attributeLocation("a_texcoord");
+			program->enableAttributeArray(texcoordLocation);
+			program->setAttributeBuffer(texcoordLocation, GL_FLOAT, vertices[0].getTexOffset(), 2, sizeof(vertices[0]));
+		}
+
+		// bind tangent data?
+		if (T::hasTangent()) {
+			int tanLocation = program->attributeLocation("a_tangent");
+			program->enableAttributeArray(tanLocation);
+			program->setAttributeBuffer(tanLocation, GL_FLOAT, vertices[0].getTanOffset(), 3, sizeof(vertices[0]));
+		}
+
+		// bind color data?
+		if (T::hasColor()) {
+			int colorLoc = program->attributeLocation("a_color");
+			program->enableAttributeArray(colorLoc);
+			program->setAttributeBuffer(colorLoc, GL_FLOAT, vertices[0].getColorOffset(), 3, sizeof(vertices[0]));
+		}
+
+		// texture
+		program->setUniformValue("texture", 0);
+
+		// Draw cube geometry using indices from VBO 1
+		glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
+
+	}
+
+private:
+
+	void addFace(const T& vnt1, const T& vnt2, const T& vnt3, const int mode) {
+
+		// add vertices (remove duplicates!)
+		const int i1 = addOnce(vnt1);
+		const int i2 = addOnce(vnt2);
+		const int i3 = addOnce(vnt3);
+
+		// get current orientation
+		const bool ccw = GLHelper::isCCW(vnt1.vert, vnt2.vert, vnt3.vert);
+
+		// create indices
+		if (mode == 0 || (mode == 1 && ccw) || (mode == 2 && !ccw) ) {
+			indices.push_back(i1);
+			indices.push_back(i2);
+			indices.push_back(i3);
+		} else {
+			indices.push_back(i3);
+			indices.push_back(i2);
+			indices.push_back(i1);
+		}
+
+	}
+
+	/** to conserve memory, avoid duplicate VNTs! */
+	int addOnce(const T& vnt) {
+
+		const auto it = std::find(vertices.begin(), vertices.end(), vnt);
+
+		if (it == vertices.end()) {
+			const int idx = vertices.size();
+			vertices.push_back(vnt);
+			return idx;
+		} else {
+			const int idx = it - vertices.begin();
+			return idx;
+		}
+
+	}
+
+
+
+
+};
+
+#endif // GLTRIANGLES_H