A mipmap is a collection of images with different resolutions. A mipmap is arranged in a chain where each image is half the size of the previous one. Each resolution is a level of detail or LOD. The first level (LOD 0) is the biggest image while the last level is the smallest image.

Mipmapping is a widely used technique in 3D programming and game development. Almost all games use mipmaping. When the camera is near a textured object, the level 0 of the mipmap is used. And when the camera moves away from the object, a smaller resolution is used (smaller resolution = higher level).

Debugging a mipmap chain can be made easier with the use of a debug DDS texture. This DDS texture (provided in the GeeXLab demo below) is made of 7 mipmap levels: level 0: red, level 1: green, level 2: blue, level 3: yellow, level 4: pink, level 5: black and level 6: white.

The simple GeeXLab demo I coded for this article uses a GLSL shader to render a textured plane.

The GLSL shader is very simple:

[Vertex_Shader]
void main(void)
{
  gl_Position = ftransform();
  gl_TexCoord[0] = gl_MultiTexCoord0;
}
[Pixel_Shader]
uniform sampler2D colorMap;
uniform float lod;
void main (void)
{
  vec4 base = texture2DLod(colorMap, gl_TexCoord[0].st, lod);
  //vec4 base = texture2D(colorMap, gl_TexCoord[0].st);
  gl_FragColor = base;
}

The texture2DLod GLSL function makes it possible to fetch the texels of a particular mipmap level. You can select the level (lod) with the tweak bar:

And when you replace texture2DLod by texture2D in the fragment shader, you can see how OpenGL does the transition between two levels when you move the camera away the plane:

And depending on the point of view, you can see all mipmap levels in the same time:

You can download the GeeXLab demo here

You need the latest version of GeeXLab to play with the demo. You can download GeeXLab HERE.

Just drop the mipmap_debug.xml into GeeXLab and you’re ready.

For this demo, I used Lua as scripting language so if you don’t have Python or don’t want to install it, just download the version of GeeXLab without Python.

Some links about mipmapping:

• Texture filtering: mipmaps
• Texture Filtering with Mipmaps (Direct3D 9)
• Mipmap @ wikipedia

Related posts:

1. [Shader Library] Bump Mapping Shader with Multiple Lights (GLSL)
2. [Shader Library] Dream Vision Post Processing Filter (GLSL)
3. [Shader Library] 2D Shockwave Post Processing Filter (GLSL)

This short article brings some details to the first articles published yesterday about hardware tessellation on Radeon graphics cards:

• [TEST] Hardware Tessellation on Radeon in OpenGL (Part 1/2) – Theory
• [TEST] Hardware Tessellation on Radeon in OpenGL (Part 2/2) – Practice

AMD just provided me some clarification about the hardware tessellation on Radeon.

The main question in both first articles was about the max value of the tessellation factor.

On Radeon HD 2000, 3000 and 4000, the hardware tessellation unit (called tessellator) has a max tessellation factor of 15.0. This is a hardware limitation that can’t be changed by software tweaks. The tessellator of Radeon HD 2000, 3000 and 4000 is a fixed function unit and we can’t program it with a shader. In OpenGL there are only two functions (described HERE) that allow to control it.

On Radeon HD 5000 series (Evergreen family), things are different. The Radeon HD 5000 includes the fixed tessellator of HD 2000, 3000 and 4000 AND a new programmable tessellation unit. This new programmable tessellation unit will be exposed via a new OpenGL extension (available shortly). And this new extension will allow to exploit the maximum tessellation factor supported on HD 5000 graphics cards: 64.0. And this value of 64.0 is forced by Direct3D 11 specification. So we’ll be able to do Direct3D11-like tessellation in OpenGL shortly under all versions of Windows. Great news my friends

On Evergreen family, both tessellation engines (fixed and programmable) are physically separated.

That’s why in the GeeXLab demo I was limited to 15.0 on my HD 5770. Currently GeeXLab uses the fixed tessellator (with a factor limited to 15.0) and not the new tessellator (with a factor of 64.0).

I can’t wait to test the new tessellator in OpenGL and add this support in GeeXLab.

And good news, the support of the fixed tessellation unit will be kept in all new Radeon and Catalyst.

Thanks to AMD for this clarification

References:

• AMD Publishes 6 New Direct3D 10 and 11 Demos: Quick Test and New Details About Tessellation
• Tessellation Overview @ Microsoft DX11

Related posts:

1. [TEST] Hardware Tessellation on Radeon in OpenGL (Part 1/2)
2. AMD Publishes 6 New Direct3D 10 and 11 Demos: Quick Test and New Details About Tessellation
3. [TEST] Hardware Tessellation on Radeon in OpenGL (Part 2/2)

We can find on Crytek’s website an updated version of the famous Sponza model used in many global illumination tests like this one:

The model is available in OBJ and 3ds Max formats and all texture maps are provided.

You can download the Sponza model HERE.

Just for fun, I quickly tested the OBJ format in GeeXLab with basic texturing and no lighting. I cleaned a little bit the material file to make relative the path to textures and also removed the Tr coefficient (transparency for GeeXLab).

When I’ll find a little time, I’ll try to improve the rendering by using the normal maps and other ambient maps (all available in the download).

According to GeeXLab, the OBJ version of Sponza model has 279,163 triangular faces.

[via]

Related posts:

1. 3DS MAX Tutorial: Making of Italian Creek
2. PhysX Tool: Convert Physics Scenes into an OBJ file with PhysX2Obj
3. Global Illumination in CryEngine 3 Tech Trailer

This article is the second part of Hardware Tessellation on Radeon in OpenGL. The first part can be found HERE.

Tessellation on Radeon – Practice

I added the functionalities brought by GL_AMD_vertex_shader_tessellator in GeeXLab (in version 0.1.15) and coded a small demo that uses the shader given in the extension specification.

You can download the demo here

Just drop the demo in GeeXLab 0.1.15+. That’s all.

The demo is rather simple: a mesh plane is rendered (with VBO) in wireframe in order to see the impact of tessellation.

Here is the code of the shader used to render the mesh plane

[Vertex_Shader]
#extension GL_AMD_vertex_shader_tessellator : require
varying vec4 color;
__samplerVertexAMD VertexPosition; // 0
__samplerVertexAMD VertexColor; // 1
void main()
{
  vec4 gVertex = vec4(0.0);
  vec4 gColor = vec4(0.0);
  for (int i=0; i<3; i++)
  {
    float weight = gl_BarycentricCoord[i];
    gVertex += weight *
         vertexFetchAMD(VertexPosition, gl_VertexTriangleIndex[i]);

    gColor += weight *
         vertexFetchAMD(VertexColor, gl_VertexTriangleIndex[i]);
  }
  gl_Vertex = gVertex;
  color = gColor;
  gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}
[Pixel_Shader]
varying vec4 color;
void main (void)
{
  //gl_FragColor = color;
  gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}

This code works fine except the fetching of vertex color. Only the vertex position can be fetched. Color or normal fetching always returns the vector vec4(0.0, 0.0, 0.0, 0.0). A bug in GeeXLab? Maybe but after after many tests, I decided to download AMD's Catmull Clark Subdivision demo. It's an OpenGL demo that uses the tessellator. And same result: the color attribute can't be fetched.

So currently with Catalyst 10.1 only the vertex position can be fetched.

I tested the demo on a Radeon HD 5770. The Radeon HD 5770 is a DX11 card and I thought: cool I can increase the tessellation factor up to 64.0. Result: the max factor is 15.0.

Conclusion: the tessellation amplication factor depends on the API used even if you have a DX11 hardware. For DX9, DX10 and OpenGL 2, the tessellation factor
is limited to 15.0. In Direct3D 11 the factor can be increased up to 64.0. And in OpenGL 3.0 ? I don't know yet. I have to code a small demo in GPU Caps Viewer for that. But I'll do it when all vertex attributes can be fetched.

The previous conclusion is valid at the time of the article writing. Maybe in a next release of Catalyst, AMD will allow a X64-tessellation factor for Radeon HD 5000 series.

Here are some screenshots forvarious tessellation factors:

Discrete tessellation mode

Continuous tessellation mode

These examples show us one limitation: to get a highly tessellated mesh, the coarse mesh (also called control cage or superprimitive mesh) must have enough polygons to generate the desired high-resolution mesh.

As soon as the fetching of all vertex attributes is okay, I'll code a displacement mapping demo with real time tessellation....

Related posts:

1. [TEST] Hardware Tessellation on Radeon in OpenGL: Radeon HD 5000 Tessellators Details
2. [TEST] Hardware Tessellation on Radeon in OpenGL (Part 1/2)
3. AMD Publishes 6 New Direct3D 10 and 11 Demos: Quick Test and New Details About Tessellation

The Python version of GeeXLab has been compiled with the latest Python 2.6.4.

And stay tuned, new versions of GeeXLab are planned shortly with PhysX update, OpenCTM support and other cool things…

As usual, GeeXLab is available in two versions: one with Python and Lua and the other with Lua only.

DOWNLOAD: GeeXLab 0.1.15 full (Python + Lua)




DOWNLOAD: GeeXLab 0.1.15 no Python

Changelog:

• New: added AMDSetTessellationFactor() and AMDSetTessellationMode() to HYP_Renderer lib (Lua / Python).
• New: added GetFaceMaterialIndex() and GetFaceMaterialId() to HYP_Mesh (Python / Lua).
• New: added Translate() to Python version of HYP_Object.
• New: added export_pack_source_code attribute in script node to force the export of script source code to binary scene. By default if a script is not embedded in XML, the script file is not packed in binary scene file.
• Change: updated with Python 2.6.4
• Bugfix: in HYP_Utils.SetDrawVertexNormalLengthFactor() in Python. Length was processed by an integer leading to very large factors.
• Bugfix: in the W4K loader when there were several materials per mesh.

Related posts:

1. GeeXLab 0.1.14 Available
2. GeeXLab 0.1.13 Available
3. GeeXLab 0.1.12 Available

The night vision post processing effect I developed for GeeXLab has been ported to Blender Game Engine by a Blender user called Letun. I tested Letun’s work on Blender 2.49a and the demo works fine.

Remark: For the sake of speed rendering, the night vision effect is not used as a post processing filter over the final image. Rather, the shader is executed on a per-object basis (see the variable ShaderObjects).

You can find more details HERE.

If you don’t have an account on blenderartists.org’s forums, you can grab the blend file right here:

Related posts:

1. [Shader Library] Night Vision Post Processing Filter (GLSL)
2. [Shader Library] Dream Vision Post Processing Filter (GLSL)
3. [Shader Library] Posterization Post Processing Effect (GLSL)

With NVIDIA’s display drivers R195.xx like the latest R195.62 WHQL, just open the NVIDIA Control Panel and you’ll find in the 3D Settings menu bar item, the PhysX Visual Indicator ON/OFF.

If the application uses PhysX GPU, you will see PhysX > GPU otherwise you’ll see PhysX > CPU like in the GeeXLab simple PhysX demo:

Related posts:

1. PhysX Visual Debugger 1.1.8 Available
2. [TIPS] Mipmap Levels Debugging with a DDS Debug Texture
3. NVIDIA Application Acceleration Engines: OptiX, SceniX, CompleX and PhysX 64

This new shader shows a 2D shockwave post processing effect. In the GeeXLab demo, just hit the [K] key to create a shockwave at the mouse position. I found the original shader here.

You can download the demo here:

This demo requires GeeXLab and does not use Python so you can use the version of GeeXLab without Python. This demo has been tested with GeeXLab 0.1.14.

Unzip the source code somewhere, start GeeXLab and drop the 2D_Shockwave_Demo.xml file in GeeXLab.

Here is a video of the effect in action (the 2d grid has been added to better visualize the shockwave effect):

Shader desription

Language: OpenGL 2 – GLSL

Type: Post processing filter.

Inputs

• sceneTex (sampler2D): the final scene image.
• center (vec2): mouse position (in texture coord space: [0 ; 1]).
• time (float): shockwave elapsed time in second.
• shockParams (vec3): shockwave parameters

Ouputs: color buffer

[Vertex_Shader]
void main(void)
{
  gl_Position = ftransform();
  gl_TexCoord[0] = gl_MultiTexCoord0;
}

[Pixel_Shader]
uniform sampler2D sceneTex; // 0
uniform vec2 center; // Mouse position
uniform float time; // effect elapsed time
uniform vec3 shockParams; // 10.0, 0.8, 0.1
void main()
{
  vec2 uv = gl_TexCoord[0].xy;
  vec2 texCoord = uv;
  float distance = distance(uv, center);
  if ( (distance <= (time + shockParams.z)) &&
       (distance >= (time - shockParams.z)) )
  {
    float diff = (distance - time);
    float powDiff = 1.0 - pow(abs(diff*shockParams.x),
                                shockParams.y);
    float diffTime = diff  * powDiff;
    vec2 diffUV = normalize(uv - center);
    texCoord = uv + (diffUV * diffTime);
  }
  gl_FragColor = texture2D(sceneTex, texCoord);
}

Related posts:

1. [Shader Library] Dream Vision Post Processing Filter (GLSL)
2. [Shader Library] Lens Circle Post Processing Effect (GLSL)
3. [Shader Library] Night Vision Post Processing Filter (GLSL)

A video is available here.

You can download this demo / game here:

The code source is included and the main source code file is YIQING_GXL.xml. Scripting is done with Lua and PhysX is used for the fall of the two sticks.

Related posts:

1. [GeeXLab] YI King Video Game Preview
2. GeeXLab 0.1.13 Available
3. GeeXLab 0.1.15 Available

As usual, GeeXLab is available in two versions: one with Python and Lua and the other with Lua only.

DOWNLOAD: GeeXLab 0.1.14 full (Python + Lua)

DOWNLOAD: GeeXLab 0.1.14 NO PYTHON

ChangeLog:

• New: added float_depth_buffer attribute to shadow_mapping element of scene node.
  Setting this attribute to TRUE allows to use a 32-bit floating point depth buffer for shadow mapping.
• Change: modified fullscreen management (now available in the free version).
• Change: update Freeimage and OpenAL plugins with latest versions of respective libraries.

I take advantage of this post to show the WIP of a space shooter:

Related posts:

1. GeeXLab 0.1.15 Available
2. GeeXLab 0.1.13 Available
3. GeeXLab 0.1.11 Available

Related posts:

1. GeeXLab 0.1.15 Available
2. GeeXLab 0.1.12 Available
3. GeeXLab 0.1.11 Available

You can grab the GLSL shader and the demo here:

This demo requires GeeXLab and does not use Python so you can use the version of GeeXLab without Python.

Unzip the source code somewhere, start GeeXLab and drop the file Dream_Vision_Demo.xml in GeeXLab.

Shader desription

Language: OpenGL 2 – GLSL

Type: Post processing filter.

Inputs

• sceneTex (sampler2D): the final scene image.

Ouputs: color buffer

Shader code:

[Vertex_Shader]
void main()
{
  gl_Position = ftransform();
  gl_TexCoord[0] = gl_MultiTexCoord0;
}
[Pixel_Shader]
uniform sampler2D sceneTex; // 0
void main ()
{
  vec2 uv = gl_TexCoord[0].xy;
  vec4 c = texture2D(sceneTex, uv);

  c += texture2D(sceneTex, uv+0.001);
  c += texture2D(sceneTex, uv+0.003);
  c += texture2D(sceneTex, uv+0.005);
  c += texture2D(sceneTex, uv+0.007);
  c += texture2D(sceneTex, uv+0.009);
  c += texture2D(sceneTex, uv+0.011);

  c += texture2D(sceneTex, uv-0.001);
  c += texture2D(sceneTex, uv-0.003);
  c += texture2D(sceneTex, uv-0.005);
  c += texture2D(sceneTex, uv-0.007);
  c += texture2D(sceneTex, uv-0.009);
  c += texture2D(sceneTex, uv-0.011);

  c.rgb = vec3((c.r+c.g+c.b)/3.0);
  c = c / 9.5;
  gl_FragColor = c;
}

Related posts:

1. [Shader Library] Night Vision Post Processing Filter (GLSL)
2. [Shader Library] 2D Shockwave Post Processing Filter (GLSL)
3. [Shader Library] Lens Circle Post Processing Effect (GLSL)

I just tried this new version with GeeXLab. You can’t debug the first PhysX based app you have with PVD. The application must have an instruction to connect itself to PVD. GeeXLab offers such a functionality. I took the PhysX revolute joints demo and I added the HYP_PhysX.ConnectToVisualPhysXDebugger() instruction in the init script. Then I launched PVD, started GeeXLab, dropped the demo in GeeXLab and I was able to visualize and step inside the PhysX demo in PVD

[via]

Related posts:

1. [TIPS] How To Know If a PhysX Application Uses PhysX GPU
2. GeeXLab 0.1.15 Available
3. NVIDIA GeForce PhysX Performances Tests

I coded a small demo with a textured ground, a textured torus, a light and, of course, the shadow mapping enabled. You can download the demo here:

As usual to run the demo you need the latest version of GeeXLab, and for this demo it’s the version 0.1.13. If you don’t have Python, just download GeeXLab NO PYTHON.

Unzip the demo anywhere and drop ShadowMappingTest.xml in GeeXLab.

I did two kind of tests: the first one with the light near (x=0.0 y=150.0 z=50.0) the torus and the second one with the light further (x=0.0 y=500.0 z=200.0). The light position does not impact the FPS but impacts the visual aspect of the shadow due to depth map resolution.

In the first test, the depth map size varies from 128×128 to the possible max size with a 16-bit resolution (OpenGL format = GL_DEPTH_COMPONENT16). When the light is near the object, a 16-bit depth map is enough. In the second test, the light is far from the object and a 32-bit depth map (OpenGL format = GL_DEPTH_COMPONENT32) is required. The filtering type (LINEAR or NONE) of the depth map does not change the FPS. I did the test with no filtering in order to visualize the depth map precision.

Linear depth map look up is actually the PCF (Percentage Closer Filtering) algorithm with 4 samples (equivalent to 4 texture fetches). GeForce and Radeon cards have a built-in PCF depth map look-up and this look-up is free. Linear depth map look up is called fetch4 on Radeon. I’ll discuss about depth map filtering in another post.

Here are the results of this first test :

- Demo settings: 800×600 windowed, no AA.

16-bit depth-map

• 128×128: 830 FPS
• 256×256: 830 FPS
• 512×512: 830 FPS
• 1024×1024: 830 FPS – depth map size: 2MB
• 2048×2048: 830 FPS – depth map size: 8MB
• 4096×4096: 830 FPS – depth map size: 32MB
• 8192×8192: 300 FPS – depth map size: 128MB
• 10000×10000: 260 FPS – depth map size: 190MB
• 12000×12000: 270 FPS – depth map size: 274MB
• 14000×14000: 350 FPS – depth map size: 373MB
• 15350×15350: 380 FPS – depth map size: 449MB

In this first test, 15350×15350 seems to be the max size of the depth map. Up to 4k, the FPS is constant (830) and drops to 300 for a 8k depth map. Oddly for larger depth map the FPS goes up again. The Radeon HD 5770 supports NPOT (non power of two) textures that’s why we end up with a size like 15350.

Let’s see the results of the second test:

- Demo settings: 800×600 windowed, no AA.

32-bit depth-map

• 512×512: 820 FPS
• 1024×1024: 820 FPS – depth map size: 4MB
• 2048×2048: 820 FPS – depth map size: 16MB
• 4096×4096: 690 FPS – depth map size: 24MB
• 8192×8192: 230 FPS – depth map size: 256MB
• 14015×14015: 220 FPS – depth map size: 749MB

Ouch! 749MB for the largest depth map. With 1GB of graphics memory, such a depth map is useless (except in this test ). As for 16-bit depth map, there is a FPS collapse with 8k+ depth map (maybe a 2GB video card could improve a bit the situation…).

Here are the screenshots with the light close to the torus (16-bit depth map):

Now the screenshots with the light far from the torus (32-bit shadow map):

As you see, high resolution depth maps are graphics memory ogres and FPS killers that ’s why usually low resolution depth maps are used in games. Low resolution depth maps combined with some algorithms like cascaded shadow maps (CSM) make it possible to shadow large areas where light is far from objects.

Related posts:

1. [GeeXLab] How to Visualize the Depth Buffer in GLSL
2. Real-time Shadow Algorithms and Techniques Collection
3. GeeXLab 0.1.14 Available

Image posterization is the tranformation of an image with a continuous gradation of tone to several regions of fewer tones, with abrupt changes from one tone to another. The left part of the image shows the posterization effect while the right part shows the normal image.

You can download the demo source code here:

To see the shader in real time, you need GeeXLab 0.1.13. This demo does not use Python so you can use the version of GeeXLab without Python.

Unzip the source code somewhere, start GeeXLab and drop the file Posterize_Effect_Demo.xml in GeeXLab.

Some results:

• AMD X2 3800+ / Radeon HD 5770 (Cat9.11 beta) / WinXP SP2: 710 FPS (640×480) and 690 FPS (1920×1080)

Shader desription (for NVIDIA and ATI)

Language: OpenGL 2 – GLSL

Type: Post processing filter

Inputs:

• sceneBuffer (sampler2D): the scene buffer.
• numColors (float): number of tone regions. Default=8.0
• gamma (float): gamma factor. Default=0.6

Ouputs: color buffer

Shader code:

[Vertex_Shader]
void main(void)
{
  gl_Position = ftransform();
  gl_TexCoord[0] = gl_MultiTexCoord0;
}
[Pixel_Shader]
uniform sampler2D sceneTex; // 0
uniform float gamma; // 0.6
uniform float numColors; // 8.0
void main()
{
  vec3 c = texture2D(sceneTex, gl_TexCoord[0].xy).rgb;
  c = pow(c, vec3(gamma, gamma, gamma));
  c = c * numColors;
  c = floor(c);
  c = c / numColors;
  c = pow(c, vec3(1.0/gamma));
  gl_FragColor = vec4(c, 1.0);
}

References

• Posterization @ wikipedia

Related posts:

1. [Shader Library] Lens Circle Post Processing Effect (GLSL)
2. [Shader Library] Night Vision Post Processing Filter (GLSL)
3. [Shader Library] 2D Shockwave Post Processing Filter (GLSL)

The code samples have been updated.

DOWNLOAD: GeeXLab 0.1.13 full

DOWNLOAD: GeeXLab 0.1.13 NO PYTHON

ChangeLog

• New: added depth_bits attribute to shadow_mapping element of scene node.
• New: added in config file the possibility to initialize the number of bits for color, depth and stencil buffers.
• Change: VSYNC is OFF by default.
• Bugfix: fixed a crash in anti-aliasing on Radeon when MSAA was greater than max MSAA supported.
• Bugfix: in the Python version of HYP_Utils::OpenUrl().

Related links

• GeeXLab: Laboratory for Real Time 3D Learning and Experiments
• YI King Video Game Preview

Related posts:

1. GeeXLab 0.1.15 Available
2. GeeXLab 0.1.11 Available
3. GeeXLab 0.1.12 Available

This game a is simplified YI King simulation scripted in Lua and uses PhysX for… physics! The Yi King is an ancient Chinese system of divination. Throw two sticks and interpret the result to discover your future!

Related posts:

1. [GeeXLab] Discover your Future with YI QING
2. Mirror’s Edge: Upcoming Video Game With PhysX Effects
3. Underwater Wars: a Video Game with DirectX 10 and PhysX

This simple shader adds a lens circle effect to the final scene image. The core of this effect is the smoothstep() function:

smoothstep(outer, inner, dist);

How this function works? If dist is greater than outer, smoothstep returns 0. If dist is lesser than inner, smoothstep returns 1. Between outer and inner, smoothstep returns an interpolated value between 0.0 and 1.0.

You can download the demo source code here:

To see the shader in real time, you need GeeXLab 0.1.12 and Python 2.6.3.

Unzip the source code somewhere, start GeeXLab and drop the file Lens_Circle_Effect_Demo.xml in GeeXLab.

Some results:

• Core 2 Duo E8400 / Radeon HD 5770 (Cat9.10 beta) / WinXP SP2: 830 FPS (640×480) and 750 FPS (1920×1200)
• AMD X2 3800+ / GeForce GTS 250 (fw191.07) / WinXP SP2: 644 FPS (640×480) and 620 FPS (1920×1080)

Shader desription (for NVIDIA and ATI)

Language: OpenGL 2 – GLSL

Type: Post processing filter

Inputs:

• sceneBuffer (sampler2D): the scene buffer.
• lensRadius (vec2): outer (default=0.45) and inner (default=0.38) radius.

Ouputs: color buffer

Shader code:

[Vertex_Shader]
void main(void)
{
  gl_Position = ftransform();
  gl_TexCoord[0] = gl_MultiTexCoord0;
}
[Pixel_Shader]
uniform sampler2D sceneTex; // 0
uniform vec2 lensRadius; // 0.45, 0.38
void main()
{
  vec4 Color = texture2D(sceneTex, gl_TexCoord[0].xy);
  float dist = distance(gl_TexCoord[0].xy, vec2(0.5,0.5));
  Color.rgb *= smoothstep(lensRadius.x, lensRadius.y, dist);
  gl_FragColor = Color;
}

Related posts:

1. [Shader Library] Posterization Post Processing Effect (GLSL)
2. [Shader Library] 2D Shockwave Post Processing Filter (GLSL)
3. [Shader Library] Dream Vision Post Processing Filter (GLSL)

This is a bump mapping shader (Phong lighting) based on this tutorial.
This shader supports several lights (up to 8).

You can download a GeeXLab demo to see the shader in real time:

Unzip the archive somewhere and launch the demo with Start_Demo_ATI_NVIDIA.bat.

Some results:

• Core 2 Duo E8400 / GeForce GTS 250 (Fw191.07) / WinXP SP2: 2050FPS (800×600) and 650 FPS (1920×1200)
• AMD X2 3800+ / Radeon HD 4850 (Cat9.9) / WinXP SP2: 2480FPS (800×600) and 1150 FPS (1920×1080)

Shader desription (for NVIDIA and ATI)

Language: OpenGL 2 – GLSL

Type: Lighting

Inputs:

• glTangent4f (vec4): tangent space vector per vertex. glTangent4f is a vertex attribute and is provided by GeeXLab 3D engine.
• colorMap (sampler2D): color texture on texture unit 0
• normalMap (sampler2D): normal texture on texture unit 1

Ouputs: color buffer

Shader code:

[Vertex_Shader]
#define MAX_LIGHTS 8
#define NUM_LIGHTS 3
varying vec3 lightVec[MAX_LIGHTS];
varying vec3 viewVec;
attribute vec4 glTangent4f;
void main(void)
{
  gl_Position = ftransform();
  gl_TexCoord[0] = gl_MultiTexCoord0;

  vec3 n = normalize(gl_NormalMatrix * gl_Normal);
  vec3 t = normalize(gl_NormalMatrix * glTangent4f.xyz);
  vec3 b = cross(n, t);

  vec3 v;
  vec3 vVertex = vec3(gl_ModelViewMatrix * gl_Vertex);
  int i;
  for (i=0; i<NUM_LIGHTS; ++i)
  {
    vec3 lVec = gl_LightSource[i].position.xyz - vVertex;
    v.x = dot(lVec, t);
    v.y = dot(lVec, b);
    v.z = dot(lVec, n);
    lightVec[i] = v;
  }

  vec3 vVec = -vVertex;
  v.x = dot(vVec, t);
  v.y = dot(vVec, b);
  v.z = dot(vVec, n);
  viewVec = v;
}

[Pixel_Shader]
#define MAX_LIGHTS 8
#define NUM_LIGHTS 3
varying vec3 lightVec[MAX_LIGHTS];
varying vec3 viewVec;
uniform sampler2D colorMap;
uniform sampler2D normalMap;
void main (void)
{
  vec2 uv = gl_TexCoord[0].st * 4.0;
  vec4 base = texture2D(colorMap, uv);
  vec4 final_color = vec4(0.2, 0.2, 0.2, 1.0) * base;
  vec3 vVec = normalize(viewVec);
  vec3 bump =
     normalize(texture2D(normalMap, uv).xyz * 2.0 - 1.0);
  vec3 R = reflect(-vVec, bump);
  int i;
  for (i=0; i<NUM_LIGHTS; ++i)
  {
    vec3 lVec = normalize(lightVec[i]);
    float diffuse = max(dot(lVec, bump), 0.0);
    vec4 vDiffuse =
       gl_FrontLightProduct[i].diffuse *
       diffuse * base;
    final_color += vDiffuse;

    float specular =
      pow(clamp(dot(R, lVec), 0.0, 1.0),
            gl_FrontMaterial.shininess);
    vec4 vSpecular =
      gl_FrontLightProduct[i].specular *
      specular * diffuse;
    final_color += vSpecular;
  }

  gl_FragColor = final_color;
}

Related posts:

1. [Shader Library] Phong Shader with Multiple Lights (GLSL)
2. [Shader Library] Night Vision Post Processing Filter (GLSL)
3. [Shader Library] Posterization Post Processing Effect (GLSL)

This is a lighting shader based on my old Phong model tutorial. This shader supports several lights (up to 8). There are two versions of the shader: the first one that works on both NVIDIA and ATI boards. The second one, more flexible, accepts the number of lights as an uniform variable. This uniform variable is used in a for() loop (in both vertex and pixel shaders). Currently, only NVIDIA GeForce and ATI Radeon HD 5000 support this construction. A bug in Catalyst prevents previous generation of Radeon (HD 4k, 3k, 2k) from executing the second shader.

You can download a GeeXLab demo to see the shader in real time:

Unzip the archive somewhere. You can start the ATI/NVIDIA demo with Start_Demo_ATI_NVIDIA.bat and the NVIDIA and ATI HD 5000 demo with Start_Demo_NVIDIA_only.bat.

Some results:

• Core 2 Duo E8400 / GeForce GTS 250 (Fw191.07) / WinXP SP2: 2800 FPS (800×600) and 800 FPS (1920×1200)
• AMD X2 3800+ / Radeon HD 4850 (Cat9.9) / WinXP SP2: 2850 FPS (800×600) and 1350 FPS (1920×1080)

First Shader desription (for NVIDIA and ATI)

Language: OpenGL 2 – GLSL

Type: Lighting

Inputs: none (the number of lights is hard coded: see NUM_LIGHTS define).

Ouputs: color buffer

Shader code:

[Vertex_Shader]
varying vec3 normal, eyeVec;
#define MAX_LIGHTS 8
#define NUM_LIGHTS 3
varying vec3 lightDir[MAX_LIGHTS];
void main()
{
  gl_Position = ftransform();
  normal = gl_NormalMatrix * gl_Normal;
  vec4 vVertex = gl_ModelViewMatrix * gl_Vertex;
  eyeVec = -vVertex.xyz;
  int i;
  for (i=0; i<NUM_LIGHTS; ++i)
    lightDir[i] =
      vec3(gl_LightSource[i].position.xyz - vVertex.xyz);
}
[Pixel_Shader]
varying vec3 normal, eyeVec;
#define MAX_LIGHTS 8
#define NUM_LIGHTS 3
varying vec3 lightDir[MAX_LIGHTS];
void main (void)
{
  vec4 final_color =
       gl_FrontLightModelProduct.sceneColor;
  vec3 N = normalize(normal);
  int i;
  for (i=0; i<NUM_LIGHTS; ++i)
  {
    vec3 L = normalize(lightDir[i]);
    float lambertTerm = dot(N,L);
    if (lambertTerm > 0.0)
    {
      final_color +=
        gl_LightSource[i].diffuse *
        gl_FrontMaterial.diffuse *
        lambertTerm;
      vec3 E = normalize(eyeVec);
      vec3 R = reflect(-L, N);
      float specular = pow(max(dot(R, E), 0.0),
                           gl_FrontMaterial.shininess);
      final_color +=
        gl_LightSource[i].specular *
        gl_FrontMaterial.specular *
        specular;
    }
  }
  gl_FragColor = final_color;
}

Second Shader desription (for NVIDIA and ATI Radeon HD 5000 only)

Language: OpenGL 2 – GLSL

Type: Lighting

Inputs

• numLights (int): number of lights. Max = 8.

Ouputs: color buffer

Shader code:

[Vertex_Shader]
varying vec3 normal, eyeVec;
#define MAX_LIGHTS 8
varying vec3 lightDir[MAX_LIGHTS];
uniform int numLights;
void main()
{
  gl_Position = ftransform();
  normal = gl_NormalMatrix * gl_Normal;
  vec4 vVertex = gl_ModelViewMatrix * gl_Vertex;
  eyeVec = -vVertex.xyz;
  int i;
  for (i=0; i<numLights; ++i)
    lightDir[i] =
      vec3(gl_LightSource[i].position.xyz - vVertex.xyz);
}
[Pixel_Shader]
varying vec3 normal, eyeVec;
#define MAX_LIGHTS 8
varying vec3 lightDir[MAX_LIGHTS];
uniform int numLights;
void main (void)
{
  vec4 final_color =
       gl_FrontLightModelProduct.sceneColor;
  vec3 N = normalize(normal);
  int i;
  for (i=0; i<numLights; ++i)
  {
    vec3 L = normalize(lightDir[i]);
    float lambertTerm = dot(N,L);
    if (lambertTerm > 0.0)
    {
      final_color +=
        gl_LightSource[i].diffuse *
        gl_FrontMaterial.diffuse *
        lambertTerm;
      vec3 E = normalize(eyeVec);
      vec3 R = reflect(-L, N);
      float specular = pow(max(dot(R, E), 0.0),
                           gl_FrontMaterial.shininess);
      final_color +=
        gl_LightSource[i].specular *
        gl_FrontMaterial.specular *
        specular;
    }
  }
  gl_FragColor = final_color;
}

And for lazy people, the one light shader (works both on ATI and NVIDIA):

Shader code:

[Vertex_Shader]
varying vec3 normal, eyeVec, lightDir;
void main()
{
  gl_Position = ftransform();
  normal = gl_NormalMatrix * gl_Normal;
  vec4 vVertex = gl_ModelViewMatrix * gl_Vertex;
  eyeVec = -vVertex.xyz;
  lightDir =
      vec3(gl_LightSource[0].position.xyz - vVertex.xyz);
}
[Pixel_Shader]
varying vec3 normal, eyeVec, lightDir;
void main (void)
{
  vec4 final_color =
       gl_FrontLightModelProduct.sceneColor;
  vec3 N = normalize(normal);
  vec3 L = normalize(lightDir[0]);
  float lambertTerm = dot(N,L);
  if (lambertTerm > 0.0)
  {
    final_color +=
      gl_LightSource[0].diffuse *
      gl_FrontMaterial.diffuse *
      lambertTerm;
    vec3 E = normalize(eyeVec);
    vec3 R = reflect(-L, N);
    float specular = pow(max(dot(R, E), 0.0),
                         gl_FrontMaterial.shininess);
    final_color +=
      gl_LightSource[0].specular *
      gl_FrontMaterial.specular *
      specular;
  }
  gl_FragColor = final_color;
}

Related posts:

1. [Shader Library] Bump Mapping Shader with Multiple Lights (GLSL)
2. [Shader Library] Posterization Post Processing Effect (GLSL)
3. [Shader Library] 2D Shockwave Post Processing Filter (GLSL)