Hello,
I have been having the toughest time getting an .fx file exported from the RenderMonkey shadow example into my simple spinning cube program. I know the basics about shaders but not quite near efficient yet. If anyone would be able to help me integrate this shader into my program, this would be a tremendous help, and hopefully help out whoever else stumbles upon my post.
Here is the simple spinning cube example I am using
#pragma comment(lib, "d3dx9.lib")
#pragma comment(lib, "d3d9.lib")
#include <windows.h>
#include <dx9/d3dx9.h>
#include <dx9/d3d9.h>
HDC hDC = NULL;
HWND hWnd = NULL;
HINSTANCE hInstance;
LPDIRECT3D9 pD3D = NULL;
LPDIRECT3DDEVICE9 pD3DDevice = NULL;
bool keys[256];
bool active=TRUE;
bool fullscreen=TRUE;
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE)
IDirect3DVertexBuffer9 *pVertexBuffer = NULL; // Our Vertex Buffer
struct tVertex // Our new vertex struct
{
float x, y, z; // 3D position
DWORD color; // Hex Color Value
};
tVertex cube[24] = // Vertex Array
{
// Front Blue Color
{-1.0f, 1.0f,-1.0f, 0xF00FF00F },
{ 1.0f, 1.0f,-1.0f, 0xF00FF00F },
{-1.0f,-1.0f,-1.0f, 0xF00FF00F },
{ 1.0f,-1.0f,-1.0f, 0xF00FF00F },
// Back Orange Color
{-1.0f, 1.0f, 1.0f, 0xFFF8800F },
{-1.0f,-1.0f, 1.0f, 0xFFF8800F },
{ 1.0f, 1.0f, 1.0f, 0xFFF8800F },
{ 1.0f,-1.0f, 1.0f, 0xFFF8800F },
// Top Red Color
{-1.0f, 1.0f, 1.0f, 0xFFF0000F },
{ 1.0f, 1.0f, 1.0f, 0xFFF0000F },
{-1.0f, 1.0f,-1.0f, 0xFFF0000F },
{ 1.0f, 1.0f,-1.0f, 0xFFF0000F },
// Bottom Yellow Color
{-1.0f,-1.0f, 1.0f, 0xFFFFF00F },
{-1.0f,-1.0f,-1.0f, 0xFFFFF00F },
{ 1.0f,-1.0f, 1.0f, 0xFFFFF00F },
{ 1.0f,-1.0f,-1.0f, 0xFFFFF00F },
// Right Blue Color
{ 1.0f, 1.0f,-1.0f, 0xF0000FFF },
{ 1.0f, 1.0f, 1.0f, 0xF0000FFF },
{ 1.0f,-1.0f,-1.0f, 0xF0000FFF },
{ 1.0f,-1.0f, 1.0f, 0xF0000FFF },
// Left Violet Color
{-1.0f, 1.0f,-1.0f, 0xFFF00FFF },
{-1.0f,-1.0f,-1.0f, 0xFFF00FFF },
{-1.0f, 1.0f, 1.0f, 0xFFF00FFF },
{-1.0f,-1.0f, 1.0f, 0xFFF00FFF }
};
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void ReSizeD3DScene(int width, int height) // Resize And Initialize The DX Window
{
if (height==0) // Prevent A Divide By Zero By
{
height=1; // Making Height Equal One
}
D3DXMATRIX projection_matrix;
D3DXMatrixPerspectiveFovLH(&projection_matrix, 45.0f, (float)width/(float)height, 0.1f, 100.0f );
pD3DDevice->SetTransform( D3DTS_PROJECTION, &(D3DMATRIX)projection_matrix );
D3DXMatrixIdentity(&projection_matrix);
}
int InitD3D()
{
pD3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE ); // Z-Buffer (Depth Buffer)
pD3DDevice->SetRenderState(D3DRS_CULLMODE, FALSE); // Disable Backface Culling
pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE); // Disable Light
pD3DDevice->CreateVertexBuffer( 24*sizeof(tVertex),0, D3DFVF_CUSTOMVERTEX,
D3DPOOL_DEFAULT, &pVertexBuffer, NULL );
unsigned char *pVertices = NULL;
pVertexBuffer->Lock( 0, sizeof(cube), (void**)&pVertices, 0 );
memcpy( pVertices, cube, sizeof(cube) );
pVertexBuffer->Unlock();
return TRUE;
}
int DrawD3DScene()
{
pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
D3DCOLOR_COLORVALUE(0.0f,0.0f,0.0f,0.0f), 1.0f, 0 );
static float rotqube = 0.0f;
rotqube += 0.9f;
D3DXMATRIX matWorld; // Create The World Matrix
D3DXMATRIX matTranslation; // Create a Translation Matrix
D3DXMATRIX matRotX; // Create X Axis Rotation Matrix
D3DXMATRIX matRotY; // Create Y Axis Rotation Matrix
D3DXMATRIX matRotZ; // Create Z Axis Rotation Matrix
D3DXMATRIX matRotXYZ; // Create XYZ Rotation Matrix
D3DXMatrixTranslation( &matTranslation, 0.0f, 0.0f, 5.0f ); // Translate The Cube 5 Units Into The Screen
D3DXMatrixRotationY(&matRotY, D3DXToRadian(rotqube)); // Rotate In Y Direction
D3DXMatrixRotationX(&matRotX, D3DXToRadian(rotqube)); // Rotate In X Direction
D3DXMatrixRotationY(&matRotY, D3DXToRadian(rotqube)); // Rotate In Z Direction
D3DXMatrixRotationZ(&matRotZ, D3DXToRadian(rotqube));
D3DXMatrixRotationYawPitchRoll( &matRotXYZ, D3DXToRadian(rotqube), D3DXToRadian(rotqube), D3DXToRadian(rotqube) );
matWorld = (matRotY * matRotX * matRotZ) * matTranslation;
pD3DDevice->SetTransform( D3DTS_WORLD, &matWorld ); // Set The Transformation
pD3DDevice->BeginScene(); // Begin Direct3D Scene
pD3DDevice->SetStreamSource( 0, pVertexBuffer, 0, sizeof(tVertex) );
pD3DDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 ); // Draw Front
pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 4, 2 ); // Draw Back
pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 8, 2 ); // Draw Top
pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 12, 2 ); // Draw Bottom
pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 16, 2 ); // Draw Right
pD3DDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 20, 2 ); // Draw Left
pD3DDevice->EndScene(); // End Direct3D Scene
pD3DDevice->Present( NULL, NULL, NULL, NULL );// Display The Result
return TRUE;
}
void KillD3DScene()
{
if( pVertexBuffer != NULL )
{
pVertexBuffer->Release(); // Release The Vertex Buffer
pVertexBuffer = NULL;
}
}
void KillD3DWindow() // Properly Kill The Window
{
KillD3DScene(); // Release D3D Scene
if (pD3DDevice != NULL) pD3DDevice->Release(); // Release D3D Device
if (pD3D != NULL) pD3D->Release(); // Release D3D Interface
if (fullscreen) // Are We In Fullscreen Mode?
{
ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
ShowCursor(TRUE); // Show Mouse Pointer
}
if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able To Release The DC
{
MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hDC=NULL; // Set DC To NULL
}
if (hWnd && !DestroyWindow(hWnd)) // Are We Able To Destroy The Window?
{
MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hWnd=NULL; // Set hWnd To NULL
}
if (!UnregisterClass("Direct3D",hInstance)) // Are We Able To Unregister Class
{
MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hInstance=NULL; // Set hInstance To NULL
}
}
BOOL CreateD3DWindow(char* title, int width, int height, bool fullscreenflag)
{
WNDCLASS wc;
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
WindowRect.left=(long)0; // Set Left Value To 0
WindowRect.right=(long)width; // Set Right Value To Requested Width
WindowRect.top=(long)0; // Set Top Value To 0
WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height
fullscreen=fullscreenflag; // Set The Global Fullscreen Flag
hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For D3D
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = "Direct3D"; // Set The Class Name
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (fullscreen) // Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
}
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
"Direct3D", // Class Name
title, // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
hInstance, // Instance
NULL))) // Dont Pass Anything To WM_CREATE
{
KillD3DWindow(); // Reset The Display
MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
{
KillD3DWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
pD3D = Direct3DCreate9( D3D_SDK_VERSION ); // Check for correct DirectX 3D version
if ( pD3D == NULL )
{
KillD3DWindow(); // Reset The Display
MessageBox(NULL,"Can't find D3D SDK Version 9.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
D3DPRESENT_PARAMETERS d3dpp= // d3dpp Tells Windows How We Want Things To Be
{
width, // Back Buffer Width
height, // Back Buffer Height
D3DFMT_R5G6B5, // Back Buffer Format (Color Depth)
1, // Back Buffer Count (Double Buffer)
D3DMULTISAMPLE_NONE, // Multi Sample Type
0, // Multi Sample Quality
D3DSWAPEFFECT_DISCARD, // Swap Effect (Fast)
hWnd, // The Window Handle
!fullscreen, // Windowed or Fullscreen
TRUE, // Enable Auto Depth Stencil
D3DFMT_D16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Flags
D3DPRESENT_RATE_DEFAULT, // Default Refresh Rate
D3DPRESENT_INTERVAL_DEFAULT // Default Presentation Interval (vertical sync)
};
// Check The Wanted Surface Format.
if ( FAILED( pD3D->CheckDeviceFormat( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
d3dpp.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
D3DRTYPE_SURFACE, d3dpp.AutoDepthStencilFormat ) ) )
{
KillD3DWindow(); // Reset The Display
MessageBox(NULL,"Can't Find Surface Format.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
// Create The DirectX 3D Device
if(FAILED( pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pD3DDevice ) ) )
{
KillD3DWindow(); // Reset The Display
MessageBox(NULL,"Can't Create DirectX 3D Device.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
ShowWindow(hWnd,SW_SHOW); // Show The Window
SetForegroundWindow(hWnd); // Slightly Higher Priority
SetFocus(hWnd); // Sets Keyboard Focus To The Window
ReSizeD3DScene(width, height); // Set Up Our Perspective D3D Screen
if (!InitD3D()) // Initialize Our Newly Created D3D Window
{
KillD3DWindow(); // Reset The Display
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
return TRUE;
}
LRESULT CALLBACK WndProc( HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
switch( uMsg )
{
case WM_ACTIVATE: // Watch For Window Activate Message
{
if (!HIWORD(wParam)) // Check Minimization State
{
active=TRUE; // Program Is Active
}
else
{
active=FALSE; // Program Is No Longer Active
}
return 0; // Return To The Message Loop
}
case WM_SYSCOMMAND: // Intercept System Commands
{
switch (wParam) // Check System Calls
{
case SC_SCREENSAVE: // Screensaver Trying To Start?
case SC_MONITORPOWER: // Monitor Trying To Enter Powersave?
return 0; // Prevent From Happening
}
break; // Exit
}
case WM_CLOSE: // Did We Receive A Close Message?
{
PostQuitMessage(0); // Send A Quit Message
return 0; // Jump Back
}
case WM_KEYDOWN: // Is A Key Being Held Down?
{
keys[wParam] = TRUE; // If So, Mark It As TRUE
return 0; // Jump Back
}
case WM_KEYUP: // Has A Key Been Released?
{
keys[wParam] = FALSE; // If So, Mark It As FALSE
return 0; // Jump Back
}
case WM_SIZE: // Resize The Direct3D Window
{
if(!fullscreen)
ReSizeD3DScene(LOWORD(lParam), HIWORD(lParam)); // LoWord=Width, HiWord=Height
return 0; // Jump Back
}
}
// Pass All Unhandled Messages To DefWindowProc
return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
int WINAPI WinMain( HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow )
{
MSG msg;
BOOL done=FALSE; // Bool Variable To Exit Loop
// Ask The User Which Screen Mode They Prefer
if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
{
fullscreen=FALSE; // Windowed Mode
}
// Create Our DirectX 3D Window
if (!CreateD3DWindow("APRON TUTORIALS",640,480,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
while(!done) // Loop That Runs While done=FALSE
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
{
if (msg.message==WM_QUIT) // Have We Received A Quit Message?
{
done=TRUE; // If So done=TRUE
}
else // If Not, Deal With Window Messages
{
TranslateMessage(&msg); // Translate The Message
DispatchMessage(&msg); // Dispatch The Message
}
}
else // If There Are No Messages
{
// Draw The Scene. Watch For ESC Key And Quit Messages From DrawD3DScene()
if ((active && !DrawD3DScene()) || keys[VK_ESCAPE]) // Active? Was There A Quit Received?
{
done=TRUE; // ESC or DrawD3DScene Signalled A Quit
}
if (keys[VK_F1]) // Is F1 Being Pressed?
{
keys[VK_F1]=FALSE; // If So Make Key FALSE
KillD3DWindow(); // Kill Our Current Window
fullscreen=!fullscreen; // Toggle Fullscreen / Windowed Mode
// Recreate Our DirectX 3D Window
if (!CreateD3DWindow("APRON TUTORIALS",640,480,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
}
}
}
// Shutdown
KillD3DWindow();
return (msg.wParam); // Exit The Program
}
Here is the shader I am using which was exported from the RenderMonkey Shadow example
//**************************************************************//
// Effect File exported by RenderMonkey 1.6
//
// - Although many improvements were made to RenderMonkey FX
// file export, there are still situations that may cause
// compilation problems once the file is exported, such as
// occasional naming conflicts for methods, since FX format
// does not support any notions of name spaces. You need to
// try to create workspaces in such a way as to minimize
// potential naming conflicts on export.
//
// - Note that to minimize resulting name collisions in the FX
// file, RenderMonkey will mangle names for passes, shaders
// and function names as necessary to reduce name conflicts.
//**************************************************************//
//--------------------------------------------------------------//
// Shadow Effects
//--------------------------------------------------------------//
//--------------------------------------------------------------//
// SoftShadows
//--------------------------------------------------------------//
//--------------------------------------------------------------//
// Object
//--------------------------------------------------------------//
string Shadow_Effects_SoftShadows_Object_Sphere : ModelData = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Models\\Sphere.3ds";
float4x4 view_proj_matrix : ViewProjection;
float4 lightPos
<
string UIName = "lightPos";
string UIWidget = "Direction";
bool UIVisible = true;
float4 UIMin = float4( -400.00, -400.00, -400.00, -400.00 );
float4 UIMax = float4( 400.00, 400.00, 400.00, 400.00 );
bool Normalize = false;
> = float4( -62.00, 104.00, 60.00, 0.00 );
float4 view_position : ViewPosition;
struct VS_OUTPUT {
float4 Pos: POSITION;
float3 normal: TEXCOORD0;
float3 lightVec: TEXCOORD1;
float3 viewVec: TEXCOORD2;
};
VS_OUTPUT Shadow_Effects_SoftShadows_Object_Vertex_Shader_main(float4 Pos: POSITION, float3 normal: NORMAL){
VS_OUTPUT Out;
Out.Pos = mul(view_proj_matrix, Pos);
// World-space lighting
Out.normal = normal;
Out.lightVec = lightPos - Pos.xyz;
Out.viewVec = view_position - Pos.xyz;
return Out;
}
float4 modelColor
<
string UIName = "modelColor";
string UIWidget = "Color";
bool UIVisible = true;
> = float4( 0.36, 0.45, 1.00, 1.00 );
float4 Shadow_Effects_SoftShadows_Object_Pixel_Shader_main(float3 normal: TEXCOORD0, float3 lightVec: TEXCOORD1, float3 viewVec: TEXCOORD2) : COLOR {
normal = normalize(normal);
lightVec = normalize(lightVec);
viewVec = normalize(viewVec);
// Simple standard lighting
float diffuse = 0.5 + 0.5 * dot(lightVec, normal);
float specular = pow(saturate(dot(reflect(-viewVec, normal), lightVec)), 16);
return diffuse * modelColor + 0.5 * specular;
}
//--------------------------------------------------------------//
// Light
//--------------------------------------------------------------//
string Shadow_Effects_SoftShadows_Light_Sphere : ModelData = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Models\\Sphere.3ds";
float4x4 Shadow_Effects_SoftShadows_Light_Vertex_Shader_view_proj_matrix : ViewProjection;
float4 Shadow_Effects_SoftShadows_Light_Vertex_Shader_lightPos
<
string UIName = "Shadow_Effects_SoftShadows_Light_Vertex_Shader_lightPos";
string UIWidget = "Direction";
bool UIVisible = true;
float4 UIMin = float4( -400.00, -400.00, -400.00, -400.00 );
float4 UIMax = float4( 400.00, 400.00, 400.00, 400.00 );
bool Normalize = false;
> = float4( -62.00, 104.00, 60.00, 0.00 );
struct Shadow_Effects_SoftShadows_Light_Vertex_Shader_VS_OUTPUT {
float4 Pos: POSITION;
};
Shadow_Effects_SoftShadows_Light_Vertex_Shader_VS_OUTPUT Shadow_Effects_SoftShadows_Light_Vertex_Shader_main(float4 Pos: POSITION){
Shadow_Effects_SoftShadows_Light_Vertex_Shader_VS_OUTPUT Out;
// Compensate for model not being a
// perfect sphere around origin
Pos.xyz = 10 * normalize(Pos.xyz);
// Get the light in place
Pos.xyz += Shadow_Effects_SoftShadows_Light_Vertex_Shader_lightPos;
Out.Pos = mul(Shadow_Effects_SoftShadows_Light_Vertex_Shader_view_proj_matrix, Pos);
return Out;
}
float4 Shadow_Effects_SoftShadows_Light_Pixel_Shader_main() : COLOR {
return 1;
}
//--------------------------------------------------------------//
// Depth
//--------------------------------------------------------------//
string Shadow_Effects_SoftShadows_Depth_Sphere : ModelData = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Models\\Sphere.3ds";
texture Depth_Tex : RenderColorTarget
<
float2 RenderTargetDimensions = {512,512};
string Format="D3DFMT_A8R8G8B8";
float ClearDepth=1.000000;
int ClearColor=0;
>;
float4x4 Shadow_Effects_SoftShadows_Depth_Vertex_Shader_view_proj_matrix;
float planeZ
<
string UIName = "planeZ";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = -100.00;
float UIMax = 0.00;
> = float( -59.00 );
float4 Shadow_Effects_SoftShadows_Depth_Vertex_Shader_lightPos
<
string UIName = "Shadow_Effects_SoftShadows_Depth_Vertex_Shader_lightPos";
string UIWidget = "Direction";
bool UIVisible = true;
float4 UIMin = float4( -400.00, -400.00, -400.00, -400.00 );
float4 UIMax = float4( 400.00, 400.00, 400.00, 400.00 );
bool Normalize = false;
> = float4( -62.00, 104.00, 60.00, 0.00 );
float planeSize
<
string UIName = "planeSize";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 1000.00;
> = float( 500.00 );
struct Shadow_Effects_SoftShadows_Depth_Vertex_Shader_VS_OUTPUT {
float4 Pos: POSITION;
float3 lVec: TEXCOORD0;
float3 sVec: TEXCOORD1;
};
Shadow_Effects_SoftShadows_Depth_Vertex_Shader_VS_OUTPUT Shadow_Effects_SoftShadows_Depth_Vertex_Shader_main(float4 Pos: POSITION, float3 normal: NORMAL){
Shadow_Effects_SoftShadows_Depth_Vertex_Shader_VS_OUTPUT Out;
// The z + planeZ = 0 plane
float4 plane = float4(0, 0, 1, -planeZ);
// We create a matrix that projects the model down into
// the plane. This is a task that's better done on the
// CPU and just passed to the vertex shader since it's
// constant for the whole model. However,in RenderMonkey
// we don't have that choice and will have to create it
// in the vertex shader instead.
float4x4 shadowMatrix;
shadowMatrix[0] = -Shadow_Effects_SoftShadows_Depth_Vertex_Shader_lightPos.x * plane;
shadowMatrix[1] = -Shadow_Effects_SoftShadows_Depth_Vertex_Shader_lightPos.y * plane;
shadowMatrix[2] = -Shadow_Effects_SoftShadows_Depth_Vertex_Shader_lightPos.z * plane;
shadowMatrix[3] = -plane;
float dist = dot(Shadow_Effects_SoftShadows_Depth_Vertex_Shader_lightPos, plane.xyz) - planeZ;
shadowMatrix[0].x += dist;
shadowMatrix[1].y += dist;
shadowMatrix[2].z += dist;
shadowMatrix[3].w += dist;
// Project the vertex down in the plane
float4 sPos = mul(shadowMatrix, Pos);
// Map the plane onto the rendertarget. The rendertarget
// will cover exactly the quad we put shadows on.
Out.Pos = float4(planeZ * sPos.xy / (planeSize * sPos.z), 0, 1);
// How blurry the shadows are supposed to be is determined
// by how far the vertex and the shadow is from the light.
Out.lVec = Shadow_Effects_SoftShadows_Depth_Vertex_Shader_lightPos - Pos.xyz;
// sPos.w will in general not be 1, so we'll have
// to do the perspective division
Out.sVec = Shadow_Effects_SoftShadows_Depth_Vertex_Shader_lightPos - sPos.xyz / sPos.w;
return Out;
}
float4 Shadow_Effects_SoftShadows_Depth_Pixel_Shader_main(float3 lVec: TEXCOORD0, float3 sVec: TEXCOORD1) : COLOR {
float lLen = length(lVec);
float sLen = length(sVec);
// Blurriness factor
return 1 - lLen / sLen;
}
//--------------------------------------------------------------//
// Dilate
//--------------------------------------------------------------//
string Shadow_Effects_SoftShadows_Dilate_Sphere : ModelData = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Models\\Sphere.3ds";
texture Dilate_Tex : RenderColorTarget
<
float2 RenderTargetDimensions = {512,512};
string Format="D3DFMT_A8R8G8B8";
float ClearDepth=1.000000;
int ClearColor=0;
>;
float4x4 Shadow_Effects_SoftShadows_Dilate_Vertex_Shader_view_proj_matrix;
struct Shadow_Effects_SoftShadows_Dilate_Vertex_Shader_VS_OUTPUT {
float4 Pos: POSITION;
float2 texCoord: TEXCOORD;
};
Shadow_Effects_SoftShadows_Dilate_Vertex_Shader_VS_OUTPUT Shadow_Effects_SoftShadows_Dilate_Vertex_Shader_main(float4 Pos: POSITION){
Shadow_Effects_SoftShadows_Dilate_Vertex_Shader_VS_OUTPUT Out;
// Clean up inaccuracies
Pos.xy = sign(Pos.xy);
Out.Pos = float4(Pos.xy, 0, 1);
// Image-space
Out.texCoord.x = 0.5 * (1 + Pos.x);
Out.texCoord.y = 0.5 * (1 - Pos.y);
return Out;
}
float dilateSize
<
string UIName = "dilateSize";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 0.10;
> = float( 0.02 );
sampler Depth = sampler_state
{
Texture = (Depth_Tex);
ADDRESSU = CLAMP;
ADDRESSV = CLAMP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
// Simple dilate filter. We need to dilate the blurriness
// render target since the blur needs to spread outside the
// source image. If we didn't dilate, the shadow would get
// end with a sharp edge after a partial blur.
const float2 samples[12] = {
-0.326212, -0.405805,
-0.840144, -0.073580,
-0.695914, 0.457137,
-0.203345, 0.620716,
0.962340, -0.194983,
0.473434, -0.480026,
0.519456, 0.767022,
0.185461, -0.893124,
0.507431, 0.064425,
0.896420, 0.412458,
-0.321940, -0.932615,
-0.791559, -0.597705,
};
float4 Shadow_Effects_SoftShadows_Dilate_Pixel_Shader_main(float2 texCoord: TEXCOORD) : COLOR {
float4 dilate = tex2D(Depth, texCoord);
for (int i = 0; i < 12; i++){
dilate = max(dilate, tex2D(Depth, texCoord + dilateSize * samples));
}
return dilate;
}
//--------------------------------------------------------------//
// Shadow
//--------------------------------------------------------------//
string Shadow_Effects_SoftShadows_Shadow_Sphere : ModelData = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Models\\Sphere.3ds";
texture Shadow_Tex : RenderColorTarget
<
float2 RenderTargetDimensions = {1024,1024};
string Format="D3DFMT_A8R8G8B8";
float ClearDepth=1.000000;
int ClearColor=0;
>;
float4x4 Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_view_proj_matrix;
float Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeZ
<
string UIName = "Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeZ";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = -100.00;
float UIMax = 0.00;
> = float( -59.00 );
float4 Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_lightPos
<
string UIName = "Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_lightPos";
string UIWidget = "Direction";
bool UIVisible = true;
float4 UIMin = float4( -400.00, -400.00, -400.00, -400.00 );
float4 UIMax = float4( 400.00, 400.00, 400.00, 400.00 );
bool Normalize = false;
> = float4( -62.00, 104.00, 60.00, 0.00 );
float Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeSize
<
string UIName = "Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeSize";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 1000.00;
> = float( 500.00 );
struct Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_VS_OUTPUT {
float4 Pos: POSITION;
};
Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_VS_OUTPUT Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_main(float4 Pos: POSITION){
Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_VS_OUTPUT Out;
// The z + Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeZ = 0 plane
float4 plane = float4(0, 0, 1, -Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeZ);
// We create a matrix that projects the model down into
// the plane. This is a task that's better done on the
// CPU and just passed to the vertex shader since it's
// constant for the whole model. However,in RenderMonkey
// we don't have that choice and will have to create it
// in the vertex shader instead.
float4x4 shadowMatrix;
shadowMatrix[0] = -Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_lightPos.x * plane;
shadowMatrix[1] = -Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_lightPos.y * plane;
shadowMatrix[2] = -Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_lightPos.z * plane;
shadowMatrix[3] = -plane;
float dist = dot(Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_lightPos, plane.xyz) - Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeZ;
shadowMatrix[0].x += dist;
shadowMatrix[1].y += dist;
shadowMatrix[2].z += dist;
shadowMatrix[3].w += dist;
// Project the vertex down in the plane
float4 sPos = mul(shadowMatrix, Pos);
// Map the plane onto the rendertarget. The rendertarget
// will cover exactly the quad we put shadows on.
Out.Pos = float4(Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeZ * sPos.xy / (Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_planeSize * sPos.z), 0, 1);
return Out;
}
float4 Shadow_Effects_SoftShadows_Shadow_Pixel_Shader_main() : COLOR {
return 1;
}
//--------------------------------------------------------------//
// Blur0
//--------------------------------------------------------------//
string Shadow_Effects_SoftShadows_Blur0_ScreenAlignedQuad : ModelData = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Models\\ScreenAlignedQuad.3ds";
texture Blur0_Tex : RenderColorTarget
<
float2 RenderTargetDimensions = {512,512};
string Format="D3DFMT_A8R8G8B8";
float ClearDepth=1.000000;
int ClearColor=0;
>;
float4x4 Shadow_Effects_SoftShadows_Blur0_Vertex_Shader_view_proj_matrix;
struct Shadow_Effects_SoftShadows_Blur0_Vertex_Shader_VS_OUTPUT {
float4 Pos: POSITION;
float2 texCoord: TEXCOORD;
};
Shadow_Effects_SoftShadows_Blur0_Vertex_Shader_VS_OUTPUT Shadow_Effects_SoftShadows_Blur0_Vertex_Shader_main(float4 Pos: POSITION){
Shadow_Effects_SoftShadows_Blur0_Vertex_Shader_VS_OUTPUT Out;
// Clean up inaccuracies
Pos.xy = sign(Pos.xy);
Out.Pos = float4(Pos.xy, 0, 1);
// Image-space
Out.texCoord.x = 0.5 * (1 + Pos.x);
Out.texCoord.y = 0.5 * (1 - Pos.y);
return Out;
}
float sampleDist0
<
string UIName = "sampleDist0";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 0.20;
> = float( 0.42 );
float depthBlur
<
string UIName = "depthBlur";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 15.00;
> = float( 6.45 );
sampler Dilate = sampler_state
{
Texture = (Dilate_Tex);
ADDRESSU = CLAMP;
ADDRESSV = CLAMP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
sampler Shadow = sampler_state
{
Texture = (Shadow_Tex);
ADDRESSU = CLAMP;
ADDRESSV = CLAMP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
const float2 Shadow_Effects_SoftShadows_Blur0_Pixel_Shader_samples[12] = {
-0.326212, -0.405805,
-0.840144, -0.073580,
-0.695914, 0.457137,
-0.203345, 0.620716,
0.962340, -0.194983,
0.473434, -0.480026,
0.519456, 0.767022,
0.185461, -0.893124,
0.507431, 0.064425,
0.896420, 0.412458,
-0.321940, -0.932615,
-0.791559, -0.597705,
};
float4 Shadow_Effects_SoftShadows_Blur0_Pixel_Shader_main(float2 texCoord: TEXCOORD) : COLOR {
float4 sum = tex2D(Shadow, texCoord);
// Blur filter kernel size
float x = tex2D(Dilate, texCoord).r;
float size = sampleDist0 * pow(x, depthBlur);
for (int i = 0; i < 12; i++){
sum += tex2D(Shadow, texCoord + size * Shadow_Effects_SoftShadows_Blur0_Pixel_Shader_samples);
}
return sum / 13;
}
//--------------------------------------------------------------//
// Blur1
//--------------------------------------------------------------//
string Shadow_Effects_SoftShadows_Blur1_ScreenAlignedQuad : ModelData = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Models\\ScreenAlignedQuad.3ds";
texture Blur1_Tex : RenderColorTarget
<
float2 RenderTargetDimensions = {512,512};
string Format="D3DFMT_A8R8G8B8";
float ClearDepth=1.000000;
int ClearColor=0;
>;
float4x4 Shadow_Effects_SoftShadows_Blur1_Vertex_Shader_view_proj_matrix;
struct Shadow_Effects_SoftShadows_Blur1_Vertex_Shader_VS_OUTPUT {
float4 Pos: POSITION;
float2 texCoord: TEXCOORD;
};
Shadow_Effects_SoftShadows_Blur1_Vertex_Shader_VS_OUTPUT Shadow_Effects_SoftShadows_Blur1_Vertex_Shader_main(float4 Pos: POSITION){
Shadow_Effects_SoftShadows_Blur1_Vertex_Shader_VS_OUTPUT Out;
// Clean up inaccuracies
Pos.xy = sign(Pos.xy);
Out.Pos = float4(Pos.xy, 0, 1);
// Image-space
Out.texCoord.x = 0.5 * (1 + Pos.x);
Out.texCoord.y = 0.5 * (1 - Pos.y);
return Out;
}
float sampleDist1
<
string UIName = "sampleDist1";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 0.20;
> = float( 0.16 );
float Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_depthBlur
<
string UIName = "Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_depthBlur";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 15.00;
> = float( 6.45 );
sampler Blur0 = sampler_state
{
Texture = (Blur0_Tex);
ADDRESSU = CLAMP;
ADDRESSV = CLAMP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
sampler Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_Dilate = sampler_state
{
Texture = (Dilate_Tex);
ADDRESSU = CLAMP;
ADDRESSV = CLAMP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
const float2 Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_samples[12] = {
-0.326212, -0.405805,
-0.840144, -0.073580,
-0.695914, 0.457137,
-0.203345, 0.620716,
0.962340, -0.194983,
0.473434, -0.480026,
0.519456, 0.767022,
0.185461, -0.893124,
0.507431, 0.064425,
0.896420, 0.412458,
-0.321940, -0.932615,
-0.791559, -0.597705,
};
float4 Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_main(float2 texCoord: TEXCOORD) : COLOR {
float4 sum = tex2D(Blur0, texCoord);
// Blur filter kernel size
float x = tex2D(Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_Dilate, texCoord).r;
float size = sampleDist1 * pow(x, Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_depthBlur);
for (int i = 0; i < 12; i++){
sum += tex2D(Blur0, texCoord + size * Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_samples);
}
return sum / 13;
}
//--------------------------------------------------------------//
// Plane
//--------------------------------------------------------------//
string Shadow_Effects_SoftShadows_Plane_ScreenAlignedQuad : ModelData = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Models\\ScreenAlignedQuad.3ds";
float4x4 Shadow_Effects_SoftShadows_Plane_Vertex_Shader_view_proj_matrix : ViewProjection;
float Shadow_Effects_SoftShadows_Plane_Vertex_Shader_planeZ
<
string UIName = "Shadow_Effects_SoftShadows_Plane_Vertex_Shader_planeZ";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = -100.00;
float UIMax = 0.00;
> = float( -59.00 );
float4 Shadow_Effects_SoftShadows_Plane_Vertex_Shader_lightPos
<
string UIName = "Shadow_Effects_SoftShadows_Plane_Vertex_Shader_lightPos";
string UIWidget = "Direction";
bool UIVisible = true;
float4 UIMin = float4( -400.00, -400.00, -400.00, -400.00 );
float4 UIMax = float4( 400.00, 400.00, 400.00, 400.00 );
bool Normalize = false;
> = float4( -62.00, 104.00, 60.00, 0.00 );
float4 Shadow_Effects_SoftShadows_Plane_Vertex_Shader_view_position : ViewPosition;
float Shadow_Effects_SoftShadows_Plane_Vertex_Shader_planeSize
<
string UIName = "Shadow_Effects_SoftShadows_Plane_Vertex_Shader_planeSize";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 1000.00;
> = float( 500.00 );
struct Shadow_Effects_SoftShadows_Plane_Vertex_Shader_VS_OUTPUT {
float4 Pos: POSITION;
float2 texCoord: TEXCOORD0;
float3 normal: TEXCOORD1;
float3 lightVec: TEXCOORD2;
float3 viewVec: TEXCOORD3;
};
Shadow_Effects_SoftShadows_Plane_Vertex_Shader_VS_OUTPUT Shadow_Effects_SoftShadows_Plane_Vertex_Shader_main(float4 Pos: POSITION, float3 normal: NORMAL){
Shadow_Effects_SoftShadows_Plane_Vertex_Shader_VS_OUTPUT Out;
// Image-space
Out.texCoord.x = 0.5 * (1 + Pos.x);
Out.texCoord.y = 0.5 * (1 - Pos.y);
// Put the plane into place
Pos.xy *= Shadow_Effects_SoftShadows_Plane_Vertex_Shader_planeSize;
Pos.z = Shadow_Effects_SoftShadows_Plane_Vertex_Shader_planeZ;
Out.Pos = mul(Shadow_Effects_SoftShadows_Plane_Vertex_Shader_view_proj_matrix, Pos);
// World-space lighting
Out.normal = normal;
Out.lightVec = Shadow_Effects_SoftShadows_Plane_Vertex_Shader_lightPos - Pos.xyz;
Out.viewVec = Shadow_Effects_SoftShadows_Plane_Vertex_Shader_view_position - Pos.xyz;
return Out;
}
float ambient
<
string UIName = "ambient";
string UIWidget = "Numeric";
bool UIVisible = true;
float UIMin = 0.00;
float UIMax = 1.00;
> = float( 0.30 );
sampler Blur1 = sampler_state
{
Texture = (Blur1_Tex);
ADDRESSU = CLAMP;
ADDRESSV = CLAMP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
texture Floor_Tex
<
string ResourceName = "..\\..\\..\\..\\..\\..\\..\\Program Files\\AMD\\RenderMonkey 1.81\\Examples\\Media\\Textures\\Wood.dds";
>;
sampler Floor = sampler_state
{
Texture = (Floor_Tex);
ADDRESSU = CLAMP;
ADDRESSV = CLAMP;
MAGFILTER = LINEAR;
MINFILTER = LINEAR;
MIPFILTER = LINEAR;
};
float4 Shadow_Effects_SoftShadows_Plane_Pixel_Shader_main(float2 texCoord: TEXCOORD0, float3 normal: TEXCOORD1, float3 lightVec: TEXCOORD2, float3 viewVec: TEXCOORD3) : COLOR {
normal = normalize(normal);
lightVec = normalize(lightVec);
viewVec = normalize(viewVec);
float4 base = tex2D(Floor, texCoord);
// The last blur gives us the shadow factor
float shadow = 1 - tex2D(Blur1, texCoord).r;
// Basic lighting
float diffuse = 0.5 + 0.5 * dot(lightVec, normal);
float specular = pow(saturate(dot(reflect(-viewVec, normal), lightVec)), 16);
return (shadow * diffuse + ambient) * base + 0.4 * shadow * specular;
}
//--------------------------------------------------------------//
// Technique Section for Shadow Effects
//--------------------------------------------------------------//
technique SoftShadows
{
pass Object
{
ZWRITEENABLE = TRUE;
CULLMODE = CCW;
VertexShader = compile vs_1_1 Shadow_Effects_SoftShadows_Object_Vertex_Shader_main();
PixelShader = compile ps_2_0 Shadow_Effects_SoftShadows_Object_Pixel_Shader_main();
}
pass Light
{
CULLMODE = CCW;
VertexShader = compile vs_1_1 Shadow_Effects_SoftShadows_Light_Vertex_Shader_main();
PixelShader = compile ps_2_0 Shadow_Effects_SoftShadows_Light_Pixel_Shader_main();
}
pass Depth
<
string Script = "RenderColorTarget0 = Depth_Tex;"
"ClearColor = (0, 0, 0, 0);"
"ClearDepth = 1.000000;";
>
{
ZWRITEENABLE = FALSE;
SRCBLEND = ONE;
DESTBLEND = ONE;
CULLMODE = NONE;
ALPHABLENDENABLE = TRUE;
BLENDOP = MAX;
VertexShader = compile vs_1_1 Shadow_Effects_SoftShadows_Depth_Vertex_Shader_main();
PixelShader = compile ps_2_0 Shadow_Effects_SoftShadows_Depth_Pixel_Shader_main();
}
pass Dilate
<
string Script = "RenderColorTarget0 = Dilate_Tex;"
"ClearColor = (0, 0, 0, 0);"
"ClearDepth = 1.000000;";
>
{
ZWRITEENABLE = FALSE;
CULLMODE = NONE;
ALPHABLENDENABLE = FALSE;
VertexShader = compile vs_1_1 Shadow_Effects_SoftShadows_Dilate_Vertex_Shader_main();
PixelShader = compile ps_2_0 Shadow_Effects_SoftShadows_Dilate_Pixel_Shader_main();
}
pass Shadow
<
string Script = "RenderColorTarget0 = Shadow_Tex;"
"ClearColor = (0, 0, 0, 0);"
"ClearDepth = 1.000000;";
>
{
ZWRITEENABLE = FALSE;
CULLMODE = NONE;
ALPHABLENDENABLE = FALSE;
VertexShader = compile vs_1_1 Shadow_Effects_SoftShadows_Shadow_Vertex_Shader_main();
PixelShader = compile ps_2_0 Shadow_Effects_SoftShadows_Shadow_Pixel_Shader_main();
}
pass Blur0
<
string Script = "RenderColorTarget0 = Blur0_Tex;"
"ClearColor = (0, 0, 0, 0);"
"ClearDepth = 1.000000;";
>
{
CULLMODE = NONE;
VertexShader = compile vs_1_1 Shadow_Effects_SoftShadows_Blur0_Vertex_Shader_main();
PixelShader = compile ps_2_0 Shadow_Effects_SoftShadows_Blur0_Pixel_Shader_main();
}
pass Blur1
<
string Script = "RenderColorTarget0 = Blur1_Tex;"
"ClearColor = (0, 0, 0, 0);"
"ClearDepth = 1.000000;";
>
{
VertexShader = compile vs_1_1 Shadow_Effects_SoftShadows_Blur1_Vertex_Shader_main();
PixelShader = compile ps_2_0 Shadow_Effects_SoftShadows_Blur1_Pixel_Shader_main();
}
pass Plane
{
ZWRITEENABLE = TRUE;
CULLMODE = NONE;
ALPHABLENDENABLE = FALSE;
VertexShader = compile vs_1_1 Shadow_Effects_SoftShadows_Plane_Vertex_Shader_main();
PixelShader = compile ps_2_0 Shadow_Effects_SoftShadows_Plane_Pixel_Shader_main();
}
}
