LWJGL Work Frame:
http://www.realityflux.com/abba/Lwjgl/LWJGLFrame/LWJGLFrame.jpg
Keys: Escape to exit
H to display statistics
Source
Zip File Source
Author’s notes:
This Frame works makes developping demos and maybe games a hell lot easier since the programmer doesn’t have to worry about implementing the following things:
TextureGeneration.
Shaders handling including the new shading language OGLSL.
TextureLoading.
Milkshape3D and 3D Studio max files (with an option to generate Tangents and binormals vectors 
).
Cursor rendering.
Text rendering with different fonts.
First person persepective camera.
Frustum class.
Cos and Sin look-up tables.
Quaternion class.
and so on…
It is largely inspired by Xith3D, and yet it is much more flexible (and less features complete).
Enjoy 
Cubic Environment bump mapping:
http://www.realityflux.com/abba/Lwjgl/CEBumpMap/CEBumpMap.jpg
Mouse: left drag for rotation, right drag for translation and middle button for zooming
Keys: Escape to exit, H to display statistics, S to switch OGLSL/Fragment-Vertex programs
Source
Zip File Source
Author’s notes:
Ok I updated this demo to use my latest framework and therefore I’m putting it up here again.
It now runs on top of my mini-scenegraph which is largely inspired by Xith3D, and although it’s not as complete as the latter, it is much much more flexible and Faster.
I also included the license terms on top of every class that I borrowed/modified from Xith3D.
Since OGLSL (Opengl Slang) shading language is now enabled on both Nvidia and ATi’s high end cards, I included an option to switch over it instead of the Vertex/Fragment Program combo.
However, OGLSL is noticeably slower than regular shader programs which is understandable since assembly is always faster than high-end language.
I for one prefer to write my shaders using the fragment/vertex program extension since they yield the fastest frame rate, and aren’t that hard to work with.
Keep in mind that fragment/vertex assembly-like syntax is a lot less complicated that x86 instructions.
This demo also introduces my MilkShape3D model loader even though I think it sucks the big sweaty-goat’s balls. Part of my negative impression regarding that file format is the fact that it writes the normal components into an independent array from the vertices, meaning that for a quad composed by 2 triangles and hence 4 vertices, we actually have a normal array of size 6!!!
Now if you still don’t see how that could cause any problem besides the few more bytes required for the extra normals’ components, remember that all the drawing functions in opengl (except the immediate which is not even an option considering how slow it is) take only one array of indices. Therefore we need to duplicate all the vertices till they match the size of our normal array ;Quite wasteful indeed, but mandatory.
The only reason that I use MS3D loader is because generating “good” noramls in 3DS is a true pain.
I haven’t done any animation yet with this loader, maybe MojoMonkey can throw me a hint on how I do them?
PROs: Awesome reflection effects
Cons: Requires a Radeon 9600+ or GeForce Fx 5200+.
Dynamic Cube Mapping:
http://www.realityflux.com/abba/Lwjgl/DynamicCubeMap/DynamicCubeMap.jpg
Mouse: Move to look around the scene.
Keys: A,Q,W,S,E,D, up, down, left and right to move around. H to display or hide the info.
Ok I’m back as promised to comment on the dynamic cube mapping demo ;D
/me takes a long and deep breath
I spent a lot of time coding this application since I had to first learn and understand VBOs (Vertex Buffer Object) and then try to use them with LWJGL.
Few days ago I thought my demo was ready to be published, but then at the very last moment I decided it wasn’t since I wasn’t entirely satisfied with the performance on my Radeon 9700Pro backed by a 2.1 Ghz Athlon Xp CPU.
Now I understand that rendering the scene 7 times before displaying onto the screen takes a hell lot of computation and time, still the 140 FPS wasn’t something to be too proud of :
So like I said I decided to give VBOs a shot knowing that they mostly store the data on the Graphic Card memory and thus would reduce if not eliminate the time necessary for it to transit from the system’s memory to the graphic accelerator through the AGP bus.
At first, I generated 4 VBOs per shape; 1 for the vertices, 1 for the normals, 1 for the indices and finally 1 for the texture coordinates.
I noticed some performance boost over the conventional Vertex Arrays, and again I was attempted at uploading my work and move on to something else, yet I decided to hold on and attempt tweaking this demo even further.
I read on the Opengl forums that one can generate a unique VBO and use strides and offsets to differentiate texture coordinates, normals, vertices etc…;
Few hours later, I’m down to 1 VBO, but I haven’t noticed any performance boost over the version that used 4, so thinking there is nothing I can do about it anymore, I went ahead and posted it right here.
This morning when I was reading through my code again, an idea hit me; the indices buffer that I’m sending to the card every single frame is indeed slowing things down, so why not cache it too on the graphic card’s memory?
I proceeded to implement that idea and I was pleased by the 15% boost in the frame rate.
After that, I cleaned my code a bit, created a function to safely remove any OpenGL resource created and voila, I uploaded the improved demo to the server :).
Before I leave, just few things about the 3Ds max loader; there is a lot of features missing, but I’ll be working on implementing them in due time
Texture Fonts:
http://www.realityflux.com/abba/Lwjgl/GLFonts/GLFonts.jpg
Keys: Escape to exit
Here’s the font factory that generates the textures:
FontFactory.
Notice that some fonts are screwed up until you increase their sizes in the FontFactory class, for example Batang needs at least a size of 27 to look sharp.
Blinn Lighting:
http://www.realityflux.com/abba/Lwjgl/BlinnLighting/BlinnLighting.png
Mouse: A,W,S,D up, down, left and right to move camera location, mouse to look around the seen.
Keys: Escape to exit, H to display statistics, P to enter camera tracking mode, + - decrease and increase the bumping, / * modify the light range
Lighting is computed via a vertex and pixel shader program and is using the Blinn Lighting illumination algorithm which is explained in this page.
Blinn lighting albeit less intensive than Phong Lighting is known to stress and push the most powerful machines to their limits.
Still a modern Graphic accelerator like the Radeon 9700 pro sitting on my machine can push about 250 FPS at 640*480.
Requires Vertex And Fragment shaders.
Parallax Mapping:
http://www.realityflux.com/abba/Lwjgl/ParallaxMapping/ParallaxMapping.png
Mouse: A,W,S,D up, down, left and right to move camera location, mouse to look around the seen.
Keys: Escape to exit, H to display statistics, P to enter camera tracking mode, + - decrease and increase the bumping, / * modify the light range
As seen in Unreal 3 technological demo, this demo produces an effect similar to bump mapping and yet a hell lot better.
Requires Vertex And Fragment shaders.
Enjoy
