more code cleaned up

source/app.d

@@ -10,7 +10,7 @@ import std.experimental.logger;
 
 
 
-
+import three.gl.util;
 
 
 

source/gl/buffer.d

@@ -1,6 +1,7 @@
 module three.gl.buffer;
 
-import three.common;
+public import derelict.opengl3.gl3;
+import three.gl.util;
 
 enum GlBufferTarget {
 	Array = GL_ARRAY_BUFFER, 

source/gl/draw.d

@@ -1,6 +1,6 @@
 module three.gl.draw;
 
-import three.common;
+public import derelict.opengl3.gl3;
 import three.mesh;
 
 struct GlDrawElementsIndirectCommand {
@@ -13,4 +13,33 @@ struct GlDrawElementsIndirectCommand {
 
 struct GlDrawParameter {
 	Matrix4 transformationMatrix;
-}
+}
+
+struct Position {
+	float x, y, z;
+}
+
+struct Normal {
+	float x, y, z;
+}
+
+struct Color {
+	float r, g, b, a;
+}
+
+struct TextureCoordinate {
+	float u, v;
+}
+
+struct Matrix4 {
+	float[4*4] data;
+}
+
+struct VertexData {
+	Position position;
+	Normal normal;
+	Color color;
+	TextureCoordinate textureCoordinate;
+}
+
+alias IndexData = uint;

source/gl/sync.d

@@ -1,9 +1,11 @@
 module three.gl.sync;
 
-import three.common;
+public import derelict.opengl3.gl3;
+import three.gl.util;
 
 
 struct GlSyncManager {
+private:
 	struct LockRange
 	{
 		size_t startOffset;
@@ -21,6 +23,13 @@ struct GlSyncManager {
 	}
 	
 	Lock[] locks;
+
+public:
+	void construct() pure @safe nothrow @nogc {
+	}
+	
+	void destruct() pure @safe nothrow @nogc {
+	}
 	
 	void waitForLockedRange(size_t lockBeginOffset, size_t lockLength) { 
 		LockRange testRange = LockRange(lockBeginOffset, lockLength);

source/gl/util.d

@@ -0,0 +1,103 @@
+module three.gl.util;
+
+public import derelict.opengl3.gl3;
+
+import std.traits : ReturnType;
+
+ReturnType!func glCheck(alias func, string file = __FILE__, size_t line = __LINE__, string mod = __MODULE__, string funcd = __FUNCTION__, string pretty = __PRETTY_FUNCTION__, Args...)(Args args) nothrow {
+	import std.stdio;
+	import std.stdio : stderr;
+	import std.array : join;
+	import std.range : repeat;
+	import std.string : format;
+	try{
+		debug scope(exit) {
+			GLenum err = glGetError();
+			if(err != GL_NO_ERROR) {
+				stderr.writeln("\n===============================");
+				stderr.writeln("File: ", file, "\nLine: ", line, "\nModule: ",mod, "\nFunction: ",funcd, "\n",pretty);
+				stderr.writeln("-------------------------------");
+				stderr.writefln(`OpenGL function "%s(%s)" failed: "%s."`, func.stringof, format("%s".repeat(Args.length).join(", "), args), glErrorString(err));
+				stderr.writeln("=============================== \n");
+				assert(false);
+			}
+		}
+	}
+	catch(Exception e){
+	}
+	
+	debug if(func is null) {
+		try{
+			stderr.writefln("%s is null! OpenGL loaded? Required OpenGL version not supported?".format(func.stringof));
+		}
+		catch(Exception e){
+			assert(false);
+		}
+		assert(false);
+	}	
+	return func(args);
+}
+
+string glErrorString(GLenum error) pure @safe nothrow @nogc {
+	final switch(error) {
+		case GL_NO_ERROR: return "no error";
+		case GL_INVALID_ENUM: return "invalid enum";
+		case GL_INVALID_VALUE: return "invalid value";
+		case GL_INVALID_OPERATION: return "invalid operation";
+			//case GL_STACK_OVERFLOW: return "stack overflow";
+			//case GL_STACK_UNDERFLOW: return "stack underflow";
+		case GL_INVALID_FRAMEBUFFER_OPERATION: return "invalid framebuffer operation";
+		case GL_OUT_OF_MEMORY: return "out of memory";
+	}
+	assert(false, "invalid enum");
+}
+
+
+//==============================================================================
+///
+template toGlType(T) {
+	static if(is(T == byte)) {
+		enum toGlType = GL_BYTE;
+	} else static if(is(T == ubyte)) {
+		enum toGlType = GL_UNSIGNED_BYTE;
+	} else static if(is(T == short)) {
+		enum toGlType = GL_SHORT;
+	} else static if(is(T == ushort)) {
+		enum toGlType = GL_UNSIGNED_SHORT;
+	} else static if(is(T == int)) {
+		enum toGlType = GL_INT;
+	} else static if(is(T == uint)) {
+		enum toGlType = GL_UNSIGNED_INT;
+	} else static if(is(T == float)) {
+		enum toGlType = GL_FLOAT;
+	} else static if(is(T == double)) {
+		enum toGlType = GL_DOUBLE;
+	} else {
+		static assert(false, T.stringof ~ " cannot be represented as GLenum");
+	}
+}
+
+
+//==============================================================================
+///
+template sizeofGlType(GLenum t) {
+	static if(t == GL_BYTE) {
+		enum sizeofGlType = byte.sizeof;
+	} else static if(t == GL_UNSIGNED_BYTE) {
+		enum sizeofGlType = ubyte.sizeof;
+	} else static if(t == GL_SHORT) {
+		enum sizeofGlType = short.sizeof;
+	} else static if(t == GL_UNSIGNED_SHORT) {
+		enum sizeofGlType = ushort.sizeof;
+	} else static if(t == GL_INT) {
+		enum sizeofGlType = int.sizeof;
+	} else static if(t == GL_UNSIGNED_INT) {
+		enum sizeofGlType = uint.sizeof;
+	} else static if(t == GL_FLOAT) {
+		enum sizeofGlType = float.sizeof;
+	} else static if(t == GL_DOUBLE) {
+		enum sizeofGlType = double.sizeof;
+	} else {
+		static assert(false, T.stringof ~ " cannot be represented as D-Type");
+	}
+}

source/three/common.d

@@ -11,104 +11,3 @@ public import std.experimental.logger;
 
 alias SoA(T) = T[];
 
-
-
-import std.traits : ReturnType;
-
-ReturnType!func glCheck(alias func, string file = __FILE__, size_t line = __LINE__, string mod = __MODULE__, string funcd = __FUNCTION__, string pretty = __PRETTY_FUNCTION__, Args...)(Args args) nothrow {
-	import std.stdio;
-	import std.stdio : stderr;
-	import std.array : join;
-	import std.range : repeat;
-	import std.string : format;
-	try{
-		debug scope(exit) {
-			GLenum err = glGetError();
-			if(err != GL_NO_ERROR) {
-				stderr.writeln("\n===============================");
-				stderr.writeln("File: ", file, "\nLine: ", line, "\nModule: ",mod, "\nFunction: ",funcd, "\n",pretty);
-				stderr.writeln("-------------------------------");
-				stderr.writefln(`OpenGL function "%s(%s)" failed: "%s."`, func.stringof, format("%s".repeat(Args.length).join(", "), args), glErrorString(err));
-				stderr.writeln("=============================== \n");
-				assert(false);
-			}
-		}
-	}
-	catch(Exception e){
-	}
-	
-	debug if(func is null) {
-		try{
-			stderr.writefln("%s is null! OpenGL loaded? Required OpenGL version not supported?".format(func.stringof));
-		}
-		catch(Exception e){
-			assert(false);
-		}
-		assert(false);
-	}	
-	return func(args);
-}
-
-string glErrorString(GLenum error) pure @safe nothrow @nogc {
-	final switch(error) {
-		case GL_NO_ERROR: return "no error";
-		case GL_INVALID_ENUM: return "invalid enum";
-		case GL_INVALID_VALUE: return "invalid value";
-		case GL_INVALID_OPERATION: return "invalid operation";
-			//case GL_STACK_OVERFLOW: return "stack overflow";
-			//case GL_STACK_UNDERFLOW: return "stack underflow";
-		case GL_INVALID_FRAMEBUFFER_OPERATION: return "invalid framebuffer operation";
-		case GL_OUT_OF_MEMORY: return "out of memory";
-	}
-	assert(false, "invalid enum");
-}
-
-
-//==============================================================================
-///
-template toGlType(T) {
-	static if(is(T == byte)) {
-		enum toGlType = GL_BYTE;
-	} else static if(is(T == ubyte)) {
-		enum toGlType = GL_UNSIGNED_BYTE;
-	} else static if(is(T == short)) {
-		enum toGlType = GL_SHORT;
-	} else static if(is(T == ushort)) {
-		enum toGlType = GL_UNSIGNED_SHORT;
-	} else static if(is(T == int)) {
-		enum toGlType = GL_INT;
-	} else static if(is(T == uint)) {
-		enum toGlType = GL_UNSIGNED_INT;
-	} else static if(is(T == float)) {
-		enum toGlType = GL_FLOAT;
-	} else static if(is(T == double)) {
-		enum toGlType = GL_DOUBLE;
-	} else {
-		static assert(false, T.stringof ~ " cannot be represented as GLenum");
-	}
-}
-
-
-//==============================================================================
-///
-template sizeofGlType(GLenum t) {
-	static if(t == GL_BYTE) {
-		enum sizeofGlType = byte.sizeof;
-	} else static if(t == GL_UNSIGNED_BYTE) {
-		enum sizeofGlType = ubyte.sizeof;
-	} else static if(t == GL_SHORT) {
-		enum sizeofGlType = short.sizeof;
-	} else static if(t == GL_UNSIGNED_SHORT) {
-		enum sizeofGlType = ushort.sizeof;
-	} else static if(t == GL_INT) {
-		enum sizeofGlType = int.sizeof;
-	} else static if(t == GL_UNSIGNED_INT) {
-		enum sizeofGlType = uint.sizeof;
-	} else static if(t == GL_FLOAT) {
-		enum sizeofGlType = float.sizeof;
-	} else static if(t == GL_DOUBLE) {
-		enum sizeofGlType = double.sizeof;
-	} else {
-		static assert(false, T.stringof ~ " cannot be represented as D-Type");
-	}
-}

source/three/mesh.d

@@ -2,36 +2,9 @@
 
 import three.common;
 
+import three.gl.draw;
 
 
-struct Position {
-	float x, y, z;
-}
-
-struct Normal {
-	float x, y, z;
-}
-
-struct Color {
-	float r, g, b, a;
-}
-
-struct TextureCoordinate {
-	float u, v;
-}
-
-struct Matrix4 {
-	float[4*4] data;
-}
-
-struct VertexData {
-	Position position;
-	Normal normal;
-	Color color;
-	TextureCoordinate textureCoordinate;
-}
-
-alias IndexData = uint;
 
 struct MeshData {
 	VertexData[] vertexData;

source/three/renderTarget.d

@@ -1,24 +1,23 @@
 module three.renderTarget;
 
-import three.common;
+import three.gl.util;
 
 struct RenderTarget {
 	uint width;
 	uint height;
 	GLuint textureTarget;
-}
 
-void construct(out RenderTarget renderTarget, uint width, uint height) nothrow {
-	renderTarget.width = width;
-	renderTarget.height = height;
-	glCheck!glGenTextures(1, &renderTarget.textureTarget);
-	glCheck!glBindTexture(GL_TEXTURE_2D, renderTarget.textureTarget);
-	glCheck!glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, width, height);
-	glCheck!glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_FLOAT, null);	
-	glCheck!glBindTexture(GL_TEXTURE_2D, 0);
+	void construct(uint width, uint height) nothrow {
+		this.width = width;
+		this.height = height;
+		glCheck!glGenTextures(1, &this.textureTarget);
+		glCheck!glBindTexture(GL_TEXTURE_2D, this.textureTarget);
+		glCheck!glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, width, height);
+		glCheck!glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_FLOAT, null);	
+		glCheck!glBindTexture(GL_TEXTURE_2D, 0);
+	}
+	
+	void destruct() nothrow {
+		glCheck!glDeleteTextures(1, &this.textureTarget);
+	}
 }
-
-void destruct(ref RenderTarget renderTarget) nothrow {
-	glCheck!glDeleteTextures(1, &renderTarget.textureTarget);
-	renderTarget = RenderTarget.init;
-}

source/three/renderer.d

@@ -15,6 +15,7 @@ import std.experimental.logger;
 import three.gl.buffer;
 import three.gl.draw;
 import three.gl.sync;
+import three.gl.util;
 
 enum maxVertices = 1024;
 enum maxIndices = 1024;
@@ -31,11 +32,11 @@ enum kOneSecondInNanoSeconds = GLuint64(1000000000);
 struct Renderer {
 	uint width;
 	uint height;
-	GlSyncManager syncManager;
 	GlArrayBuffer!VertexData vertexBuffer; // vertex data for all meshes
 	GlElementArrayBuffer!IndexData indexBuffer; //index data for all meshes
 	GlShaderStorageBuffer!GlDrawParameter perInstanceParamBuffer; // is filled with draw parameters for each instance each frame. shall be accessed as a ringbuffer
 	GlDispatchIndirectBuffer!GlDrawElementsIndirectCommand dispatchIndirectCommandBuffer; // is filled with DrawElementsIndirectCommand for each mesh each frame. shall be accessed as a ringbuffer
+	GlSyncManager syncManager;
 
 	void construct(uint width, uint height) {
 		GLbitfield createFlags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;//TODO: ?? | GL_MAP_DYNAMIC_STORAGE_BIT;
@@ -45,6 +46,7 @@ struct Renderer {
 		this.indexBuffer.construct(bufferCount * maxIndices, createFlags, mapFlags);
 		this.perInstanceParamBuffer.construct(bufferCount * maxPerInstanceParams, createFlags, mapFlags);
 		this.dispatchIndirectCommandBuffer.construct(bufferCount * maxIndirectCommands, createFlags, mapFlags);
+		this.syncManager.construct();
 
 		glCheck!glEnableVertexAttribArray(0);
 		glCheck!glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, VertexData.sizeof, cast(GLvoid*)0 );
@@ -57,40 +59,41 @@ struct Renderer {
 	}
 
 	void destruct() {
-		this.vertexBuffer.destruct();
-		this.indexBuffer.destruct();
-		this.perInstanceParamBuffer.destruct();
+		this.syncManager.destruct();
 		this.dispatchIndirectCommandBuffer.destruct();
+		this.perInstanceParamBuffer.destruct();
+		this.indexBuffer.destruct();
+		this.vertexBuffer.destruct();
 	}
 
-	void uploadModelData(GlArrayBuffer!VertexData vertexBuffer, GlElementArrayBuffer!IndexData indexBuffer, ModelData modelData) {
-		//TODO: wait for buffer range
-		//mBufferLockManager.WaitForLockedRange(mStartDestOffset, _vertices.size() * sizeof(Vec2));
-
-		// TODO: check if buffers are bound. they should always be bound here!
-
-		// we need to store all models in one giant vbo to use glMultiDrawElementsIndirect. 
-		// TODO: implement triple buffering. -> use vertexBuffer and indexBuffer as giant ring buffers
-		GLuint vertexBufferOffset = 0;
-		GLuint indexBufferOffset = 0;
-		
-		foreach(meshData; modelData.meshData) {
-			import std.c.string: memcpy;
-			//upload vertex data
-			assert(this.vertexBuffer.length >= meshData.vertexData.length);
-			memcpy(this.vertexBuffer.data + vertexBufferOffset, meshData.vertexData.ptr, meshData.vertexData.length * VertexData.sizeof);
-			vertexBufferOffset += meshData.vertexData.length * VertexData.sizeof;
-			//upload index data
-			assert(this.indexBuffer.length >= meshData.indexData.length);
-			memcpy(this.indexBuffer.data + indexBufferOffset, meshData.indexData.ptr, meshData.indexData.length * IndexData.sizeof);
-			indexBufferOffset += meshData.indexData.length * IndexData.sizeof;
-		}
-	}
+//	void uploadModelData(GlArrayBuffer!VertexData vertexBuffer, GlElementArrayBuffer!IndexData indexBuffer, ModelData modelData) {
+//		//TODO: wait for buffer range
+//		//mBufferLockManager.WaitForLockedRange(mStartDestOffset, _vertices.size() * sizeof(Vec2));
+//
+//		// TODO: check if buffers are bound. they should always be bound here!
+//
+//		// we need to store all models in one giant vbo to use glMultiDrawElementsIndirect. 
+//		// TODO: implement triple buffering. -> use vertexBuffer and indexBuffer as giant ring buffers
+//		GLuint vertexBufferOffset = 0;
+//		GLuint indexBufferOffset = 0;
+//		
+//		foreach(meshData; modelData.meshData) {
+//			import std.c.string: memcpy;
+//			//upload vertex data
+//			assert(this.vertexBuffer.length >= meshData.vertexData.length);
+//			memcpy(this.vertexBuffer.data + vertexBufferOffset, meshData.vertexData.ptr, meshData.vertexData.length * VertexData.sizeof);
+//			vertexBufferOffset += meshData.vertexData.length * VertexData.sizeof;
+//			//upload index data
+//			assert(this.indexBuffer.length >= meshData.indexData.length);
+//			memcpy(this.indexBuffer.data + indexBufferOffset, meshData.indexData.ptr, meshData.indexData.length * IndexData.sizeof);
+//			indexBufferOffset += meshData.indexData.length * IndexData.sizeof;
+//		}
+//	}
 
 	void renderOneFrame(ref Scene scene, ref Camera camera, ref RenderTarget renderTarget, ref Viewport viewport) {
 
 		// wait until GPU has finished rendereing from our desired buffer destination
-		//TODO: syncManager.WaitForLockedRange(mStartDestOffset, _vertices.size() * sizeof(Vec2));
+		//TODO: this.syncManager.WaitForLockedRange(mStartDestOffset, _vertices.size() * sizeof(Vec2));
 
 
 		/*
@@ -128,7 +131,7 @@ struct Renderer {
 		
 		glCheck!glMultiDrawElementsIndirect(GL_TRIANGLES, toGlType!(this.indexBuffer.ValueType), null, meshCount, 0);
 
-		//TODO: syncManager.LockRange(mStartDestOffset, _vertices.size() * sizeof(Vec2));
+		//TODO: this.syncManager.LockRange(mStartDestOffset, _vertices.size() * sizeof(Vec2));
 	}
 	
 	debug {