Initial commit

application/demos/example.opengl/engine/renderPasses/renderPass.c

@@ -0,0 +1,46 @@
+/* 
+ * This file is automaticaly generated, Please dont edit this file! 
+ */
+#include <engine/renderPasses/renderPass.h> 
+
+
+
+
+
+
+
+
+
+
+void renderPass_prepare( renderPass * this ) {
+
+
+	}
+
+
+void renderPass_render( renderPass * this ) {
+
+
+
+	}
+
+renderPass renderPass_new() {
+
+	renderPass instance;
+
+	instance.enabled =  true;
+
+	return instance;
+
+}
+
+renderPass * renderPass_newPointer() {
+
+	struct renderPass * pointer = malloc( sizeof ( struct renderPass ) );
+
+	pointer->enabled =  true;
+
+	return pointer;
+
+}
+

application/demos/example.opengl/engine/renderPasses/renderPass.h

@@ -0,0 +1,47 @@
+#ifndef _renderPass
+
+#define _renderPass
+
+
+// Macros
+
+
+
+#include "stdlib.h"
+
+extern char * __ClassNames[];
+
+
+// Includes
+
+#include "mesh.h"
+
+#include "shader.h"
+
+
+typedef struct renderPass{
+
+	bool enabled;
+
+	struct shader * shader;
+
+	struct mesh * mesh;
+
+
+} renderPass;
+
+void renderPass_prepare( renderPass * this );
+
+void renderPass_render( renderPass * this );
+
+renderPass renderPass_new(  );
+
+renderPass * renderPass_newPointer(  );
+
+#endif
+
+
+typedef struct renderPass renderPass;
+
+
+

application/demos/example.opengl/engine/renderPasses/renderPassCompute.c

@@ -0,0 +1,115 @@
+/* 
+ * This file is automaticaly generated, Please dont edit this file! 
+ */
+#include <engine/renderPasses/renderPassCompute.h> 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void compute_prepare( compute * this ) {
+
+		printf("\n\n\n		Prepare renderPass Compute\n\n\n\n\n");
+
+		shader * computeShader = shader_newPointer( GL_COMPUTE_SHADER );
+
+		shader_loadFromFile( computeShader,  "assets/shaders/addition.comp" );
+
+
+		this->program 			= program_newPointer();
+
+		program_addShader( this->program,  computeShader );
+
+		program_create( this->program );
+
+
+		vector_vector2 * inputA = vector_vector2_newPointer();
+
+		for (int i = 0; i < 100; ++i)
+		{
+
+			vector2 a	= vector2_new( i, i );
+
+			vector_vector2_add( inputA,  a );
+
+		}
+
+		vector_vector2 * inputB = vector_vector2_newPointer();
+
+		for (int i = 0; i < 100; ++i)
+		{
+
+			vector2 a	= vector2_new( 0, 10 );
+
+			vector_vector2_add( inputB,  a );
+
+		}
+
+		block * inputBlock				= program_getBlock( this->program,  "inputBlock" );
+
+		block_setMemberArray( inputBlock,  "array_a[0]", ( float * ) inputA->items );
+
+		block_setMemberArray( inputBlock,  "array_b[0]", ( float * ) inputB->items );
+
+		block_upload( inputBlock );
+
+	}
+
+void compute_render( compute * this ) {
+
+		program_use( this->program );
+
+		program_bindBlock( this->program,  "inputBlock");
+
+		program_bindBlock( this->program,  "outputBlock");
+
+
+		glDispatchCompute( 1, 1, 1 );
+
+		glMemoryBarrier( GL_SHADER_STORAGE_BARRIER_BIT );
+
+	}
+
+compute compute_new() {
+
+	compute instance;
+
+	instance.active =  true;
+
+	return instance;
+
+}
+
+compute * compute_newPointer() {
+
+	struct compute * pointer = malloc( sizeof ( struct compute ) );
+
+	pointer->active =  true;
+
+	return pointer;
+
+}
+

application/demos/example.opengl/engine/renderPasses/renderPassCompute.h

@@ -0,0 +1,63 @@
+#ifndef _renderPassCompute
+
+#define _renderPassCompute
+
+
+// Macros
+
+
+
+#include "stdlib.h"
+
+extern char * __ClassNames[];
+
+
+// Includes
+
+#include "../mesh.h"
+
+#include "../vector.h"
+
+#include "../block.h"
+
+#include "stdbool.h"
+
+#include "../sampler2D.h"
+
+#include "../int.h"
+
+#include "../program.h"
+
+#include "../shader.h"
+
+#include "../vector2.h"
+
+#include "../event.h"
+
+#include "./renderPass.h"
+
+
+typedef struct compute{
+
+	struct program * program;
+
+	int active;
+
+
+} compute;
+
+void compute_prepare( compute * this );
+
+void compute_render( compute * this );
+
+compute compute_new(  );
+
+compute * compute_newPointer(  );
+
+#endif
+
+
+typedef struct compute compute;
+
+
+

application/demos/example.opengl/engine/renderPasses/renderPassCompute2.c

@@ -0,0 +1,99 @@
+/* 
+ * This file is automaticaly generated, Please dont edit this file! 
+ */
+#include <engine/renderPasses/renderPassCompute2.h> 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void compute2_prepare( compute2 * this ) {
+
+		printf("\n\n\n		Prepare renderPass Compute 2\n\n\n\n\n");
+
+		shader * computeShader = shader_newPointer( GL_COMPUTE_SHADER );
+
+		shader_loadFromFile( computeShader,  "assets/shaders/addition2.comp" );
+
+
+		this->program 			= program_newPointer();
+
+		program_addShader( this->program,  computeShader );
+
+		program_create( this->program );
+
+	}
+
+void compute2_render( compute2 * this ) {
+
+		if( this->active ) {
+
+			program_use( this->program );
+
+			program_bindBlock( this->program,  "outputBlock2" );
+			
+
+			glDispatchCompute( 1, 1, 1 );
+
+
+			block * outputBlock			= program_getBlock( this->program,  "outputBlock2" );
+
+			vector_vector2 * output	= block_getMemberArray( outputBlock,  "array_d[0]" );
+
+			int count					= vector_vector2_length( output );
+
+			for (int i = 0; i < count; ++i)
+			{
+
+				vector2 currentVector = vector_vector2_get( output,  i );
+
+				printf("%i  = %f %f \n", i, i, currentVector.x, currentVector.y );
+
+			}
+
+			printf("length:	%i\n\n", count);
+		
+			this->active = false;
+
+		}
+
+	}
+
+compute2 compute2_new() {
+
+	compute2 instance;
+
+	instance.active =  true;
+
+	return instance;
+
+}
+
+compute2 * compute2_newPointer() {
+
+	struct compute2 * pointer = malloc( sizeof ( struct compute2 ) );
+
+	pointer->active =  true;
+
+	return pointer;
+
+}
+

application/demos/example.opengl/engine/renderPasses/renderPassCompute2.h

@@ -0,0 +1,59 @@
+#ifndef _renderPassCompute2
+
+#define _renderPassCompute2
+
+
+// Macros
+
+
+
+#include "stdlib.h"
+
+extern char * __ClassNames[];
+
+
+// Includes
+
+#include "../block.h"
+
+#include "stdbool.h"
+
+#include "../sampler2D.h"
+
+#include "../../int.h"
+
+#include "../program.h"
+
+#include "../shader.h"
+
+#include "../../vector2.h"
+
+#include "../event.h"
+
+#include "renderPass.h"
+
+
+typedef struct compute2{
+
+	struct program * program;
+
+	int active;
+
+
+} compute2;
+
+void compute2_prepare( compute2 * this );
+
+void compute2_render( compute2 * this );
+
+compute2 compute2_new(  );
+
+compute2 * compute2_newPointer(  );
+
+#endif
+
+
+typedef struct compute2 compute2;
+
+
+

application/demos/example.opengl/engine/renderPasses/renderPassFont.c

@@ -0,0 +1,193 @@
+/* 
+ * This file is automaticaly generated, Please dont edit this file! 
+ */
+#include <engine/renderPasses/renderPassFont.h> 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+char * font_textFromNumber( font * this, int i ) {
+
+		char * fileName = malloc( sizeof( char ) * 100 );
+
+		sprintf( fileName, "%d", i );
+
+		return fileName;
+
+	}
+
+void font_prepare( font * this ) {
+
+		printf("\n\n\n		Prepare renderPass Font\n\n\n\n\n");
+
+		
+
+
+		shader * vertexShader = shader_newPointer( GL_VERTEX_SHADER );
+
+		shader_loadFromFile( vertexShader,  "assets/shaders/quad.vertex" );
+
+
+		shader * fragmentShader = shader_newPointer( GL_FRAGMENT_SHADER );
+
+		shader_loadFromFile( fragmentShader,  "assets/shaders/quad.fragment" );
+
+
+
+		this->program 	= program_newPointer();
+
+		program_addShader( this->program,  vertexShader );
+
+		program_addShader( this->program,  fragmentShader );
+
+		program_create( this->program );
+
+
+		sampler2D * samplerArray		= sampler2D_newPointer();
+
+		samplerArray->target			= GL_TEXTURE_2D_ARRAY;
+
+		samplerArray->format  			= GL_RED;
+
+		samplerArray->internalFormat  	= GL_RED;
+
+		samplerArray->WRAP_S  			= GL_CLAMP_TO_EDGE;
+
+		samplerArray->WRAP_S  			= GL_CLAMP_TO_EDGE;
+
+		samplerArray->cubeSize			= vector3_newPointer( 128, 128, 170 );
+
+		samplerArray->UNPACK_ALIGNMENT	= true;
+
+
+		this->samplerArray = samplerArray;
+
+		block * fontBlock				= program_getBlock( this->program,  "fontData" );
+
+
+		this->mesh = mesh_newPointer();
+
+		mesh_setProgram( this->mesh,  this->program );
+
+		mesh_createBuffers( this->mesh );
+
+
+		glUseProgram( this->program->glProgram );
+
+		for ( int i = 1; i < 170; ++i )
+		{
+			texture2D * characterTexture 	= fontRenderer_loadFont( this->font,  34 + i );
+
+			vector2 * offset 				= characterTexture->offset;
+
+			printf("%c  offset left:	%f,  offset top:	%f  bitmap->rows:	%i\n", (char) 34 +  i, offset->x, offset->y, characterTexture->height );
+
+			vector2 * size					= vector2_newPointer( characterTexture->width, characterTexture->height );
+
+			block_setMemberItem( fontBlock,  "fontOffsets[0]", i - 35, offset );
+
+			
+
+				block_setMemberItem( fontBlock,  "fontSizes[0]", i - 35, size );
+			
+			
+
+			sampler2D_addTexture( samplerArray,  characterTexture );
+
+		}
+
+		block_upload( fontBlock );
+
+		program_setUniform( this->program,  "samplerArray", samplerArray );
+
+
+
+		vector_int * textArray = vector_int_newPointer();
+
+		char * someText			= "Wauw this is myp first text.";
+
+		for (int i = 0; i < strlen(someText); ++i)
+		{
+
+			int charNumber = ( char ) someText[i] - 35;
+
+			printf("	%i\n", charNumber   );
+
+			vector_int_add( textArray,  charNumber );
+
+		}
+
+		block * inputBlock				= program_getBlock( this->program,  "inputBlock" );
+
+		block_setMemberArray( inputBlock,  "characters[0]", ( float * ) textArray->items );
+
+		block_upload( inputBlock );
+
+	}
+
+void font_render( font * this ) {
+
+		int numItems	= 12;
+
+
+		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+		
+		program_use( this->program );
+
+		program_bindBlock( this->program,  "inputBlock");
+
+		program_bindBlock( this->program,  "fontData");
+
+
+		program_setUniform( this->program,  "samplerArray", this->samplerArray );
+
+
+
+		glBindVertexArray( this->mesh->vertexArrayObject );
+
+		glDrawElements( GL_TRIANGLES, numItems, GL_UNSIGNED_INT, ( void * ) 0 ); 
+
+	}
+
+font font_new() {
+
+	font instance;
+
+	instance.font = fontRenderer_newPointer();
+
+	return instance;
+
+}
+
+font * font_newPointer() {
+
+	struct font * pointer = malloc( sizeof ( struct font ) );
+
+	pointer->font = fontRenderer_newPointer();
+
+	return pointer;
+
+}
+

application/demos/example.opengl/engine/renderPasses/renderPassFont.h

@@ -0,0 +1,63 @@
+#ifndef _renderPassFont
+
+#define _renderPassFont
+
+
+// Macros
+
+
+
+#include "stdlib.h"
+
+extern char * __ClassNames[];
+
+
+// Includes
+
+#include "../mesh.h"
+
+#include "../program.h"
+
+#include "../fontRenderer.h"
+
+#include "int.h"
+
+#include "../shader.h"
+
+#include "../vector2.h"
+
+#include "../event.h"
+
+#include "renderPass.h"
+
+
+typedef struct font{
+
+	struct program * program;
+
+	struct mesh * mesh;
+
+	fontRenderer * font;
+
+	sampler2D * samplerArray;
+
+
+} font;
+
+char * font_textFromNumber( font * this, int i );
+
+void font_prepare( font * this );
+
+void font_render( font * this );
+
+font font_new(  );
+
+font * font_newPointer(  );
+
+#endif
+
+
+typedef struct font font;
+
+
+

application/demos/example.opengl/engine/renderPasses/renderPassQuads.c

@@ -0,0 +1,731 @@
+/* 
+ * This file is automaticaly generated, Please dont edit this file! 
+ */
+#include <engine/renderPasses/renderPassQuads.h> 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+event * globalEvent; 
+
+resourceManager	* resources; 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+char * quads_textFromNumber( quads * this, int i ) {
+
+		char * fileName = malloc( sizeof( char ) * 100 );
+
+		sprintf( fileName, "%d", i );
+
+		return fileName;
+
+	}
+
+void quads_prepare( quads * this ) {
+
+		printf("\n\n\n		Prepare renderPass Quad\n\n\n\n\n");
+
+
+
+
+
+
+
+
+		this->samplerArray			= sampler2D_newPointer();
+
+
+		for (int i = 1; i < 10; ++i )
+		{
+
+			char * fileName  	= quads_textFromNumber( this,  i );
+
+			char_operator_add( fileName	,  ".png");
+
+			printf("load png:	%s\n", fileName);
+
+			
+
+		}
+
+		printf("\n\n");
+
+		this->samplerArray->target				= GL_TEXTURE_2D_ARRAY;
+
+
+		shader * vertexShader = shader_newPointer( GL_VERTEX_SHADER );
+
+		shader_loadFromFile( vertexShader,  "assets/shaders/multiQuad.vertex" );
+
+
+		shader * fragmentShader = shader_newPointer( GL_FRAGMENT_SHADER );
+
+		shader_loadFromFile( fragmentShader,  "assets/shaders/multiQuad.fragment" );
+
+
+		this->program 	= program_newPointer();
+
+		program_addShader( this->program,  vertexShader );
+
+		program_addShader( this->program,  fragmentShader );
+
+		program_create( this->program );
+
+
+
+		
+
+		block * orientationBlock		= program_getBlock( this->program,  "orientation" );
+
+		block * meshesBlock				= program_getBlock( this->program,  "meshes" );
+
+
+		this->mesh = mesh_newPointer();
+
+		mesh_setProgram( this->mesh,  this->program );
+
+		mesh_createBuffers( this->mesh );
+
+	
+		
+
+		
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		quads_createMeshes( this );
+
+		
+
+
+		sampler2D_addTexture( this->samplerArray,  resourceManager_loadPngImage( resources,  "1.png" ) );
+
+
+		block_upload( meshesBlock );
+
+	}
+
+void quads_sortOpacity( quads * this, vector_quadMesh * meshes ) {
+
+
+		int count = vector_quadMesh_length( meshes );
+
+		int i, j;
+
+		struct quadMesh temp;
+
+		for (i = 0; i < (count - 1); ++i)
+		{
+			for (j = 0; j < count - 1 - i; ++j )
+			{
+
+				struct quadMesh quadA	= vector_quadMesh_get( meshes,  j );
+
+				struct quadMesh quadB	= vector_quadMesh_get( meshes,  j + 1 );
+
+				float a = ( intptr_t ) quadA.zIndex;
+
+				float b = ( intptr_t ) quadB.zIndex;
+
+				if ( a > b )
+				{
+
+					temp 						= meshes->items[j+1];
+
+					meshes->items[ j + 1 ] 		= meshes->items[j];
+
+					meshes->items[ j ] 			= temp;
+
+				}
+			}
+		}
+
+	}
+
+void quads_createMeshes( quads * this ) {
+
+
+		vector_quadMesh * meshes	= this->meshes;
+
+		vector_quadMesh_resize( meshes,  100 );
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		vector_element * elements	= this->elements;
+
+
+		{
+
+			element instance 		= element_new();
+
+			element_setter_position( &instance, vector3_new( 200, 200, 1100 ) );
+
+			element_setter_size( &instance, vector2_new( 200., 200. ) );
+
+			
+
+			instance.opacity		= 1;
+
+			element_setter_background( &instance, 1, (int[1]){ -2 }, "9.png" );
+
+			
+
+			vector_element_add( elements,  instance );
+
+
+
+
+		}	
+
+
+		{
+
+			element instance 		= element_new();
+
+			element_setter_position( &instance, vector3_new( 100, 100, 500 ) );
+
+			element_setter_size( &instance, vector2_new( 400., 400. ) );
+
+			element_setter_background( &instance, 1, (int[1]){ -2 }, "3.png" );
+
+			
+
+			
+
+			instance.opacity			= .9;
+
+
+			
+
+
+
+
+
+
+
+
+
+
+
+			
+
+			
+
+			
+
+		
+
+			
+
+		vector_element_add( elements,  instance );
+
+
+
+		{
+
+			element instance 		= element_new();
+
+			element_setter_position( &instance, vector3_new( 20, 0, 1300 ) );
+
+			element_setter_size( &instance, vector2_new( 40., 40. ) );
+
+			element_setter_background( &instance, 1, (int[1]){ -2 }, "7.png" );
+
+			instance.opacity		= 1;
+
+			vector_element_add( elements,  instance );
+
+
+		}	
+
+
+
+		
+
+
+			int count = vector_element_length( elements );
+
+			for (int i = 0; i < count; ++i)
+			{
+
+				element currentElement =  vector_element_get( elements,  i );
+
+				quadMesh meshInstance 	= quadMesh_new();
+
+
+				meshInstance.elementIndex = i;
+				
+				meshInstance.position	= vector2_new( currentElement.position.x, currentElement.position.y );
+
+				meshInstance.zIndex		= currentElement.position.z;
+
+				meshInstance.size		= currentElement.size;
+
+
+				printf("zIndex:		%f\n", currentElement.position.z);
+
+				int features		= 0;
+
+				if( currentElement.useBackgroundImage ) {
+
+
+					
+
+
+					meshInstance.textureIndex		= sampler2D_getTextureIndex( this->samplerArray );
+
+					printf("use background image.		%s \n", currentElement.backgroundImagePath  );
+
+					sampler2D_addTexture( this->samplerArray,  resourceManager_loadPngImage( resources,  currentElement.backgroundImagePath ) );
+
+				} else {
+
+					printf("dont use background color.  %f  %f  %f \n", currentElement.backgroundColor.x, currentElement.backgroundColor.y, currentElement.backgroundColor.z);
+
+					meshInstance.color		= currentElement.backgroundColor;
+
+				}
+				
+
+				meshInstance.features		= element_updateFeature( &currentElement );
+
+				meshInstance.opacity		= currentElement.opacity;
+
+					
+
+
+				element_setOriginal( &currentElement );
+
+				vector_element_set( elements,  i, currentElement );
+
+
+				vector_quadMesh_add( meshes,  meshInstance );
+
+			}
+
+
+
+			quads_sortOpacity( this,  meshes );
+
+
+
+		}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		block * meshesBlock				= program_getBlock( this->program,  "meshes" );
+
+		block_setData( meshesBlock,  ( float * ) meshes->items );
+
+	}
+
+
+quadMesh quads_updateMesh( quads * this, quadMesh currentMesh,  element currentElement ) {
+
+		vector2 position 		= vector2_new( currentElement.position.x, currentElement.position.y );
+
+		currentMesh.position	= position;
+
+		currentMesh.zIndex		= currentElement.position.z;
+
+		currentMesh.size		= currentElement.size;
+
+		currentMesh.color		= currentElement.backgroundColor;
+
+		return currentMesh;
+
+	}
+
+void quads_callElementEvents( quads * this, event * currentEvent,  element * currentElement,  int elementIndex ) {
+
+		vector_char_pointer * mouseEvents	 = currentEvent->mouse->eventTypes;
+
+		int mouseEventCount			 = vector_char_pointer_length( mouseEvents );
+
+		for (int k = 0; k < mouseEventCount; ++k)
+		{
+			char * mouseEventCode = vector_char_pointer_get( mouseEvents,  k );
+
+			printf("			mouse event:	%s\n", mouseEventCode);
+
+
+			if( char_operator_compare( mouseEventCode ,  "click") ) {
+
+				element_click( currentElement );
+
+				
+
+			}
+
+			if( char_operator_compare( mouseEventCode ,  "mousedown") ) {
+
+				element_mousedown( currentElement );
+
+				
+
+			}
+
+
+			if( char_operator_compare( mouseEventCode ,  "mouseup") ) {
+
+				element_mouseup( currentElement );
+
+				
+
+			}
+
+			if( char_operator_compare( mouseEventCode ,  "mousemove") ) {
+
+				if( !quads_integerContains( this,  this->mouseOverElements, elementIndex ) ) {
+
+					element_mouseover( currentElement );
+
+					vector_int_add( this->mouseOverElements,  elementIndex );
+
+				}
+
+			}
+
+		}
+
+	}
+
+bool quads_integerContains( quads * this, vector_int * numbers,  int a ) {
+
+		int count = vector_int_length( numbers );
+
+		for (int j = 0; j < count; ++j)
+		{
+
+			int b = vector_int_get( numbers,  j );
+
+			if( a == b ) {
+
+				return true;
+
+			}
+
+		}
+
+		return false;
+
+	}
+
+void quads_render( quads * this ) {
+
+		program * currentProgram 			= this->program;
+
+		event * currentEvent 				= globalEvent;
+
+
+		block * eventsBlock 				= program_getBlock( currentProgram,  "events" );
+
+		
+
+
+		block * meshesBlock 				= program_getBlock( currentProgram,  "meshes" );
+
+
+		eventsBlock->autoUpload 			= true;
+
+		block_setMember( eventsBlock,  "window", &currentEvent->screen->size );
+
+
+		meshesBlock->autoUpload 		= true;
+
+		vector2 mousePosition			= globalEvent->mouse->position;
+
+
+		int mouseX						= ( int ) mousePosition.x;
+
+		int mouseY						= ( int ) mousePosition.y;
+
+
+		vector_element * elements		= this->elements;
+
+		vector_quadMesh * meshes		= this->meshes;
+
+
+		vector_int * 	mouseOverElements = this->mouseOverElements;
+
+		int count = vector_quadMesh_length( meshes );
+
+		for (int i = 0; i < count; ++i)
+		{
+			quadMesh currentMesh	= vector_quadMesh_get( meshes,  i );
+
+			int left	= currentMesh.position.x;
+
+			int top		= currentMesh.position.y;
+
+			int right	= currentMesh.position.x + currentMesh.size.x;
+
+			int bottom	= currentMesh.position.y + currentMesh.size.y;
+
+			int elementIndex 		= currentMesh.elementIndex;
+
+
+			if( mouseX > left && mouseX < right && mouseY > top && mouseY < bottom ) {
+
+				element currentElement	= vector_element_get( elements,  elementIndex );
+		
+				quads_callElementEvents( this,  currentEvent, &currentElement, elementIndex );
+
+				currentMesh				= quads_updateMesh( this,  currentMesh, currentElement );
+
+				vector_element_set( elements,  elementIndex, currentElement );
+
+				block_setMemberArrayRow( meshesBlock,  "meshArray[0].color", i, ( float * ) & currentMesh );
+				
+			} else {
+
+				if( quads_integerContains( this,  this->mouseOverElements, elementIndex ) ) {
+
+					printf("mouseout\n\n");
+
+					vector_int_delete( this->mouseOverElements,  elementIndex );
+
+					element currentElement	= vector_element_get( elements,  elementIndex );
+
+
+					element_mouseleave( &currentElement );
+
+
+
+					currentMesh				= quads_updateMesh( this,  currentMesh, currentElement );
+
+					vector_element_set( elements,  elementIndex, currentElement );
+
+					block_setMemberArrayRow( meshesBlock,  "meshArray[0].color", i, ( float * ) & currentMesh );
+				
+				}
+
+
+			}
+
+		}
+
+
+		
+
+
+		
+
+		
+
+	
+
+
+		vector2 * position2	= vector2_newPointer( 0.4, 0 );
+
+		
+
+
+
+		program_setUniform( this->program,  "samplerArray", this->samplerArray );
+
+		glUseProgram( currentProgram->glProgram );
+
+		int numItems	= 200;
+
+
+
+		
+		
+
+		
+		
+
+		
+		glDisable(GL_DEPTH_TEST);
+
+
+
+		
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		
+
+
+		glDepthRange(0.0, 1.0);
+
+		glDepthFunc(GL_ALWAYS);
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+		glEnable(GL_CULL_FACE);
+
+
+
+
+
+		glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
+
+
+
+		glBindVertexArray( this->mesh->vertexArrayObject );
+
+		glDrawElements( GL_TRIANGLES, numItems, GL_UNSIGNED_INT, ( void * ) 0 ); 
+
+	}
+
+quads quads_new() {
+
+	quads instance;
+
+	instance.font = fontRenderer_newPointer();
+
+	instance.meshes = vector_quadMesh_newPointer();
+
+	instance.elements = vector_element_newPointer();
+
+	instance.mouseOverElements = vector_int_newPointer();
+
+	return instance;
+
+}
+
+quads * quads_newPointer() {
+
+	struct quads * pointer = malloc( sizeof ( struct quads ) );
+
+	pointer->font = fontRenderer_newPointer();
+
+	pointer->meshes = vector_quadMesh_newPointer();
+
+	pointer->elements = vector_element_newPointer();
+
+	pointer->mouseOverElements = vector_int_newPointer();
+
+	return pointer;
+
+}
+

application/demos/example.opengl/engine/renderPasses/renderPassQuads.h

@@ -0,0 +1,95 @@
+#ifndef _renderPassQuads
+
+#define _renderPassQuads
+
+
+// Macros
+
+
+
+#include "stdlib.h"
+
+extern char * __ClassNames[];
+
+
+// Includes
+
+#include "../element.h"
+
+#include "../quadMesh.h"
+
+#include "../mesh.h"
+
+#include "../resourceManager.h"
+
+#include "../fontRenderer.h"
+
+#include "../../int.h"
+
+#include "../program.h"
+
+#include "../shader.h"
+
+#include "../program.h"
+
+#include "../vector4.h"
+
+#include "../vector3.h"
+
+#include "../vector2.h"
+
+#include "../event.h"
+
+#include "renderPass.h"
+
+
+typedef struct quads{
+
+	mesh * mesh;
+
+	fontRenderer * font;
+
+	sampler2D * samplerArray;
+
+	program * program;
+
+	vector_quadMesh * meshes;
+
+	vector_element * elements;
+
+	vector_int * mouseOverElements;
+
+
+} quads;
+
+char * quads_textFromNumber( quads * this, int i );
+
+void quads_prepare( quads * this );
+
+void quads_sortOpacity( quads * this, vector_quadMesh * meshes );
+
+void quads_createMeshes( quads * this );
+
+quadMesh quads_updateMesh( quads * this, quadMesh currentMesh,  element currentElement );
+
+void quads_callElementEvents( quads * this, event * currentEvent,  element * currentElement,  int elementIndex );
+
+bool quads_integerContains( quads * this, vector_int * numbers,  int a );
+
+void quads_render( quads * this );
+
+extern resourceManager	* resources; 
+
+extern event * globalEvent; 
+
+quads quads_new(  );
+
+quads * quads_newPointer(  );
+
+#endif
+
+
+typedef struct quads quads;
+
+
+

application/demos/example.opengl/engine/renderPasses/renderPassTesselation.c

@@ -0,0 +1,137 @@
+/* 
+ * This file is automaticaly generated, Please dont edit this file! 
+ */
+#include <engine/renderPasses/renderPassTesselation.h> 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+char * tesselation_textFromNumber( tesselation * this, int i ) {
+
+		char * fileName = malloc( sizeof( char ) * 100 );
+
+		sprintf( fileName, "%d", i );
+
+		return fileName;
+
+	}
+
+void tesselation_prepare( tesselation * this ) {
+
+		shader * vertexShader = shader_newPointer( GL_VERTEX_SHADER );
+
+		shader_loadFromFile( vertexShader,  "assets/shaders/quadScale.vertex" );
+
+
+		shader * fragmentShader = shader_newPointer( GL_FRAGMENT_SHADER );
+
+		shader_loadFromFile( fragmentShader,  "assets/shaders/color.fragment" );
+
+
+		shader * geometryShader = shader_newPointer( GL_GEOMETRY_SHADER );
+
+		shader_loadFromFile( geometryShader,  "assets/shaders/tesselation.geometry.shader" );
+
+
+		shader * tesselationControlShader = shader_newPointer( GL_TESS_CONTROL_SHADER );
+
+		shader_loadFromFile( tesselationControlShader,  "assets/shaders/tesselation.triangle.tsc.shader" );
+
+
+		shader * tesselationEvaluationShader = shader_newPointer( GL_TESS_EVALUATION_SHADER );
+
+		shader_loadFromFile( tesselationEvaluationShader,  "assets/shaders/tesselation.triangle.shader" );
+
+
+
+		this->program 	= program_newPointer();
+
+		program_addShader( this->program,  vertexShader );
+
+		program_addShader( this->program,  fragmentShader );
+
+
+
+
+
+
+
+
+
+		program_create( this->program );
+
+
+
+
+		this->mesh = mesh_newPointer();
+
+		mesh_setProgram( this->mesh,  this->program );
+
+		mesh_createBuffers( this->mesh );
+
+
+		glUseProgram( this->program->glProgram );
+
+
+	}
+
+void tesselation_render( tesselation * this ) {
+
+		glUseProgram( this->program->glProgram );
+
+		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+		int numItems	= 12;
+
+		
+
+		glBindVertexArray( this->mesh->vertexArrayObject );
+
+
+
+
+		glDrawElements( GL_LINE_STRIP, numItems, GL_UNSIGNED_INT, ( void * ) 0 ); 
+
+	}
+
+tesselation tesselation_new() {
+
+	tesselation instance;
+
+	instance.font = fontRenderer_newPointer();
+
+	return instance;
+
+}
+
+tesselation * tesselation_newPointer() {
+
+	struct tesselation * pointer = malloc( sizeof ( struct tesselation ) );
+
+	pointer->font = fontRenderer_newPointer();
+
+	return pointer;
+
+}
+

application/demos/example.opengl/engine/renderPasses/renderPassTesselation.h

@@ -0,0 +1,63 @@
+#ifndef _renderPassTesselation
+
+#define _renderPassTesselation
+
+
+// Macros
+
+
+
+#include "stdlib.h"
+
+extern char * __ClassNames[];
+
+
+// Includes
+
+#include "../mesh.h"
+
+#include "../program.h"
+
+#include "../fontRenderer.h"
+
+#include "int.h"
+
+#include "../shader.h"
+
+#include "../vector2.h"
+
+#include "../event.h"
+
+#include "renderPass.h"
+
+
+typedef struct tesselation{
+
+	struct program * program;
+
+	struct mesh * mesh;
+
+	fontRenderer * font;
+
+	sampler2D * samplerArray;
+
+
+} tesselation;
+
+char * tesselation_textFromNumber( tesselation * this, int i );
+
+void tesselation_prepare( tesselation * this );
+
+void tesselation_render( tesselation * this );
+
+tesselation tesselation_new(  );
+
+tesselation * tesselation_newPointer(  );
+
+#endif
+
+
+typedef struct tesselation tesselation;
+
+
+