Solved merge conflict

modules/planetbrowsing/CMakeLists.txt

@@ -27,12 +27,14 @@ include(${OPENSPACE_CMAKE_EXT_DIR}/module_definition.cmake)
 set(HEADER_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/rendering/planet.h
     ${CMAKE_CURRENT_SOURCE_DIR}/rendering/distanceswitch.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/rendering/geometry.h
 )
 source_group("Header Files" FILES ${HEADER_FILES})
 
 set(SOURCE_FILES
    ${CMAKE_CURRENT_SOURCE_DIR}/rendering/planet.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/rendering/distanceswitch.cpp
+   ${CMAKE_CURRENT_SOURCE_DIR}/rendering/geometry.cpp
 )
 source_group("Source Files" FILES ${SOURCE_FILES})
 

modules/planetbrowsing/rendering/geometry.cpp

@@ -0,0 +1,135 @@
+#include <modules/planetbrowsing/rendering/geometry.h>
+#include <ghoul/logging/logmanager.h>
+
+namespace {
+	const std::string _loggerCat = "Geometry";
+}
+
+namespace openspace
+{
+
+Geometry::Geometry(
+	std::vector<unsigned int> elements,
+	Positions usePositions,
+	Textures useTextures,
+	Normals useNormals) :
+	_vaoID(0),
+	_vertexBufferID(0),
+	_elementBufferID(0),
+	_usePositions(usePositions == Positions::Yes ? true : false),
+	_useTextures(useTextures == Textures::Yes ? true : false),
+	_useNormals(useNormals == Normals::Yes ? true : false)
+{
+	setElementData(elements);
+}
+
+Geometry::~Geometry() {
+	glDeleteBuffers(1, &_vertexBufferID);
+	glDeleteBuffers(1, &_elementBufferID);
+	glDeleteVertexArrays(1, &_vaoID);
+}
+
+void Geometry::setPositionData(std::vector<glm::vec4> positions) {
+	for (size_t i = 0; i < positions.size(); i++)
+	{
+		_vertexData[i].position[0] = static_cast<GLfloat>(positions[i].x);
+		_vertexData[i].position[1] = static_cast<GLfloat>(positions[i].y);
+		_vertexData[i].position[2] = static_cast<GLfloat>(positions[i].z);
+		_vertexData[i].position[3] = static_cast<GLfloat>(positions[i].w);
+	}
+}
+
+void Geometry::setTextureData(std::vector<glm::vec2> textures) {
+	for (size_t i = 0; i < textures.size(); i++)
+	{
+		_vertexData[i].texture[0] = static_cast<GLfloat>(textures[i].s);
+		_vertexData[i].texture[1] = static_cast<GLfloat>(textures[i].t);
+	}
+}
+
+void Geometry::setNormalData(std::vector<glm::vec3> normals) {
+	for (size_t i = 0; i < normals.size(); i++)
+	{
+		_vertexData[i].normal[0] = static_cast<GLfloat>(normals[i].x);
+		_vertexData[i].normal[1] = static_cast<GLfloat>(normals[i].y);
+		_vertexData[i].normal[2] = static_cast<GLfloat>(normals[i].z);
+	}
+}
+
+void Geometry::setElementData(std::vector<unsigned int> elements) {
+	for (size_t i = 0; i < elements.size(); i++)
+	{
+		_elementData[i] = static_cast<GLuint>(elements[i]);
+	}
+}
+
+bool Geometry::initialize() {
+	// Create VAO
+	if (_vaoID == 0)
+		glGenVertexArrays(1, &_vaoID);
+
+	// Create VBOs
+	if (_vertexBufferID == 0 && _vertexData.size() > 0) {
+		glGenBuffers(1, &_vertexBufferID);
+		if (_vertexBufferID == 0) {
+			LERROR("Could not create vertex buffer");
+			return false;
+		}
+	}
+	if (_elementBufferID == 0 && _elementData.size() > 0) {
+		glGenBuffers(1, &_elementBufferID);
+		if (_elementBufferID == 0) {
+			LERROR("Could not create vertex element buffer");
+			return false;
+		}
+	}
+
+	// First VAO setup
+	glBindVertexArray(_vaoID);
+
+	// Vertex buffer
+	glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferID);
+	glBufferData(
+		GL_ARRAY_BUFFER,
+		_elementData.size() * sizeof(Vertex),
+		&_elementData[0],
+		GL_STATIC_DRAW);
+
+	// Positions at location 0
+	if (_usePositions) {
+		glEnableVertexAttribArray(0);
+		glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+			reinterpret_cast<const GLvoid*>(offsetof(Vertex, position)));
+	}
+	// Textures at location 1
+	if (_useTextures) {
+		glEnableVertexAttribArray(1);
+		glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+			reinterpret_cast<const GLvoid*>(offsetof(Vertex, texture)));
+	}
+	// Normals at location 2
+	if (_useNormals) {
+		glEnableVertexAttribArray(2);
+		glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+			reinterpret_cast<const GLvoid*>(offsetof(Vertex, normal)));
+	}
+
+	// Element buffer
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _elementBufferID);
+	glBufferData(
+		GL_ELEMENT_ARRAY_BUFFER,
+		_elementData.size() * sizeof(GLint),
+		&_elementData[0],
+		GL_STATIC_DRAW);
+
+	glBindVertexArray(0);
+	return true;
+}
+void Geometry::render() const {
+	glBindVertexArray(_vaoID);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _elementBufferID);
+	glDrawElements(GL_TRIANGLES, _elementData.size(), GL_UNSIGNED_INT, 0);
+	glBindVertexArray(0);
+}
+
+} // namespace openspace

modules/planetbrowsing/rendering/geometry.h

@@ -0,0 +1,91 @@
+/*****************************************************************************************
+*                                                                                       *
+* OpenSpace                                                                             *
+*                                                                                       *
+* Copyright (c) 2014-2016                                                               *
+*                                                                                       *
+* Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
+* software and associated documentation files (the "Software"), to deal in the Software *
+* without restriction, including without limitation the rights to use, copy, modify,    *
+* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
+* permit persons to whom the Software is furnished to do so, subject to the following   *
+* conditions:                                                                           *
+*                                                                                       *
+* The above copyright notice and this permission notice shall be included in all copies *
+* or substantial portions of the Software.                                              *
+*                                                                                       *
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
+* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
+* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
+* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
+* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
+****************************************************************************************/
+
+#ifndef __GEOMETRY_H__
+#define __GEOMETRY_H__
+
+#include <ghoul/opengl/ghoul_gl.h>
+#include <glm/glm.hpp>
+
+#include <vector>
+
+namespace openspace {
+
+/**
+	Class to hold vertex data and handling OpenGL interfacing and rendering. A Geometry
+	has all data needed such as position buffer and normal buffer but all data is not
+	necessarily needed for all purpouses so the Geometry can disable use of normals for
+	example.
+*/
+class Geometry
+{
+public:
+	enum class Positions { Yes, No };
+	enum class Textures { Yes, No };
+	enum class Normals { Yes, No };
+
+	Geometry(
+		std::vector<unsigned int> elements, // At least elements are required
+		Positions usePositions,
+		Textures useTextures,
+		Normals useNormals);
+	~Geometry();
+
+	// Setters
+	void setPositionData(std::vector<glm::vec4> positions);
+	void setTextureData(std::vector<glm::vec2> textures);
+	void setNormalData(std::vector<glm::vec3> normals);
+	void setElementData(std::vector<unsigned int> elements);
+
+	/**
+		Initialize GPU handles. Before calling this function, the data must be set.
+	*/
+	bool initialize();
+	void render() const;
+
+private:
+	typedef struct {
+		GLfloat position[4];
+		GLfloat texture[2];
+		GLfloat normal[3];
+		GLubyte padding[28];  // Pads the struct out to 64 bytes for performance increase
+	} Vertex;
+	// Vertex data
+	std::vector<Vertex> _vertexData;
+	std::vector<GLuint> _elementData;
+
+	// GL handles
+	GLuint _vaoID;
+	GLuint _vertexBufferID;
+	GLuint _elementBufferID;
+
+	// Determines what attribute data is in use
+	const bool _usePositions;
+	const bool _useTextures;
+	const bool _useNormals;
+};
+
+} // namespace openspace
+
+#endif // __GEOMETRY_H__