In order to accomplish a bilateral blur you will need to use FBOs (Frame Buffer Objects). You essentially render your scene to an FBO and then blur that in one direction. You then render the first FBO to either another FBO or to the screen then you blur that in the other direction.
Your Shaders are going to look something like this, you will have two of them, each in a different direction.
Oh, really? Please, do enlighten us on how you write GPU shaders. Do you cobble them together from C++ macros? Or perhaps you write them directly in IL assembly, hardcore-style? Also, how long does it take you to write a tool that replaces sequences of bytes in a binary buffer? Still waiting, cause in Python I'm done: buf.replace(). Oh, yours is... what? Faster? Oh, but I was only going to use it for a 10kb file anyway.
More specifically c++ is in my opinion the best general purpose language for writing games.
Once you've programmed in a sane language, C++ feels SOOOOOOO much *more* painful. I need to make my own ??what??, to do what?? Really..... sheeesh.
C++ is the only sane language.
Once you know c++ there is no reason to use anything else. Unless of course you want the best speed possible in that case you would use assembly (sometimes I use it inline with c++ just for speed). As for making your own code for complicated things you can either have fun and do it yourself or use a third party library.
I tried learning JAVA, I decided it was just like c++ but slower and with too many rules.
Thanks. I'm a little reluctant to switch to VBOs at this point, especially if the gain won't be much.
VBO's look really complicated at first but start to make sense if you just take a half hour and really just study some example code you will get them. The performance gain will be massive if you are currently using glbegin/glend but if you are already using vertex arrays then it won't be huge but still measurable.
All in all glbegin/glend sucks for speed on anything.
I'm developing an opengl application and I have cast a ray from the camera to a point in 3D space. I would like to define a plane where such point lays, with the cast ray vector perpendicular to such plane. Is it possible? If it's not clear I can make an image.
You should be able to define this plane if you know the tangent and the binormal, which can be derived from the normal.
We know that these vectors are both perpendicular to the normal. To find the tangent you will find two vectors perpendicular to the normal and pick one depending on whether the normal is positive or negative, the binormal will be the cross product of the tangent and the normal and at that point you should have enough information to define a plane, this will however be a massive burden on your CPU if you want to do this in real time so see if you can offload some calculations to the GPU using shaders or OpenCL.