Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 2 of 2

Thread: steep parallax mapping

  1. #1
    Member Regular Contributor
    Join Date
    Jul 2005
    Location
    Germany
    Posts
    306

    steep parallax mapping

    i could finally afford a new graphics card (gf7800gt) and so i wanted to test features possible with sm3.0 like advanced parallax mapping. i downloaded the ati sdk which had a nice demo on that, but it won't run on my nv as it does not support texture2dlod.. argh!

    then i found this: http://graphics.cs.brown.edu/games/S...lax/index.html
    i tried to compile the sample fragment shader and after i fixed about a dozen syntax errors i got it running. it does not look like i expected, though. seems that my vertex shader does not provide the correct information.

    vertex:
    Code :
    varying vec2 v_Coordinates;
    varying vec3 v_ViewDirection;
    varying vec3 v_LightDirection;
     
    attribute vec3 a_Normal;
    attribute vec3 a_Tangent;
    attribute vec3 a_Bitangent;
    attribute vec2 a_Coordinates;
     
    uniform float u_LightRadius;
    uniform vec3 u_LightPosition;
    uniform vec3 u_CameraPosition;
     
    void main()
    {
    	v_Coordinates = a_Coordinates;
    	vec3 Vertex = vec3(gl_ModelViewMatrix*gl_Vertex);
     
    	vec3 ViewDirection = u_CameraPosition-Vertex;
    	vec3 LightDirection = (1.0/u_LightRadius)*(u_LightPosition-Vertex);
     
    	// compute normalized TBN matrix
    	vec3 Normal = normalize( gl_NormalMatrix*a_Normal );
    	vec3 Tangent = normalize( gl_NormalMatrix*a_Tangent );
    	vec3 Bitangent = normalize( gl_NormalMatrix*a_Bitangent );
     
    	// compute view direction
    	v_ViewDirection.x = dot( Tangent, ViewDirection );
    	v_ViewDirection.y = dot( Bitangent, ViewDirection );
    	v_ViewDirection.z = dot( Normal, ViewDirection );
     
    	// compute light direction
    	v_LightDirection.x = dot( Tangent, LightDirection.xyz );
    	v_LightDirection.y = dot(Bitangent, LightDirection.xyz );
    	v_LightDirection.z = dot( Normal, LightDirection.xyz );
     
    	gl_Position = ftransform();
    }
    fragment:
    Code :
    uniform sampler2D u_Texture0;
    uniform sampler2D  u_Texture1;
     
    float bumpScale = 0.05;
     
    varying vec3 v_LightDirection;
    varying vec3 v_ViewDirection;
     
    varying vec2 v_Coordinates;
     
    void main()
    {
    	float Height = 1.0;
    	float StepCount = 5.0;
     
    	vec2 OffsetCoordinates = v_Coordinates.xy;
    	vec4 NormalHeight = texture2D( u_Texture1, OffsetCoordinates );
     
    	StepCount = mix( StepCount*2.0, StepCount,  normalize( v_ViewDirection ).z );
     
    	float Step = 1.0 / StepCount;
    	vec2 Delta = vec2( -v_ViewDirection.x, v_ViewDirection.y ) * bumpScale / ( v_ViewDirection.z * StepCount );
     
    	while ( NormalHeight.a < Height )
    	{
    		Height -= Step;
    		OffsetCoordinates +=Delta;
    		NormalHeight = texture2D( u_Texture1, OffsetCoordinates );
    	}
     
    	Height = NormalHeight.a;
     
    	vec3 Color = texture2D( u_Texture0, OffsetCoordinates ).rgb;
     
    	vec3 LightDirection = normalize( v_LightDirection );
     
    	vec3 Normal = NormalHeight.xyz * 2.0 - 1.0;
     
    	vec3 tsH = normalize( LightDirection + normalize( v_ViewDirection ) );
     
    	float NdotL = max( 0.0, dot( Normal, LightDirection ) );
    	float NdotH = max( 0.0, dot( Normal, tsH ) );
    	float spec = NdotH * NdotH;
     
    	float Shadow = 0.0;
     
    	if ( NdotL > 0.0 )
    	{
    		float ShadowStepCount = mix( 60.0, 5.0, LightDirection.z );
     
    		Step = 1.0 / ShadowStepCount;
     
    		Delta = vec2( LightDirection.x, -LightDirection.y ) * bumpScale / ( ShadowStepCount * LightDirection.z );
     
    		Height = NormalHeight.a + Step * 0.1;
     
    		while ( ( NormalHeight.a < Height ) &amp;&amp; ( Height < 1.0 ) )
    		{
    			Height += Step;
    			OffsetCoordinates +=Delta;
    			NormalHeight = texture2D( u_Texture1, OffsetCoordinates );
    		}
     
    		Shadow = ( NormalHeight.a < Height ? 1.0 : 0.0 );
    	}
     
    	gl_FragColor.rgb =Color * NdotL * Shadow;
    }
    any ideas? thanks!

  2. #2
    Junior Member Regular Contributor Swiftless's Avatar
    Join Date
    Apr 2005
    Location
    Australia
    Posts
    118

    Re: steep parallax mapping

    I see you posted this a few months ago. Have you figured out the problem yet? If not, let me know, I managed to get Steep Parallax Mapping implemented into my programs using the same site you linked to as a reference, so I should be able to lend a hand. Also, can you explain what you mean when you say that it doesn't look as you had expected?

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •