Merge branch 'develop' of https://bitbucket.org/volumesoffun/polyvox into feature/extractor-refactor

Conflicts:
	examples/Basic/main.cpp

CMakeLists.txt

@@ -20,7 +20,7 @@
 # 3. This notice may not be removed or altered from any source
 # distribution.
 
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.3)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.6)
 
 PROJECT(PolyVox)
 
@@ -55,12 +55,6 @@ else()
 	set_package_properties(Qt4 PROPERTIES TYPE OPTIONAL PURPOSE "Building the tests")
 endif()
 
-if(MSVC AND (MSVC_VERSION LESS 1600))
-	# Require boost for older (pre-vc2010) Visual Studio compilers
-	# See library/include/polyvoxcore/impl/TypeDef.h
-	find_package(Boost REQUIRED)
-	include_directories(${Boost_INCLUDE_DIRS})
-endif()
 
 IF(CMAKE_COMPILER_IS_GNUCXX) #Maybe "OR MINGW"
 	ADD_DEFINITIONS(-std=c++0x) #Enable C++0x mode
@@ -89,7 +83,6 @@ INCLUDE(Packaging.cmake)
 OPTION(ENABLE_TESTS "Should the tests be built" ON)
 IF(ENABLE_TESTS AND QT_QTTEST_FOUND)
 	INCLUDE(CTest)
-	MARK_AS_ADVANCED(FORCE DART_TESTING_TIMEOUT) #This is only needed to hide the variable in the GUI (CMake bug) until 2.8.5
 	MARK_AS_ADVANCED(FORCE BUILD_TESTING)
 	ADD_SUBDIRECTORY(tests)
 	SET(BUILD_TESTS ON)

examples/Basic/OpenGLWidget.cpp

@@ -1,6 +1,8 @@
 #include "OpenGLWidget.h"
 
 #include <QMouseEvent>
+#include <QMatrix4x4>
+//#include <QtMath>
 
 using namespace PolyVox;
 using namespace std;
@@ -12,43 +14,42 @@ OpenGLWidget::OpenGLWidget(QWidget *parent)
 {
 }
 
-void OpenGLWidget::setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PositionMaterialNormal>& surfaceMesh)
+void OpenGLWidget::setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PositionMaterial>& surfaceMesh)
 {
 	//Convienient access to the vertices and indices
-	const vector<uint32_t>& vecIndices = surfaceMesh.getIndices();
+	const auto& vecIndices = surfaceMesh.getIndices();
-	const vector<PositionMaterialNormal>& vecVertices = surfaceMesh.getVertices();
+	const auto& vecVertices = surfaceMesh.getVertices();
-
+	
-	//Build an OpenGL index buffer
+	//Create the VAO for the mesh
-	glGenBuffers(1, &indexBuffer);
+	glGenVertexArrays(1, &vertexArrayObject);
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
+	glBindVertexArray(vertexArrayObject);
-	const GLvoid* pIndices = static_cast<const GLvoid*>(&(vecIndices[0]));		
+	
-	glBufferData(GL_ELEMENT_ARRAY_BUFFER, vecIndices.size() * sizeof(uint32_t), pIndices, GL_STATIC_DRAW);
+	//The GL_ARRAY_BUFFER will contain the list of vertex positions
-
-	//Build an OpenGL vertex buffer
 	glGenBuffers(1, &vertexBuffer);
 	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
-	const GLvoid* pVertices = static_cast<const GLvoid*>(&(vecVertices[0]));	
+	glBufferData(GL_ARRAY_BUFFER, vecVertices.size() * sizeof(PositionMaterial), vecVertices.data(), GL_STATIC_DRAW);
-	glBufferData(GL_ARRAY_BUFFER, vecVertices.size() * sizeof(PositionMaterialNormal), pVertices, GL_STATIC_DRAW);
+	
-
+	//and GL_ELEMENT_ARRAY_BUFFER will contain the indices
-	m_uBeginIndex = 0;
+	glGenBuffers(1, &indexBuffer);
-	m_uEndIndex = vecIndices.size();
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, vecIndices.size() * sizeof(uint32_t), vecIndices.data(), GL_STATIC_DRAW);
+	
+	//We need to tell OpenGL how to understand the format of the vertex data
+	glEnableVertexAttribArray(0); //We're talking about shader attribute '0' 
+	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(PositionMaterial), 0); //take the first 3 floats from every sizeof(decltype(vecVertices)::value_type)
+	
+	glBindVertexArray(0);
+	
+	noOfIndices = vecIndices.size(); //Save this for the call to glDrawElements later
 }
 
 void OpenGLWidget::initializeGL()
 {
-	//We need GLEW to access recent OpenGL functionality
+	GLenum err = glewInit();
-	std::cout << "Initialising GLEW...";
+	if (GLEW_OK != err)
-	GLenum result = glewInit();
-	if (result == GLEW_OK)
-	{
-	  std::cout << "success" << std::endl;
-	}
-	else
 	{
 		/* Problem: glewInit failed, something is seriously wrong. */
-		std::cout << "failed" << std::endl;
+		std::cout << "GLEW Error: " << glewGetErrorString(err) << std::endl;
-		std::cout << "Initialising GLEW failed with the following error: " << glewGetErrorString(result) << std::endl;
-		exit(EXIT_FAILURE);
 	}
 	
 	//Print out some information about the OpenGL implementation.
@@ -61,74 +62,121 @@ void OpenGLWidget::initializeGL()
 	  std::cout << "\tGL_VERSION: " << glGetString(GL_VERSION) << std::endl;
 	if(glGetString(GL_SHADING_LANGUAGE_VERSION))
 	  std::cout << "\tGL_SHADING_LANGUAGE_VERSION: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
-	
-	//Check our version of OpenGL is recent enough.
-	//We need at least 1.5 for vertex buffer objects,
-	if (!GLEW_VERSION_1_5)
-	{
-	  std::cout << "Error: You need OpenGL version 1.5 to run this example." << std::endl;
-	  exit(EXIT_FAILURE);
-	}
 
 	//Set up the clear colour
-	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		
+	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-	glClearDepth(1.0f);		
+	glClearDepth(1.0f);
-
+	
-	//Enable the depth buffer
+	glEnable(GL_CULL_FACE);
-	glEnable(GL_DEPTH_TEST);					
+	glEnable(GL_DEPTH_TEST);
-	glDepthFunc(GL_LEQUAL);						
+	glDepthMask(GL_TRUE);
-
+	glDepthFunc(GL_LEQUAL);
-	//Anable smooth lighting
+	glDepthRange(0.0, 1.0);
-	glEnable(GL_LIGHTING);
+	
-	glEnable(GL_LIGHT0);
+	if (!shader.addShaderFromSourceCode(QGLShader::Vertex, R"(
-	glShadeModel(GL_SMOOTH);
+		#version 140
-
+		
-	//We'll be rendering with index/vertex arrays
+		in vec4 position; //This will be the position of the vertex in model-space
-	glEnableClientState(GL_VERTEX_ARRAY);
+		
-	glEnableClientState(GL_NORMAL_ARRAY);
+		uniform mat4 cameraToClipMatrix;
+		uniform mat4 worldToCameraMatrix;
+		uniform mat4 modelToWorldMatrix;
+		
+		out vec4 worldPosition; //This is being passed to the fragment shader to calculate the normals
+		
+		void main()
+		{
+			worldPosition = modelToWorldMatrix * position;
+			vec4 cameraPosition = worldToCameraMatrix * worldPosition;
+			gl_Position = cameraToClipMatrix * cameraPosition;
+		}
+	)"))
+	{
+		std::cerr << shader.log().toStdString() << std::endl;
+		exit(EXIT_FAILURE);
+	}
+	
+	if (!shader.addShaderFromSourceCode(QGLShader::Fragment, R"(
+		#version 130
+		
+		in vec4 worldPosition; //Passed in from the vertex shader
+		
+		out vec4 outputColor;
+		
+		void main()
+		{
+			vec3 normal = normalize(cross(dFdy(worldPosition.xyz), dFdx(worldPosition.xyz)));
+			
+			float color = clamp(abs(dot(normalize(normal.xyz), vec3(0.9,0.1,0.5))), 0, 1);
+			outputColor = vec4(1.0, 0.5, color, 1.0);
+		}
+	)"))
+	{
+		std::cerr << shader.log().toStdString() << std::endl;
+		exit(EXIT_FAILURE);
+	}
+	
+	shader.bindAttributeLocation("position", 0);
+	
+	if(!shader.link())
+	{
+		std::cerr << shader.log().toStdString() << std::endl;
+		exit(EXIT_FAILURE);
+	}
+	
+	shader.bind();
+	
+	QMatrix4x4 worldToCameraMatrix{};
+	worldToCameraMatrix.translate(0, 0, -50); //Move the camera back by 50 units
+	
+	shader.setUniformValue("worldToCameraMatrix", worldToCameraMatrix);
+	
+	shader.release();
 }
 
 void OpenGLWidget::resizeGL(int w, int h)
 {
 	//Setup the viewport
 	glViewport(0, 0, w, h);
-
+	
-	//Set up the projection matrix
+	auto aspectRatio = w / (float)h;
-	glMatrixMode(GL_PROJECTION);
+	float zNear = 1.0;
-	glLoadIdentity();
+	float zFar = 1000.0;
-	float frustumSize = 32.0f; //Half the volume size
+	
-	float aspect = static_cast<float>(width()) / static_cast<float>(height());
+	QMatrix4x4 cameraToClipMatrix{};
-	glOrtho(frustumSize*aspect, -frustumSize*aspect, frustumSize, -frustumSize, 1.0, 1000);
+	cameraToClipMatrix.frustum(-aspectRatio, aspectRatio, -1, 1, zNear, zFar);
+	
+	shader.bind();
+	shader.setUniformValue("cameraToClipMatrix", cameraToClipMatrix);
+	shader.release();
 }
 
 void OpenGLWidget::paintGL()
 {
 	//Clear the screen
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
+	
-	//Set up the viewing transformation
+	QMatrix4x4 modelToWorldMatrix{};
-	glMatrixMode(GL_MODELVIEW); 
+	modelToWorldMatrix.rotate(m_xRotation, 0, 1, 0); //rotate around y-axis
-	glLoadIdentity();
+	modelToWorldMatrix.rotate(m_yRotation, 1, 0, 0); //rotate around x-axis
-	glTranslatef(0.0f,0.0f,-100.0f); //Centre volume and move back
+	modelToWorldMatrix.translate(-32, -32, -32); //centre the model on the origin
-	glRotatef(-m_xRotation, 0.0f, 1.0f, 0.0f);
+	
-	glRotatef(-m_yRotation, 1.0f, 0.0f, 0.0f);
+	shader.bind();
-	glTranslatef(-32.0f,-32.0f,-32.0f); //Centre volume and move back
+	
-
+	shader.setUniformValue("modelToWorldMatrix", modelToWorldMatrix); //Update to the latest camera matrix
-	//Bind the index buffer
+	
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
+	glBindVertexArray(vertexArrayObject);
-
+	
-	//Bind the vertex buffer
+	glDrawElements(GL_TRIANGLES, noOfIndices, GL_UNSIGNED_INT, 0);
-	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
+	
-	glVertexPointer(3, GL_FLOAT, sizeof(PositionMaterialNormal), 0);
+	glBindVertexArray(0);
-	glNormalPointer(GL_FLOAT, sizeof(PositionMaterialNormal), (GLvoid*)12);
+	
-
+	shader.release();
-	glDrawRangeElements(GL_TRIANGLES, m_uBeginIndex, m_uEndIndex-1, m_uEndIndex - m_uBeginIndex, GL_UNSIGNED_INT, 0);
 	
 	GLenum errCode = glGetError();
 	if(errCode != GL_NO_ERROR)
 	{
-	  //What has replaced getErrorString() in the latest OpenGL?
+	  std::cerr << "OpenGL Error: " << errCode << std::endl;
-	  std::cout << "OpenGL Error: " << errCode << std::endl;
 	}
 }
 

examples/Basic/OpenGLWidget.h

@@ -29,6 +29,7 @@ distribution.
 #include "glew/glew.h"
 
 #include <QGLWidget>
+#include <QGLShaderProgram>
 
 class OpenGLWidget : public QGLWidget
 {
@@ -40,8 +41,8 @@ public:
 	void mouseMoveEvent(QMouseEvent* event);
 	void mousePressEvent(QMouseEvent* event);
 
-	//Convert a SrfaceMesh to OpenGL index/vertex buffers
+	//Convert a SurfaceMesh to OpenGL index/vertex buffers
-	void setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PolyVox::PositionMaterialNormal>& surfaceMesh);
+	void setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PolyVox::PositionMaterial>& surfaceMesh);
 
 protected:
 	//Qt OpenGL functions
@@ -51,11 +52,12 @@ protected:
 
 private:
 	//Index/vertex buffer data
-	GLuint m_uBeginIndex;
-	GLuint m_uEndIndex;
 	GLuint noOfIndices;
 	GLuint indexBuffer;
 	GLuint vertexBuffer;
+	GLuint vertexArrayObject;
+	
+	QGLShaderProgram shader;
 
 	//Mouse data
 	QPoint m_LastFrameMousePos;

examples/Basic/main.cpp

@@ -23,7 +23,7 @@ freely, subject to the following restrictions:
 
 #include "OpenGLWidget.h"
 
-#include "PolyVoxCore/CubicSurfaceExtractorWithNormals.h"
+#include "PolyVoxCore/CubicSurfaceExtractor.h"
 #include "PolyVoxCore/MarchingCubesSurfaceExtractor.h"
 #include "PolyVoxCore/SurfaceMesh.h"
 #include "PolyVoxCore/SimpleVolume.h"
@@ -76,10 +76,10 @@ int main(int argc, char *argv[])
 	//Create an empty volume and then place a sphere in it
 	SimpleVolume<uint8_t> volData(PolyVox::Region(Vector3DInt32(0,0,0), Vector3DInt32(63, 63, 63)));
 	createSphereInVolume(volData, 30);
-
+
 	// Extract the surface for the specified region of the volume. Uncomment the line for the kind of surface extraction you want to see.
-	//auto mesh = extractCubicSurfaceWithNormals(&volData, volData.getEnclosingRegion());
+	auto mesh = extractCubicSurface(&volData, volData.getEnclosingRegion());
-	auto mesh = extractMarchingCubesSurface(&volData, volData.getEnclosingRegion());
+	//auto mesh = extractMarchingCubesSurface(&volData, volData.getEnclosingRegion());
 
 	//Pass the surface to the OpenGL window
 	openGLWidget.setSurfaceMeshToRender(mesh);

examples/SmoothLOD/OpenGLWidget.cpp

@@ -7,6 +7,15 @@ using namespace std;
 
 OpenGLWidget::OpenGLWidget(QWidget *parent)
 	:QGLWidget(parent)
+	,m_uBeginIndex(0)
+	,m_uEndIndex(0)
+	,indexBuffer(0)
+	,vertexBuffer(0)
+	
+	,m_uBeginIndexLow(0)
+	,m_uEndIndexLow(0)
+	,indexBufferLow(0)
+	,vertexBufferLow(0)
 	,m_xRotation(0)
 	,m_yRotation(0)
 {