Geometry shaders part 3

Transform feedback, is one of the tools of the trade not often discussed on the net, in fact i couldn’t find a single tutorial, so i better write one. the essential function of this little feature is to enable you to do very complicated stuff in the geometry shader, stuff that would inevitably make things run slowly, or to assemble a vbo using tiny little parts and then save it to a buffer for later use, or for that matter constant use. Read more »

Geometry shaders part 2

In this part we will be doing a bit of simple geometry instancing with a minecraft twist, basically what we are going to do is first generate a volumetric landscape of sorts, then render it using cubes, but not the usual way, we are going to do it as a particle system, which is i guess a little bit more than usual as it involves other stuff than strictly openGL, and since there are a few things i want to try out in this field you will be seeing more of it.
This tutorial assumes that you have all the stuff needed for part 1 and in addition texturing available. Read more »

Geometry shaders part 1

New in OpenGL 3.2 is so called geometry shaders, if you don’t know what they are then what the essentially do is allow you to create new or duplicate geometry. Like instead of drawing a bunch of cubes one after another you could just render a point cloud and let the geometry shader “upgrade” them to cubes, which is probably how i would render minecraft if i where it’s creator, which i would if i had a hat half as awesome as notch does.
Read more »

Screenshots

Hi, here is a little Yule gift for all you GL junkies out there, it’s a short quick and easy tool for taking a screen shot into the tga format, sure it’s uncompressed and doesn’t increment the file name, but it’s pretty slick.

Usage: screenshot (“test.tga”,800,600);
Just call the function with the correct window size just before SwapBuffers and it will take a screen shot of everything in the frame buffer, easy.

Running OpenGL3.0 – part3

In our third installment we are looking into replacing all the matrix math previously built into openGL, what I am going to show you replaces most of it almost exactly like openGL used to work, naturally if your doing something a bit more advanced like a game or so, I would suggest that you use your scene graph to generate new matrices.

It’s really quite simple though, and as with the previous part we have to do some changes a bit here and there, so I am going to start with the most generalized bit and work my way down, and finally end up with the classic rotating cube.
But first the prerequisites, I am assuming that you started where part 2 left off, we will also need the following functions made to work
glGetUniformLocation
glUniformMatrix4fv

Step 1 – the shader
it’s really not that much but after

add

this will be where we send our new matrix to.
Then later in the code you need to do something like this to use our matrix

You could use and I almost recommend that you use two matrices one for the camera and one for the model transformation, but I leave that task to you.
Please note that the order of the multiplication is important. Read more »

Running OpenGL3.0 – part2

In this part I will show you what you must do to render even the smallest speck of graphical garbage on the screen in the openGL 3.0 API, it’s somewhat simple once you have all the tools.
First you need a good GLSL shader implementation because nothing will render without it, you can use mine if you want but just remember that we are gonna modify it a bit so it can’t be to abstracted.
Next you need to take a look at the VAO tutorial since well be using that too, naturally since we are using VAO well also be using VBO and in this example I have 3 buffers with the vertex, texture and normal coordinates for a cube, you could use anything, but I am using a cube.
We are also going to use 4 new functions so go ahead am make them work as well.
glVertexAttribPointer
glBindAttribLocation
glDisableVertexAttribArray
glEnableVertexAttribArray
Finally remove anything that has to do with matrices, well discuss those in part 3, in fact remove or comment out any deprecated function (you can find them in part 1).

Now then, there are about four steps to this, that is there are 4 things you need to change in your already existing code for things to work, so I will explain them in order. Read more »

Running OpenGL3.0 – part1

Welcome to a series I have planned on OpenGL 3.0 regarding the forward compatible mode, or in layman’s terms, using OpenGLwithout all the stuff that got cut.
It’s quite a different beast to work with, even I have problems getting my head around it since so much things that you used for every other line has to be done differently, I find myself adding the line glTranslatef(…. only to suddenly stop thinking “o, right, doesn’t work anymore”.

It’s a bit harder also as you have to use shaders or it won’t be drawn, you cant just use a VBO like before but instead you have to bind it to a input variable.
In short everything is different, but I will try to guide you trough the basic stuff, but look at it from the bright side, now you have no more excuse not to code the way it should be done.

So what got cut well quite a bit, take a look at http://www.opengl.org/documentation/specs/ and download the 3.0 specification and then check under the section called “The Deprecation Model”, but here are some highlights Read more »

Vertex array objects

With openGL 3 came a few cool features most of these are pretty small and quick to learn, VAOs are among these, I really didn’t want to write a full fledged tutorial about it before, but seeing as I’m changing the format to promote shorter and more article like posts, it seemed like as good as place as any to start.

There hasn’t been that much written about the vertex_array_object extension, also there is some confusion on where to use it and how.
Simply put it couldn’t be simpler, it’s used to make the daily life of using VBOs easier and the code prettier, earlier you had to call these three functions for each buffer to set up rendering, normally that would be at least 3.

glEnableClientState
glBindBuffer
glTexCoordPointer Read more »

PCF

In the last previous tutorial we explored the depth shadow maps in all it’s aliasing glory.
I showed you ho to fix the steep angle artifacts by using the diffuse term, and the shadow poping by adding a bias to the shadows.
In this lesson we are going to implement something called Percentage Closer Filtering or PCF as it is more commonly called, the name doesn’t exactly reveal what it does.
It is in fact a way to multi sample the shadows and this is pretty simple, so simple that i am not going to supply you with anything other than the new shader file, the rest is exactly the same as tutorial 03a.

1. transform the texture coordinates first two values by a really small amount.
2.make a shadow test against those coordinates.
3. repeat 1 and 2 as many times as needed..
4. take the collective result from the shadow tests and divide it with the number if samples you just did.

Lets demonstrate this with some code.
First we set up some variables + load the other textures besides the shadows.
Since we are also going to do 25 samples we want to eliminate as much as possible from the loop, that is why i added the inverted bias to gl_TexCoord[2].z instead of the shadow value.

next do the sampling, note that because a division is more problematic than a add, we pre divided the samples so instead of adding one for each sample we are adding 0.04, this saves us the trouble of having to divide at runtime.

Great now all we have to do is include the rest and we are done

You can now begin to play around with the numbers, increasing the values in blur_spread will make it a bit more blurry, but then other artifacts show up, these can be fixed by fiddling with the bias parameters, but ultimately PCF is just a hack and won’t work every time.
I originally planned to include a version that changed the blurriness according to the distance from the shadow casting surface, it looked pretty good, unfortunately not good enough in all situations, it was done by getting the distance between the fragment and the shadow map depth value and with this manipulating the values in blur_spread.
It would have worked if it whereat for those meddling kids(read:artifacts).
Test and see if you can do it.

Download the new shader file for this tutorial, to get the rest download the previous tutorial

Depth Shadow maps

Shadows are always nice, but they can sometimes be a hazzle to implement, i am going to show you the simplest way to implement them in a method called projected depth shadow maps.
I am also going to bring up a way to create some nice shadows and light effects.

But first some theory, what we are going to do is.
1. render the depth to a texture, i will use a FBO here since they are nice an easy to use.
2. i am going to compare this map with the distance from the lightsource to what i am going to render.
3. finally we have to mask all the artifacts, and believe me, there are plenty of them there.

Now the real problem here is the texture projection, but fortunately openGL and glsl has some tricks up it’s sleeve.
What you do is you first make two matrices, one projection and one modelview matrix, we do the same with the rendering matrices to insure we will get the same every time.
Next we multiply the lightprojection and lightmodelview matrices into a temp matrix.
Then we combine that matrix with the inverted camera matrix and call it the texture matrix.

When we render the final rendering we then need to feed openGL with the new texture matrix, normally this is normally done with glTexGen, but we are going to take a little shortcut by directly uploading it with glLoadMatrixf.

Then in the shader we call a simple little code to buid new texture coordinates
gl_TexCoord[2] = gl_TextureMatrix[0]*gl_ModelViewMatrix*gl_Vertex; // in the vertex shader

gl_TexCoord[2] = gl_TexCoord[2]/gl_TexCoord[2].w; // fragment shader
gl_TexCoord[2]=(gl_TexCoord[2]+ 1.0) * 0.5;

now you need only use this texture coordinate and then compare the resulting texture lookup with the third parameter in the texture coordinate to determine if it’s in a shadow or not.

Sounds simple, so let’s get cracking

First of all this lesson is based on lesson 2c + the FBO parts of lesson 1, so all the helper funcs are there then we need two more functions.

THese will help with some of the matrix math, once you start making more advanced stuff you should put all of this in a larger class.

Next we set up the fbo

Then in the update function we need to build all five matrices, these matrices are really only float[16].

Notice that we invert the cameraViewMatrix and combine it with the combined light matrix, we do this to cancel out the camera movement, this moves the texture matrix from world space to camera space and it’s what allows us to move things about without it getting all “funky”.
Next we have the renderplane function, i won’t explain it but it draws a single quad, super simple.
Then we are going to start rendering, first the light pass., it’s simple enough, but instead of the usual glTranslatef and glRotatef we load our premade matrices.

Then we set up a few things

Now comes the fun bit, just make a note that we are not doing anything funny here, it’s a simple setup of multi texturing and then the rendering.

Ok on to the shader parts.

Vertex shader

Fragment shader

And that is it, shadow mapping will produce a lot of artifacts, one of them can be hidden by always including the diffuse value among the shadow.
I will continue to clear out some of them in coming tuts.

Download this tutorial for MSVCPP 6.0
note: this does not include the updated code so you need to change it before using.