Initial commit

application/source/engine/block.c

@@ -0,0 +1,560 @@
+
+#define GL_GLEXT_PROTOTYPES
+
+#include <GL/glext.h>
+
+#include <GL/gl.h> // GL 1.1 functions 
+
+#include <GL/glx.h>
+
+#include <stdio.h>
+
+#include "fileSystem.h"
+
+#include "array.h"
+
+#include "char.h"
+
+#include "sampler2D.h"
+
+#include "member.h"
+
+class block{
+
+	array * members		= new array();
+
+	GLint buffer;
+
+	GLuint index;
+
+	GLenum bufferType;
+
+	GLint bufferSize;
+
+	GLint bindingPoint;
+
+	GLchar * name;
+
+	float * data;
+
+	GLint autoUpload	= 0;
+
+
+
+	add( struct member * memberInstance ) {
+
+		this->members->add( memberInstance );
+
+	}
+
+	enableAutoUpload() {
+
+		this->autoUpload	= 1;
+
+	}
+
+
+	char * getBufferTypeText(  ) {
+
+		switch( this->bufferType ) {
+
+			case GL_SHADER_STORAGE_BUFFER:
+
+				return "GL_SHADER_STORAGE_BUFFER";
+
+			break;
+
+			case GL_UNIFORM_BUFFER:
+
+				return "GL_UNIFORM_BUFFER";
+
+			break;
+		}
+
+		return "buffer message not found";
+
+	}
+
+	createBuffer() {
+
+		unsigned int blockBufferSize	= this->bufferSize; // allocate 152 bytes of memory
+
+		//printf("	create array for block %s os size %i  \n", this->name, this->bufferSize );
+
+		this->data	= ( float * ) malloc( blockBufferSize );
+
+		glGenBuffers( 1, &this->buffer );
+
+		glBindBuffer( this->bufferType, this->buffer );
+
+		glBindBufferBase( this->bufferType, this->index, this->buffer );
+
+		glBufferData( this->bufferType, blockBufferSize, 0, GL_DYNAMIC_DRAW );
+
+	}
+
+	void upload() {
+
+		//printf("upload uniform buffer:	%f 	%f  %f 	%f\n", this->data[0], this->data[1], this->data[2], this->data[3]);
+
+		//printf("upload uniform buffer:	%i\n", this->index);
+
+		//glBindBuffer( this->bufferType, this->buffer );
+
+		//glBindBufferBase( this->bufferType, this->bindingPoint, this->buffer );
+
+		//glBufferData( this->bufferType, this->bufferSize, this->data, GL_DYNAMIC_DRAW );
+
+
+		glBindBuffer( this->bufferType, this->buffer );
+
+		glBindBufferBase( this->bufferType,  this->bindingPoint, this->buffer );
+
+		glBufferSubData( this->bufferType, 0, this->bufferSize, this->data );
+
+	}
+
+	mapBufferError( void * pointer ) {
+
+		if ( pointer == NULL ){
+
+			GLenum errorCode = glGetError();
+
+			switch( errorCode ) {
+
+				case GL_INVALID_ENUM:
+
+					printf("GL_INVALID_ENUM\n");
+
+				break;
+
+				case GL_INVALID_OPERATION:
+
+					printf("GL_INVALID_OPERATION\n");
+
+				break;
+
+				case GL_INVALID_VALUE:
+
+					printf("GL_INVALID_VALUE\n");
+
+				break;
+
+			}
+
+
+			printf("null pointer on buffer:		%i\n", errorCode);
+
+			return;
+
+		}
+
+	}
+
+	void * getMemberArray( char * name ) {
+
+		glMemoryBarrier( GL_SHADER_STORAGE_BARRIER_BIT );
+
+		vector<vector2> * output	= new vector();
+
+
+		int uniformCount 	= this->members->length();
+
+		for (int i = 0; i < uniformCount; ++i)
+		{
+			member * currentMember = this->members->get( i );
+
+			char * memberName	= ( char * ) currentMember->name;
+
+			if( memberName == name ) {
+
+				int size	= currentMember->size * 8;
+
+				int offset	= currentMember->offset / 4;
+
+				output->items 	= glMapBufferRange( GL_SHADER_STORAGE_BUFFER, 0, size, GL_MAP_WRITE_BIT ); 
+
+				output->total	= currentMember->size;
+				
+				this->mapBufferError( output->items );
+
+
+			}
+
+		}
+
+		glUnmapBuffer( GL_SHADER_STORAGE_BUFFER );
+
+
+		return output;
+
+	}
+
+	void setMemberArrayRow( char * name, int arrayIndex, float * data ) {
+
+		int memberCount 	= this->members->length();
+
+		for (int i = 0; i < memberCount; ++i)
+		{
+			member * currentMember = this->members->get( i );
+
+			char * memberName	= ( char * ) currentMember->name;
+
+			if( memberName == name ) {
+
+				int size		= currentMember->size * 8;
+
+				int arrayStride = currentMember->arrayStride;
+
+				int offset		= arrayStride * arrayIndex;
+
+				//printf("set array stride:		%i 	%i\n", arrayIndex, arrayStride);
+
+				//int offset	= currentMember->offset / 4;
+
+
+				if( this->autoUpload ) {
+
+
+
+					glBindBuffer( this->bufferType, this->buffer );
+
+					glBindBufferBase( this->bufferType, this->bindingPoint, this->buffer );
+
+					glBufferSubData( this->bufferType, offset, arrayStride, data );
+
+				}
+
+
+				memcpy( this->data + offset, data, arrayStride );
+
+				
+
+			}
+
+		}
+
+	}
+
+	void setMemberArray( char * name, float * data ) {
+
+		int memberCount 	= this->members->length();
+
+		for (int i = 0; i < memberCount; ++i)
+		{
+			member * currentMember = this->members->get( i );
+
+			char * memberName	= ( char * ) currentMember->name;
+
+			if( memberName == name ) {
+
+				int size	= currentMember->size * 8;
+
+				int offset	= currentMember->offset / 4;
+
+				memcpy( this->data + offset, data, size );
+
+			}
+
+		}
+
+	}
+
+	void setMemberItem( char * name, int index, void * value ) {
+
+
+		int uniformCount 	= this->members->length();
+
+		//printf("uniformCount:		%i\n\n", uniformCount);
+
+		for (int i = 0; i < uniformCount; ++i)
+		{
+			member * currentMember = this->members->get( i );
+
+			char * memberName	= ( char * ) currentMember->name;
+
+			if( memberName == name ) {
+
+			//printf("\n\n Update this uniform  from uniform block %s\n\n", name);
+						int stride;	
+
+						int strideNormalized;
+
+						int size;
+
+						int offset;
+
+
+				switch( currentMember->type ) {
+
+					case GL_FLOAT_VEC2:
+
+						stride 				= currentMember->arrayStride;
+
+						strideNormalized	=  stride  / sizeof( float ) ;
+
+						//printf("get size of item:		%i\n",strideNormalized );
+
+					
+
+						vector2 * vector2Value	= ( vector2 * ) value;
+
+						size				= 8;
+
+						offset				= currentMember->offset;
+
+
+
+						if( this->autoUpload ) {
+
+							GLint arrayIndex				= ( strideNormalized * index * 2 * 8 );
+
+							float data[2]					= { vector2Value->x, vector2Value->y };
+
+							printf("%i:	(size:%i)	%f %f\n", arrayIndex, data[0], data[1]);
+
+
+							glBindBuffer( this->bufferType, this->buffer );
+
+							glBindBufferBase( this->bufferType, this->bindingPoint, this->buffer );
+
+							glBufferSubData( this->bufferType, arrayIndex, size, data );
+
+
+
+						} else {
+
+							GLint dataOffset				= offset / sizeof( float );
+
+							GLint arrayIndex				= ( strideNormalized * index );
+
+							// need to fix this
+							if( currentMember->topLevelSize == 1 ) {
+
+								//arrayIndex = 0;
+
+							}
+
+
+							//printf("	%i:	%f \n", dataOffset + 1 + arrayIndex , vector2Value->y );
+
+							this->data[ dataOffset + arrayIndex ] 		= vector2Value->x;
+
+							this->data[ dataOffset + 1 + arrayIndex ] 	= vector2Value->y;
+
+						}
+
+						
+
+					break;
+
+					case GL_FLOAT_VEC3:
+		
+						stride 				= currentMember->arrayStride;
+
+						strideNormalized	= stride  / sizeof( float ) ;
+
+
+						vector3 * vector3Value	= ( vector3 * ) value;
+
+						size				= 12;
+
+						offset			= currentMember->offset;
+
+
+
+						if( this->autoUpload ) {
+
+							float data[3]	= { vector3Value->x, vector3Value->y, vector3Value->z };
+
+						//	printf("%f %f\n", data[0], data[1]);
+
+
+							glBindBuffer( this->bufferType, this->buffer );
+
+							glBindBufferBase( this->bufferType, this->bindingPoint, this->buffer );
+
+							glBufferSubData( this->bufferType, offset, size, data );
+
+
+
+						} else {
+
+							GLint dataOffset				= offset / sizeof( float );
+
+							GLint arrayIndex				= ( strideNormalized * index );
+
+							this->data[ dataOffset + arrayIndex ] 		= vector3Value->x;
+
+							this->data[ dataOffset + 1 + arrayIndex ] 	= vector3Value->y;
+
+							this->data[ dataOffset + 2 + arrayIndex ] 	= vector3Value->z;
+
+						}
+
+					break;
+
+					case GL_SAMPLER_2D:
+
+	
+					break;
+
+				}
+
+			}
+
+		}
+
+	}
+
+	void setData( float * data ) {
+
+		this->data = data;
+
+	}
+
+	void setMember( char * name, void * value ) {
+
+		int uniformCount 	= this->members->length();
+
+		//printf("uniformCount:		%i\n\n", uniformCount);
+
+		for (int i = 0; i < uniformCount; ++i)
+		{
+			member * currentMember = this->members->get( i );
+
+			char * memberName	= ( char * ) currentMember->name;
+
+			if( memberName == name ) {
+
+			//printf("\n\n Update this uniform  from uniform block %s\n\n", name);
+
+				GLuint size = 8;
+
+				GLint offset		= currentMember->offset;
+
+				switch( currentMember->type ) {
+
+					case GL_INT:
+
+						int intValue	= *( int * ) value;
+
+						printf("set int value:	%i offset:	%i\n", intValue, offset);
+
+						
+
+						if( this->autoUpload ) {
+
+							float data[1]	= { value };
+
+						//	printf("%f %f\n", data[0], data[1]);
+
+
+							glBindBuffer( this->bufferType, this->buffer );
+
+							glBindBufferBase( this->bufferType, this->bindingPoint, this->buffer );
+
+							glBufferSubData( this->bufferType, offset, size, data );
+
+
+
+						} else {
+
+							GLint dataOffset				= offset / sizeof( float );
+
+							this->data[ dataOffset ] 		= intValue;
+
+							//this->data[ dataOffset + 1 ] 	= vector2Value->y;
+
+						}
+
+					break;
+
+					case GL_FLOAT:
+
+						float floatValue	= *( float * ) value;
+
+						printf("set int value:	%f offset:	%i\n", floatValue, offset);
+
+						
+
+						if( this->autoUpload ) {
+
+							float data[1]	= { value };
+
+						//	printf("%f %f\n", data[0], data[1]);
+
+
+							glBindBuffer( this->bufferType, this->buffer );
+
+							glBindBufferBase( this->bufferType, this->bindingPoint, this->buffer );
+
+							glBufferSubData( this->bufferType, offset, size, data );
+
+
+
+						} else {
+
+							GLint dataOffset				= offset / sizeof( float );
+
+							this->data[ dataOffset ] 		= floatValue;
+
+							//this->data[ dataOffset + 1 ] 	= vector2Value->y;
+
+						}
+
+					break;
+
+					case GL_FLOAT_VEC2:
+
+						vector2 * vector2Value	= ( vector2 * ) value;
+
+						if( this->autoUpload ) {
+
+							float data[2]	= { vector2Value->x, vector2Value->y };
+
+
+							glBindBuffer( this->bufferType, this->buffer );
+
+							glBindBufferBase( this->bufferType, this->bindingPoint, this->buffer );
+
+							glBufferSubData( this->bufferType, offset, size, data );
+
+
+
+						} else {
+
+							GLint dataOffset				= offset / sizeof( float );
+
+							this->data[ dataOffset ] 		= vector2Value->x;
+
+							this->data[ dataOffset + 1 ] 	= vector2Value->y;
+
+						}
+
+					break;
+
+					case GL_FLOAT_VEC3:
+
+						vector3 * vector3Value	= ( vector3 * ) value;
+
+						
+
+					break;
+
+					case GL_SAMPLER_2D:
+
+	
+					break;
+
+				}
+
+			}
+
+
+		}
+
+
+	}
+
+}