Beginning direct3d gameprogramming10_shaderdetail_20160506_jintaeks

Beginning Direct3D Game Programming:
10. Shader Detail
jintaeks@gmail.com
Division of Digital Contents, DongSeo University.
May 2016

Decompose a vector
 d=(a·n)
 a⊥=(a·n)n
 a∥=a-a⊥=a-(a·n)n
2

Coordinate Transform
(a·n, a·t, a·b)
3
a

Diffuse Lighting
 The diffuse lighting model following Lambert’s law is
described with the help of two vectors—the light vector L and
the normal vector N.
 The diffuse reflection has its peak (cos(θ) ≡ 1) when L and N
are aligned.
5

Diffuse Lighting
 This diffuse lighting component is usually added to the
ambient lighting component like this:
I = Aintensity * Acolor + Dintensity * Dcolor * N·L + Specular
6

Effect File: Declare Global Variables
//--------------------------------------------------------------------------------------
// Global variables
//--------------------------------------------------------------------------------------
float4 g_MaterialAmbientColor; // Material's ambient color
float4 g_MaterialDiffuseColor; // Material's diffuse color
float3 g_LightDir; // Light's direction in world space
float4 g_LightDiffuse; // Light's diffuse color
float4 g_LightAmbient = float4(0.5,0.5,0.5,0.5); // Light's ambient color
texture g_MeshTexture; // Color texture for mesh
float g_fTime; // App's time in seconds
float4x4 g_mWorld; // World matrix for object
float4x4 g_mWorldViewProjection; // World * View * Projection matrix
7

Vertex Shader Output Structure
//--------------------------------------------------------------------------------------
// Vertex shader output structure
//--------------------------------------------------------------------------------------
struct VS_OUTPUT
{
float4 Position : POSITION; // vertex position
float4 Diffuse : COLOR0; // vertex diffuse color (note that COLOR0 is clamped
from 0..1)
float2 TextureUV : TEXCOORD0; // vertex texture coords
};
8

Vertex Shader
VS_OUTPUT RenderSceneVS( float4 vPos : POSITION, float3 vNormal : NORMAL, float2
vTexCoord0 : TEXCOORD0, uniform int nUnused, uniform bool bTexture, uniform bool
bAnimate )
{
VS_OUTPUT Output;
float3 vNormalWorldSpace;
float4 vAnimatedPos = vPos;
// Transform the position from object space to homogeneous projection space
Output.Position = mul(vAnimatedPos, g_mWorldViewProjection);
// Transform the normal from object space to world space
vNormalWorldSpace = normalize(mul(vNormal, (float3x3)g_mWorld));
9

Vertex Shader
VS_OUTPUT RenderSceneVS( float4 vPos : POSITION, float3 vNormal : NORMAL, float2
vTexCoord0 : TEXCOORD0, uniform int nUnused, uniform bool bTexture, uniform bool
bAnimate )
{
VS_OUTPUT Output;
…
// Compute simple directional lighting equation
float3 vTotalLightDiffuse = float3(0,0,0);
vTotalLightDiffuse += g_LightDiffuse * max( 0, dot( vNormalWorldSpace,
g_LightDir ) );
Output.Diffuse.rgb = g_MaterialDiffuseColor * vTotalLightDiffuse +
g_MaterialAmbientColor * g_LightAmbient;
Output.Diffuse.a = 1.0f;
// Just copy the texture coordinate through
Output.TextureUV = vTexCoord0;
return Output;
}
10

Pixel Shader
struct PS_OUTPUT
{
float4 RGBColor : COLOR0; // Pixel color
};
PS_OUTPUT RenderScenePS( VS_OUTPUT In, uniform bool bTexture )
{
PS_OUTPUT Output;
// Lookup mesh texture and modulate it with diffuse
if( bTexture )
Output.RGBColor = tex2D(MeshTextureSampler, In.TextureUV) * In.Diffuse;
else
Output.RGBColor = In.Diffuse;
return Output;
}
11

Technique
technique RenderSceneWithTexture1Light
{
pass P0
{
VertexShader = compile vs_2_0 RenderSceneVS( 1, false, false );
PixelShader = compile ps_2_0 RenderScenePS( false );
}
}
12

Client : Declare Global Variables
//--------------------------------------------------------------------------------------
// Global variables
//--------------------------------------------------------------------------------------
ID3DXFont* g_pFont = NULL; // Font for drawing text
ID3DXSprite* g_pSprite = NULL; // Sprite for batching draw text calls
bool g_bShowHelp = true; // If true, it renders the UI control text
CModelViewerCamera g_Camera; // A model viewing camera
ID3DXEffect* g_pEffect = NULL; // D3DX effect interface
ID3DXMesh* g_pMesh = NULL; // Mesh object
IDirect3DTexture9* g_pMeshTexture = NULL; // Mesh texture
CDXUTDialogResourceManager g_DialogResourceManager; // manager for shared
resources of dialogs
13

OnCreateDevice()
// Read the D3DX effect file
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"BasicHLSL.fx" ) );
// If this fails, there should be debug output as to
// why the .fx file failed to compile
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL,
&g_pEffect, NULL ) );
// Create the mesh texture from a file
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"earthearth.bmp" ) );
V_RETURN( D3DXCreateTextureFromFileEx( pd3dDevice, str, D3DX_DEFAULT, D3DX_DEFAULT,
D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
D3DX_DEFAULT, D3DX_DEFAULT, 0,
NULL, NULL, &g_pMeshTexture ) );
14

OnCreateDevice()
// Set effect variables as needed
D3DXCOLOR colorMtrlDiffuse( 1.0f, 1.0f, 1.0f, 1.0f );
D3DXCOLOR colorMtrlAmbient( 0.35f, 0.35f, 0.35f, 0 );
V_RETURN( g_pEffect->SetValue( "g_MaterialAmbientColor", &colorMtrlAmbient, sizeof(
D3DXCOLOR ) ) );
V_RETURN( g_pEffect->SetValue( "g_MaterialDiffuseColor", &colorMtrlDiffuse, sizeof(
D3DXCOLOR ) ) );
V_RETURN( g_pEffect->SetTexture( "g_MeshTexture", g_pMeshTexture ) );
15

OnResetDevice()
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D9ResetDevice() );
V_RETURN( g_SettingsDlg.OnD3D9ResetDevice() );
if( g_pFont )
V_RETURN( g_pFont->OnResetDevice() );
if( g_pEffect )
V_RETURN( g_pEffect->OnResetDevice() );
// Create a sprite to help batch calls when drawing many lines of text
V_RETURN( D3DXCreateSprite( pd3dDevice, &g_pSprite ) );
16

OnFrameRender()
// Render the scene
if( SUCCEEDED( pd3dDevice->BeginScene() ) )
{
// Get the projection & view matrix from the camera class
mWorld = g_mCenterWorld * *g_Camera.GetWorldMatrix();
mProj = *g_Camera.GetProjMatrix();
mView = *g_Camera.GetViewMatrix();
mWorldViewProjection = mWorld * mView * mProj;
D3DXCOLOR arrowColor = D3DXCOLOR( 1, 1, 0, 1 );
V( g_LightControl.OnRender9( arrowColor, &mView, &mProj, g_Camera.GetEyePt() )
);
vLightDir = g_LightControl.GetLightDirection();
vLightDiffuse = g_fLightScale * D3DXCOLOR( 1, 1, 1, 1 );
17

V( g_pEffect->SetValue( "g_LightDir", &vLightDir, sizeof( D3DXVECTOR3 ) ) );
V( g_pEffect->SetValue( "g_LightDiffuse", &vLightDiffuse, sizeof( D3DXVECTOR4 ) )
);
// Update the effect's variables. Instead of using strings, it would
// be more efficient to cache a handle to the parameter by calling
// ID3DXEffect::GetParameterByName
V( g_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection ) );
V( g_pEffect->SetMatrix( "g_mWorld", &mWorld ) );
V( g_pEffect->SetFloat( "g_fTime", ( float )fTime ) );
D3DXCOLOR vWhite = D3DXCOLOR( 1, 1, 1, 1 );
V( g_pEffect->SetValue( "g_MaterialDiffuseColor", &vWhite, sizeof( D3DXCOLOR )
) );
V( g_pEffect->SetFloat( "g_fTime", ( float )fTime ) );
18

V( g_pEffect->SetTechnique( "RenderSceneWithTexture1Light" ) );
// Apply the technique contained in the effect
V( g_pEffect->Begin( &cPasses, 0 ) );
for( iPass = 0; iPass < cPasses; iPass++ )
{
V( g_pEffect->BeginPass( iPass ) );
V( g_pEffect->CommitChanges() );
// Render the mesh with the applied technique
V( g_pMesh->DrawSubset( 0 ) );
V( g_pEffect->EndPass() );
}
V( g_pEffect->End() );
19

OnLostDevice()
void CALLBACK OnLostDevice( void* pUserContext )
{
g_DialogResourceManager.OnD3D9LostDevice();
g_SettingsDlg.OnD3D9LostDevice();
CDXUTDirectionWidget::StaticOnD3D9LostDevice();
if( g_pFont )
g_pFont->OnLostDevice();
if( g_pEffect )
g_pEffect->OnLostDevice();
SAFE_RELEASE( g_pSprite );
}
20

OnDestroyDevice()
void CALLBACK OnDestroyDevice( void* pUserContext )
{
g_DialogResourceManager.OnD3D9DestroyDevice();
g_SettingsDlg.OnD3D9DestroyDevice();
CDXUTDirectionWidget::StaticOnD3D9DestroyDevice();
SAFE_RELEASE( g_pEffect );
SAFE_RELEASE( g_pFont );
SAFE_RELEASE( g_pMesh );
SAFE_RELEASE( g_pMeshTexture );
}
21

Practice: Build and Run BasicHLSL Step1
22

Step2 : Diffuse Light in Local Space
 Use Object space
uniform variables in
Shader to speed
up.
23

Client: OnFrameRender() Differences
24

27

Reflection vector
 r = a - 2(a·n)n
29

Specular Reflection
 Two vectors are used to calculate the specular component—
the Light vector L and the reflection vector R.
 The more L is aligned with R, the brighter the specular light
should be.
30

Half Vector
 If one calculates a halfway vector between the viewer and
light-source vectors we can replace L·R with H·N.
31

Client: OnFrameRender() Differences
 Prepare WorldView and WorldViewInv matrices.
35

 Get Object space eye position.
36

 Set Object space eye position.
37

38

Step4 : Specular Light in Pixel Shader
 Specular light
calculation in pixel
shader to get more
precise result.
39

Effect Differences
 Add Normal and Eye vector to VS_OUTPUT.
40

Vertex Shader Differences
 Pass Normal and Eye vector to Pixel shader.
41

43

Normal Map
 In 3D computer graphics, normal mapping is a technique
used for faking the lighting of bumps and dents – an
implementation of bump mapping.
 It is used to add details without using more polygons.
• Example of a normal map (center) with the scene it was
calculated from (left) and the result when applied to a flat
surface (right).
45

Normal Map
 RGB color of pixel in image file is a direction (x,y,z) in tangent
space.
47

Effect Differences: Added normal map texture
48

Added Light vector in tangent space
49

 Eye and Light vectors must be transformed to tangent space.
51

Pixel Shader
PS_OUTPUT RenderScenePS( VS_OUTPUT In, uniform bool bTexture )
{
PS_OUTPUT Output;
float3 N = 2.0f * tex2D( MeshBumpTextureSampler, In.TextureUV ).xyz - 1.0f;
float3 L = normalize( In.L );
float3 R = reflect( -normalize( In.Eye ), N ); // reflection vector
// Lookup mesh texture and modulate it with diffuse
if( bTexture ) {
Output.RGBColor = tex2D( MeshTextureSampler, In.TextureUV ) *In.Diffuse * max(
0, dot( N, L ) );
} else {
Output.RGBColor = In.Diffuse * max( 0, dot( N, L ) );
}//if.. else..
Output.RGBColor += pow( max( 0, dot( R, L ) ), 10 );
return Output;
}
52

Client: Added normal map texture
53

OnCreateDevice() Differences
54

OnResetDevice() Differences()
D3DVERTEXELEMENT9 decl[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
{ 0, 24, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
{ 0, 36, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};//decl[]
if( g_pMesh ) {
LPD3DXMESH pMesh;
g_pMesh->CloneMesh(
g_pMesh->GetOptions(), decl,
pd3dDevice, &pMesh );
D3DXComputeNormals( pMesh, NULL );
D3DXComputeTangent( pMesh, 0, 0, 0, TRUE, NULL );
SAFE_RELEASE( g_pMesh );
g_pMesh = pMesh;
}//if
55

OnDestroyDevice() Differences
56

Beginning direct3d gameprogramming10_shaderdetail_20160506_jintaeks

Beginning direct3d gameprogramming10_shaderdetail_20160506_jintaeks

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Beginning direct3d gameprogramming10_shaderdetail_20160506_jintaeks (20)

More from JinTaek Seo (14)

Recently uploaded (20)

Beginning direct3d gameprogramming10_shaderdetail_20160506_jintaeks