D3DXCreateTexture(pd3dDevice, SHADOWMAP_SIZE, SHADOWMAP_SIZE, 1,
 			D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, 
D3DPOOL_DEFAULT, &g_pShadowMap);

IDirect3DSurface9* pShadowSurface;
IDirect3DSurface9* pOriginalBackBuffer;

g_pShadowMap->GetSurfaceLevel(0, &pShadowSurface);
pd3dDevice->GetRenderTarget(0, &pOriginalBackBuffer);
pd3dDevice->SetRenderTarget(0, pShadowSurface);
SAFE_RELEASE(pShadowSurface);

//render the scene, then restore the settings

pd3dDevice->SetRenderTarget(0, &pOriginalBackBUffer);

            

void VertexGenerateShadowMap(float4 iPosition : POSITION, 
				 out float2 oDepth : TEXCOORD0, 
 				 out float4 oPosition : POSITION)
{
 oPosition = mul(iPosition, g_mWorldViewProjection);
 oDepth.xy = oPosition.zw;
}

void PixelGenerateShadowMap(float2 Depth : TEXCOORD0, 
 out float4 oColor : COLOR)
{
	oColor = Depth.x / Depth.y;
}

            

void VertexShadowMap(float4 iPosition : POSITION,
			 float3 iNormal : NORMAL,
			 out float4 oPosition : POSITION,
			 out float4 oViewSpacePosition : TEXCOORD0,
			 out float3 oNormal : TEXCOORD1,
			 out float4 oLightSpacePosition : TEXCOORD2)
{
oViewSpacePosition = mul(iPosition, g_mWorldView);
oPosition = mul(iPosition, g_mWorldViewProjection);
 	oNormal = mul( iNormal, (float3x3)g_mWorldView);
oLightSpacePosition = mul(oViewSpacePosition, 
				g_mViewToLightProjectionSpace);
}

            

void PixelShadowMap(float4 vViewSpacePosition : TEXCOORD0,
 float3 vNormal : TEXCOORD1,
 float4 vLightSpacePosition : TEXCOORD2,
 out float4 oColor : COLOR)
{
	// determine the depth value stored in the shadow map
	float2 ShadowMapCoord = 0.5 * vLightSpacePosition.xy /
 				vLightSpacePosition.w 
+ float2(0.5, 0.5);
ShadowMapCoord.y = 1.0f - ShadowMapCoord.y;
	float fShadowMapDistance = tex2D(ShadowMapSampler, 
						 ShadowMapCoord);
 
 	float fDistanceToLight = vLightSpacePosition.z 
					/ vLightSpacePosition.w;

	// compare the distance to the light with the shadow map value
	// the bias factor reduced impact of floating point errors
	float fShadow = fDistanceToLight - fShadowMapDistance 
> g_fShadowMapBias
				? 0.0f : 1.0f;

	float3 vLight = (float3)normalize(vViewSpacePosition – 
						 g_vPositionOfLight);
float4 vDiffuse = fShadow * g_vLightDiffuse
				* dot(-vLight, normalize(vNormal));
	oColor = saturate((vDiffuse + g_vLightAmbient) 
* g_vMaterialColor);
}

            

unsigned __stdcall GenerateShadowMap(void* pd3dDevice)
{
	while (pd3dDevice)
	{
		// Acquire the lock before attempting to create the // shadow map.

		DWORD dwResult = 
WaitForSingleObject(g_hRenderMutex, INFINITE);

		// Create the shadow map here.
		// Release the lock after the shadow map is complete. 
ReleaseMutex(g_hRenderMutex);
		
// Make the thread sleep until the shadow map should
// be updated. The sleep time is specified in 
// milliseconds.
Sleep(g_iShadowMapUpdateMS);
	}
		_endthread();
	return 0;
}

            

float4 pack(float f, int iRange) 
{
	float4 fReturn = 0.0f;
	float fRange = iRange * 1.0f;
	int i = (int) (f * iRange);
	fReturn.r = i / fRange;
	f = (f - fReturn.r) * fRange;
	i = (int) (f * iRange);
	fReturn.g = i / fRange;
	f = (f - fReturn.g) * fRange;
	i = (int) (f * iRange);
	fReturn.b = i / fRange;
	fReturn.a = 0.0f;
	return fReturn;
}

float unpack(float4 f, int iRange)
{
	float fRange = iRange * 1.0f;
	return f.r + f.g / fRange + f.b / (fRange * fRange);
}