Sign in to follow this  
Aklinger

OpenGL Fixed Pipeline and Shadow Mapping

Recommended Posts

Aklinger    110
Hi,

i am working on a OpenGL project and have problems with my shadows. They are not displayed and i dont know why. The code, which i use, is from [url="http://www.paulsprojects.net/tutorials/smt/smt.html"]http://www.paulsproj...ls/smt/smt.html[/url] .
The idea is:
I draw the scene three times. In the first draw, i write the depth values in a FBO from the lightview direction.
In the second draw, i draw the scene normal with (0.2, 0.2, 0.2, 1) light intensity.
In the third step i draw the scene with bright light and make a comparison with the depth values. Here is the code: The first part is my shadow class and the second part my viewer class. In the viewer class all draws etc. are handled.

[code]
void Shadows::generateShadowBuffer()
{
shadowMapSize = 512;

// Init texture
glGenTextures(1, &_depthTextureId);
glBindTexture(GL_TEXTURE_2D, _depthTextureId);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, shadowMapSize, shadowMapSize,
0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);

// Init buffer
glGenFramebuffersEXT(1, &_fboId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fboId);

// attach the texture to FBO color attachment point
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_TEXTURE_2D, _depthTextureId, 0);

// Instruct openGL that we won't bind a color texture with the currently binded FBO
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);

// check FBO status
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if(status != GL_FRAMEBUFFER_COMPLETE_EXT)
printf("Buffer init wasnt correct.\n");

glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

// Check for Error
GLenum error = glGetError();
if(error != 0)
{
printf("Error occured in Shadows::generateShadowBuffer: %d\n", error);
if(GL_STACK_OVERFLOW == error)
printf("GL_STACK_OVERFLOW\n");
if(GL_STACK_UNDERFLOW == error)
printf("GL_STACK_UNDERFLOW\n");
}
}

// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void Shadows::drawFromLight(Vector lightPosition)
{
// Activate Buffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fboId);

// clear buffers
glClear(GL_DEPTH_BUFFER_BIT);
glColorMask(0, 0, 0, 0);

// Init matrices
glPushMatrix();
glLoadIdentity();
gluPerspective(60.0f, 1.0f, 0.1f, lightPosition.y + 10);
glGetFloatv(GL_MODELVIEW_MATRIX, _projectionMatrix);
glPopMatrix();

glPushMatrix();
glLoadIdentity();
gluLookAt(lightPosition.x, lightPosition.y, lightPosition.z,
lightPosition.x, 0, lightPosition.z,
0, 0, 1.0f);
glGetFloatv(GL_MODELVIEW_MATRIX, _lightviewMatrix);
glPopMatrix();

//Draw from the light's point of view
glViewport(0, 0, shadowMapSize, shadowMapSize);

glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadMatrixf(_projectionMatrix);

glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(_lightviewMatrix);

glPolygonOffset(8.0f, 1.1f);
glEnable(GL_POLYGON_OFFSET_FILL);

// Check for Error
GLenum error = glGetError();
if(error != 0)
{
printf("Error occured in Shadows::drawFromLight: %d\n", error);
if(GL_STACK_OVERFLOW == error)
printf("GL_STACK_OVERFLOW\n");
if(GL_STACK_UNDERFLOW == error)
printf("GL_STACK_UNDERFLOW\n");
}
}

// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void Shadows::drawWithShadows(int width, int height, Vector position, Vector direction, Vector up, float yPos)
{
// Deactivate buffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
/*glPopAttrib();
glBindTexture(GL_TEXTURE_2D, _depthTextureId);
GLfloat* buffer = new GLfloat[shadowMapSize * shadowMapSize];
glReadPixels(0, 0, shadowMapSize, shadowMapSize, GL_DEPTH_COMPONENT, GL_FLOAT, buffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, shadowMapSize, shadowMapSize, 0, GL_DEPTH_COMPONENT, GL_FLOAT, buffer);

std::vector<float> pixbuf;
for(int i = 0; i < shadowMapSize*shadowMapSize; i++)
pixbuf.push_back(buffer[i]);
for(int i = 0; i < pixbuf.size(); i++)
if(pixbuf[i] != 1)
{
std::cout << pixbuf[i] << std::endl;
}
delete[] buffer;*/

//Clear depth buffer

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// Enable colorwriting
glColorMask(1, 1, 1, 1);

//reset viewport
glViewport(0, 0, width, height);

//Reset projection matrix
glMatrixMode(GL_PROJECTION);
glPopMatrix();

//Draw from camera's point of view
glMatrixMode(GL_MODELVIEW);
//glLoadMatrixf(viewMatrix);
glLoadIdentity();
gluLookAt(position.x, position.y, position.z,
direction.x, -direction.y, direction.z,
up.x, up.y, up.z);
glTranslatef(0, yPos, 0);

// Check for Error
GLenum error = glGetError();
if(error != 0)
{
printf("Error occured in Shadows::drawWithShadows: %d\n", error);
if(GL_STACK_OVERFLOW == error)
printf("GL_STACK_OVERFLOW\n");
if(GL_STACK_UNDERFLOW == error)
printf("GL_STACK_UNDERFLOW\n");
if(GL_INVALID_OPERATION == error)
printf("GL_INVALID_OPERATION\n");
if(GL_INVALID_VALUE == error)
printf("GL_INVALID_VALUE\n");
}
}

// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void Shadows::drawWithoutShadows()
{
//glActiveTexture(GL_TEXTURE7);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, _depthTextureId);

// Get matrix


GLfloat bias[16] = {
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0};

// concatinating all matrice into one.
MyMatrix dummy;
dummy = MyMatrix(bias) * MyMatrix(_projectionMatrix) * MyMatrix(_lightviewMatrix);

const GLfloat first[4] = {dummy[0], dummy[4], dummy[8], dummy[12]};
const GLfloat second[4] = {dummy[1], dummy[5], dummy[9], dummy[13]};
const GLfloat third[4] = {dummy[2], dummy[6], dummy[10], dummy[14]};
const GLfloat fourth[4] = {dummy[3], dummy[7], dummy[11], dummy[15]};

//Set up tex coord generation - all 4 coordinates required
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_S, GL_EYE_PLANE, first);
glEnable(GL_TEXTURE_GEN_S);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_T, GL_EYE_PLANE, second);
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_R, GL_EYE_PLANE, third);
glEnable(GL_TEXTURE_GEN_R);
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_Q, GL_EYE_PLANE, fourth);
glEnable(GL_TEXTURE_GEN_Q);

//Use SGIX_shadow comparison
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_SGIX, true);

glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);

//glBlendEquationEXT(GL_MAX_EXT);
//glEnable(GL_BLEND);
//Set alpha test to discard false comparisons
glAlphaFunc(GL_GEQUAL, 0.99f);
glEnable(GL_ALPHA_TEST);

// Check for Error
GLenum error = glGetError();
if(error != 0)
{
printf("Error occured in Shadows::drawWithoutShadows: %d\n", error);
error = 0;
}
}
[/code]

[code]
// FPS
frame++;
time=glutGet(GLUT_ELAPSED_TIME);

if (time - timebase > 1000) {
printf("FPS:%4.2f\n", frame*1000.0/(time-timebase));
timebase = time;
frame = 0;
}

// Reset to draw again
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);

// ++ ---------------------------------------------------------------------------------------------------- ++ //
// First step for shadows
glPushAttrib(GL_ALL_ATTRIB_BITS);
_shadow->drawFromLight(_sun->getPosition());

// Draw the drawables the first time
for(std::list<Drawable*>::iterator it = _drawables.begin(); it != _drawables.end(); it++)
{
(*it)->draw();
}


// ++ ---------------------------------------------------------------------------------------------------- ++ //
// Second step for shadows
_shadow->drawWithShadows(_windowWidth, _windowHeight, _cPosition , _cView, _cUp, _positionY);
_sun->shadowLight();

// Draw the drawables the second time with shadows
for(std::list<Drawable*>::iterator it = _drawables.begin(); it != _drawables.end(); it++)
{
(*it)->draw();
}

// ++ ---------------------------------------------------------------------------------------------------- ++ //
// Second step for shadows
glPushAttrib(GL_ALL_ATTRIB_BITS);
_sun->brightLight();
_shadow->drawWithoutShadows();

// Skybox
//_skybox->draw();


// Draw the drawables the third time with shadows
for(std::list<Drawable*>::iterator it = _drawables.begin(); it != _drawables.end(); it++)
{
(*it)->draw();
}

glPopAttrib();

// Water, grass
//_water->draw();
//_grass->draw();

//_shadow->debug();

// Light out
glDisable(GL_LIGHT0); glDisable(GL_LIGHTING);

// Draw and clear Buffer
glutSwapBuffers();

// Check for Error
GLenum error = glGetError();
if(error == GL_INVALID_OPERATION)
{
printf("Error occured in Viewer: %d\n", error);
error = 0;
}
[/code]

The sun class only sets the light intesity and holds the position of the light. MyMatrix multiplys the matrices correct.

P.S. I know i should use Shaders for this topic, but it is my first project and i started with the fixed pipeline.

Share this post


Link to post
Share on other sites
Aklinger    110
The lightposition is on (0, 200, 0) and the cube is on (0, 30, 0). The plane under the cube is from (-100,0, -100) to (100, 0, 100). So the shadow should be under the cube.
[attachment=4448:screen.png]

Share this post


Link to post
Share on other sites
Geri    367
[color="#0000FF"][color="#000000"]try a

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);


on the shadow tex's[/color]
[/color]

Share this post


Link to post
Share on other sites
Geri    367
ok, leave it there, its necessary.

now try to upload some random memory garbage as shadow map texture. it should give you some strange result. lets see if the cmp is working.

Share this post


Link to post
Share on other sites
Aklinger    110
This three lines should do a rnd garbage upload or?
glBindTexture(GL_TEXTURE_2D, _depthTextureId);
GLfloat* buffer = new GLfloat[shadowMapSize * shadowMapSize];
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, shadowMapSize, shadowMapSize, 0, GL_DEPTH_COMPONENT, GL_FLOAT, buffer);

The result is a black line through the picture, so i think its no rnd garbage.
[attachment=4450:screen.png]

Share this post


Link to post
Share on other sites
Aklinger    110
Mhh, that is the code for the matrix:
The matrix multiplikation
[code]
MyMatrix MyMatrix::operator*(MyMatrix& mat)
{
MyMatrix dummy;

dummy._matrix[0] = _matrix[0] * mat._matrix[0] + _matrix[1] * mat._matrix[4] + _matrix[2] * mat._matrix[8] + _matrix[3] * mat._matrix[12];
dummy._matrix[1] = _matrix[0] * mat._matrix[1] + _matrix[1] * mat._matrix[5] + _matrix[2] * mat._matrix[9] + _matrix[3] * mat._matrix[13];
dummy._matrix[2] = _matrix[0] * mat._matrix[2] + _matrix[1] * mat._matrix[6] + _matrix[2] * mat._matrix[10] + _matrix[3] * mat._matrix[14];
dummy._matrix[3] = _matrix[0] * mat._matrix[3] + _matrix[1] * mat._matrix[7] + _matrix[2] * mat._matrix[11] + _matrix[3] * mat._matrix[15];

dummy._matrix[4] = _matrix[4] * mat._matrix[0] + _matrix[5] * mat._matrix[4] + _matrix[6] * mat._matrix[8] + _matrix[7] * mat._matrix[12];
dummy._matrix[5] = _matrix[4] * mat._matrix[1] + _matrix[5] * mat._matrix[5] + _matrix[6] * mat._matrix[9] + _matrix[7] * mat._matrix[13];
dummy._matrix[6] = _matrix[4] * mat._matrix[2] + _matrix[5] * mat._matrix[6] + _matrix[6] * mat._matrix[10] + _matrix[7] * mat._matrix[14];
dummy._matrix[7] = _matrix[4] * mat._matrix[3] + _matrix[5] * mat._matrix[7] + _matrix[6] * mat._matrix[11] + _matrix[7] * mat._matrix[15];

dummy._matrix[8] = _matrix[8] * mat._matrix[0] + _matrix[9] * mat._matrix[4] + _matrix[10] * mat._matrix[8] + _matrix[11] * mat._matrix[12];
dummy._matrix[9] = _matrix[8] * mat._matrix[1] + _matrix[9] * mat._matrix[5] + _matrix[10] * mat._matrix[9] + _matrix[11] * mat._matrix[13];
dummy._matrix[10] = _matrix[8] * mat._matrix[2] + _matrix[9] * mat._matrix[6] + _matrix[10] * mat._matrix[10] + _matrix[11] * mat._matrix[14];
dummy._matrix[11] = _matrix[8] * mat._matrix[3] + _matrix[9] * mat._matrix[7] + _matrix[10] * mat._matrix[11] + _matrix[11] * mat._matrix[15];

dummy._matrix[12] = _matrix[12] * mat._matrix[0] + _matrix[13] * mat._matrix[4] + _matrix[14] * mat._matrix[8] + _matrix[15] * mat._matrix[12];
dummy._matrix[13] = _matrix[12] * mat._matrix[1] + _matrix[13] * mat._matrix[5] + _matrix[14] * mat._matrix[9] + _matrix[15] * mat._matrix[13];
dummy._matrix[14] = _matrix[12] * mat._matrix[2] + _matrix[13] * mat._matrix[6] + _matrix[14] * mat._matrix[10] + _matrix[15] * mat._matrix[14];
dummy._matrix[15] = _matrix[12] * mat._matrix[3] + _matrix[13] * mat._matrix[7] + _matrix[14] * mat._matrix[11] + _matrix[15] * mat._matrix[15];

return dummy;
}
[/code]

And with this code i save the lightmatrix and projectionmatrix:
[code]
// Init matrices
glPushMatrix();
glLoadIdentity();
gluPerspective(60.0f, 1.0f, 0.1f, lightPosition.y + 10);
glGetFloatv(GL_MODELVIEW_MATRIX, _projectionMatrix);
glPopMatrix();

glPushMatrix();
glLoadIdentity();
gluLookAt(lightPosition.x, lightPosition.y, lightPosition.z,
lightPosition.x, 0, lightPosition.z,
0, 0, 1.0f);
glGetFloatv(GL_MODELVIEW_MATRIX, _lightviewMatrix);
glPopMatrix();
[/code]

And in drawWithoutShadows i multiply the three matrices:
[code]
MyMatrix dummy;
dummy = MyMatrix(bias) * MyMatrix(_projectionMatrix) * MyMatrix(_lightviewMatrix);

const GLfloat first[4] = {dummy[0], dummy[4], dummy[8], dummy[12]};
const GLfloat second[4] = {dummy[1], dummy[5], dummy[9], dummy[13]};
const GLfloat third[4] = {dummy[2], dummy[6], dummy[10], dummy[14]};
const GLfloat fourth[4] = {dummy[3], dummy[7], dummy[11], dummy[15]};
[/code]

First, second, third and fourth are the arguments for glTexGenfv.
So i dont know why it is bad.

Share this post


Link to post
Share on other sites
Geri    367
You see lines instead of ,,white-noise'' while you switched to random image. This means that your shadow map being projected badly.

i suggest you to copy a correctly working matrix code from a working shadow map tutorial, then insert it to your code.

Share this post


Link to post
Share on other sites
Aklinger    110
Nice, you are my hero!

The shadow for the cube is now perfect :-)

So the next step is to load the real landscape with my "beatiful" trees. But the result is not very impressive :-/
[attachment=4452:screen.png]

In theory the shadows are working with the cube and plane. But the trees should also make shadows, right?

If i look under the landscape, you see this picture:
[attachment=4453:screen.png]

And i have one more problem: Shadows and texture? My landscape is in normal mode multitextured, but when i draw with shadows, the shadows disappear and only the texture and the detailtexture is visible. Is there a solution?

Share this post


Link to post
Share on other sites
Aklinger    110
Ok, i have solved the problem. A few tries with glPolygonOffset(4.3f, 3.1f); and no black fragments are left.
The texturing is also solved. The problem was, that my OpenGL/graficcard only supports 4 texture units.

Great thanks for your help, Geri!

Share this post


Link to post
Share on other sites
Geri    367
You are welcome! ;)

At the moment, almost all drivers reporting 4 units.
But with some, in reality, you can simply ignore that fact, and you can adress 8 or even 32.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

  • Similar Content

    • By Zaphyk
      I am developing my engine using the OpenGL 3.3 compatibility profile. It runs as expected on my NVIDIA card and on my Intel Card however when I tried it on an AMD setup it ran 3 times worse than on the other setups. Could this be a AMD driver thing or is this probably a problem with my OGL code? Could a different code standard create such bad performance?
    • By Kjell Andersson
      I'm trying to get some legacy OpenGL code to run with a shader pipeline,
      The legacy code uses glVertexPointer(), glColorPointer(), glNormalPointer() and glTexCoordPointer() to supply the vertex information.
      I know that it should be using setVertexAttribPointer() etc to clearly define the layout but that is not an option right now since the legacy code can't be modified to that extent.
      I've got a version 330 vertex shader to somewhat work:
      #version 330 uniform mat4 osg_ModelViewProjectionMatrix; uniform mat4 osg_ModelViewMatrix; layout(location = 0) in vec4 Vertex; layout(location = 2) in vec4 Normal; // Velocity layout(location = 3) in vec3 TexCoord; // TODO: is this the right layout location? out VertexData { vec4 color; vec3 velocity; float size; } VertexOut; void main(void) { vec4 p0 = Vertex; vec4 p1 = Vertex + vec4(Normal.x, Normal.y, Normal.z, 0.0f); vec3 velocity = (osg_ModelViewProjectionMatrix * p1 - osg_ModelViewProjectionMatrix * p0).xyz; VertexOut.velocity = velocity; VertexOut.size = TexCoord.y; gl_Position = osg_ModelViewMatrix * Vertex; } What works is the Vertex and Normal information that the legacy C++ OpenGL code seem to provide in layout location 0 and 2. This is fine.
      What I'm not getting to work is the TexCoord information that is supplied by a glTexCoordPointer() call in C++.
      Question:
      What layout location is the old standard pipeline using for glTexCoordPointer()? Or is this undefined?
       
      Side note: I'm trying to get an OpenSceneGraph 3.4.0 particle system to use custom vertex, geometry and fragment shaders for rendering the particles.
    • By markshaw001
      Hi i am new to this forum  i wanted to ask for help from all of you i want to generate real time terrain using a 32 bit heightmap i am good at c++ and have started learning Opengl as i am very interested in making landscapes in opengl i have looked around the internet for help about this topic but i am not getting the hang of the concepts and what they are doing can some here suggests me some good resources for making terrain engine please for example like tutorials,books etc so that i can understand the whole concept of terrain generation.
       
    • By KarimIO
      Hey guys. I'm trying to get my application to work on my Nvidia GTX 970 desktop. It currently works on my Intel HD 3000 laptop, but on the desktop, every bind textures specifically from framebuffers, I get half a second of lag. This is done 4 times as I have three RGBA textures and one depth 32F buffer. I tried to use debugging software for the first time - RenderDoc only shows SwapBuffers() and no OGL calls, while Nvidia Nsight crashes upon execution, so neither are helpful. Without binding it runs regularly. This does not happen with non-framebuffer binds.
      GLFramebuffer::GLFramebuffer(FramebufferCreateInfo createInfo) { glGenFramebuffers(1, &fbo); glBindFramebuffer(GL_FRAMEBUFFER, fbo); textures = new GLuint[createInfo.numColorTargets]; glGenTextures(createInfo.numColorTargets, textures); GLenum *DrawBuffers = new GLenum[createInfo.numColorTargets]; for (uint32_t i = 0; i < createInfo.numColorTargets; i++) { glBindTexture(GL_TEXTURE_2D, textures[i]); GLint internalFormat; GLenum format; TranslateFormats(createInfo.colorFormats[i], format, internalFormat); // returns GL_RGBA and GL_RGBA glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, createInfo.width, createInfo.height, 0, format, GL_FLOAT, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); DrawBuffers[i] = GL_COLOR_ATTACHMENT0 + i; glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, textures[i], 0); } if (createInfo.depthFormat != FORMAT_DEPTH_NONE) { GLenum depthFormat; switch (createInfo.depthFormat) { case FORMAT_DEPTH_16: depthFormat = GL_DEPTH_COMPONENT16; break; case FORMAT_DEPTH_24: depthFormat = GL_DEPTH_COMPONENT24; break; case FORMAT_DEPTH_32: depthFormat = GL_DEPTH_COMPONENT32; break; case FORMAT_DEPTH_24_STENCIL_8: depthFormat = GL_DEPTH24_STENCIL8; break; case FORMAT_DEPTH_32_STENCIL_8: depthFormat = GL_DEPTH32F_STENCIL8; break; } glGenTextures(1, &depthrenderbuffer); glBindTexture(GL_TEXTURE_2D, depthrenderbuffer); glTexImage2D(GL_TEXTURE_2D, 0, depthFormat, createInfo.width, createInfo.height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthrenderbuffer, 0); } if (createInfo.numColorTargets > 0) glDrawBuffers(createInfo.numColorTargets, DrawBuffers); else glDrawBuffer(GL_NONE); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) std::cout << "Framebuffer Incomplete\n"; glBindFramebuffer(GL_FRAMEBUFFER, 0); width = createInfo.width; height = createInfo.height; } // ... // FBO Creation FramebufferCreateInfo gbufferCI; gbufferCI.colorFormats = gbufferCFs.data(); gbufferCI.depthFormat = FORMAT_DEPTH_32; gbufferCI.numColorTargets = gbufferCFs.size(); gbufferCI.width = engine.settings.resolutionX; gbufferCI.height = engine.settings.resolutionY; gbufferCI.renderPass = nullptr; gbuffer = graphicsWrapper->CreateFramebuffer(gbufferCI); // Bind glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); // Draw here... // Bind to textures glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textures[0]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, textures[1]); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, textures[2]); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, depthrenderbuffer); Here is an extract of my code. I can't think of anything else to include. I've really been butting my head into a wall trying to think of a reason but I can think of none and all my research yields nothing. Thanks in advance!
    • By Adrianensis
      Hi everyone, I've shared my 2D Game Engine source code. It's the result of 4 years working on it (and I still continue improving features ) and I want to share with the community. You can see some videos on youtube and some demo gifs on my twitter account.
      This Engine has been developed as End-of-Degree Project and it is coded in Javascript, WebGL and GLSL. The engine is written from scratch.
      This is not a professional engine but it's for learning purposes, so anyone can review the code an learn basis about graphics, physics or game engine architecture. Source code on this GitHub repository.
      I'm available for a good conversation about Game Engine / Graphics Programming
  • Popular Now