"He is able who thinks he is able."
- Buddha
More pages: 1 ... 5 6 7 8 9 10 11 12
Framework 3 (Last updated: February 6, 2017)
Framework 2 (Last updated: October 8, 2006)
Framework (Last updated: October 8, 2006)
Libraries (Last updated: September 16, 2004)
Really old framework (Last updated: September 16, 2004)
Phong
Friday, November 8, 2002 | Permalink

Executable
Source code
Phong.zip (492 KB)

Required:
GL_ARB_fragment_program
I have implemented a slightly simplified version of the phong lighting model. The lighting equation is evaluated completely in a fragment program. Gone is normalizing cubemaps, 3d texture attenuation and vectorfields and vertex interpolated halfvectors as have been the standard for perpixel lighting on last generation hardware. However, while pushing all this work onto the fragment program gives you much better quality it does also slow things down significantly. Accessing a texture it still much faster than evaluating reciprocals and reciprocal square roots. If you wanted an app for bringing your Radeon 9700 down on it's knees, this demo is what you want , expect around 50fps in 1024x768.

Will run on Radeon 9500/9700 only at this time.

2002-11-09:
Updated to support both Blinn and Phong models. Type "blinn" or "phong" on the console to change between the different illumination models, default is Phong. Fixed a small mistake with ambient too.

Volumetric fogging
Saturday, October 26, 2002 | Permalink

Executable
Source code
VolumetricFogging.zip (1.9 MB)

Required:
GL_ARB_texture_env_combine
GL_EXT_texture3D
GL_EXT_texture_edge_clamp
GL_EXT_blend_subtract

Recommended:
GL_ARB_texture_compression
GL_EXT_texture_compression_s3tc
This is a demo showing how to render volumetric fogging, which it does in some kind of heaven and hell theme. I've based my work on the NaliLord Unreal level and another Unreal level I've designed myself. To get the right ambience I've added some suitable music made by the very talented group The sins of thy beloved who are able to seamlessly mix metal with moody violins. The full song is available from their website.
The volumetric fogging works by rendering the radial distance of the scene into destination alpha. The same is then done with the fog volume with front face culling. Then the fog volume is drawn again with back face culling and doing a reverse subtract with the destination alpha. The destination alpha will then contain the distance through the fog. With the 8 bit alpha of most todays cards it might take a little tweaking to get it to look good, but I was surprised I could even get this good results. I plan to make a better implementation once I get my Radeon 9700.
Don't mind the "lighting" in this demo, I didn't care to write a whole per pixel lighting engine for this demo, instead I've done some ugly tricks with primary color. But the lighting isn't what I've focused on in this demo and not what I wanted to show. There are some other dirty aspects of my code you might find if you decide to inspect the source.
I have added some particle systems for some fires and smoke too, which might be interesting for some. It's basically the same particle system implementation I've shown earlier.

It should run on Radeon 8500/GF3/Parhelia and up.

2002-12-15:
Changed the Bass audio library to OpenAL + libvorbis. There's now sound support for both Windows and Linux.

Dither
Wednesday, September 25, 2002 | Permalink

Executable
Source code
Dither.zip (441 KB)

Required:
GL_ATI_fragment_shader or GL_NV_register_combiners
GL_ARB_texture_env_dot3
GL_EXT_texture3D
GL_EXT_texture_edge_clamp
WGL_ARB_render_texture/GLX_ATI_render_texture
This gotta be the first implementation of 1-bit perpixel lighting. Quite cool, but pretty useless .
What I have done is to render the scene into a texture, then I do some fake dithering to create a monocrome image which will looks somewhat decent for being monocrome. Real dithering will take neighbouring pixels into account, however, that's a little too much for realtime rendering, but there are tricks you can do to fake it. Tom Nuydens at Delphi3D has done some previous work in this area. Tom uses a dither pattern he replicates over the whole framebuffer in the alpha channel, then he does a dependent texture read to solve a expression of (red + alpha > 0.5)? 1 : 0. This works, but the pattern is easy to spot as shown in the screenshot on his page.

A better way (the way I do it ) is to create a texture containing random offsets of the full size of the rendered texture. The randomness can be tweaked until it looks nice. The random values are added to the rendered values and checked for > 0.5, and either a black or white pixel is outputted. No dependent texture read neccesary.

Thanks to Basic for the idea, certainly better than my previous implementation.

Will run on Radeon 8500/GF3 and up.


Laplace
Tuesday, September 24, 2002 | Permalink

Executable
Source code
Laplace.zip (398 KB)

Required:
GL_ATI_fragment_shader
GL_EXT_texture_edge_clamp
WGL_ARB_render_texture/GLX_ATI_render_texture

Recommended:
GL_ARB_texture_compression
GL_EXT_texture_compression_s3tc
This demo renders a simple scene into a texture. Then it draws a quad over the screen with this texture and applies a Laplace filter through a fragment shader to the texture. This will extract the edges in the picture.
Will run on Radeon 8500 and up.

Shadows that don't suck
Saturday, September 21, 2002 | Permalink

Executable
Source code
shadowsthatdontsuck.zip (594 KB)

Required:
GL_ATI_fragment_shader or GL_NV_register_combiners
GL_ARB_texture_cube_map
GL_EXT_texture3D
GL_EXT_texture_edge_clamp
WGL_ARB_render_texture/GLX_ATI_render_texture

Recommended:
GL_ARB_texture_compression
GL_EXT_texture_compression_s3tc
When I was at my job interview with nVidia we spoke a little about what kind of project I'd do. As shadows are one of the hardest problems in 3d graphics and most shadowing implementations has some kind of serious drawbacks I got the suggestion to work on "shadows that don't suck" for a project. Even though I didn't get the job I decided to try finding a good shadow algorithm myself anyway. However, after being held back by a driver bug I left the project for the time being and only recently got back into the project again.
What I have done is a shadow mapping implementation that works for point lights. The idea is quite simple, instead of rendering the depth into a texture as with normal shadow mapping I render the radial distance into a cubemap. The radial distance is easy to look up in a 3d texture. A check with the stored distance and the currently calculated distance is done in a fragment shader and can easily interact with perpixel lighting. The final result is a very realistic shadow effect.
One of my better demos IMO. This is also the first demo based on my new and much improved framework.

Thanks to MZ for the help with the register combiner code.

It will run on Radeon 8500/GF3 and up.

Sea
Monday, July 15, 2002 | Permalink

Executable
Source code
Sea.zip (287 KB)

Required:
Pixel shaders 1.4
This is a cool little screensaver.

Shadowed particles
Wednesday, May 22, 2002 | Permalink

Executable
Source code
ShadowedParticles.zip (437 KB)

Required:
GL_ARB_texture_env_dot3
GL_ARB_texture_env_crossbar or GL_NV_texture_env_combine4
GL_EXT_blend_subtract
GL_EXT_texture3D
GL_EXT_texture_edge_clamp

Recommended:
GL_ARB_texture_compression
GL_EXT_texture_compression_s3tc
This demo shows a particle system creating a smoke effect. This smoke is lit by a partly shadowed spotlight with the smoke aswell as the ground being clearly shadowed accordingly. The shadow from the smoke is also projected to the ground (which is bumpmapped btw). One of my best demos IMHO.

It should run on Radeon 8500, Parhelia and GF3/4.
Source is included as usual.

Perpixel spotlights
Monday, May 13, 2002 | Permalink

Executable
Source code
Spotlights.zip (625 KB)

Required:
GL_ARB_texture_env_dot3
GL_ARB_texture_env_crossbar or GL_NV_texture_env_combine4
GL_EXT_texture3D
GL_EXT_texture_edge_clamp

Recommended:
GL_ARB_texture_compression
GL_EXT_texture_compression_s3tc
This is a demo of perpixel shotlights. Two flashlights are flying around lighting the bumpy walls. Looks pretty cool
The effect requires four texture units, a bumpmap, vectorfield, spotlight texture, and a small 2 texel texture to remove the backprojection. (With fragment shaders the last texture shouldn't be neccesary)

It should run on Radeon 8500, Parhelia and GF3/4.
Source is included as usual.

More pages: 1 ... 5 6 7 8 9 10 11 12