/* * This file is automaticaly generated, Please dont edit this file! */ #include void program_addShader( program * this, struct shader * shaderInstance ) { array_add( this->shaders, shaderInstance ); } GLint program_glGetProgramResourceiv( program * this, GLint programProperty, GLint index, GLint Property ) { GLint offsetValues; glGetProgramResourceiv( this->glProgram, programProperty, index, 1, &Property , 1, 0, &offsetValues ); return offsetValues; } GLchar * program_glGetProgramResourceName( program * this, GLint programProperty, GLint index, GLint nameLength ) { GLchar name[ GL_NAME_LENGTH + 1 ]; glGetProgramResourceName( this->glProgram, programProperty, index, GL_NAME_LENGTH + 1, 0, name ); return name; } void program_extractBlocks( program * this ) { GLint programInterfaces[2] = { GL_SHADER_STORAGE_BLOCK, GL_UNIFORM_BLOCK }; GLint programProperties[2] = { GL_BUFFER_VARIABLE, GL_UNIFORM }; GLenum programBufferTypes[2] = { GL_SHADER_STORAGE_BUFFER, GL_UNIFORM_BUFFER }; for (int blockTypeIndex = 0; blockTypeIndex < 2; ++blockTypeIndex) { GLint program = this->glProgram; GLint numActiveResources; GLint programInterface = programInterfaces[blockTypeIndex]; GLint programProperty = programProperties[blockTypeIndex]; GLenum programBufferType = programBufferTypes[blockTypeIndex]; glGetProgramInterfaceiv( program, programInterface, GL_ACTIVE_RESOURCES, &numActiveResources ); for ( GLuint blockIndex = 0; blockIndex < numActiveResources; blockIndex++ ) { struct block * blockInstance = block_newPointer(); GLint blockNameLength = program_glGetProgramResourceiv( this, programInterface, blockIndex, GL_NAME_LENGTH ); blockInstance->bufferSize = program_glGetProgramResourceiv( this, programInterface, blockIndex, GL_BUFFER_DATA_SIZE ); GLint numberActiveVariables = program_glGetProgramResourceiv( this, programInterface, blockIndex, GL_NUM_ACTIVE_VARIABLES ); blockInstance->bindingPoint = program_glGetProgramResourceiv( this, programInterface, blockIndex, GL_BUFFER_BINDING ); GLchar name[ GL_NAME_LENGTH + 1 ]; glGetProgramResourceName( this->glProgram, programInterface, blockIndex, GL_NAME_LENGTH + 1, NULL, name ); blockInstance->name = malloc( GL_NAME_LENGTH ); strcpy( blockInstance->name, name ); blockInstance->bufferType = programBufferType; printf("block:%s \n\n", blockInstance->name ); printf(" block name %s\n", blockInstance->name); printf(" block buffer size: %i\n", blockInstance->bufferSize); printf(" block binding point: %i\n\n", blockInstance->bindingPoint); GLint indices[ numberActiveVariables ]; GLenum member = GL_ACTIVE_VARIABLES; glGetProgramResourceiv( program, programInterface, blockIndex, 1, &member, numberActiveVariables, 0, indices ); printf(" number of variables: %i\n\n\n", numberActiveVariables); for ( GLuint index = 0; index < numberActiveVariables; index++ ) { struct member * memberInstance = member_newPointer(); GLint itemIndex = indices[ index ]; memberInstance->index = itemIndex; GLint nameLength = program_glGetProgramResourceiv( this, programProperty, itemIndex, GL_NAME_LENGTH ); memberInstance->offset = program_glGetProgramResourceiv( this, programProperty, itemIndex, GL_OFFSET ); memberInstance->type = program_glGetProgramResourceiv( this, programProperty, itemIndex, GL_TYPE ); memberInstance->arrayStride = program_glGetProgramResourceiv( this, programProperty, itemIndex, GL_ARRAY_STRIDE ); memberInstance->size = program_glGetProgramResourceiv( this, programProperty, itemIndex, GL_ARRAY_SIZE ); int topLevelSize = program_glGetProgramResourceiv( this, programProperty, itemIndex, GL_TOP_LEVEL_ARRAY_SIZE ); int topLevelStride = program_glGetProgramResourceiv( this, programProperty, itemIndex, GL_TOP_LEVEL_ARRAY_STRIDE ); if( memberInstance->arrayStride == 0 ) { memberInstance->arrayStride = topLevelStride; } memberInstance->topLevelSize = topLevelSize; GLchar memberName[ GL_NAME_LENGTH + 1 ]; glGetProgramResourceName( this->glProgram, programProperty, itemIndex, GL_NAME_LENGTH + 1, NULL, memberName ); memberInstance->name = malloc( GL_NAME_LENGTH ); strcpy( memberInstance->name, memberName ); printf(" offset: #%i name: %s vec2: %i offset: %i itemSize / arrayStride: %i Array size: %i toplevel size: %i top level size: %i \n\n", memberInstance->index, memberInstance->name, memberInstance->type == GL_FLOAT_VEC2, memberInstance->offset, memberInstance->arrayStride, memberInstance->size, topLevelSize, topLevelStride ); block_add( blockInstance, memberInstance ); } block_createBuffer( blockInstance ); array_add( this->blocks, blockInstance ); } } } struct block * program_createNewBlock( program * this, char * blockName ) { printf("Copy buffer: %s\n\n", blockName); block * originalBlock = program_getBlock( this, blockName ); block * blockCopy = block_newPointer(); blockCopy->members = originalBlock->members; blockCopy->bindingPoint = originalBlock->bindingPoint; blockCopy->index = originalBlock->index; blockCopy->bufferSize = originalBlock->bufferSize; block_createBuffer( blockCopy ); return blockCopy; } struct block * program_getBlock( program * this, char * blockName ) { int blockCount = array_length( this->blocks ); for ( int i = 0; i < blockCount; ++i ) { block * currentBlock = array_get( this->blocks, i ); char * currentBlockName = currentBlock->name; if( char_operator_compare( currentBlockName , blockName) ) { return currentBlock; } } return NULL; } void program_create( program * this ) { this->glProgram = glCreateProgram(); array * shaders = this->shaders; int shaderCount = array_length( shaders ); for (int i = 0; i < shaderCount; ++i) { shader * currentShader = array_get( shaders, i ); glAttachShader( this->glProgram, currentShader->glShader ); } glLinkProgram( this->glProgram ); glUseProgram( this->glProgram ); program_extractBlocks( this ); program_extractAttributes( this ); program_extractUniforms( this ); } void program_bindBlock( program * this, char * blockName ) { block * currentBlock = program_getBlock( this, blockName ); glBindBufferBase( currentBlock->bufferType, currentBlock->bindingPoint, currentBlock->buffer ); } void program_use( program * this ) { glUseProgram( this->glProgram ); } void program_extractUniforms( program * this ) { int attributeCount = 0; GLsizei bufSize = 64; GLsizei length; GLint size; GLenum type; int uniformCount = 0; glGetProgramiv( this->glProgram, GL_ACTIVE_UNIFORMS, &uniformCount ); for (int i = 0; i < uniformCount; i++) { struct uniform * uniformInstance = uniform_newPointer(); GLenum type; GLchar name[bufSize]; glGetActiveUniform( this->glProgram, ( GLuint ) i, bufSize, &length, &size, &type, uniformInstance->name ); GLint uniformLocation = glGetUniformLocation( this->glProgram, uniformInstance->name ); uniformInstance->location = uniformLocation; uniformInstance->type = type; array_add( this->uniforms, uniformInstance ); } } void program_extractAttributes( program * this ) { int attributeCount = 0; GLsizei bufSize = 64; GLsizei length; GLint size; GLenum type; glGetProgramiv( this->glProgram, GL_ACTIVE_ATTRIBUTES, &attributeCount ); for (int i = 0; i < attributeCount; i++) { GLenum type; attribute * attributeInstance = attribute_newPointer(); glGetActiveAttrib( this->glProgram, ( GLuint ) i, bufSize, &length, &size, &type, attributeInstance->name); GLint attributeLocation = glGetAttribLocation( this->glProgram, attributeInstance->name ); glEnableVertexAttribArray( attributeLocation ); attributeInstance->location = attributeLocation; attributeInstance->type = type; array_add( this->attributes, attributeInstance ); } } struct attribute * program_getAttributeByName( program * this, char * attributeName ) { int attributeCount = array_length( this->attributes ); for ( int i = 0; i < attributeCount; ++i ) { struct attribute * currentAttribute = array_get( this->attributes, i ); char * currentAttributeName = currentAttribute->name; if( char_operator_compare( currentAttributeName , attributeName) ) { return currentAttribute; } } return NULL; } void program_setUniform( program * this, char * name, void * value ) { int uniformCount = array_length( this->uniforms ); for (int i = 0; i < uniformCount; ++i) { uniform * currentUniform = array_get( this->uniforms, i ); char * uniformName = (char *)currentUniform->name; if( char_operator_compare( uniformName , name) ) { switch( currentUniform->type ) { case GL_FLOAT_VEC2: vector2 * vector2Value = ( vector2 * ) value; glUniform2f( currentUniform->location, vector2Value->x, vector2Value->y ); break; case GL_FLOAT_VEC3: vector3 * vector3Value = ( vector3 * ) value; glUniform3f( currentUniform->location, vector3Value->x, vector3Value->y, vector3Value->z ); break; case GL_SAMPLER_2D: program_updateSampler2D( this, currentUniform, value ); break; case GL_SAMPLER_2D_ARRAY: program_updateSampler2D( this, currentUniform, value ); break; } } } } void program_updateSampler2D( program * this, uniform * currentUniform, void * value ) { glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); sampler2D * sampler = ( sampler2D * ) value; if( !sampler->binded ) { sampler->index = this->samplerIndex++; sampler2D_bind( sampler ); } glActiveTexture( GL_TEXTURE0 + sampler->index ); glBindTexture( sampler->target, sampler->glTexture ); glUniform1i( currentUniform->location, sampler->index ); } program program_new() { program instance; instance.samplerIndex = 0; instance.uniforms = array_newPointer(); instance.attributes = array_newPointer(); instance.blocks = array_newPointer(); instance.shaders = array_newPointer(); return instance; } program * program_newPointer() { struct program * pointer = malloc( sizeof ( struct program ) ); pointer->samplerIndex = 0; pointer->uniforms = array_newPointer(); pointer->attributes = array_newPointer(); pointer->blocks = array_newPointer(); pointer->shaders = array_newPointer(); return pointer; }