XNA for C#
DirectX 9 for C#
DirectX 9 for C++
DirectX 9 for VB
Forum
   
My XNA Book
      
       Go to section on this site

Additional info


Latest Forum posts

 Account settings
  Posted by: Anonymous
  When: 07/05/2014 at 09:48:39

 forced subtitle
  Posted by: Applefly
  When: 07/05/2014 at 06:00:48

 convert DVD into PMS
  Posted by: Applefly
  When: 07/05/2014 at 05:55:25

 DVD to Digital Copy easily
  Posted by: VIKIVannessa
  When: 05/05/2014 at 06:52:29

 DVD on Xbox 360/Xbox One Console
  Posted by: VIKIVannessa
  When: 05/05/2014 at 06:51:47

 Extract .Srt Subtitles
  Posted by: Applefly
  When: 04/05/2014 at 03:54:38

 Encode Movie collection
  Posted by: Applefly
  When: 04/05/2014 at 03:52:41

 Convert DVD to WMV
  Posted by: Applefly
  When: 29/04/2014 at 05:53:50

 rip DVDs into digital files
  Posted by: Applefly
  When: 29/04/2014 at 05:51:20

 iTunes movies/music to Kindle Fire
  Posted by: ciciyu80
  When: 29/04/2014 at 05:10:20


Ads

Specular Highlights - Flat Bump Mapping

You can find a fully detailed explanation on Specular Highlights in Recipe 6-9, and on Bump Mapping of a flat surface in Recipe 5-15. Therefore, this chapter will only briefly discuss the theory and focus on the implementation of the code.

Our moving water looks quite nice, but if thereís one thing missing that could be added quite easily, itís specular highlights. These are small spots of high reflectivity on the water, near the region where the sun (or another light source) is reflected in the water. This is shown in the image below:



The question is: how can we find the pixels inside such an area? Itís quite easy: mirror the direction of the light (the left arrow in the image) over the normal in the pixel, and compare it to the eye vector (the right arrow in the image). If both are almost the same, the pixel is situated in a specular highlighted area.

So how can we code this in our HLSL file? Quite easily, actually, with thanks to the reflect intrinsic. And also because we already have defined a normalVector and calculated and eyeVector in our pixel shader.

This line calculates the direction of the light, reflected over the normal vector:

float3 reflectionVector = -reflect(xLightDirection, normalVector);

Next, we need to find out how much this reflected vector is the same as the eyeVector. This can be done perfectly using by taking their dot product: the dot product will be 1 of they are 100% the same, and will be 0 if they are perpendicular:

float specular = dot(normalize(reflectionVector), normalize(eyeVector));

Since we are interested only in those vectors that are something like 99% the same, we are interested only in the dot values that are higher than 0.95. By taking this number to a very high power, only those numbers very close to 1 will remain (see Recipe 6-4 and 6-9 to read why):

specular = pow(specular, 256);        
Output.Color.rgb += specular;

The last line adds this amount as white to our final color of the pixel. If you would run this code, you would get something like this:



Looks quite nice, but it looks like a flat disc. This is because we are using the (0,1,0) Up vector normal in each pixel of the water, while in reality the normal is perturated by the ripples.

In the Ripples chapter, weíve already seen that the bump map contains the actual normal in each pixel. Now itís time to replace the fixed (0,1,0) vector with the vector stored in the bump map. So find the line in our pixel shader where we define the normalVector, and replace that line with this one:

float3 normalVector = (bumpColor.rbg-0.5f)*2.0f;

As explained in the Ripples chapter, the components of a color can only contain a value in the [0,1] region. To get them into the [-1,1] region, we subtract them by 0.5 and multiply them by 2.

When you run this code, you should see the image below. Note that this improved normalVector not only influences the specular reflections, our Fresnel coefficient will now also be improved, as it will take the ripples into account!




DirectX Tutorial 14 - Specular highlights

If you appreciate the amount of time I spend creating and updating
these pages, feel free to donate -- any amount is welcome !



Click here to go to the forum on this chapter!

Or click on one of the topics on this chapter to go there:
  • Specula highlight when light under map
          Hello, i have created a Vector3 called lightPos...
  • XNA 4.0
           ******************************** **************...
  • Lightning not showing
          Hello, the lightning on the water, is just not wor...



    When you make your code run for some time, youíll notice you can easily see the bump map pattern in the specular reflections. This can be solved by scrolling the same bumpmap multiple times over each other, each time with a different scaling, scroll speed, and preferrably also X and Y texture coordinate swapped. This is done in Recipe 5-17, which creates the 3D ocean Iím using as main image for my XNA 2.0 Recipe book pages!

    Nothing changed to our XNA code, so here is our HLSL file:

    //----------------------------------------------------
    //--                                                --
    //--             www.riemers.net                 --
    //--         Series 4: Advanced terrain             --
    //--                 Shader code                    --
    //--                                                --
    //----------------------------------------------------

    //------- Constants --------
    float4x4 xView;
    float4x4 xReflectionView;
    float4x4 xProjection;
    float4x4 xWorld;
    float3 xLightDirection;
    float xAmbient;
    bool xEnableLighting;
    float xWaveLength;
    float xWaveHeight;
    float3 xCamPos;
    float xTime;
    float xWindForce;
    float3 xWindDirection;

    //------- Texture Samplers --------
    Texture xTexture;

    sampler TextureSampler = sampler_state { texture = <xTexture> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xTexture0;

    sampler TextureSampler0 = sampler_state { texture = <xTexture0> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = wrap; AddressV = wrap;};Texture xTexture1;

    sampler TextureSampler1 = sampler_state { texture = <xTexture1> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = wrap; AddressV = wrap;};Texture xTexture2;

    sampler TextureSampler2 = sampler_state { texture = <xTexture2> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xTexture3;

    sampler TextureSampler3 = sampler_state { texture = <xTexture3> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xReflectionMap;

    sampler ReflectionSampler = sampler_state { texture = <xReflectionMap> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xRefractionMap;

    sampler RefractionSampler = sampler_state { texture = <xRefractionMap> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xWaterBumpMap;

    sampler WaterBumpMapSampler = sampler_state { texture = <xWaterBumpMap> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};
    //------- Technique: Textured --------
    struct TVertexToPixel
    {
        float4 Position     : POSITION;    
        float4 Color        : COLOR0;
        float LightingFactor: TEXCOORD0;
        float2 TextureCoords: TEXCOORD1;
    };

    struct TPixelToFrame
    {
        float4 Color : COLOR0;
    };

    TVertexToPixel TexturedVS( float4 inPos : POSITION, float3 inNormal: NORMAL, float2 inTexCoords: TEXCOORD0)
    {    
        TVertexToPixel Output = (TVertexToPixel)0;
        float4x4 preViewProjection = mul (xView, xProjection);
        float4x4 preWorldViewProjection = mul (xWorld, preViewProjection);
        
        Output.Position = mul(inPos, preWorldViewProjection);    
        Output.TextureCoords = inTexCoords;
        
        float3 Normal = normalize(mul(normalize(inNormal), xWorld));    
        Output.LightingFactor = 1;
        if (xEnableLighting)
            Output.LightingFactor = saturate(dot(Normal, -xLightDirection));
        
        return Output;    
    }

    TPixelToFrame TexturedPS(TVertexToPixel PSIn)
    {
        TPixelToFrame Output = (TPixelToFrame)0;        
        
        Output.Color = tex2D(TextureSampler, PSIn.TextureCoords);
        Output.Color.rgb *= saturate(PSIn.LightingFactor + xAmbient);

        return Output;
    }

    technique Textured_2_0
    {
        pass Pass0
        {
            VertexShader = compile vs_2_0 TexturedVS();
            PixelShader = compile ps_2_0 TexturedPS();
        }
    }

    technique Textured
    {
        pass Pass0
        {
            VertexShader = compile vs_1_1 TexturedVS();
            PixelShader = compile ps_1_1 TexturedPS();
        }
    }

    //------- Technique: Multitextured --------
    struct MTVertexToPixel
    {
        float4 Position         : POSITION;    
        float4 Color            : COLOR0;
        float3 Normal            : TEXCOORD0;
        float2 TextureCoords    : TEXCOORD1;
        float4 LightDirection    : TEXCOORD2;
        float4 TextureWeights    : TEXCOORD3;
        float Depth                : TEXCOORD4;
    };

    struct MTPixelToFrame
    {
        float4 Color : COLOR0;
    };

    MTVertexToPixel MultiTexturedVS( float4 inPos : POSITION, float3 inNormal: NORMAL, float2 inTexCoords: TEXCOORD0, float4 inTexWeights: TEXCOORD1)
    {    
        MTVertexToPixel Output = (MTVertexToPixel)0;
        float4x4 preViewProjection = mul (xView, xProjection);
        float4x4 preWorldViewProjection = mul (xWorld, preViewProjection);
        
        Output.Position = mul(inPos, preWorldViewProjection);
        Output.Normal = mul(normalize(inNormal), xWorld);
        Output.TextureCoords = inTexCoords;
        Output.LightDirection.xyz = -xLightDirection;
        Output.LightDirection.w = 1;    
        Output.TextureWeights = inTexWeights;
        Output.Depth = Output.Position.z/Output.Position.w;
        
        return Output;    
    }

    MTPixelToFrame MultiTexturedPS(MTVertexToPixel PSIn)
    {
        MTPixelToFrame Output = (MTPixelToFrame)0;        
        
        float lightingFactor = 1;
        if (xEnableLighting)
            lightingFactor = saturate(saturate(dot(PSIn.Normal, PSIn.LightDirection)) + xAmbient);
            
        float blendDistance = 0.99f;
        float blendWidth = 0.005f;
        float blendFactor = clamp((PSIn.Depth-blendDistance)/blendWidth, 0, 1);
            
        float4 farColor;
        farColor = tex2D(TextureSampler0, PSIn.TextureCoords)*PSIn.TextureWeights.x;
        farColor += tex2D(TextureSampler1, PSIn.TextureCoords)*PSIn.TextureWeights.y;
        farColor += tex2D(TextureSampler2, PSIn.TextureCoords)*PSIn.TextureWeights.z;
        farColor += tex2D(TextureSampler3, PSIn.TextureCoords)*PSIn.TextureWeights.w;
        
        float4 nearColor;
        float2 nearTextureCoords = PSIn.TextureCoords*3;
        nearColor = tex2D(TextureSampler0, nearTextureCoords)*PSIn.TextureWeights.x;
        nearColor += tex2D(TextureSampler1, nearTextureCoords)*PSIn.TextureWeights.y;
        nearColor += tex2D(TextureSampler2, nearTextureCoords)*PSIn.TextureWeights.z;
        nearColor += tex2D(TextureSampler3, nearTextureCoords)*PSIn.TextureWeights.w;

        Output.Color = lerp(nearColor, farColor, blendFactor);
        Output.Color *= lightingFactor;
        
        return Output;
    }

    technique MultiTextured
    {
        pass Pass0
        {
            VertexShader = compile vs_1_1 MultiTexturedVS();
            PixelShader = compile ps_2_0 MultiTexturedPS();
        }
    }

    //------- Technique: Water --------
    struct WVertexToPixel
    {
        float4 Position                 : POSITION;
        float4 ReflectionMapSamplingPos    : TEXCOORD1;
        float2 BumpMapSamplingPos        : TEXCOORD2;
        float4 RefractionMapSamplingPos : TEXCOORD3;
        float4 Position3D                : TEXCOORD4;
    };

    struct WPixelToFrame
    {
        float4 Color : COLOR0;
    };

    WVertexToPixel WaterVS(float4 inPos : POSITION, float2 inTex: TEXCOORD)
    {    
        WVertexToPixel Output = (WVertexToPixel)0;

        float4x4 preViewProjection = mul (xView, xProjection);
        float4x4 preWorldViewProjection = mul (xWorld, preViewProjection);
        float4x4 preReflectionViewProjection = mul (xReflectionView, xProjection);
        float4x4 preWorldReflectionViewProjection = mul (xWorld, preReflectionViewProjection);

        Output.Position = mul(inPos, preWorldViewProjection);
        Output.ReflectionMapSamplingPos = mul(inPos, preWorldReflectionViewProjection);    
        Output.RefractionMapSamplingPos = mul(inPos, preWorldViewProjection);
        Output.Position3D = mul(inPos, xWorld);        
        
        float3 windDir = normalize(xWindDirection);    
        float3 perpDir = cross(xWindDirection, float3(0,1,0));
        float ydot = dot(inTex, xWindDirection.xz);
        float xdot = dot(inTex, perpDir.xz);
        float2 moveVector = float2(xdot, ydot);
        moveVector.y += xTime*xWindForce;    
        Output.BumpMapSamplingPos = moveVector/xWaveLength;    

        
        return Output;
    }

    WPixelToFrame WaterPS(WVertexToPixel PSIn)
    {
        WPixelToFrame Output = (WPixelToFrame)0;        
        
        float4 bumpColor = tex2D(WaterBumpMapSampler, PSIn.BumpMapSamplingPos);
        float2 perturbation = xWaveHeight*(bumpColor.rg - 0.5f)*2.0f;
        
        float2 ProjectedTexCoords;
        ProjectedTexCoords.x = PSIn.ReflectionMapSamplingPos.x/PSIn.ReflectionMapSamplingPos.w/2.0f + 0.5f;
        ProjectedTexCoords.y = -PSIn.ReflectionMapSamplingPos.y/PSIn.ReflectionMapSamplingPos.w/2.0f + 0.5f;        
        float2 perturbatedTexCoords = ProjectedTexCoords + perturbation;
        float4 reflectiveColor = tex2D(ReflectionSampler, perturbatedTexCoords);
        
        float2 ProjectedRefrTexCoords;
        ProjectedRefrTexCoords.x = PSIn.RefractionMapSamplingPos.x/PSIn.RefractionMapSamplingPos.w/2.0f + 0.5f;
        ProjectedRefrTexCoords.y = -PSIn.RefractionMapSamplingPos.y/PSIn.RefractionMapSamplingPos.w/2.0f + 0.5f;    
        float2 perturbatedRefrTexCoords = ProjectedRefrTexCoords + perturbation;    
        float4 refractiveColor = tex2D(RefractionSampler, perturbatedRefrTexCoords);
        

         float3 eyeVector = normalize(xCamPos - PSIn.Position3D);

        float3 normalVector = (bumpColor.rbg-0.5f)*2.0f;
        
        float fresnelTerm = dot(eyeVector, normalVector);    
        float4 combinedColor = lerp(reflectiveColor, refractiveColor, fresnelTerm);
        
        float4 dullColor = float4(0.3f, 0.3f, 0.5f, 1.0f);
        
        Output.Color = lerp(combinedColor, dullColor, 0.2f);    
        

         float3 reflectionVector = -reflect(xLightDirection, normalVector);
         float specular = dot(normalize(reflectionVector), normalize(eyeVector));
         specular = pow(specular, 256);        
         Output.Color.rgb += specular;

        
        return Output;
    }

    technique Water
    {
        pass Pass0
        {
            VertexShader = compile vs_1_1 WaterVS();
            PixelShader = compile ps_2_0 WaterPS();
        }
    }



    Google
     
    Webwww.riemers.net


    If you appreciate the amount of time I spend creating and updating
    these pages, feel free to donate -- any amount is welcome !



    - Website design & XNA + DirectX code : Riemer Grootjans -
    ©2003 - 2011 Riemer Grootjans
  • Translations

    This site in English
    This site in Korean
    This site in Czech

    Microsoft MVP Award



    2007 - 2011 MVP Award
    DirectX - XNA

    Contents

    News
    Home
    Forum
    XNA 2.0 Recipes Book (8)
    XNA 3.0 Recipes Book (8)
    Downloads
    Extra Reading (3)
    Matrices: geometrical
    Matrix Mathematics
    Homogenous matrices
    Community Projects (1)
    Tutorials (160)
    XNA 4.0 using C# (89)
    2D Series: Shooters (22)
    3D Series 1: Terrain (13)
    3D Series 2: Flightsim (14)
    3D Series 3: HLSL (18)
    3D Series 4: Adv. terrain (19)
    Starting code
    Mouse camera
    Textured terrain
    Multitexturing
    Adding detail
    Skydome
    The water technique
    Refraction map
    Reflection map
    Perfect mirror
    Ripples
    The Fresnel term
    Moving water
    Specular highlights
    Billboarding
    Region growing
    Billboarding renderstates
    Perlin noise
    Gradient skybox
    Short Tuts (3)
    DirectX using C# (54)
    DirectX using C++ (15)
    DirectX using VB (2)
    -- Expand all --


    Thank you!

    Support this site --
    any amount is welcome !

    Stay up-to-date

    I don't have the time to keep a News section, so stay informed about the updates by clicking on this RSS file!