Sorry your browser is not supported!

/*********************************************************************NVMH3****
File:  $Id: //sw/devrel/SDK/MEDIA/HLSL/BumpReflectHLSL.fx#4 $

Copyright NVIDIA Corporation 2002
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.


Comments:
	Bumped reflection, DX9

******************************************************************************/

/// un-tweakables //////////////////////

float4x4 worldMatrix : World < string UIWidget="None"; >;	// World or Model matrix
float4x4 wvpMatrix : WorldViewProjection < string UIWidget="None"; >;	// Model*View*Projection
float4x4 worldViewMatrix : WorldView < string UIWidget="None"; >;
float4x4 worldViewMatrixI : WorldViewInverse < string UIWidget="None"; >;
float4x4 viewInverseMatrix : ViewInverse < string UIWidget="None"; >;
float4x4 viewMatrix : View < string UIWidget="None"; >;

// Tweakables /////////////////

float bumpHeight
<
	string UIWidget = "slider";
	float UIMin = 0.0;
	float UIMax = 2.0;
	float UIStep = 0.1;
> = 0.5;

///////////////////

texture normalMap : NORMAL
<
	string ResourceName = "default_bump_normal.dds";
    string TextureType = "2D";
>;

texture cubeMap : ENVIRONMENT
<
	string ResourceName = "nvlobby_cube_mipmap.dds";
	string TextureType = "Cube";
>;

sampler2D normalMapSampler = sampler_state
{
	Texture = <normalMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

samplerCUBE envMapSampler = sampler_state
{
	Texture = <cubeMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

/////////////////////////////

struct a2v {
	float4 Position : POSITION; //in object space
	float3 TexCoord : TEXCOORD0;
	float3 Tangent : TANGENT0; //in object space
	float3 Binormal : BINORMAL0; //in object space
	float3 Normal : NORMAL; //in object space
};

struct v2f {
	float4 Position : POSITION; //in projection space
	float4 TexCoord : TEXCOORD0;
	float4 TexCoord1 : TEXCOORD1; //first row of the 3x3 transform from tangent to cube space
	float4 TexCoord2 : TEXCOORD2; //second row of the 3x3 transform from tangent to cube space
	float4 TexCoord3 : TEXCOORD3; //third row of the 3x3 transform from tangent to cube space
};

///////////////// vertex shader //////////////////

v2f BumpReflectVS(a2v IN,
		uniform float4x4 WorldViewProj,
		uniform float4x4 World,
		uniform float4x4 ViewIT)
{
	v2f OUT;
	// Position in screen space.
	OUT.Position = mul(IN.Position, WorldViewProj);
	// pass texture coordinates for fetching the normal map
	OUT.TexCoord.xyz = IN.TexCoord;
	OUT.TexCoord.w = 1.0;
	// compute the 4x4 tranform from tangent space to object space
	float3x3 TangentToObjSpace;
	// first rows are the tangent and binormal scaled by the bump scale
	TangentToObjSpace[0] = float3(IN.Tangent.x, IN.Binormal.x, IN.Normal.x);
	TangentToObjSpace[1] = float3(IN.Tangent.y, IN.Binormal.y, IN.Normal.y);
	TangentToObjSpace[2] = float3(IN.Tangent.z, IN.Binormal.z, IN.Normal.z);
	OUT.TexCoord1.x = dot(World[0].xyz, TangentToObjSpace[0]);
    OUT.TexCoord1.y = dot(World[1].xyz, TangentToObjSpace[0]);
    OUT.TexCoord1.z = dot(World[2].xyz, TangentToObjSpace[0]);
	OUT.TexCoord2.x = dot(World[0].xyz, TangentToObjSpace[1]);
    OUT.TexCoord2.y = dot(World[1].xyz, TangentToObjSpace[1]);
    OUT.TexCoord2.z = dot(World[2].xyz, TangentToObjSpace[1]);
	OUT.TexCoord3.x = dot(World[0].xyz, TangentToObjSpace[2]);
    OUT.TexCoord3.y = dot(World[1].xyz, TangentToObjSpace[2]);
    OUT.TexCoord3.z = dot(World[2].xyz, TangentToObjSpace[2]);
	float4 worldPos = mul(IN.Position, World);
	// compute the eye vector (going from shaded point to eye) in cube space
	float4 eyeVector = worldPos - ViewIT[3]; // view inv. transpose contains eye position in world space in last row.
	OUT.TexCoord1.w = eyeVector.x;
	OUT.TexCoord2.w = eyeVector.y;
	OUT.TexCoord3.w = eyeVector.z;
	return OUT;
}

///////////////// pixel shader //////////////////

float4 BumpReflectPS(v2f IN,
				uniform sampler2D NormalMap,
				uniform samplerCUBE EnvironmentMap,
                uniform float BumpScale) : COLOR
{
	// fetch the bump normal from the normal map
	float3 normal = tex2D(NormalMap, IN.TexCoord.xy).xyz * 2.0 - 1.0;
    normal = normalize(float3(normal.x * BumpScale, normal.y * BumpScale, normal.z)); 
	// transform the bump normal into cube space
	// then use the transformed normal and eye vector to compute a reflection vector
	// used to fetch the cube map
	// (we multiply by 2 only to increase brightness)
    float3 eyevec = float3(IN.TexCoord1.w, IN.TexCoord2.w, IN.TexCoord3.w);
    float3 worldNorm;
    worldNorm.x = dot(IN.TexCoord1.xyz,normal);
    worldNorm.y = dot(IN.TexCoord2.xyz,normal);
    worldNorm.z = dot(IN.TexCoord3.xyz,normal);
    float3 lookup = reflect(eyevec, worldNorm);
    return texCUBE(EnvironmentMap, lookup);
}

//////////////////////////////// technique ////////////////

technique BumpReflect0
{
	pass p0
	{
		VertexShader = compile vs_2_0 BumpReflectVS(wvpMatrix,worldMatrix,viewInverseMatrix);
		
		Zenable = true;
		ZWriteEnable = true;
		CullMode = None;

		PixelShader = compile ps_2_0 BumpReflectPS(normalMapSampler,envMapSampler,bumpHeight);
	}
}

technique ReflectNoPixelShader
{
    pass p0
    {
		Zenable = true;
		ZWriteEnable = true;
		CullMode = None;
		NormalizeNormals = true;
		LocalViewer = true;

        TextureFactor = 0x008080ff; // 808080FF == 0,0,0,1

        TexCoordIndex[ 1 ] = 1 | CameraSpaceReflectionVector;

        TextureTransform[ 1 ] = <worldViewMatrix>;

        TextureTransformFlags[1] = Count3;

		Texture[1] = <cubeMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Point;

		Texture[0] = <normalMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Point;

		ColorOp[0] = DotProduct3; 
		ColorArg1[0] = Texture;
		ColorArg2[0] = TFactor;
		AlphaOp[0] = SelectArg1;
		AlphaArg1[0] = Texture;
		AlphaArg2[0] = Current;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
		AlphaOp[1] = SelectArg1;
		AlphaArg1[1] = Current;
		AlphaArg2[1] = Current;
    }

    pass p1
    {
		Zenable = true;
		ZWriteEnable = false;
		CullMode = None;
		NormalizeNormals = true;
		LocalViewer = true;

        TextureFactor = 0x0000ff80;

        TextureTransform[ 1 ] = <worldViewMatrixI>;
        TexCoordIndex[ 1 ] = 1 | CameraSpaceReflectionVector;

        TextureTransformFlags[1] = Count3;

		Texture[1] = <cubeMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Point;

		Texture[0] = <normalMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Point;

		ColorOp[0] = DotProduct3; 
		ColorArg1[0] = Texture;
		ColorArg2[0] = TFactor;
		AlphaOp[0] = SelectArg1;
		AlphaArg1[0] = Texture;
		AlphaArg2[0] = Current;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
		AlphaOp[1] = SelectArg2;
		AlphaArg1[1] = Texture;
		AlphaArg2[1] = Current;

        SrcBlend = SrcAlpha;
        DestBlend = InvSrcAlpha;
        AlphaBlendEnable = true;
    }

    pass p2
    {
		Zenable = true;
		ZWriteEnable = false;
		CullMode = None;
		NormalizeNormals = true;
		LocalViewer = true;

        TextureFactor = 0x00ff0080; 

        TextureTransform[ 1 ] = <worldViewMatrixI>;
        TexCoordIndex[ 1 ] = 1 | CameraSpaceReflectionVector;

        TextureTransformFlags[1] = Count3;

		Texture[1] = <cubeMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Point;

		Texture[0] = <normalMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Point;

		ColorOp[0] = DotProduct3; 
		ColorArg1[0] = Texture;
		ColorArg2[0] = TFactor;
		AlphaOp[0] = SelectArg1;
		AlphaArg1[0] = Texture;
		AlphaArg2[0] = Current;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
		AlphaOp[1] = SelectArg2;
		AlphaArg1[1] = Texture;
		AlphaArg2[1] = Current;

         SrcBlend = SrcAlpha;
        DestBlend = InvSrcAlpha;
       AlphaBlendEnable = true;
    }
}

/////////////////////// eof ///

/// un-tweakables //////////////////////

float4x4 worldMatrix : World < string UIWidget="None"; >;	// World or Model matrix
float4x4 wvpMatrix : WorldViewProjection < string UIWidget="None"; >;	// Model*View*Projection
float4x4 worldViewMatrix : WorldView < string UIWidget="None"; >;
float4x4 worldViewMatrixI : WorldViewInverse < string UIWidget="None"; >;
float4x4 viewInverseMatrix : ViewInverse < string UIWidget="None"; >;
float4x4 viewMatrix : View < string UIWidget="None"; >;

float4x4 worldMatrix : World < string UIWidget="None"; >;

// Tweakables /////////////////

float bumpHeight
<
	string UIWidget = "slider";
	float UIMin = 0.0;
	float UIMax = 2.0;
	float UIStep = 0.1;
> = 0.5;

///////////////////

texture normalMap : NORMAL
<
	string ResourceName = "default_bump_normal.dds";
    string TextureType = "2D";
>;

texture cubeMap : ENVIRONMENT
<
	string ResourceName = "nvlobby_cube_mipmap.dds";
	string TextureType = "Cube";
>;

sampler2D normalMapSampler = sampler_state
{
	Texture = <normalMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

samplerCUBE envMapSampler = sampler_state
{
	Texture = <cubeMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

string Resource = "default_bump_normal.dds";

string name = "default_bump_normal.dds";

string name = "nvlobby_cube_mipmap.dds";

struct a2v {
	float4 Position : POSITION; //in object space
	float3 TexCoord : TEXCOORD0;
	float3 Tangent : TANGENT0; //in object space
	float3 Binormal : BINORMAL0; //in object space
	float3 Normal : NORMAL; //in object space
};

struct v2f {
	float4 Position : POSITION; //in projection space
	float4 TexCoord : TEXCOORD0;
	float4 TexCoord1 : TEXCOORD1; //first row of the 3x3 transform from tangent to cube space
	float4 TexCoord2 : TEXCOORD2; //second row of the 3x3 transform from tangent to cube space
	float4 TexCoord3 : TEXCOORD3; //third row of the 3x3 transform from tangent to cube space
};

///////////////// vertex shader //////////////////

v2f BumpReflectVS(a2v IN,
		uniform float4x4 WorldViewProj,
		uniform float4x4 World,
		uniform float4x4 ViewIT)
{
	v2f OUT;
	// Position in screen space.
	OUT.Position = mul(IN.Position, WorldViewProj);
	// pass texture coordinates for fetching the normal map
	OUT.TexCoord.xyz = IN.TexCoord;
	OUT.TexCoord.w = 1.0;
	// compute the 4x4 tranform from tangent space to object space
	float3x3 TangentToObjSpace;
	// first rows are the tangent and binormal scaled by the bump scale
	TangentToObjSpace[0] = float3(IN.Tangent.x, IN.Binormal.x, IN.Normal.x);
	TangentToObjSpace[1] = float3(IN.Tangent.y, IN.Binormal.y, IN.Normal.y);
	TangentToObjSpace[2] = float3(IN.Tangent.z, IN.Binormal.z, IN.Normal.z);
	OUT.TexCoord1.x = dot(World[0].xyz, TangentToObjSpace[0]);
    OUT.TexCoord1.y = dot(World[1].xyz, TangentToObjSpace[0]);
    OUT.TexCoord1.z = dot(World[2].xyz, TangentToObjSpace[0]);
	OUT.TexCoord2.x = dot(World[0].xyz, TangentToObjSpace[1]);
    OUT.TexCoord2.y = dot(World[1].xyz, TangentToObjSpace[1]);
    OUT.TexCoord2.z = dot(World[2].xyz, TangentToObjSpace[1]);
	OUT.TexCoord3.x = dot(World[0].xyz, TangentToObjSpace[2]);
    OUT.TexCoord3.y = dot(World[1].xyz, TangentToObjSpace[2]);
    OUT.TexCoord3.z = dot(World[2].xyz, TangentToObjSpace[2]);
	float4 worldPos = mul(IN.Position, World);
	// compute the eye vector (going from shaded point to eye) in cube space
	float4 eyeVector = worldPos - ViewIT[3]; // view inv. transpose contains eye position in world space in last row.
	OUT.TexCoord1.w = eyeVector.x;
	OUT.TexCoord2.w = eyeVector.y;
	OUT.TexCoord3.w = eyeVector.z;
	return OUT;
}

///////////////// pixel shader //////////////////

float4 BumpReflectPS(v2f IN,
				uniform sampler2D NormalMap,
				uniform samplerCUBE EnvironmentMap,
                uniform float BumpScale) : COLOR
{
	// fetch the bump normal from the normal map
	float3 normal = tex2D(NormalMap, IN.TexCoord.xy).xyz * 2.0 - 1.0;
    normal = normalize(float3(normal.x * BumpScale, normal.y * BumpScale, normal.z)); 
	// transform the bump normal into cube space
	// then use the transformed normal and eye vector to compute a reflection vector
	// used to fetch the cube map
	// (we multiply by 2 only to increase brightness)
    float3 eyevec = float3(IN.TexCoord1.w, IN.TexCoord2.w, IN.TexCoord3.w);
    float3 worldNorm;
    worldNorm.x = dot(IN.TexCoord1.xyz,normal);
    worldNorm.y = dot(IN.TexCoord2.xyz,normal);
    worldNorm.z = dot(IN.TexCoord3.xyz,normal);
    float3 lookup = reflect(eyevec, worldNorm);
    return texCUBE(EnvironmentMap, lookup);
}

//////////////////////////////// technique ////////////////

technique BumpReflect0
{
	pass p0
	{
		VertexShader = compile vs_2_0 BumpReflectVS(wvpMatrix,worldMatrix,viewInverseMatrix);
		
		Zenable = true;
		ZWriteEnable = true;
		CullMode = None;

		PixelShader = compile ps_2_0 BumpReflectPS(normalMapSampler,envMapSampler,bumpHeight);
	}
}

technique ReflectNoPixelShader
{
    pass p0
    {
		Zenable = true;
		ZWriteEnable = true;
		CullMode = None;
		NormalizeNormals = true;
		LocalViewer = true;

        TextureFactor = 0x008080ff; // 808080FF == 0,0,0,1

        TexCoordIndex[ 1 ] = 1 | CameraSpaceReflectionVector;

        TextureTransform[ 1 ] = <worldViewMatrix>;

        TextureTransformFlags[1] = Count3;

		Texture[1] = <cubeMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Point;

		Texture[0] = <normalMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Point;

		ColorOp[0] = DotProduct3; 
		ColorArg1[0] = Texture;
		ColorArg2[0] = TFactor;
		AlphaOp[0] = SelectArg1;
		AlphaArg1[0] = Texture;
		AlphaArg2[0] = Current;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
		AlphaOp[1] = SelectArg1;
		AlphaArg1[1] = Current;
		AlphaArg2[1] = Current;
    }

    pass p1
    {
		Zenable = true;
		ZWriteEnable = false;
		CullMode = None;
		NormalizeNormals = true;
		LocalViewer = true;

        TextureFactor = 0x0000ff80;

        TextureTransform[ 1 ] = <worldViewMatrixI>;
        TexCoordIndex[ 1 ] = 1 | CameraSpaceReflectionVector;

        TextureTransformFlags[1] = Count3;

		Texture[1] = <cubeMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;

		MipFilter[1] = Point;

		Texture[0] = <normalMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Point;

		ColorOp[0] = DotProduct3; 
		ColorArg1[0] = Texture;
		ColorArg2[0] = TFactor;
		AlphaOp[0] = SelectArg1;
		AlphaArg1[0] = Texture;
		AlphaArg2[0] = Current;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
		AlphaOp[1] = SelectArg2;
		AlphaArg1[1] = Texture;
		AlphaArg2[1] = Current;

        SrcBlend = SrcAlpha;
        DestBlend = InvSrcAlpha;
        AlphaBlendEnable = true;
    }

    pass p2
    {
		Zenable = true;
		ZWriteEnable = false;
		CullMode = None;
		NormalizeNormals = true;
		LocalViewer = true;

        TextureFactor = 0x00ff0080; 

        TextureTransform[ 1 ] = <worldViewMatrixI>;
        TexCoordIndex[ 1 ] = 1 | CameraSpaceReflectionVector;

        TextureTransformFlags[1] = Count3;

		Texture[1] = <cubeMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Point;

		Texture[0] = <normalMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Point;

		ColorOp[0] = DotProduct3; 
		ColorArg1[0] = Texture;
		ColorArg2[0] = TFactor;
		AlphaOp[0] = SelectArg1;
		AlphaArg1[0] = Texture;
		AlphaArg2[0] = Current;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
		AlphaOp[1] = SelectArg2;
		AlphaArg1[1] = Texture;
		AlphaArg2[1] = Current;

         SrcBlend = SrcAlpha;
        DestBlend = InvSrcAlpha;
       AlphaBlendEnable = true;
    }
}

load effect "BumpReflectHLSL.fx",1,1
make object sphere 1,10,100,100 : `Make it highly tessellated.
set object effect 1,1

PERFORM CHECKLIST FOR EFFECT VALUES 1


do


  FOR C=1 TO CHECKLIST QUANTITY()
   PRINT "Name:";CHECKLIST STRING$(C);
   PRINT "  Vartype:";CHECKLIST VALUE (C);
   PRINT "  Hook:";CHECKLIST VALUE B(C)
  NEXT C

loop

set effect constant float 1,"bumpHeight", 0.5

null = make matrix4(1)
null = make matrix4(2)

world matrix4 1
view matrix4 2

multiply matrix4 1, 1, 2

null# = inverse matrix4(1,1)

set effect constant matrix 1, "worldViewMatrixI", 1

null# = inverse matrix4(2,2)

set effect constant matrix 1, "viewInverseMatrix", 2

/*********************************************************************NVMH3****
File:  $Id: //sw/devtools/FXComposer1.0/SDK/MEDIA/HLSL/goochy.fx#6 $

Copyright NVIDIA Corporation 2002
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.


Comments:
    Gooch-style diffuse texturing, calculated per-vertex.

******************************************************************************/

/************* TWEAKABLES **************/

float4x4 WorldIT : WorldIT < string UIWidget="None"; >;
float4x4 WorldViewProj : WorldViewProjection < string UIWidget="None"; >;
float4x4 World : World < string UIWidget="None"; >;

float4 LightPos : Position
<
	string Object = "PointLight";
	string Space = "World";
> = {100.0f, 100.0f, 100.0f, 0.0f};

float4 LiteColor : Diffuse <
    string UIName =  "Bright Surface Color";
    string UIWidget = "Color";
> = {0.8f, 0.5f, 0.1f, 1.0f};

float4 DarkColor <
    string UIName =  "Dark Surface Color";
    string UIWidget = "Color";
> = {0.0f, 0.0f, 0.0f, 1.0f};

float4 WarmColor <
    string UIName =  "Gooch warm tone";
    string UIWidget = "Color";
> = {0.5f, 0.4f, 0.05f, 1.0f};

float4 CoolColor <
    string UIName =  "Gooch cool tone";
    string UIWidget = "Color";
> = {0.05f, 0.05f, 0.6f, 1.0f};

/************* DATA STRUCTS **************/

/* data from application vertex buffer */
struct appdata {
    float3 Position	: POSITION;
    // float4 UV		: TEXCOORD0;
    float4 Normal	: NORMAL;
};

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
    float4 HPosition	: POSITION;
    // float4 TexCoord0	: TEXCOORD0;
    float4 diffCol	: COLOR0;
};

/*********** vertex shader ******/

vertexOutput goochVS(appdata IN)
{
    vertexOutput OUT;
    float3 Nn = normalize(mul(IN.Normal, WorldIT).xyz);
    float4 Po = float4(IN.Position.xyz,1);
    //compute worldspace position
    float3 Pw = mul(Po, World).xyz;
    float3 Ln = normalize(LightPos - Pw);
    float mixer = 0.5 * (dot(Ln,Nn) + 1.0);
    float4 surfColor = lerp(DarkColor,LiteColor,mixer);
    float4 toneColor = lerp(CoolColor,WarmColor,mixer);
    float4 mixColor = surfColor + toneColor;
    mixColor.w = 1.0;
    OUT.diffCol = mixColor;
    // OUT.TexCoord0 = IN.UV;
    OUT.HPosition = mul(Po, WorldViewProj);
    return OUT;
}

/*************/

technique NoPixelShaderVersion
{
    pass p0 
    {		
	    VertexShader = compile vs_1_1 goochVS();
	    ZEnable = true;
	    ZWriteEnable = true;
	    CullMode = None;
        SpecularEnable = false;
        ColorArg1[ 0 ] = Diffuse;
        ColorOp[ 0 ]   = SelectArg1;
        ColorArg2[ 0 ] = Specular;
        AlphaArg1[ 0 ] = Diffuse;
        AlphaOp[ 0 ]   = SelectArg1;
    }
}

/***************************** eof ***/

rem Load and set our effect and make a sphere.
load effect "goochy.fx",1,1
make object sphere 1,100
set object effect 1,1

`Standard setup code.
sync on : sync rate 60
global FrameTime as integer

`Will need this for our input routines.
global KeyCode as integer

`-------Need these for our print routines
type PrintQueue
   StringToPrint as string
   Tag as integer
   TimeToTerminate as integer
   TextX as integer
   TextY as integer
   DisplayNum as integer
endtype

type Space
   ScreenY as integer
   Occupied as boolean
endtype

dim PrintQ() as PrintQueue
dim DisplaySpace(5) as Space

`Setup ScreenY values
DisplaySpace(1).ScreenY = 0
DisplaySpace(2).ScreenY = 12
DisplaySpace(3).ScreenY = 24
DisplaySpace(4).ScreenY = 36
DisplaySpace(5).ScreenY = 48
`---------------------------------------

`Create needed vectors.
null = make vector4(1)
null = make vector4(2)
null = make vector4(3)
null = make vector4(4)
null = make vector4(5)

`Set constant data. Should be the same as in goochy.
set vector4 1, 0.8, 0.5, 0.1, 1.0 : `diffuse
set vector4 2, 0.0, 0.0, 0.0, 1.0 : `Dark color
set vector4 3, 0.5, 0.4, 0.05, 1.0 : `Warm color
set vector4 4, 0.05, 0.05, 0.6, 1.0 : `Cool color
set vector4 5, 110.0, 110.0, 110.0, 0.0 : `Light pos

rem here in case we want to use the FX Composer version
rem which doesn't have the WorldIT after WorldIT
null = make matrix4(1) : `worldinversetranspose
world matrix4 1
null = inverse matrix4( 1,1)
transpose matrix4 1,1

`Set all of my effect constants
set effect constant vector 1,"LiteColor",1
set effect constant vector 1,"DarkColor",2
set effect constant vector 1,"WarmColor",3
set effect constant vector 1,"CoolColor",4
set effect constant vector 1,"LightPos", 5

`------------------------------------------------------
`--------------------MAIN LOOP-------------------------
`------------------------------------------------------
do
   `Uncomment this to see the values that are needed by the file.
   remstart
   PERFORM CHECKLIST FOR EFFECT VALUES 1
   FOR C=1 TO CHECKLIST QUANTITY()
      PRINT "Name:";CHECKLIST STRING$(C);"  Vartype:";CHECKLIST VALUE A(C);" Hook:";CHECKLIST VALUE B(C)
      NEXT C
   remend

   rem Holds the time for the current frame. Used in printing
   rem routines.
   FrameTime = timer()

   rem move light according to where mouse is. Taken from one
   rem of the DBPro example files.
   position light 0,mousex()-320,240-mousey(),-200

   rem update light vector.
   x# = light position x(0) : y# = light position y(0) : z# = light position z(0)
   set vector4 5, x#, y#, z#, 0.0
   set effect constant vector 1,"LightPos", 5

   rem Look for user input and modify these effect constants
   rem accordingly.
   ChangeLiteColor() : `Upkey - Increment DownKey - Decrement
   ChangeDarkColor() : `Leftkey - Increment RightKey - Decrement
   ChangeWarmColor() : `W - Increment S - Decrement
   ChangeCoolColor() : `A - Increment D - Decrement

   rem Print what was modified to the screen for 3 seconds.
   PrintInfo()
   rem Account for DBP's array delete element command being
   rem broken.
   CheapHack()
   `render everything to the screen.
   fastsync
loop

function ChangeLiteColor()

rem If upkey is pressed increment the LiteColor
if keystate(200) = 1 and KeyCode <> 200
   rem Increment the Lite Color
   x# = x vector4(1) : y# = y vector4(1) : z# = z vector4(1)
   x# = x# + 0.05 : y# = y# + 0.05 : z# = z# + 0.05
   set vector4 1, x#, y#, z#, 1.0

   rem Set to the current scancode.
   rem This is to prevent the key from registering
   rem more than once. That way if it is held down
   rem for any period of time it will only increment the
   rem value once.
   KeyCode = 200

   rem Check for identical message.
   rem If we don't find one make a new
   rem message.
   result = CheckForIdenticalTag(0)

   if result = 0
     `Add a new item to the list of things to be printed.
      Array Insert at Top PrintQ()
      `Get the screen height and tag for the new item.
      num = GetFreeSpace()
      newy = DisplaySpace(num).ScreenY
      `Make sure that Display Space is flaged as occupied.
      DisplaySpace(num).Occupied = 1
      `Set the new items screen y and its associated display space.
      PrintQ().TextY = newy
      PrintQ().DisplayNum = num
   endif
      rem Tags are used to identify the kind of message we are putting
      rem into the queue. If we put an identical message into the queue
      rem we can check the tag. If its the same as another message we
      rem remove the old message and replace it with a new one.
      PrintQ().Tag = 0
      rem Statement we will be printing.
      PrintQ().StringToPrint = "Lite Color = " + Str$(x#) + " " + Str$(y#) + " " + Str$(z#)
      PrintQ().TimeToTerminate = FrameTime + 3000
      PrintQ().TextX = 0

endif

rem Reset the KeyCode if the upkey isn't being pressed.
if keystate(200) = 0 and KeyCode = 200 then KeyCode = 0

if keystate(208) = 1 and KeyCode <> 208
   rem Decrement the Lite Color
   x# = x vector4(1) : y# = y vector4(1) : z# = z vector4(1)
   x# = x# - 0.05 : y# = y# - 0.05 : z# = z# - 0.05
   set vector4 1, x#, y#, z#, 1.0

   rem Set to the current scancode.
   rem This is to prevent the key from registering
   rem more than once. That way if it is held down
   rem for any period of time it will only decrement the
   rem value once.
   KeyCode = 208

   rem Check for identical message.
   rem If we don't find one make a new
   rem message. The array will
   result = CheckForIdenticalTag(0)
   if result = 0
      `Add a new item to the list of things to be printed.
       Array Insert at Top PrintQ()
      `Get the screen height and tag for the new item.
      num = GetFreeSpace()
      newy = DisplaySpace(num).ScreenY
      `Make sure that Display Space is flaged as occupied.
      DisplaySpace(num).Occupied = 1
      `Set the new items screen y and its associated display space.
      PrintQ().TextY = newy
      PrintQ().DisplayNum = num
   endif

   rem Tags are used to identify the kind of message we are putting
   rem into the queue. If we put an identical message into the queue
   rem we can check the tag. If its the same as another message we
   rem remove the old message and replace it with a new one.
   PrintQ().Tag = 0
   PrintQ().StringToPrint = "Lite Color = " + Str$(x#) + " " + Str$(y#) + " " + Str$(z#)
   rem Make sure that we have a time to get rid of the print
   rem statement. We don't want it being printed for ever.
   PrintQ().TimeToTerminate = FrameTime + 3000
   PrintQ().TextX = 0
endif

rem Reset the KeyCode if the downkey isn't being pressed.
if keystate(208) = 0 and KeyCode = 208 then KeyCode = 0

rem Apply changes to effect constant.
set effect constant vector 1, "LiteColor", 1

endfunction

function ChangeDarkColor()

   rem If leftkey is pressed increment Dark Color.
   if keystate(203) = 1 and KeyCode <> 203
      rem Increment the Dark Color
      x# = x vector4(2) : y# = y vector4(2) : z# = z vector4(2)
      x# = x# + 0.05 : y# = y# + 0.05 : z# = z# + 0.05
      set vector4 2, x#, y#, z#, 1.0

      KeyCode = 203

      result = CheckForIdenticalTag(1)
      if result = 0
         `Add a new item to the list of things to be printed.
          Array Insert at Top PrintQ()
         `Get the screen height and tag for the new item.
         num = GetFreeSpace()
         newy = DisplaySpace(num).ScreenY
         `Make sure that Display Space is flaged as occupied.
         DisplaySpace(num).Occupied = 1
         `Set the new items screen y and its associated display space.
         PrintQ().TextY = newy
         PrintQ().DisplayNum = num
      endif

      rem Tags are used to identify the kind of message we are putting
      rem into the queue. If we put an identical message into the queue
      rem we can check the tag. If its the same as another message we
      rem remove the old message and replace it with a new one.
      PrintQ().Tag = 1
      PrintQ().StringToPrint = "Dark Color = " + Str$(x#) + " " + Str$(y#) + " " + Str$(z#)
      rem Make sure that we have a time to get rid of the print
      rem statement. We don't want it being printed for ever.
      PrintQ().TimeToTerminate = FrameTime + 3000
      rem Increment TextY so we don't end up printing over other
      rem messages.
      PrintQ().TextX = 0
   endif

   if keystate(203) = 0 and KeyCode = 203 then KeyCode = 0

   rem If right key is pressed decrement Dark Color.
   if keystate(205) = 1 and KeyCode <> 205
      rem Decrement the Dark Color
      x# = x vector4(2) : y# = y vector4(2) : z# = z vector4(2)
      x# = x# - 0.05 : y# = y# - 0.05 : z# = z# - 0.05
      set vector4 2, x#, y#, z#, 1.0

      KeyCode = 205

      result = CheckForIdenticalTag(1)
      if result = 0
         `Add a new item to the list of things to be printed.
          Array Insert at Top PrintQ()
         `Get the screen height and tag for the new item.
         num = GetFreeSpace()
         newy = DisplaySpace(num).ScreenY
         `Make sure that Display Space is flaged as occupied.
         DisplaySpace(num).Occupied = 1
         `Set the new items screen y and its associated display space.
         PrintQ().TextY = newy
         PrintQ().DisplayNum = num
      endif

      rem Tags are used to identify the kind of message we are putting
      rem into the queue. If we put an identical message into the queue
      rem we can check the tag. If its the same as another message we
      rem remove the old message and replace it with a new one.
      PrintQ().Tag = 1
      PrintQ().StringToPrint = "Dark Color = " + Str$(x#) + " " + Str$(y#) + " " + Str$(z#)
      rem Make sure that we have a time to get rid of the print
      rem statement. We don't want it being printed for ever.
      PrintQ().TimeToTerminate = FrameTime + 3000
      rem Increment TextY so we don't end up printing over other
      rem messages.
      PrintQ().TextX = 0
   endif

   if keystate(205) = 0 and KeyCode = 205 then KeyCode = 0

   set effect constant vector 1, "DarkColor", 2

endfunction

function ChangeWarmColor()

   rem If the "W" key is pressed increment Warm Color.
   if keystate(17) = 1 and KeyCode <> 17
      rem Increment the Dark Color
      x# = x vector4(3) : y# = y vector4(3) : z# = z vector4(3)
      x# = x# + 0.05 : y# = y# + 0.05 : z# = z# + 0.05
      set vector4 3, x#, y#, z#, 1.0

      KeyCode = 17

      result = CheckForIdenticalTag(2)
      if result = 0
         `Add a new item to the list of things to be printed.
          Array Insert at Top PrintQ()
         `Get the screen height and tag for the new item.
         num = GetFreeSpace()
         newy = DisplaySpace(num).ScreenY
         `Make sure that Display Space is flaged as occupied.
         DisplaySpace(num).Occupied = 1
         `Set the new items screen y and its associated display space.
         PrintQ().TextY = newy
         PrintQ().DisplayNum = num
      endif

      rem Tags are used to identify the kind of message we are putting
      rem into the queue. If we put an identical message into the queue
      rem we can check the tag. If its the same as another message we
      rem remove the old message and replace it with a new one.
      PrintQ().Tag = 2
      PrintQ().StringToPrint = "Warm Color = " + Str$(x#) + " " + Str$(y#) + " " + Str$(z#)
      rem Make sure that we have a time to get rid of the print
      rem statement. We don't want it being printed for ever.
      PrintQ().TimeToTerminate = FrameTime + 3000
      rem Increment TextY so we don't end up printing over other
      rem messages.
      PrintQ().TextX = 0
   endif

   if keystate(17) = 0 and KeyCode = 17 then KeyCode = 0

   rem If "S" key is pressed decrement Warm Color.
   if keystate(31) = 1 and KeyCode <> 31
      rem Decrement the Dark Color
      x# = x vector4(3) : y# = y vector4(3) : z# = z vector4(3)
      x# = x# - 0.05 : y# = y# - 0.05 : z# = z# - 0.05
      set vector4 3, x#, y#, z#, 1.0

      KeyCode = 31

      result = CheckForIdenticalTag(2)
      if result = 0
         `Add a new item to the list of things to be printed.
          Array Insert at Top PrintQ()
         `Get the screen height and tag for the new item.
         num = GetFreeSpace()
         newy = DisplaySpace(num).ScreenY
         `Make sure that Display Space is flaged as occupied.
         DisplaySpace(num).Occupied = 1
         `Set the new items screen y and its associated display space.
         PrintQ().TextY = newy
         PrintQ().DisplayNum = num
      endif

      rem Tags are used to identify the kind of message we are putting
      rem into the queue. If we put an identical message into the queue
      rem we can check the tag. If its the same as another message we
      rem remove the old message and replace it with a new one.
      PrintQ().Tag = 2
      PrintQ().StringToPrint = "Warm Color = " + Str$(x#) + " " + Str$(y#) + " " + Str$(z#)
      rem Make sure that we have a time to get rid of the print
      rem statement. We don't want it being printed for ever.
      PrintQ().TimeToTerminate = FrameTime + 3000
      rem Increment TextY so we don't end up printing over other
      rem messages.
      PrintQ().TextX = 0
   endif

   if keystate(31) = 0 and KeyCode = 31 then KeyCode = 0

   set effect constant vector 1, "WarmColor", 3

endfunction

function ChangeCoolColor()

   rem If the "A" key is pressed increment Warm Color.
   if keystate(30) = 1 and KeyCode <> 30
      rem Increment the Dark Color
      x# = x vector4(4) : y# = y vector4(4) : z# = z vector4(4)
      x# = x# + 0.05 : y# = y# + 0.05 : z# = z# + 0.05
      set vector4 4, x#, y#, z#, 1.0

      KeyCode = 30

      result = CheckForIdenticalTag(3)
      if result = 0
         `Add a new item to the list of things to be printed.
          Array Insert at Top PrintQ()
         `Get the screen height and tag for the new item.
         num = GetFreeSpace()
         newy = DisplaySpace(num).ScreenY
         `Make sure that Display Space is flaged as occupied.
         DisplaySpace(num).Occupied = 1
         `Set the new items screen y and its associated display space.
         PrintQ().TextY = newy
         PrintQ().DisplayNum = num
      endif

      rem Tags are used to identify the kind of message we are putting
      rem into the queue. If we put an identical message into the queue
      rem we can check the tag. If its the same as another message we
      rem remove the old message and replace it with a new one.
      PrintQ().Tag = 3
      PrintQ().StringToPrint = "Cool Color = " + Str$(x#) + " " + Str$(y#) + " " + Str$(z#)
      rem Make sure that we have a time to get rid of the print
      rem statement. We don't want it being printed for ever.
      PrintQ().TimeToTerminate = FrameTime + 3000
      rem Increment TextY so we don't end up printing over other
      rem messages.
      PrintQ().TextX = 0
   endif

   if keystate(30) = 0 and KeyCode = 30 then KeyCode = 0

   rem If "S" key is pressed decrement Warm Color.
   if keystate(32) = 1 and KeyCode <> 32
      rem Decrement the Dark Color
      x# = x vector4(4) : y# = y vector4(4) : z# = z vector4(4)
      x# = x# - 0.05 : y# = y# - 0.05 : z# = z# - 0.05
      set vector4 4, x#, y#, z#, 1.0

      KeyCode = 32

      result = CheckForIdenticalTag(3)
      if result = 0
         `Add a new item to the list of things to be printed.
          Array Insert at Top PrintQ()
         `Get the screen height and tag for the new item.
         num = GetFreeSpace()
         newy = DisplaySpace(num).ScreenY
         `Make sure that Display Space is flaged as occupied.
         DisplaySpace(num).Occupied = 1
         `Set the new items screen y and its associated display space.
         PrintQ().TextY = newy
         PrintQ().DisplayNum = num
      endif

      rem Tags are used to identify the kind of message we are putting
      rem into the queue. If we put an identical message into the queue
      rem we can check the tag. If its the same as another message we
      rem remove the old message and replace it with a new one.
      PrintQ().Tag = 3
      PrintQ().StringToPrint = "Cool Color = " + Str$(x#) + " " + Str$(y#) + " " + Str$(z#)
      rem Make sure that we have a time to get rid of the print
      rem statement. We don't want it being printed for ever.
      PrintQ().TimeToTerminate = FrameTime + 3000
      rem Increment TextY so we don't end up printing over other
      rem messages.
      PrintQ().TextX = 0
   endif

   if keystate(32) = 0 and KeyCode = 32 then KeyCode = 0

   set effect constant vector 1, "CoolColor", 4

endfunction


function PrintInfo()
   Array Index to Top PrintQ()
   NumOfItems = Array Count(PrintQ())
   for i = 0 to NumOfItems -1
      `We keep the item printing for a period of time.
      `When that time is up we delete the item.
      if PrintQ().TimeToTerminate <= FrameTime
         `Free up display space.
         num =PrintQ().DisplayNum
         DisplaySpace(num).Occupied = 0
         `Remove message from the list.
         `^^^^^KNOWN BUG^^^^^^^^^^^^^.
         `As of DBP U5.2 array delete element deletes
         `an element and makes the first element in the
         `list set to zero. Then it reverses the order of
         `all of the elements there after. As a result, one
         `of the display spaces occupied flag doesn't get set
         `to zero like it should. Also, that means that when
         `ever an element is removed from the print list, it
         `takes whatever element is at the start of the list
         `withit because the TimeToTerminate field is set
         `to zero and is thus <= FrameTime.
         Array Delete Element PrintQ(),i
      else
         `Its not time to delete it so print it to the screen instead.
         Text PrintQ().TextX, PrintQ().TextY, PrintQ().StringToPrint
      endif
      `Move back a step.
      Next Array Index PrintQ()
   next i

endfunction

function CheckForIdenticalTag( tag as integer)
   Array Index to Top PrintQ()
   NumOfItems = Array Count(PrintQ())
   for i = 0 to NumOfItems - 1
      if PrintQ().Tag = tag
         rem Basically we have found a repeat element.
         rem We exit here so that the array is set to
         rem the current repeat element. After this function
         rem is called there is some code that writes to
         rem the current repeat element overwriting
         rem old info, like time to terminate and string
         rem to print as well as keeping some old info,
         rem like tag(obviously) and display num.
         exitfunction -1
      endif
      Next Array Index PrintQ()
   next i
endfunction 0

function GetFreeSpace()
   rem Cycle through all display spaces to find
   rem an available one. We return the number
   rem we found as available so whatever called
   rem this can fetch the ScreenY value and
   rem assign it to a message that needs to be
   rem displayed.
   for i = 1 to 5
      if DisplaySpace(i).Occupied = 0
         exitfunction i
      endif
   next i
endfunction 0

function CheapHack()
   rem Account for the fact that array delete element
   rem messes up the list and causes one of the diplay
   rem spaces to remain occupied even though there is
   rem nothing occupying it.
   if Array Count(PrintQ()) = 0
      for i = 0 to 5
         DisplaySpace(i).Occupied = 0
      next i
   endif
endfunction

//
// FX Effect file - Cartoon
//

// Constants
matrix wvp : WorldViewProjection;
matrix world : World;
matrix worldIT : WorldIT;
float4 eyePos : EyePosition;
float4 lhtDir < string UIDirectional = "Light Direction"; >;

// Model and Texture Names
string XFile = "default.x";
texture toonshade < string name = "shade.bmp"; >;
texture toonedge < string name = "edge.dds"; >;

technique Toon
{
	pass p0
	{
		VertexShaderConstant[0] = <wvp>;
		VertexShaderConstant[4] = <worldIT>;
		VertexShaderConstant[8] = <world>;
		VertexShaderConstant[12] = <eyePos>;
		VertexShaderConstant[13] = <lhtDir>;

		VertexShader = 
		asm
		{

			// v0  -- position
			// v3  -- normal

			vs.1.1

			dcl_position      v0
			dcl_normal        v3

			// transform position
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

			// transform normal
			dp3 r0.x, v3, c8
			dp3 r0.y, v3, c9
			dp3 r0.z, v3, c10

			// normalize normal
			dp3 r0.w, r0, r0
			rsq r0.w, r0.w
			mul r0, r0, r0.w

			// compute world space position
			dp4 r1.x, v0, c8
			dp4 r1.y, v0, c9
			dp4 r1.z, v0, c10
			dp4 r1.w, v0, c11

			// vector from point to eye
			add r2, c12, -r1

			// normalize e
			dp3 r2.w, r2, r2
			rsq r2.w, r2.w
			mul r2, r2, r2.w

			// e dot n
			dp3 oT1.x, r0, r2

			// l dot n
			dp3 oT0.x, r0, -c13
		};

		Texture[0] = <toonshade>;
		Texture[1] = <toonedge>;

		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;

		AddressU[0] = Clamp;
		AddressV[0] = Clamp;
		AddressU[1] = Clamp;
		AddressV[1] = Clamp;

		ColorOp[0] = SelectArg1;
		ColorArg1[0] = Texture;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
	}
}

string XFile = "default.x";
texture toonshade < string name = "shade.bmp"; >;
texture toonedge < string name = "edge.dds"; >;

load effect "cartoon.fx", 1, 0

load image "edge.bmp", 1
load image "shade.bmp", 2

make object sphere 1, 100,100,100

texture object 1, 0, 2
texture object 1, 1, 1

		Texture[0] = <toonshade>;
		Texture[1] = <toonedge>;

		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;

		AddressU[0] = Clamp;
		AddressV[0] = Clamp;
		AddressU[1] = Clamp;
		AddressV[1] = Clamp;

		ColorOp[0] = SelectArg1;
		ColorArg1[0] = Texture;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;

set object effect 1, 1

rem Vector for our lhtDir constant
null = make vector4(1)

while spacekey() = 0

rem Control light position using mousex
position light 0,mousex()-320,240-mousey(),-300

rem Make sure our light is constantly pointing at the object
point light 0, object position x(1), object position y(1), object position z(1)

rem Update the light direction
set vector4 1, light direction x(0), light direction y(0), light direction z(0), 1.0

rem Make sure the direction constant is constantly updated
set effect constant vector 1,"lhtDir",1

endwhile

technique ToonWithTex
{
	pass p0
	{
		VertexShaderConstant[0] = <wvp>;
		VertexShaderConstant[4] = <worldIT>;
		VertexShaderConstant[8] = <world>;
		VertexShaderConstant[12] = <eyePos>;
		VertexShaderConstant[13] = <lhtDir>;

		VertexShader = 
		asm
		{

			// v0  -- position
			// v3  -- normal

			vs.1.1

			dcl_position      v0
			dcl_normal        v3
			dcl_texcoord0	  v6		
	
			// transform position
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

			// transform normal
			dp3 r0.x, v3, c8
			dp3 r0.y, v3, c9
			dp3 r0.z, v3, c10

			// normalize normal
			dp3 r0.w, r0, r0
			rsq r0.w, r0.w
			mul r0, r0, r0.w

			// compute world space position
			dp4 r1.x, v0, c8
			dp4 r1.y, v0, c9
			dp4 r1.z, v0, c10
			dp4 r1.w, v0, c11

			// vector from point to eye
			add r2, c12, -r1

			// normalize e
			dp3 r2.w, r2, r2
			rsq r2.w, r2.w
			mul r2, r2, r2.w

			// e dot n
			dp3 oT1.x, r0, r2

			// l dot n
			dp3 oT2.x, r0, -c13
		
			//Dump our basetex's coords into oT0.
			mov oT0, v6
		};

		Texture[2] = <toonshade>;
		Texture[1] = <toonedge>;
		Texture[0] = <basetex>;

		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;
		MinFilter[2] = Linear;
		MagFilter[2] = Linear;
		MipFilter[2] = Linear;		

		AddressU[2] = Clamp;
		AddressV[2] = Clamp;
		AddressU[1] = Clamp;
		AddressV[1] = Clamp;
		AddressU[0] = Wrap;
		AddressV[0] = Wrap;
		
		ColorOp[0] = SelectArg1;
		ColorArg1[0] = Texture;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
		
		ColorOp[2] = Lerp;
		ColorArg1[2]= Texture;
		ColorArg2[2] = Current;

	}
}

//Our base texture
texture basetex < string name = "base.bmp"; >;

load image "marble.bmp", 3

texture object 1, 2, 3

Set Effect Technique 1, "ToonWithTex" 

load effect "cartoon.fx", 1, 0

rem Load our images
load image "edge.bmp", 1
load image "shade.bmp", 2
load image "marble.bmp", 3

make object sphere 1, 100,100,100

rem Assign our images to texture stage indexs
texture object 1, 0, 2
texture object 1, 1, 1
texture object 1, 2, 3

set object effect 1, 1

rem New and improved version of the Cartoon.fx effect
set effect technique 1, "ToonWithTex"

rem Vector for our lhtDir constant
null = make vector4(1)

while spacekey() = 0

rem Control light position using mousex
position light 0,mousex()-320,240-mousey(),-300

rem Make sure our light is constantly pointing at the object
point light 0, object position x(1), object position y(1), object position z(1)

rem Update the light direction
set vector4 1, light direction x(0), light direction y(0), light direction z(0), 1.0

rem Make sure the direction constant is constantly updated
set effect constant vector 1,"lhtDir",1

endwhile

/*********************************************************************NVMH3****
Path:  NVSDKCommonmediacgfx
File:  Pocean.fx

Copyright NVIDIA Corporation 2003
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.


Comments:
	Simple ocean shader with animated bump map and geometric waves
	Based partly on "Effective Water Simulation From Physical Models", GPU Gems

******************************************************************************/

float4x4 worldMatrix : World < string UIWidget = "none";>;	        // World or Model matrix
float4x4 wvpMatrix : WorldViewProjection < string UIWidget = "none";>;	// Model*View*Projection
float4x4 worldViewMatrix : WorldView < string UIWidget = "none";>;
float4x4 viewInverseMatrix : ViewIT < string UIWidget = "none";>;

float time : Time < string UIWidget = "none"; >;
float ptime < string UIWidget = "none"; >;

texture normalMap : Normal
<
	string Name = "waves2.dds";
	string TextureType = "2D";
>;

texture cubeMap : Environment
<
	string Name = "CloudyHillsCubemap2.dds";
	string TextureType = "Cube";
>;

sampler2D normalMapSampler = sampler_state
{
	Texture = <normalMap>;
#if 1
	// this is a trick from Halo - use point sampling for sparkles
	MagFilter = Linear;	
	MinFilter = Point;
	MipFilter = None;
#else
	MagFilter = Linear;	
	MinFilter = Linear;
	MipFilter = Linear;
#endif
    AddressU = Wrap;
    AddressV = Wrap;
};

samplerCUBE envMapSampler = sampler_state
{
	Texture = <cubeMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
        AddressU = Wrap;
        AddressV = Wrap;
};

float bumpHeight
<
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 2.0; float UIStep = 0.01;
	string UIName = "Bump Height";
> = 0.5;

float2 textureScale
<
    string UIName = "Texture scale";
> = { 8.0, 4.0 };

float2 bumpSpeed
<
    string UIName = "Bumpmap translation speed";
> = { -0.05, 0.0 };

float fresnelBias
<
    string UIName = "Fresnel bias";
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 1.0; float UIStep = 0.01;
> = 0.1;

float fresnelPower
<
    string UIName = "Fresnel exponent";
	string UIWidget = "slider";
	float UIMin = 1.0; float UIMax = 10.0; float UIStep = 0.01;
> = 4.0;

float hdrMultiplier
<
    string UIName = "HDR multiplier";
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 100.0; float UIStep = 0.01;
> = 4.0;

float4 deepColor : Diffuse
<
    string UIName = "Deep water color";
> = {0.0f, 0.1f, 0.2f, 1.0f};

float4 shallowColor : Diffuse
<
    string UIName = "Shallow water color";
> = {0.0f, 0.6f, 0.7f, 1.0f};

float4 reflectionColor : Specular
<
    string UIName = "Reflection color";
> = {0.9f, 1.0f, 0.45f, 1.0f};

// these are redundant, but makes the ui easier:
float reflectionAmount
<
    string UIName = "Reflection amount";
	string UIWidget = "slider";    
	float UIMin = 0.0; float UIMax = 2.0; float UIStep = 0.01;    
> = 0.2f;

float waterAmount
<
    string UIName = "Water color amount";
	string UIWidget = "slider";    
	float UIMin = 0.0; float UIMax = 2.0; float UIStep = 0.01;    
> = 0.6f;

float waveAmp
<
    string UIName = "Wave amplitude";
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 10.0; float UIStep = 0.1;
> = 0.2;

float waveFreq
<
    string UIName = "Wave frequency";
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 1.0; float UIStep = 0.001;
> = 1.;



struct a2v {
	float4 Position : POSITION;   // in object space
	float2 TexCoord : TEXCOORD0;
	float3 Tangent  : TEXCOORD1;
	float3 Binormal : TEXCOORD2;
	float3 Normal   : NORMAL;
};

struct v2f {
	float4 Position  : POSITION;  // in clip space
	float2 TexCoord  : TEXCOORD0;
	float3 TexCoord1 : TEXCOORD1; // first row of the 3x3 transform from tangent to cube space
	float3 TexCoord2 : TEXCOORD2; // second row of the 3x3 transform from tangent to cube space
	float3 TexCoord3 : TEXCOORD3; // third row of the 3x3 transform from tangent to cube space

	float2 bumpCoord0 : TEXCOORD4;
	float2 bumpCoord1 : TEXCOORD5;
	float2 bumpCoord2 : TEXCOORD6;
	
	float3 eyeVector  : TEXCOORD7;
};

// wave functions

struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  float2 dir;
};

#define NWAVES 2
Wave wave[NWAVES] = {
	{ 1.0, 1.0, 0.5, float2(-1, 0) },
	{ 2.0, 0.5, 1.3, float2(-0.7, 0.7) }	
};

float evaluateWave(Wave w, float2 pos, float t)
{
  return w.amp * sin( dot(w.dir, pos) * w.freq + t  * w.phase );
}

// derivative of wave function
float evaluateWaveDeriv(Wave w, float2 pos, float t)
{
//  return w.amp * 1.0 ; //sin( /*dot(w.dir, pos) * w.freq +*/ t /* * w.phase */);
  return w.freq * w.amp * cos( dot(w.dir, pos)*w.freq + t * w.phase );
}

// sharp wave functions
float evaluateWaveSharp(Wave w, float2 pos, float t, float k)
{
  return w.amp * pow(sin( dot(w.dir, pos)*w.freq + t*w.phase)* 0.5 + 0.5 , k);
}

float evaluateWaveDerivSharp(Wave w, float2 pos, float t, float k)
{
  return k*w.freq*w.amp * pow(sin( dot(w.dir, pos)*w.freq + t*w.phase)* 0.5 + 0.5 , k - 1) * cos( dot(w.dir, pos)*w.freq + t*w.phase);
}

v2f BumpReflectWaveVS(a2v IN,
					  uniform float4x4 WorldViewProj,
					  uniform float4x4 World,
					  uniform float4x4 ViewIT,
					  uniform float BumpScale,
					  uniform float2 textureScale,
					  uniform float2 bumpSpeed,
					  uniform float time,
					  uniform float waveFreq,
					  uniform float waveAmp
                	  )
{
	v2f OUT;
// time = ptime;
// time = time / 20;

    wave[0].freq = waveFreq;
    wave[0].amp = waveAmp;

    wave[1].freq = waveFreq*2.0;
    wave[1].amp = waveAmp*0.5;

    float4 P = IN.Position;
	// sum waves	
	P.y = 0.0;
	float ddx = 0.0, ddy = 0.0;
   for(int i=0; i<NWAVES; i++) {
    	P.y += evaluateWave(wave[i], P.xz, time);
//    	float deriv = evaluateWaveDerivSharp(wave[i], P.xz, time, 0.01);
    	float deriv = evaluateWaveDeriv(wave[i], P.xz, time);
    	ddx += deriv * wave[i].dir.x;
    	ddy += deriv * wave[i].dir.y;
    }

	// compute tangent basis
        float3 B = float3(1, ddx, 0);
        float3 T = float3(0, ddy, 1);
        float3 N = float3(-ddx, 1, -ddy);

	OUT.Position = mul(P, WorldViewProj);
	
	// pass texture coordinates for fetching the normal map
	OUT.TexCoord.xy = IN.TexCoord*textureScale;

	time = fmod(time, 100.0);
	OUT.bumpCoord0.xy = IN.TexCoord*textureScale + time*bumpSpeed;
	OUT.bumpCoord1.xy = IN.TexCoord*textureScale*2.0 + time*bumpSpeed*4.0;
	OUT.bumpCoord2.xy = IN.TexCoord*textureScale*4.0 + time*bumpSpeed*8.0;

	// compute the 3x3 tranform from tangent space to object space
	float3x3 objToTangentSpace;
	// first rows are the tangent and binormal scaled by the bump scale
	objToTangentSpace[0] = BumpScale * normalize(T);
	objToTangentSpace[1] = BumpScale * normalize(B);
	objToTangentSpace[2] = normalize(N);

	OUT.TexCoord1.xyz = mul(objToTangentSpace, World[0].xyz);
	OUT.TexCoord2.xyz = mul(objToTangentSpace, World[1].xyz);
	OUT.TexCoord3.xyz = mul(objToTangentSpace, World[2].xyz);

	// compute the eye vector (going from shaded point to eye) in cube space
	float4 worldPos = mul(P, World);
	OUT.eyeVector = ViewIT[3] - worldPos; // view inv. transpose contains eye position in world space in last row
	return OUT;
}


// Pixel Shaders

float4 BumpReflectPS20(v2f IN,
					   uniform sampler2D NormalMap,
					   uniform samplerCUBE EnvironmentMap) : COLOR
{
	// fetch the bump normal from the normal map
	float4 N = tex2D(NormalMap, IN.TexCoord.xy)*2.0 - 1.0;
	
	float3x3 m; // tangent to world matrix
	m[0] = IN.TexCoord1;
	m[1] = IN.TexCoord2;
	m[2] = IN.TexCoord3;
	float3 Nw = mul(m, N.xyz);
	
//	float3 E = float3(IN.TexCoord1.w, IN.TexCoord2.w, IN.TexCoord3.w);
	float3 E = IN.eyeVector;
    float3 R = reflect(-E, Nw);

	return texCUBE(EnvironmentMap, R);
}

float4 OceanPS20(v2f IN,
				 uniform sampler2D NormalMap,
				 uniform samplerCUBE EnvironmentMap,
				 uniform half4 deepColor,
				 uniform half4 shallowColor,
				 uniform half4 reflectionColor,
				 uniform half4 reflectionAmount,
				 uniform half4 waterAmount,
				 uniform half fresnelPower,
				 uniform half fresnelBias,
				 uniform half hdrMultiplier
				 ) : COLOR
{
	// sum normal maps
    half4 t0 = tex2D(NormalMap, IN.bumpCoord0.xy)*2.0-1.0;
    half4 t1 = tex2D(NormalMap, IN.bumpCoord1.xy)*2.0-1.0;
    half4 t2 = tex2D(NormalMap, IN.bumpCoord2.xy)*2.0-1.0;
    half3 N = t0.xyz + t1.xyz + t2.xyz;
//    half3 N = t1.xyz;

    half3x3 m; // tangent to world matrix
    m[0] = IN.TexCoord1;
    m[1] = IN.TexCoord2;
    m[2] = IN.TexCoord3;
    half3 Nw = mul(m, N.xyz);
    Nw = normalize(Nw);

	// reflection
    float3 E = normalize(IN.eyeVector);
    half3 R = reflect(-E, Nw);

    half4 reflection = texCUBE(EnvironmentMap, R);
    // hdr effect (multiplier in alpha channel)
    reflection.rgb *= (1.0 + reflection.a*hdrMultiplier);

	// fresnel - could use 1D tex lookup for this
    half facing = 1.0 - max(dot(E, Nw), 0);
    half fresnel = fresnelBias + (1.0-fresnelBias)*pow(facing, fresnelPower);

    half4 waterColor = lerp(deepColor, shallowColor, facing);

	return waterColor*waterAmount + reflection*reflectionColor*reflectionAmount*fresnel;
//	return waterColor;
//	return fresnel;
//	return reflection;
}

technique PS20
{
	pass p0
	{
		VertexShader = compile vs_2_0 BumpReflectWaveVS(wvpMatrix, worldMatrix, viewInverseMatrix,
                                                        bumpHeight, textureScale, bumpSpeed, time,
                                                        waveFreq, waveAmp);
		
		Zenable = true;
		ZWriteEnable = true;
		CullMode = None;

//		PixelShader = compile ps_2_0 BumpReflectPS20(normalMapSampler, envMapSampler);
		PixelShader = compile ps_2_0 OceanPS20(normalMapSampler, envMapSampler,
                                               deepColor, shallowColor, reflectionColor, reflectionAmount, waterAmount,
                                               fresnelPower, fresnelBias, hdrMultiplier);
	}
}

load effect "POcean.fx", 1, 1
load object "slab.x",1

set object effect 1, 1

do
gosub _move_camera
loop

_move_camera:

 cax# = camera angle x(): cay# = camera angle y(): caz# = camera angle z()
 rotate camera cax#+(mousemovey()/2.0),cay#+(mousemovex()/2.0),0
 cax# = camera angle x(): cay# = camera angle y(): caz# = camera angle z()

 acc# = 1

 if upkey()=1 then move camera acc#:acc2# = 0.
 if downkey()=1 then move camera -acc#:acc2# = 0.
 if leftkey()=1 then yrotate camera cay#-90 : move camera acc# : yrotate camera cay#:acc2# = 0.
 if rightkey()=1 then yrotate camera cay#+90 : move camera acc# : yrotate camera cay#:acc2# = 0.
return

/*********************************************************************NVMH3****
Path:  NVSDKCommonmediacgfx
File:  ocean.fx

Copyright NVIDIA Corporation 2003
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.


Comments:
	Simple ocean shader with animated bump map and geometric waves
	Based partly on "Effective Water Simulation From Physical Models", GPU Gems

******************************************************************************/

float4x4 worldMatrix : World < string UIWidget = "none";>;	        // World or Model matrix
float4x4 wvpMatrix : WorldViewProjection < string UIWidget = "none";>;	// Model*View*Projection
float4x4 worldViewMatrix : WorldView < string UIWidget = "none";>;
float4x4 viewInverseMatrix : ViewIT < string UIWidget = "none";>;

float time : Time < string UIWidget = "none"; >;
float ptime < string UIWidget = "none"; >;

texture normalMap : Normal
<
	string Name = "waves2.dds";
	string TextureType = "2D";
>;

texture cubeMap : Environment
<
	string Name = "CloudyHillsCubemap2.dds";
	string TextureType = "Cube";
>;

sampler2D normalMapSampler = sampler_state
{
	Texture = <normalMap>;
#if 1
	// this is a trick from Halo - use point sampling for sparkles
	MagFilter = Linear;	
	MinFilter = Point;
	MipFilter = None;
#else
	MagFilter = Linear;	
	MinFilter = Linear;
	MipFilter = Linear;
#endif
    AddressU = Wrap;
    AddressV = Wrap;
};

samplerCUBE envMapSampler = sampler_state
{
	Texture = <cubeMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
        AddressU = Wrap;
        AddressV = Wrap;
};

float bumpHeight
<
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 2.0; float UIStep = 0.01;
	string UIName = "Bump Height";
> = 0.5;

float2 textureScale
<
    string UIName = "Texture scale";
> = { 8.0, 4.0 };

float2 bumpSpeed
<
    string UIName = "Bumpmap translation speed";
> = { -0.05, 0.0 };

float fresnelBias
<
    string UIName = "Fresnel bias";
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 1.0; float UIStep = 0.01;
> = 0.1;

float fresnelPower
<
    string UIName = "Fresnel exponent";
	string UIWidget = "slider";
	float UIMin = 1.0; float UIMax = 10.0; float UIStep = 0.01;
> = 4.0;

float hdrMultiplier
<
    string UIName = "HDR multiplier";
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 100.0; float UIStep = 0.01;
> = 4.0;

float4 deepColor : Diffuse
<
    string UIName = "Deep water color";
> = {0.0f, 0.1f, 0.2f, 1.0f};

float4 shallowColor : Diffuse
<
    string UIName = "Shallow water color";
> = {0.0f, 0.6f, 0.7f, 1.0f};

float4 reflectionColor : Specular
<
    string UIName = "Reflection color";
> = {0.9f, 1.0f, 0.45f, 1.0f};

// these are redundant, but makes the ui easier:
float reflectionAmount
<
    string UIName = "Reflection amount";
	string UIWidget = "slider";    
	float UIMin = 0.0; float UIMax = 2.0; float UIStep = 0.01;    
> = 0.2f;

float waterAmount
<
    string UIName = "Water color amount";
	string UIWidget = "slider";    
	float UIMin = 0.0; float UIMax = 2.0; float UIStep = 0.01;    
> = 0.6f;

float waveAmp
<
    string UIName = "Wave amplitude";
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 10.0; float UIStep = 0.1;
> = 0.2;

float waveFreq
<
    string UIName = "Wave frequency";
	string UIWidget = "slider";
	float UIMin = 0.0; float UIMax = 1.0; float UIStep = 0.001;
> = 1.;

float Hither <
    string UIName =  "near distance";
> = 1.0;

float Yon <
    string UIName =  "far distance";
> = 300.0;

float Gamma <
    string UIWidget = "slider";
    float UIMin = 0.1;
    float UIMax = 5.0;
    float UIStep = 0.05;
    string UIName =  "adjust rolloff";
> = 1.0;


float4 NearColor <
    string UIName =  "FG Color";
	string UIWidget = "Color";
> = {1.0f, 1.0f, 1.0f, 1.0f};

float4 FarColor <
    string UIName =  "BG Color";
	string UIWidget = "Color";
> = {0.0f, 0.0f, 0.0f, 1.0f};


struct a2v {
	float4 Position : POSITION;   // in object space
	float2 TexCoord : TEXCOORD0;
	float3 Tangent  : TEXCOORD1;
	float3 Binormal : TEXCOORD2;
	float3 Normal   : NORMAL;
};

struct v2f {
	float4 Position  : POSITION;  // in clip space
	float2 TexCoord  : TEXCOORD0;
	float3 TexCoord1 : TEXCOORD1; // first row of the 3x3 transform from tangent to cube space
	float3 TexCoord2 : TEXCOORD2; // second row of the 3x3 transform from tangent to cube space
	float3 TexCoord3 : TEXCOORD3; // third row of the 3x3 transform from tangent to cube space

	float2 bumpCoord0 : TEXCOORD4;
	float2 bumpCoord1 : TEXCOORD5;
	float2 bumpCoord2 : TEXCOORD6;
	
	float3 eyeVector  : TEXCOORD7;
	float4  dl : COLOR ;
};

// wave functions

struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  float2 dir;
};

#define NWAVES 2
Wave wave[NWAVES] = {
	{ 1.0, 1.0, 0.5, float2(-1, 0) },
	{ 2.0, 0.5, 1.3, float2(-0.7, 0.7) }	
};

float evaluateWave(Wave w, float2 pos, float t)
{
  return w.amp * sin( dot(w.dir, pos) * w.freq + t  * w.phase );
}

// derivative of wave function
float evaluateWaveDeriv(Wave w, float2 pos, float t)
{
//  return w.amp * 1.0 ; //sin( /*dot(w.dir, pos) * w.freq +*/ t /* * w.phase */);
  return w.freq * w.amp * cos( dot(w.dir, pos)*w.freq + t * w.phase );
}

// sharp wave functions
float evaluateWaveSharp(Wave w, float2 pos, float t, float k)
{
  return w.amp * pow(sin( dot(w.dir, pos)*w.freq + t*w.phase)* 0.5 + 0.5 , k);
}

float evaluateWaveDerivSharp(Wave w, float2 pos, float t, float k)
{
  return k*w.freq*w.amp * pow(sin( dot(w.dir, pos)*w.freq + t*w.phase)* 0.5 + 0.5 , k - 1) * cos( dot(w.dir, pos)*w.freq + t*w.phase);
}

v2f BumpReflectWaveVS(a2v IN,
					  uniform float4x4 WorldViewProj,
					  uniform float4x4 World,
					  uniform float4x4 ViewIT,
					  uniform float BumpScale,
					  uniform float2 textureScale,
					  uniform float2 bumpSpeed,
					  uniform float time,
					  uniform float waveFreq,
					  uniform float waveAmp
                	  )
{
	v2f OUT;
// time = ptime;
// time = time / 20;

    wave[0].freq = waveFreq;
    wave[0].amp = waveAmp;

    wave[1].freq = waveFreq*2.0;
    wave[1].amp = waveAmp*0.5;

    float4 P = IN.Position;
	// sum waves	
	P.y = 0.0;
	float ddx = 0.0, ddy = 0.0;
   for(int i=0; i<NWAVES; i++) {
    	P.y += evaluateWave(wave[i], P.xz, time);
//    	float deriv = evaluateWaveDerivSharp(wave[i], P.xz, time, 0.01);
    	float deriv = evaluateWaveDeriv(wave[i], P.xz, time);
    	ddx += deriv * wave[i].dir.x;
    	ddy += deriv * wave[i].dir.y;
    }

	// compute tangent basis
        float3 B = float3(1, ddx, 0);
        float3 T = float3(0, ddy, 1);
        float3 N = float3(-ddx, 1, -ddy);

	float4 hpos = mul(P, WorldViewProj);

	OUT.Position = hpos;
	
	// pass texture coordinates for fetching the normal map
	OUT.TexCoord.xy = IN.TexCoord*textureScale;

	time = fmod(time, 100.0);
	OUT.bumpCoord0.xy = IN.TexCoord*textureScale + time*bumpSpeed;
	OUT.bumpCoord1.xy = IN.TexCoord*textureScale*2.0 + time*bumpSpeed*4.0;
	OUT.bumpCoord2.xy = IN.TexCoord*textureScale*4.0 + time*bumpSpeed*8.0;

	// compute the 3x3 tranform from tangent space to object space
	float3x3 objToTangentSpace;
	// first rows are the tangent and binormal scaled by the bump scale
	objToTangentSpace[0] = BumpScale * normalize(T);
	objToTangentSpace[1] = BumpScale * normalize(B);
	objToTangentSpace[2] = normalize(N);

	OUT.TexCoord1.xyz = mul(objToTangentSpace, World[0].xyz);
	OUT.TexCoord2.xyz = mul(objToTangentSpace, World[1].xyz);
	OUT.TexCoord3.xyz = mul(objToTangentSpace, World[2].xyz);

    float dl = (hpos.z-Hither)/(Yon-Hither);
    dl = min(dl,1.0);
    dl = max(dl,0.0);
    dl = pow(dl,Gamma);

	OUT.dl = lerp(NearColor,FarColor,dl);

	// compute the eye vector (going from shaded point to eye) in cube space
	float4 worldPos = mul(P, World);
	OUT.eyeVector = ViewIT[3] - worldPos; // view inv. transpose contains eye position in world space in last row
	return OUT;
}


// Pixel Shaders

float4 BumpReflectPS20(v2f IN,
					   uniform sampler2D NormalMap,
					   uniform samplerCUBE EnvironmentMap) : COLOR
{
	// fetch the bump normal from the normal map
	float4 N = tex2D(NormalMap, IN.TexCoord.xy)*2.0 - 1.0;
	
	float3x3 m; // tangent to world matrix
	m[0] = IN.TexCoord1;
	m[1] = IN.TexCoord2;
	m[2] = IN.TexCoord3;
	float3 Nw = mul(m, N.xyz);
	
//	float3 E = float3(IN.TexCoord1.w, IN.TexCoord2.w, IN.TexCoord3.w);
	float3 E = IN.eyeVector;
    float3 R = reflect(-E, Nw);

	return texCUBE(EnvironmentMap, R);
}

float4 OceanPS20(v2f IN,
				 uniform sampler2D NormalMap,
				 uniform samplerCUBE EnvironmentMap,
				 uniform half4 deepColor,
				 uniform half4 shallowColor,
				 uniform half4 reflectionColor,
				 uniform half4 reflectionAmount,
				 uniform half4 waterAmount,
				 uniform half fresnelPower,
				 uniform half fresnelBias,
				 uniform half hdrMultiplier
				 ) : COLOR
{
	// sum normal maps
    half4 t0 = tex2D(NormalMap, IN.bumpCoord0.xy)*2.0-1.0;
    half4 t1 = tex2D(NormalMap, IN.bumpCoord1.xy)*2.0-1.0;
    half4 t2 = tex2D(NormalMap, IN.bumpCoord2.xy)*2.0-1.0;
    half3 N = t0.xyz + t1.xyz + t2.xyz;
//    half3 N = t1.xyz;

    half3x3 m; // tangent to world matrix
    m[0] = IN.TexCoord1;
    m[1] = IN.TexCoord2;
    m[2] = IN.TexCoord3;
    half3 Nw = mul(m, N.xyz);
    Nw = normalize(Nw);

	// reflection
    float3 E = normalize(IN.eyeVector);
    half3 R = reflect(-E, Nw);

    half4 reflection = texCUBE(EnvironmentMap, R);
    // hdr effect (multiplier in alpha channel)
    reflection.rgb *= (1.0 + reflection.a*hdrMultiplier);

	// fresnel - could use 1D tex lookup for this
    half facing = 1.0 - max(dot(E, Nw), 0);
    half fresnel = fresnelBias + (1.0-fresnelBias)*pow(facing, fresnelPower);

    half4 waterColor = lerp(deepColor, shallowColor, facing);

	return (waterColor*waterAmount + reflection*reflectionColor*reflectionAmount*fresnel) * IN.dl;
//	return waterColor;
//	return fresnel;
//	return reflection;
}

technique PS20
{
	pass p0
	{
		VertexShader = compile vs_2_0 BumpReflectWaveVS(wvpMatrix, worldMatrix, viewInverseMatrix,
                                                        bumpHeight, textureScale, bumpSpeed, time,
                                                        waveFreq, waveAmp);
		
		Zenable = true;
		ZWriteEnable = true;
		CullMode = None;

//		PixelShader = compile ps_2_0 BumpReflectPS20(normalMapSampler, envMapSampler);
		PixelShader = compile ps_2_0 OceanPS20(normalMapSampler, envMapSampler,
                                               deepColor, shallowColor, reflectionColor, reflectionAmount, waterAmount,
                                               fresnelPower, fresnelBias, hdrMultiplier);
	}
}

//	eMalice Glow Test Shader - 1.0
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;

//------------------------------------
texture texMap
<
	string name = "Null.tga";
>;

//------------------------------------
technique blurTest
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;

		VertexShader = asm
		{
			// Initialise Shader
			vs.1.1
			dcl_position	v0
			dcl_texcoord	v1
			def c4, 0.005, 0.005, 0.0, 0.0
			def c5, 0.005, -0.005, 0.0, 0.0

			// Transform Position to Clip
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

			// Displace and Output Tex Coords
			add oT0, v1, c4
			add oT1, v1, c5
			add oT2, v1, -c4
			add oT3, v1, -c5
		};
		
		PixelShader = asm
		{
			// Initilise Shader
			ps.1.4
			def c0, 0.25, 0.25, 0.25, 0.5
			
			// Load Sample Textures
			texld r0, t0
			texld r1, t1
			texld r2, t2
			texld r3, t3
			
			// Take the Average of the Textures
			mul r3, r3, c0
			mad r2, r2, c0, r3
			mad r1, r1, c0, r2
			mad r0, r0, c0, r1
			
			// Scale for Glow
			sub_sat r0.rgb, r0_x2, c0.w
			//mul r0, r0, r0
			mul_sat r0, r0, r0
		};
		
		Texture[0] = <texMap>;
		Texture[1] = <texMap>;
		Texture[2] = <texMap>;
		Texture[3] = <texMap>;

		MinFilter[0] = Linear;
		MinFilter[1] = Linear;
		MinFilter[2] = Linear;
		MinFilter[3] = Linear;

		MagFilter[0] = Linear;
		MagFilter[1] = Linear;
		MagFilter[2] = Linear;
		MagFilter[3] = Linear;

		MipFilter[0] = Linear;
		MipFilter[1] = Linear;
		MipFilter[2] = Linear;
		MipFilter[3] = Linear;
	}

	pass p1 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;

		VertexShader = asm
		{
			// Initialise Shader
			vs.1.1
			dcl_position	v0
			dcl_texcoord	v1
			def c4, 0.007, 0.0, 0.0, 0.0
			def c5, 0.0, 0.007, 0.0, 0.0

			// Transform Position to Clip
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

			// Displace and Output Tex Coords
			add oT0, v1, c4
			add oT1, v1, c5
			add oT2, v1, -c4
			//add oT3, v1, -c5
			mov oT3, v1
		};

		AlphaBlendEnable = true;

		SrcBlend = One;
		DestBlend = One;
	}
}

//  Hologram Shader - 1.1
//      by Ninja Matt
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : WorldIT;
float4 EyePos <> = {0.0f, 0.0f, 0.0f, 0.0f};

//------------------------------------
texture HoloMap
<
	string name = "Hologram.tga";
>;

//------------------------------------
technique Hologram
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <World>;
		VertexShaderConstant[8] = <EyePos>;

		VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal	v1

			// Clamp Values
			def c20, 1.0f, 0.0f, 0.0f, 0.0f

			// Transform Position to Clip
			m4x4 oPos, v0, c0
			
			// Move Eye Position to Object Space
			mov r0, c8
			m4x4 r1, r0, c4
			
			// Compute Eye Vector
			add r1, r1, -v0

			// Normalise Eye Vector
			dp3 r1.w, r1, r1
			rsq r1.w, r1.w
			mul r1, r1, r1.w

			// Compute N-dot-E
			dp3 r0, v1, r1

			// Clamp to [0..1]
			min r0, r0, c20.x
			max r0, r0, c20.y

			// Output Tex Coords
			mov oT0.x, r0
		};

		Texture[0] = <HoloMap>;
		MinFilter[0] = Point;
		MagFilter[0] = Point;
		MipFilter[0] = Point;
	}
}

//	eMalice Metal Shader - 1.1
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 WorldIT : WorldIT;
float4 EyePos : EyePos;

//------------------------------------
texture BaseMap
<
	string name = "Metal.tga";
>;

texture NormalMap
<
	string name = "MetalNormal.tga";
>;

texture ShineMap
<
	string name = "MetalShine.tga";
>;

//------------------------------------
technique metal
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <WorldIT>;
		VertexShaderConstant[8] = <EyePos>;

		VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal		v1
			dcl_tangent		v2
			dcl_binormal	v3
			dcl_texcoord	v4
			def c20, 0.0f, 1.0f, 1.0f, 1.0f
			
			// Transform Position to Clip
			m4x4 oPos, v0, c0
			
			// Output Tex Coords
			mov oT0, v4
			mov oT1, v4
						
			// Move Eye Position to Object Space
			mov r0, c8
			m4x4 r1, r0, c4
			
			// Compute Eye Vector
			sub r1, r1, v0
			
			// Normalise Eye Vector
			dp3 r1.w, r1, r1
			rsq r1.w, r1.w
			mul r1, r1, r1.w
			
			// Move Light Vector to Texture Space
			dp3 r2.x, r1, v2
			dp3 r2.y, r1, v3
			dp3 r2.z, r1, v1
			
			// Output Eye Vector
			mov oT2, r2.xyz
		};
		
		PixelShader = asm
		{
			// Initialise Shader
			ps.1.1
			
			// Base Map and Normal Map
			tex t0
			tex t1
			
			// N-dot-E and load from Lookup Texture
			texm3x2pad t2, t1_bx2
			texm3x2tex t3, t1_bx2
			
			// Add Shine to Base
			add r0, t0, t3
		};

		Texture[0] = <BaseMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;

		Texture[1] = <NormalMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;

		Texture[3] = <ShineMap>;
		MinFilter[3] = Linear;
		MagFilter[3] = Linear;
		MipFilter[3] = Linear;
	}
};

Rem Project: simple blur shader
Rem Created: 22/02/2005 12:00:00

Rem ***** Main Source File *****
sync on

make object sphere 1,100,100,100

rem please load here your own texture
load image "yourtexture.jpg",10

texture object 1, 0, 10

load effect "BLOOMblur shader - para forum.fx",1,0

if get maximum pixel shader version()>=2 then set object effect 1,1

lightPos=1
mtrlAmbient=2
mtrlDiffuse=3

rem shader's float4
null=make vector4(lightPos)    : REM LIGHT POSITION
null=make vector4(mtrlAmbient) : REM AMBIENT COLOR FACTOR
null=make vector4(mtrlDiffuse) : REM DIFFUSE COLOR FACTOR

SET VECTOR4 lightPos, camera position x(0), camera position y(0), camera position z(0), 0
SET VECTOR4 mtrlAmbient, 1.0, 1.0, 1.0, 0.0
SET VECTOR4 mtrlDiffuse, 1.0, 1.0, 1.0, 0.0

set effect constant vector 1, "mtrlAmbient", mtrlAmbient
set effect constant vector 1, "mtrlDiffuse", mtrlDiffuse

rem shader's float
a#=0.001
set effect constant float 1, "pSize",a#

b#=0.1
set effect constant float 1, "factor_s",b#


rem main loop
do

rem send light position every frame
SET VECTOR4 lightPos, camera position x(0), camera position y(0), camera position z(0), 0
NORMALIZE VECTOR4 lightPos,lightPos
set effect constant vector 1, "lightPos", lightPos


rem inputs for changing shader result
rem vectors change all components (x,y,z,w) at the same time, so it only adds "white"
rem change individually for other colors

if inkey$()="a"
   SET VECTOR4 mtrlAmbient, X VECTOR4(mtrlAmbient)+0.001, X VECTOR4(mtrlAmbient)+0.001, X VECTOR4(mtrlAmbient)+0.001, X VECTOR4(mtrlAmbient)+0.001
   set effect constant vector 1, "mtrlAmbient", mtrlAmbient
endif

if inkey$()="s"
   SET VECTOR4 mtrlAmbient, X VECTOr4(mtrlAmbient)-0.001, X VECTOr4(mtrlAmbient)-0.001, X VECTOr4(mtrlAmbient)-0.001, X VECTOR4(mtrlAmbient)-0.001
   set effect constant vector 1, "mtrlAmbient", mtrlAmbient
endif


if inkey$()="z"
   SET VECTOR4 mtrlDiffuse, X VECTOR4(mtrlDiffuse)+0.001, X VECTOR4(mtrlDiffuse)+0.001, X VECTOR4(mtrlDiffuse)+0.001, X VECTOR4(mtrlDiffuse)+0.001
   set effect constant vector 1, "mtrlDiffuse", mtrlDiffuse
endif

if inkey$()="x"
   SET VECTOR4 mtrlDiffuse, X VECTOr4(mtrlDiffuse)-0.001, X VECTOr4(mtrlDiffuse)-0.001, X VECTOr4(mtrlDiffuse)-0.001, X VECTOR4(mtrlDiffuse)-0.001
   set effect constant vector 1, "mtrlDiffuse", mtrlDiffuse
endif

if inkey$()="1"
   a#=a#+0.00001
   set effect constant FLOAT 1, "pSize", a#
endif

if inkey$()="2"
   a#=a#-0.00001
   set effect constant FLOAT 1, "pSize", a#
 endif

if inkey$()="3"
   b#=b#+0.0001
   set effect constant float 1, "factor_s", b#
endif

if inkey$()="4"
   b#=b#-0.0001
   set effect constant float 1, "factor_s", b#
 endif


set cursor 0,0
print SCREEN FPS()
print "mtrlAmbient = ",X VECTOr4(mtrlAmbient)
print "mtrlDiffuse = ",X VECTOr4(mtrlDiffuse)
print "pSize = ", a#
print "factor_s = ", b#

control camera using arrowkeys 0,5,5

sync

loop

//////////////////////////////////////////////
// Simple Blur Shader
//////////////////////////////////////////////

float4x4 matWorldViewProjection : WorldViewProjection;
float4 mtrlAmbient;
float4 mtrlDiffuse;
float4 lightPos;

float pSize; //size of the displacement 
float factor_s; // factor for color addition



//VS output / PS input:
struct Blur_OUTPUT
{
    float4 vPos : POSITION;
    float4 vColor: COLOR0;
    float4 texCoord0 : TEXCOORD0;
    float4 texCoord1 : TEXCOORD1;
    float4 texCoord2 : TEXCOORD2;
    float4 texCoord3 : TEXCOORD3;
    float4 texCoord4 : TEXCOORD4;
    float4 texCoord5 : TEXCOORD5;
    float4 texCoord6 : TEXCOORD6;
    float4 texCoord7 : TEXCOORD7;
};


//////////////////////////
//  Vertex Shader:
//////////////////////////
// This blur the texture in the specific direction - up, down, left, and right.
//////////////////////////
Blur_OUTPUT BlurVS1(float4 vPos : POSITION, float4 vNorm: NORMAL, float4 texCoord0 : TEXCOORD0)
{
	Blur_OUTPUT OUT;
	
	float4 vLightDir;

	OUT.vPos = mul(vPos, matWorldViewProjection);

	// Compute diffuse lighting
	vLightDir = normalize(lightPos - vPos);

	vNorm = normalize(vNorm);

	OUT.vColor = dot(vNorm, vLightDir) * mtrlDiffuse + mtrlAmbient;

	//pick coordinates around the vertex
	//left-top
	OUT.texCoord1 = texCoord0 + float4(-pSize, pSize, 0.0f, 0.0f); 
	//top
	OUT.texCoord2 = texCoord0 + float4(0.0f, pSize, 0.0f, 0.0f); 
	//right-top
	OUT.texCoord3 = texCoord0 + float4(pSize, pSize, 0.0f, 0.0f); 
	//right
	OUT.texCoord4 = texCoord0 + float4(pSize, 0.0f, 0.0f, 0.0f); 
	//left
	OUT.texCoord5 = texCoord0 + float4(-pSize, 0.0f, 0.0f, 0.0f); 
	//left-down
	OUT.texCoord6 = texCoord0 + float4(-pSize, -pSize, 0.0f, 0.0f); 
	//down
	OUT.texCoord7 = texCoord0 + float4(0.0f, -pSize, 0.0f, 0.0f);  
	//right-down
	OUT.texCoord0 = texCoord0 + float4(pSize, -pSize, 0.0f, 0.0f); 
	
	return OUT;
}


//////////////////////////
//  Pixel Shader:
//////////////////////////


texture BlurTexture
<
	string name = "tex1.jpg";
>;

sampler BlurSampler = sampler_state
{
    Texture   = (BlurTexture);
};




float4 BlurPS1(float4 vColor: COLOR0, float4 texCoord0 : TEXCOORD0, float4 texCoord1 :TEXCOORD1, float4 texCoord2 : TEXCOORD2, 
float4 texCoord3 : TEXCOORD3, float4 texCoord4 : TEXCOORD4, 
float4 texCoord5 : TEXCOORD5, float4 texCoord6 : TEXCOORD6, 
float4 texCoord7 : TEXCOORD7
) : COLOR0


{

	// Sample the Texture
	float4 tcolor = tex2D( BlurSampler, texCoord0 ) * factor_s;
	
	// Add the texture values at each of the supplied texCoords
	tcolor += tex2D( BlurSampler, texCoord1 ) * factor_s;
	tcolor += tex2D( BlurSampler, texCoord2 ) * factor_s;
	tcolor += tex2D( BlurSampler, texCoord3 ) * factor_s;
	tcolor += tex2D( BlurSampler, texCoord4 ) * factor_s;
	tcolor += tex2D( BlurSampler, texCoord5 ) * factor_s;
	tcolor += tex2D( BlurSampler, texCoord6 ) * factor_s;
	tcolor += tex2D( BlurSampler, texCoord7 ) * factor_s;

	//Use vertex color
	tcolor *=  vColor;

	return tcolor;
}


//////////////////////////
//  Techniques:
//////////////////////////

technique T0
{
	pass P0 
	{
		CullMode = CCW;

		MipFilter[0] = LINEAR;
		MinFilter[0] = LINEAR;
		MagFilter[0] = LINEAR;

		vertexshader = compile vs_1_1 BlurVS1();
		pixelshader  = compile ps_2_0 BlurPS1();

	}
	
	
		
}

//********************************************************************************************

// un-TWEAKABLES 
	matrix WorldViewProj : WorldViewProjection; // cam view projection
	matrix ViewInv : ViewInverse;	// cam pos

//********************************************************************************************

// Textures
	texture cubeMap : ENVIRONMENT
		<
			string Name = "room-dxt5.dds"; // define texture
			string Type = "Cube"; // must set the texture to a cube sampler
		>;
	samplerCUBE envMapSampler = sampler_state // texture sampler
		{
			Texture = <cubeMap>;
		};

//********************************************************************************************

// DATA STRUCTS 
	// vertex data
		struct appdata {
    			float4 Position	: POSITION; // vertex position 
        		float3 Normal	: NORMAL; // vertex faceing direction
		};
	// vertex to pixel shader data
		struct VSOutput {
    			float4 pos	: POSITION; // new vertex position 
			float3 view     : TEXCOORD0; // view vec for the cube map to reflect to
              	};

//********************************************************************************************

VSOutput mainVS(appdata IN) 
{
  VSOutput OUT;
  	OUT.pos = mul( IN.Position , WorldViewProj ); // output vertex position 
 	    	float3 v = -ViewInv[3].xyz; // current camera position
	OUT.view = reflect(v,IN.Normal); // reflect camera position to Normals
  return OUT;
}

//********************************************************************************************

float4 cube(VSOutput IN)  : COLOR
{
	float4 result=texCUBE( envMapSampler , IN.view  )  ; // return our cubemap
   	return result;
}

//********************************************************************************************

technique cube
 	{
		pass one
		{		
			VertexShader = compile vs_1_0 mainVS(); 
			PixelShader = compile ps_1_4 cube(); 
		}
	}

//********************************************************************************************

rem set up
   sync on
   sync rate 60
   color backdrop 0
   hide mouse

rem make our object
   make object sphere 1,100,100,100

rem laod cube image
   load image "room-dxt5.dds",1

rem texture object
   texture object 1,0,1

rem effect
   load effect "cube.fx",1,1 ` toggle this to 0 to use DBP textureing
   set object effect 1,1

rem start loop
   do

rem cam
   if mouseclick()=1 then move camera 1
   if mouseclick()=2 then move camera -1
   rotate camera camera angle x()+mousemovey()/2,camera angle y()+mousemovex()/2,0

rem end
   sync
   loop