static GLint get_uniform_vector(const char *name, GLuint program, GLenum *type) { glGetError(); // flush current error state. GLint size; GLint location; // Get the position for the uniform var. if(GLSLProgram::m_bGLUseARB) { location=glGetUniformLocationARB(program, name); } else { location=glGetUniformLocation(program, name); } GLenum gl_err = glGetError(); if(gl_err != GL_NO_ERROR || location == -1) { throw GL_ERROR(gl_err); } if (GLSLProgram::m_bGLUseARB) { glGetActiveUniformARB(program, location, 0, NULL, &size, type, NULL); } else { glGetActiveUniform(program, location, 1, &AtiHackLen, &size, type, &AtiHackChar); } gl_err = glGetError(); if(gl_err != GL_NO_ERROR) { T_ERROR("Error getting type."); throw GL_ERROR(gl_err); } return location; }
VOID RenderTargetScene::AttachMaterialAndTextures( GLSLProgram* pProg, const string& strOwnerName ) const { PRenderedObj rndObj = GetRenderedObject(strOwnerName); if (!rndObj ) return; ResourceMng* pResMng = ResourceMng::GetInstance(); ////////////////////////////////////////////////////////////////////////// // Subroutines ////////////////////////////////////////////////////////////////////////// if (IsFlagUp(pProg->m_dwFlags, F_GLSL_SUBROUTINES)) { if (rndObj->m_arrSubroutinesIDs) { CONST UINT nSubroutines = rndObj->m_arrSubroutines.size(); for (UINT uiS = 0; uiS < nSubroutines; uiS++) { if(!rndObj->m_arrSubroutines[uiS].m_bGotID) { rndObj->m_arrSubroutinesIDs[uiS] = m_pOpenGL->glGetSubroutineIndex(pProg->GetID(), GL_FRAGMENT_SHADER, rndObj->m_arrSubroutines[uiS].m_strName.c_str()); rndObj->m_arrSubroutines[uiS].m_bGotID = TRUE; } } m_pOpenGL->glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, nSubroutines, rndObj->m_arrSubroutinesIDs); } GL_ERROR(); } // E/O Subroutines ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Send Material information ////////////////////////////////////////////////////////////////////////// SendMaterialColors(pProg, &rndObj->m_Material); // E/O Material ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Send Samplers to program ////////////////////////////////////////////////////////////////////////// UINT nSamplers = rndObj->m_arrSamplers.size(); for (UINT uiS = 0; uiS < nSamplers; uiS++) { const PBaseShaderInput pShaderInput = rndObj->m_arrSamplers[uiS]; SendInputToShader(pProg, pShaderInput); } // E/O Samplers ////////////////////////////////////////////////////////////////////////// }
VOID RenderTargetScene::AttachMaterialAndTextures( GLSLProgram* pProg, PTriMesh pMesh) const { GL_ERROR(); UINT unfID = -1; string strOwner = ""; if (pMesh) { strOwner = pMesh->GetOwnerName(); if (pMesh->GetParentMesh()) strOwner = pMesh->GetParentMesh()->GetName(); AttachMaterialAndTextures(pProg, strOwner); } }
int loop_hook(void *data) { t_env *env; env = (t_env*)data; context_init(env); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //world_add_chunk(env->world, chunk_create(env->world, 16, 0)); glColor3f(0,0,0); glBegin(GL_QUADS); glVertex3f(-1, 1, 10); glVertex3f(1, 1, 10); glVertex3f(1, -1, 10); glVertex3f(-1, -1, 10); glEnd(); GL_ERROR(); world_render(env->world); mlx_opengl_swap_buffers(env->window->mlx_window); return (0); }
void GLSLProgram::BindUniformBuffer( ) { UINT nUBOs = m_arrUBONames.size(); if (!nUBOs) return; for (UINT u = 0; u < nUBOs; u++) { CUBO* pUBO = UBOManager::GetInstance()->GetUBO(m_arrUBONames[u]); if (!pUBO ) continue; GL->glBindBuffer(GL_UNIFORM_BUFFER, pUBO->m_uiIndex); GL->glBindBufferBase(GL_UNIFORM_BUFFER, pUBO->m_uiBlockIndex, pUBO->m_uiIndex); /*GLint blockSize; GL->glGetActiveUniformBlockiv(m_programID, blockIndex, GL_UNIFORM_BLOCK_BINDING, &blockSize);*/ GL->glUniformBlockBinding (m_programID, pUBO->m_uiBlockIndex, 0); // reset GL->glBindBuffer(GL_UNIFORM_BUFFER, 0); GL_ERROR(); } }
bool HGE_Impl::_GfxInit() { // static const char *szFormats[]={"UNKNOWN", "R5G6B5", "X1R5G5B5", "A1R5G5B5", "X8R8G8B8", "A8R8G8B8"}; // D3DADAPTER_IDENTIFIER9 AdID; // D3DDISPLAYMODE Mode; // D3DFORMAT Format=D3DFMT_UNKNOWN; // UINT nModes, i; // Init Open GL /* HDC hDC; HGLRC hRC; long gl_error; hDC = GetDC(pHGE->hwnd); hRC = wglCreateContext(hDC); if (hRC == NULL) { System_Log("Creating GL Context Failed with error code: %d", GetLastError()); return false; } System_Log("Initializing Graphix"); wglMakeCurrent(hDC, hRC); */ long gl_error; GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ System_Log("GLEW init Error: %s\n", glewGetErrorString(err)); } else System_Log("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION)); if (!GLEW_EXT_framebuffer_object) { System_Log("Status: Unavailable Extension GL_EXT_framebuffer_object\n"); } else System_Log("Status: GL_EXT_framebuffer_object is supportet\n"); glShadeModel(GL_SMOOTH); // Enables Smooth Shading glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // 4-byte pixel alignment glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearStencil(0); // clear stencil buffer glClearDepth(1.0f); // Depth Buffer Setup glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); // glCullFace(GL_BACK); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); // glDisable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations // Get adapter info System_Log("OpenGL version: %s", glGetString( GL_VERSION )); // System_Log("OpenGL version: %s", glGetString( GL_EXTENSIONS )); // Set up Full Screen presentation parameters _AdjustWindow(); System_Log("Mode: width = %d height = %d\n",nScreenWidth,nScreenHeight); // Create vertex batch buffer textures=0; // Init all stuff that can be lost _SetProjectionMatrix(nScreenWidth, nScreenHeight); if (GL_ERROR(gl_error)) { System_Log("OpenGL error: %d", gl_error); return false; } if(!_init_lost()) return false; Gfx_Clear(0); System_Log("Graphix initialized"); return true; }
VOID IRenderTargetBase::SendInputToShader( GLSLProgram* pProg, const PBaseShaderInput pShaderInput, BOOL bStereo /*= FALSE*/ ) const { ResourceMng* pResMng = ResourceMng::GetInstance(); if (pShaderInput->m_eType == eSIT_FBO || pShaderInput->m_eType == eSIT_PREV_FBO) { UINT unfID = pProg->GetUniformLocation(pShaderInput->m_strName); // Default shadow mapping, using sampler2DShadow and textureProj(...) (PCF) if (unfID != -1) { string fboName = pShaderInput->m_strNameFBO; int iColorAtt = bStereo ? pShaderInput->m_iColAttachFBO + 1: pShaderInput->m_iColAttachFBO ; PFBO fbo = pResMng->GetFBO(fboName); if (fbo) { if (iColorAtt >= fbo->m_iCountColorAttach) iColorAtt = fbo->m_iCountColorAttach - 1; UINT uiMainTexture = fbo->m_arrTextures[iColorAtt]; m_pOpenGL->glActiveTexture(GL_TEXTURE0 + pShaderInput->m_iBindLocation); glBindTexture(GL_TEXTURE_2D, uiMainTexture); m_pOpenGL->glUniform1i(unfID, pShaderInput->m_iBindLocation); } GL_ERROR(); } } else if (pShaderInput->m_eType == eSIT_DEPTH_FBO) { UINT unfID = pProg->GetUniformLocation(pShaderInput->m_strName); // Default shadow mapping, using sampler2DShadow and textureProj(...) (PCF) if (unfID != -1) { string fboName = pShaderInput->m_strNameFBO; PFBO fbo = pResMng->GetFBO(fboName); if (fbo) { UINT uiMainTexture = fbo->m_uiRenderBuffer; m_pOpenGL->glActiveTexture(GL_TEXTURE0 + pShaderInput->m_iBindLocation); glBindTexture(GL_TEXTURE_2D, uiMainTexture); m_pOpenGL->glUniform1i(unfID, pShaderInput->m_iBindLocation); } GL_ERROR(); } } else if (pShaderInput->m_eType == eSIT_SAMPLER) { UINT unfID = pProg->GetUniformLocation(pShaderInput->m_strName); // Default shadow mapping, using sampler2DShadow and textureProj(...) (PCF) if (unfID != -1) { GLuint uiLoc = (GLuint )pShaderInput->m_iBindLocation; m_pOpenGL->glActiveTexture(GL_TEXTURE0 + uiLoc); if (IsFlagUp(pShaderInput->m_eFlags, F_SI_CUBE_MAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, pShaderInput->m_iTextureID); else glBindTexture(GL_TEXTURE_2D, pShaderInput->m_iTextureID); m_pOpenGL->glUniform1i(unfID, uiLoc); GL_ERROR(); } } else if (pShaderInput->m_eType == eSIT_OFFSET_TEX) { UINT unfID = pProg->GetUniformLocation(pShaderInput->m_strName); // Default shadow mapping, using sampler2DShadow and textureProj(...) (PCF) if (unfID != -1) { GLuint uiLoc = (GLuint )pShaderInput->m_iBindLocation + 2; m_pOpenGL->glActiveTexture(GL_TEXTURE0 + uiLoc); glBindTexture(GL_TEXTURE_3D, pShaderInput->m_iTextureID); m_pOpenGL->glUniform1i(unfID, uiLoc); GL_ERROR(); } } else if (pShaderInput->m_eType == eSIT_FLOAT4) { UINT unfID = pProg->GetUniformLocation(pShaderInput->m_strName); // Default shadow mapping, using sampler2DShadow and textureProj(...) (PCF) if (unfID != -1) { m_pOpenGL->glUniform4fv(unfID, 1, pShaderInput->m_arrVals ); GL_ERROR(); } } }
void GLSLProgram::CreateUniformBlockData( CUBO& ubo ) { /* GLuint m_uiIndex; GLuint m_uiBlockIndex; GLint m_iBlockSize; GLubyte* m_byBlockBuffer; string m_strUniformName;*/ // NEGRIN TODO (22-11-14): Share UBO data between shaders, do not recreate! /////////////////////////////////////////////////////////////////////////// if (ubo.m_bCreated) { //if the buffer was created, just bind it GL->glBindBuffer(GL_UNIFORM_BUFFER, ubo.m_uiIndex); GL->glBindBufferBase(GL_UNIFORM_BUFFER, ubo.m_uiBlockIndex, ubo.m_uiIndex); GL_ERROR(); // reset GL->glUniformBlockBinding (m_programID, ubo.m_uiBlockIndex, 0); GL->glBindBuffer(GL_UNIFORM_BUFFER, 0); return; } // Init the uniform buffer with zeros float vEmpty[4] = {1.0f,1.0f,1.0f,0.0f}; // Get uniform block id in program ubo.m_uiBlockIndex = GL->glGetUniformBlockIndex(m_programID, ubo.m_strUniformName.c_str()); // Get uniform size GL->glGetActiveUniformBlockiv(m_programID, ubo.m_uiBlockIndex, GL_UNIFORM_BLOCK_DATA_SIZE, &ubo.m_iBlockSize); ubo.m_byBlockBuffer = (GLubyte*)malloc(ubo.m_iBlockSize); ////////////////////////////////////////////////////////////////////////// // Fill the blockBuffer const GLuint iVariables = ubo.m_uiSize;// 4 * 6;// 4 Lights objects X 6 vector for each light GLuint* arrIndices = new GLuint[iVariables]; GLint* arrOffsets = new GLint[iVariables]; GetUBOIndicesAndOffsets(ubo, arrIndices, arrOffsets); // the default size is vec4 (4 floating points) size_t defaultSize = 4 * sizeof(GLfloat); for (UINT ui = 0; ui < iVariables; ui++) { memcpy(ubo.m_byBlockBuffer + arrOffsets[ui], vEmpty, defaultSize); } ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Create and bind the UBO GL->glGenBuffers(1, &ubo.m_uiIndex); GL->glBindBuffer(GL_UNIFORM_BUFFER, ubo.m_uiIndex); GL->glBufferData(GL_UNIFORM_BUFFER, ubo.m_iBlockSize, ubo.m_byBlockBuffer, GL_DYNAMIC_DRAW); GL->glBindBufferBase(GL_UNIFORM_BUFFER, ubo.m_uiBlockIndex, ubo.m_uiIndex); GL_ERROR(); // reset GL->glUniformBlockBinding (m_programID, ubo.m_uiBlockIndex, 0); GL->glBindBuffer(GL_UNIFORM_BUFFER, 0); ubo.m_bCreated = true; delete[] arrIndices ; delete[] arrOffsets ; }
bool GLSLProgram::Init( const string& strShaderName, const string& vertexShader, const string& fragmentShader, void* pShaderData /*= NULL */) { if (!GL) return false; // Setup m_strName = strShaderName; m_vertexShader.filename = vertexShader; m_fragmentShader.filename = fragmentShader; // Create Program and get the handle to it m_programID = GL->glCreateProgram(); // Vertex Shader (MUST) ////////////////////////////////////////////////////////////////////////// m_vertexShader.source = ReadFile(m_vertexShader.filename); if (m_vertexShader.source.empty()) return false; if (!CreateShader(m_vertexShader, GL_VERTEX_SHADER, m_programID)) { PRINT_ERROR("Vertex shader loading fail: %s", m_vertexShader.filename.c_str()); return false; } // Fragment Shader ////////////////////////////////////////////////////////////////////////// m_fragmentShader.source = ReadFile(m_fragmentShader.filename); if (!m_fragmentShader.source.empty()) { if (!CreateShader(m_fragmentShader, GL_FRAGMENT_SHADER, m_programID)) { PRINT_ERROR("Fragment shader loading fail: %s", m_vertexShader.filename.c_str()); return false; } } else { PRINT_WARN("Fragment shader is missing: %s", m_vertexShader.filename.c_str()); } // Last Step - Linking the program !!! // ========================================================== GL->glBindAttribLocation(m_programID, ATT_VERTEX_LOCATION, ATT_VERTEX_STRING); GL->glBindAttribLocation(m_programID, ATT_UV_LOCATION, ATT_UV_STRING); GL->glBindAttribLocation(m_programID, ATT_NORM_LOCATION, ATT_NORM_STRING); GL->glLinkProgram(m_programID); GL_ERROR(); Disable(); // Create or Bind UBO to shader if (m_arrUBONames.size()) { for (UINT uiU = 0; uiU < m_arrUBONames.size(); uiU++) { CUBO* ubo = UBOManager::GetInstance()->GetUBO(m_arrUBONames[uiU]); if (ubo) { CreateUniformBlockData(*ubo); } } } return true; }
int main(int argc, char **argv) { int exitflag = 0; rh_display_handle display = 0; rh_screen_handle screen = 0; rh_window_handle window = 0; rh_render_handle render = 0; rh_input_handle input = 0; rh_input_data input_data = 0; rh_texpak_handle texpak = 0; rh_texpak_idx texidx = 0; GLuint program = 0; GLenum target; GLuint vbuffer; GLuint texture; if(argc != 3) { printf("useage: %s \"texture pak file\" \"texture name\"\n", argv[0]); exit(1); } if( rh_texpak_open(argv[1], &texpak, RH_TEXPAK_APP) != 0 ) { printf("cant open %s\n", argv[1]); exit(1); } if( rh_texpak_get(texpak, argv[2], &texidx) != 0) { printf("cant find %s in %s\n", argv[2], argv[1]); exit(1); } rh_display_create(&display); rh_screen_create_default(&screen, display); { rh_window_attr_t window_attr = 0; int window_width; int window_height; rh_texpak_get_size(texidx, &window_width, &window_height); rh_window_attr_create(&window_attr); rh_window_attr_seti(window_attr, "w", window_width); rh_window_attr_seti(window_attr, "h", window_height); rh_window_create(&window, window_attr, screen); rh_window_attr_destroy(window_attr); } rh_render_create(&render,window, 2,1,0); rh_bind_render_window(render, window); rh_input_create(&input, window); rh_texpak_load( texpak ); rh_texpak_get_textarget(texpak, &target); program = create_program(target); vbuffer = create_vbuffer( program, target, texpak, texidx); rh_texpak_get_texture(texidx, &texture); glActiveTexture(GL_TEXTURE0 + 0); glBindTexture(GL_TEXTURE_2D, texture); GL_ERROR(); while(!exitflag) { glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); GL_ERROR(); rh_window_swapbuffers(window); if(( input_data = rh_input_get( input ) )) { switch( rh_input_gettype( input_data ) ) { case RH_INPUT_KEYPRESS: { rh_input_key_enum_t k; rh_input_getkey(input_data, &k); if( k == RH_INPUT_KEY_ESCAPE) exitflag = 1; break; } } } } rh_texpak_release(texidx); rh_texpak_close(texpak); rh_input_destroy(input); rh_bind_render_window(render, NULL); rh_render_destroy(render); rh_window_destroy(window); rh_screen_destroy(screen); rh_display_destroy(display); return 0; }