We once again add up all the light, now including specular and multiply it by the color which The result is multiplied by SpecularIntensity to make the highlight brighter or The specularĬomponent is calculated by taking the dot product of the reflection vector and the viewĭirection, raised to the power given by the SpecularPower variable making the highlight We calculate the reflection vector R with the formula discussed above. The ambient and diffuse components are calculated like before. We receive the view direction vector in TEXCOORD2 where we put it in the pixel shader. Vector results in a direction vector pointing to the view from the vertex (see 'Subtracting Subtracting the vertex world position vector from the view position The worldspace position of the vertex, so we transform the vertex position by multiplying it To calculate the view direction vector we need Know the objectspace position of the vertex. We know the world position of the view ( vecViewPos) and we The specular highlights are dependent on the view direction so we have to calculate a vector Like before, we transform the vertex and normal and pass the texture coordinate. We have added one output parameter to the vertex shader which will contain a vector pointing from the vertex to the view we call it ' OutViewDir'. vecViewPos is the position of the camera in the world. We have also added a new constant that is passed by the engine. These will be used in the pixel shader as an intensity and 'glossiness' factor. We have added two new variables: SpecularIntensity and SpecularPower. PixelShader = compile ps_2_0 SpecularPS() VertexShader = compile vs_2_0 SpecularVS() Return (Ambient + Diffuse + Specular) * Color Fetch the pixel color from the color map:įloat4 Color = tex2D(ColorMapSampler, InTex) įloat3 R = normalize(2 * dot(InNormal, -vecSunDir) * InNormal + vecSunDir) įloat Specular = pow(saturate(dot(R, normalize(InViewDir))), SpecularPower) * SpecularIntensity OutViewDir = vecViewPos - mul(InPos, matWorld) įloat4 Ambient = AmbientIntensity * vecAmbient įloat4 Diffuse = DiffuseIntensity * SunColor * saturate(dot(-vecSunDir, InNormal)) Calculate a vector from the vertex to the view: Pass the texture coordinate to the pixel shader: OutNormal = normalize(mul(InNormal, matWorld)) Transform the normal from object space to world space: Transform the vertex from object space to clip space: MipFilter = Linear // required for mipmapping Sampler ColorMapSampler = sampler_state // Color map sampler. Application fed data:Ĭonst float4x4 matWorldViewProj // World*view*projection matrix.Ĭonst float4x4 matWorld // World matrix.Ĭonst float4 vecAmbient // Ambient color.Ĭonst float4 vecSunDir // The sun light direction vector.Ĭonst float4 vecViewPos // View position. Static const float4 SunColor = // Color vector of the sunlight. Static const float SpecularPower = 8.0f // The specular power, used as 'glossiness' factor. Static const float SpecularIntensity = 2.0f // The intensity of the specular light. Static const float DiffuseIntensity = 1.0f // The intensity of the diffuse light. Static const float AmbientIntensity = 1.0f // The intensity of the ambient light. We then raise the result to a power n which makes the highlight harder or softer.įinal Color = (Diffuse Light + Ambient Light + Specular Light) * Diffuse Color Implementation // Tweakables: This time we need the difference between the view vector and the reflection vector. As with diffuse lighting, we will use the dot product to calculate the cosine of the angle difference between the two vectors. This results in a vector pointing from the vertex to the camera (see 'Subtracting Vectors' inĪppendix B). The view vector V is calculated by subtracting the vector world position from the camera position: The reflection vector R is calculated with the following formula: The angle between the reflection vector and view vector. If the angles are similar, the surface will be lit brightly, if they are far off, no specular light is reflected from the surface into the camera and only the diffuse and ambient light will be visible on this pixel.

This reflection vector R is compared to the view direction vector. This vector is calculated from the light direction vector and the normal of the We will use a reflection vector that contains the direction of the light after it has bounced off We will use the Phong specular lighting model developed by Bui Tong Phong. There are several lighting models for simulating specular reflectance. Shader Workshops Workshop 3: Specular Lightingįor simulating shiny/polished surfaces the algorithm must also take into account the location of the viewer.

Specular reflection