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;
}
