= "bigship1.x";
#include
/************************************************************/
/*** TWEAKABLES *********************************************/
/************************************************************/
float3 LightPos : Position <
string Object = "PointLight";
string Space = "World";
> = {-10.0f, 10.0f, -10.0f};
float Scale : UNITSSCALE
<
string units = "inches";
string UIWidget = "slider";
float UIMin = 0.001;
float UIMax = 40.0;
float UIStep = 0.01;
string UIName = "Deriv Scale";
> = 64.0;
float Shading <
string UIWidget = "slider";
float uimin = 0.0;
float uimax = 1.0;
float uistep = 0.01;
string UIName = "Shading";
> = 0.0;
/************* UN-TWEAKABLES **************/
float4x4 WorldITXf : WorldInverseTranspose < string UIWidget="None"; >;
float4x4 WorldViewProjectionXf : WorldViewProjection < string UIWidget="None"; >;
float4x4 WorldXf : World < string UIWidget="None"; >;
float4x4 ViewIXf : ViewInverse < string UIWidget="None"; >;
float2 ScreenSize : VIEWPORTPIXELSIZE < string UIWidget="None"; >;
/************* DATA STRUCTS **************/
/* data from application vertex buffer */
struct appdata {
float3 Pos : POSITION;
float4 UV : TEXCOORD0;
float4 Normal : NORMAL;
float4 Tangent : TANGENT0;
float4 Binormal : BINORMAL0;
};
/* data passed from vertex shader to pixel shader */
struct vertexOutput {
float4 HPosition : POSITION;
float2 TexCoord : TEXCOORD0;
float3 LightVec : TEXCOORD1;
float3 WorldNormal : TEXCOORD2;
float3 WorldEyeVec : TEXCOORD3;
float3 WorldTangent : TEXCOORD4;
float3 WorldBinorm : TEXCOORD5;
float4 BaseColor : COLOR0;
};
/*********** vertex shader for all ******/
vertexOutput simpleVS(appdata IN) {
vertexOutput OUT;
float4 Po = float4(IN.Pos,1.0);
OUT.HPosition = mul(Po, WorldViewProjectionXf);
// OUT.HPosition = mul(WorldViewProjectionXf, Po);
OUT.WorldNormal = mul(WorldITXf, IN.Normal).xyz;
OUT.WorldTangent = mul(WorldITXf, IN.Tangent).xyz;
OUT.WorldBinorm = mul(WorldITXf, IN.Binormal).xyz;
float4 Pw = mul(WorldXf, Po);
OUT.LightVec = (LightPos-Pw).xyz;
OUT.TexCoord = IN.UV.xy;
OUT.WorldEyeVec = normalize(ViewIXf[3].xyz - Pw.xyz);
float ldn = dot(normalize(OUT.LightVec),normalize(OUT.WorldNormal));
ldn = max(0,ldn);
OUT.BaseColor = lerp(float4(1,1,1,1),ldn.xxxx,Shading);
return OUT;
}
/********* pixel shaders ********/
float4 normalsRawPS(vertexOutput IN) : COLOR { return IN.BaseColor*as_rgba(IN.WorldNormal); }
float4 normalsNPS(vertexOutput IN) : COLOR { return IN.BaseColor*as_rgba_cn(IN.WorldNormal); }
float4 tangentRawPS(vertexOutput IN) : COLOR { return IN.BaseColor*as_rgba(IN.WorldTangent); }
float4 tangentNPS(vertexOutput IN) : COLOR { return IN.BaseColor*as_rgba_cn(IN.WorldTangent); }
float4 binormRawPS(vertexOutput IN) : COLOR { return IN.BaseColor*as_rgba(IN.WorldBinorm); }
float4 binormNPS(vertexOutput IN) : COLOR { return IN.BaseColor*as_rgba_cn(IN.WorldBinorm); }
float4 viewNPS(vertexOutput IN) : COLOR { return IN.BaseColor*as_rgba(IN.WorldEyeVec); }
float4 lightNPS(vertexOutput IN) : COLOR { return IN.BaseColor*as_rgba_cn(IN.LightVec); }
float4 uvcPS(vertexOutput IN) : COLOR { return IN.BaseColor*float4(IN.TexCoord,0,1); }
float4 vFacePS(vertexOutput IN,float Vf : VFACE) : COLOR {
float d = 0;
if (Vf>0) d = 1;
return IN.BaseColor*float4(d,d,d,1);
}
float4 vPosPS(vertexOutput IN,float2 Vpos : VPOS) : COLOR {
float2 c = Vpos.xy / ScreenSize.xy;
return IN.BaseColor*float4(c.xy,0,1);
}
float4 uvDerivsPS(vertexOutput IN) : COLOR
{
float2 dd = Scale * (abs(ddx(IN.TexCoord)) + abs(ddy(IN.TexCoord)));
return IN.BaseColor*float4(dd,0,1);
}
float4 halfAnglePS(vertexOutput IN) :COLOR {
float3 Ln = normalize(IN.LightVec);
float3 Vn = normalize(IN.WorldEyeVec);
// float3 Hn = normalize(Vn + Ln);
return IN.BaseColor*as_rgba_n(Vn+Ln);
}
float4 facingPS(vertexOutput IN) :COLOR {
float3 Nn = normalize(IN.WorldNormal);
float3 Vn = normalize(IN.WorldEyeVec);
return IN.BaseColor*float4(abs(dot(Nn,Vn)).xxx,1);
}
/****************************************************************/
/****************************************************************/
/******* TECHNIQUES *********************************************/
/****************************************************************/
/****************************************************************/
#define TECH(name,vertShader,pixShader) technique name { pass p0 { \
VertexShader = compile vs_2_0 vertShader (); \
ZEnable = true; ZWriteEnable = true; CullMode = None; \
PixelShader = compile ps_2_a pixShader (); } }
#define TECH3(name,vertShader,pixShader) technique name { pass p0 { \
VertexShader = compile vs_3_0 vertShader (); \
ZEnable = true; ZWriteEnable = true; CullMode = None; \
PixelShader = compile ps_3_0 pixShader (); } }
TECH(uvValues,simpleVS,uvcPS)
TECH(worldNormalVecsRaw,simpleVS,normalsRawPS)
TECH(worldNormalVecsNormalized,simpleVS, normalsNPS)
TECH(worldTangentVecsRaw,simpleVS,tangentRawPS)
TECH(worldTangentVecsNormalized,simpleVS,tangentNPS)
TECH(worldBinormalVecsRaw,simpleVS,binormRawPS)
TECH(worldBinormalVecsNormalized,simpleVS, binormNPS)
TECH(worldViewVecNormalized,simpleVS,viewNPS)
TECH(worldLightVecNormalized,simpleVS,lightNPS)
TECH(halfAngles,simpleVS,halfAnglePS)
TECH(facingRatio,simpleVS,facingPS)
TECH(uvDerivs,simpleVS,uvDerivsPS)
TECH3(vFaceReg,simpleVS,vFacePS)
TECH3(vPosReg,simpleVS,vPosPS)
technique flatBlack {
pass p0 {
VertexShader = compile vs_1_1 simpleVS();
ZEnable = true;
ZWriteEnable = true;
CullMode = None;
}
}
/***************************** eof ***/
]]>
// stripe texture, functions, checkers
#include
//
//////// instead of typical spherical normalization, project against the boundaries of a cube
//
QUAD_REAL3 cube_normalize(QUAD_REAL3 V)
{
QUAD_REAL3 Na = abs(V);
QUAD_REAL r = max(max(Na.x,Na.y),Na.z);
return (V/r);
}
QUAD_REAL3 cube_normalize(QUAD_REAL4 V) { return cube_normalize(V.xyz); }
/////////// vectors into colors /////////////
// normalized vector (saturated, at least) as a color
QUAD_REAL3 as_rgb(QUAD_REAL3 V) { return (QUAD_REAL3(0.5,0.5,0.5) + 0.5*V); }
QUAD_REAL3 as_rgb(QUAD_REAL4 V) { return as_rgb(V.xyz); }
// un-normalized vector (spherical normalize)
QUAD_REAL3 as_rgb_n(QUAD_REAL3 V) { return (QUAD_REAL3(0.5,0.5,0.5) + 0.5*normalize(V)); }
QUAD_REAL3 as_rgb_n(QUAD_REAL4 V) { return (QUAD_REAL3(0.5,0.5,0.5) + 0.5*normalize(V.xyz)); }
// un-normalized vector (cube normalize)
QUAD_REAL3 as_rgb_cn(QUAD_REAL3 V) { return (QUAD_REAL3(0.5,0.5,0.5) + 0.5*cube_normalize(V)); }
QUAD_REAL3 as_rgb_cn(QUAD_REAL4 V) { return (QUAD_REAL3(0.5,0.5,0.5) + 0.5*cube_normalize(V.xyz)); }
// return RGBA instead of RGB /////////
// normalized vector (saturated, at least) as a color
QUAD_REAL4 as_rgba(QUAD_REAL3 V) { return QUAD_REAL4((QUAD_REAL3(0.5,0.5,0.5) + 0.5*V.xyz),1.0); }
QUAD_REAL4 as_rgba(QUAD_REAL4 V) { return QUAD_REAL4((QUAD_REAL3(0.5,0.5,0.5) + 0.5*V.xyz),V.w); }
// un-normalized vector (spherical normalize)
QUAD_REAL4 as_rgba_n(QUAD_REAL3 V) { return QUAD_REAL4((QUAD_REAL3(0.5,0.5,0.5) + 0.5*normalize(V.xyz)),1.0); }
QUAD_REAL4 as_rgba_n(QUAD_REAL4 V) { return QUAD_REAL4((QUAD_REAL3(0.5,0.5,0.5) + 0.5*normalize(V.xyz)),V.w); }
// un-normalized vector (cube normalize)
QUAD_REAL4 as_rgba_cn(QUAD_REAL3 V) { return QUAD_REAL4((QUAD_REAL3(0.5,0.5,0.5) + 0.5*cube_normalize(V.xyz)),1.0); }
QUAD_REAL4 as_rgba_cn(QUAD_REAL4 V) { return QUAD_REAL4((QUAD_REAL3(0.5,0.5,0.5) + 0.5*cube_normalize(V.xyz)),V.w); }
#endif /* _DEBUG_TOOLS_FXH_ */
/***************************** eof ***/
]]>; \
sampler SampName = sampler_state { \
texture = ; \
AddressU = AddrMode; \
AddressV = AddrMode; \
MipFilter = LINEAR; \
MinFilter = LINEAR; \
MagFilter = LINEAR; \
};
//
// Simple 2D File Textures
//
// example usage: FILE_TEXTURE_2D(GlowMap,GlowSampler,"myfile.dds")
//
#define FILE_TEXTURE_2D(TextureName,SamplerName,Diskfile) FILE_TEXTURE_2D_MODAL(TextureName,SamplerName,(Diskfile),WRAP)
//
// Use this variation of DECLARE_QUAD_TEX() if you want a *scaled* render target
//
// example usage: DECLARE_SIZED_QUAD_TEX(GlowMap,GlowSampler,"A8R8G8B8",1.0)
#define DECLARE_SIZED_QUAD_TEX(TexName,SampName,PixFmt,Multiple) texture TexName : RENDERCOLORTARGET < \
float2 ViewPortRatio = {Multiple,Multiple}; \
int MipLevels = 1; \
string Format = PixFmt ; \
string UIWidget = "None"; \
>; \
sampler SampName = sampler_state { \
texture = ; \
AddressU = CLAMP; \
AddressV = CLAMP; \
MipFilter = POINT; \
MinFilter = LINEAR; \
MagFilter = LINEAR; \
};
//
// Use this macro to easily declare typical color render targets
//
// example usage: DECLARE_QUAD_TEX(ObjMap,ObjSampler,"A8R8G8B8")
#define DECLARE_QUAD_TEX(TextureName,SamplerName,PixelFormat) DECLARE_SIZED_QUAD_TEX(TextureName,SamplerName,(PixelFormat),1.0)
//
// Use this macro to easily declare variable-sized depth render targets
//
// example usage: DECLARE_SIZED_QUAD_DEPTH_BUFFER(DepthMap,"D24S8",0.5)
#define DECLARE_SIZED_QUAD_DEPTH_BUFFER(TextureName,PixelFormat,Multiple) texture TextureName : RENDERDEPTHSTENCILTARGET < \
float2 ViewPortRatio = {Multiple,Multiple}; \
string Format = (PixelFormat); \
string UIWidget = "None"; \
>;
//
// Use this macro to easily declare typical depth render targets
//
// example usage: DECLARE_QUAD_DEPTH_BUFFER(DepthMap,"D24S8")
#define DECLARE_QUAD_DEPTH_BUFFER(TexName,PixFmt) DECLARE_SIZED_QUAD_DEPTH_BUFFER(TexName,PixFmt,1.0)
//
// declare exact-sized arbitrary texture
//
// example usage: DECLARE_SIZED_TEX(BlahMap,BlahSampler,"R32F",128,1)
#define DECLARE_SIZED_TEX(Tex,Samp,Fmt,Wd,Ht) texture Tex : RENDERCOLORTARGET < \
float2 Dimensions = { Wd, Ht }; \
string Format = Fmt ; \
string UIWidget = "None"; \
int miplevels=1;\
>; \
sampler Samp = sampler_state { \
texture = ; \
AddressU = CLAMP; \
AddressV = CLAMP; \
MipFilter = NONE; \
MinFilter = LINEAR; \
MagFilter = LINEAR; \
};
//
// declare exact-sized square texture, as for shadow maps
//
// example usage: DECLARE_SQUARE_QUAD_TEX(ShadMap,ShadObjSampler,"A16R16G16B16F",512)
#define DECLARE_SQUARE_QUAD_TEX(TexName,SampName,PixFmt,Size) DECLARE_SIZED_TEX(TexName,SampName,(PixFmt),Size,Size)
//
// likewise for shadow depth targets
//
// example usage: DECLARE_SQUARE_QUAD_DEPTH_BUFFER(ShadDepth,"D24S8",512)
#define DECLARE_SQUARE_QUAD_DEPTH_BUFFER(TextureName,PixelFormat,Size) texture TextureName : RENDERDEPTHSTENCILTARGET < \
float2 Dimensions = { Size, Size }; \
string Format = (PixelFormat) ; \
string UIWidget = "None"; \
>;
////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////// Utility Functions ////////
////////////////////////////////////////////////////////////////////////////
//
// Scale inputs for use with texture-based lookup tables. A value ranging from zero to one needs
// a slight scaling and offset to be sure to point at the centers of the first and last pixels
// of that lookup texture. Pass the integer size of the table in TableSize
// For now we'll assume that all tables are 1D, square, or cube-shaped -- all axes of equal size
//
// Cost of this operation for pixel shaders: two const-register
// entries and a MAD (one cycle)
QUAD_REAL scale_lookup(QUAD_REAL Value,const QUAD_REAL TableSize)
{
QUAD_REAL scale = ((TableSize - 1.0)/TableSize);
QUAD_REAL shift = (0.5 / TableSize);
return (scale*Value + shift);
}
QUAD_REAL2 scale_lookup(QUAD_REAL2 Value,const QUAD_REAL TableSize)
{
QUAD_REAL scale = ((TableSize - 1.0)/TableSize);
QUAD_REAL shift = (0.5 / TableSize);
return (scale.xx*Value + shift.xx);
}
QUAD_REAL3 scale_lookup(QUAD_REAL3 Value,const QUAD_REAL TableSize)
{
QUAD_REAL scale = ((TableSize - 1.0)/TableSize);
QUAD_REAL shift = (0.5 / TableSize);
return (scale.xxx*Value + shift.xxx);
}
// pre-multiply and un-pre-mutliply functions. The precision
// of thse operatoions is often limited to 8-bit so don't
// always count on them!
// The macro value of NV_ALPHA_EPSILON, if defined, is used to
// avoid IEEE "NaN" values that may occur when erroneously
// dividing by a zero alpha (thanks to Pete Warden @ Apple
// Computer for the suggestion in GPU GEMS II)
// multiply color by alpha to turn an un-premultipied
// pixel value into a premultiplied one
QUAD_REAL4 premultiply(QUAD_REAL4 C)
{
return QUAD_REAL4((C.w*C.xyz),C.w);
}
#define NV_ALPHA_EPSILON 0.0001
// given a premultiplied pixel color, try to undo the premultiplication.
// beware of precision errors
QUAD_REAL4 unpremultiply(QUAD_REAL4 C)
{
#ifdef NV_ALPHA_EPSILON
QUAD_REAL a = C.w + NV_ALPHA_EPSILON;
return QUAD_REAL4((C.xyz / a),C.w);
#else /* ! NV_ALPHA_EPSILON */
return QUAD_REAL4((C.xyz / C.w),C.w);
#endif /* ! NV_ALPHA_EPSILON */
}
/////////////////////////////////////////////////////////////////////////////////////
// Structure Declaration ////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
struct QuadVertexOutput {
QUAD_REAL4 Position : POSITION;
QUAD_REAL2 UV : TEXCOORD0;
};
/////////////////////////////////////////////////////////////////////////////////////
// Hidden tweakables declared by this .fxh file /////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
#ifndef NO_TEXEL_OFFSET
#ifdef TWEAKABLE_TEXEL_OFFSET
QUAD_REAL QuadTexOffset = 0.5;
#else /* !TWEAKABLE_TEXEL_OFFSET */
QUAD_REAL QuadTexOffset < string UIWidget="None"; > = 0.5;
#endif /* !TWEAKABLE_TEXEL_OFFSET */
QUAD_REAL2 QuadScreenSize : VIEWPORTPIXELSIZE < string UIWidget="None"; >;
#endif /* NO_TEXEL_OFFSET */
////////////////////////////////////////////////////////////
////////////////////////////////// vertex shaders //////////
////////////////////////////////////////////////////////////
QuadVertexOutput ScreenQuadVS(
QUAD_REAL3 Position : POSITION,
QUAD_REAL3 TexCoord : TEXCOORD0
) {
QuadVertexOutput OUT;
OUT.Position = QUAD_REAL4(Position, 1);
#ifdef NO_TEXEL_OFFSET
OUT.UV = TexCoord.xy;
#else /* NO_TEXEL_OFFSET */
QUAD_REAL2 off = QUAD_REAL2(QuadTexOffset/(QuadScreenSize.x),QuadTexOffset/(QuadScreenSize.y));
OUT.UV = QUAD_REAL2(TexCoord.xy+off);
#endif /* NO_TEXEL_OFFSET */
return OUT;
}
//////////////////////////////////////////////////////
////////////////////////////////// pixel shaders /////
//////////////////////////////////////////////////////
// add glow on top of model
QUAD_REAL4 TexQuadPS(QuadVertexOutput IN,uniform sampler2D InputSampler) : COLOR
{
QUAD_REAL4 texCol = tex2D(InputSampler, IN.UV);
return texCol;
}
QUAD_REAL4 TexQuadBiasPS(QuadVertexOutput IN,uniform sampler2D InputSampler,QUAD_REAL TBias) : COLOR
{
QUAD_REAL4 texCol = tex2Dbias(InputSampler, QUAD_REAL4(IN.UV,0,TBias));
return texCol;
}
//////////////////////////////////////////////////////////////////
/// Macros to define passes within Techniques ////////////////////
//////////////////////////////////////////////////////////////////
// older HLSL syntax
#define TEX_TECH(TechName,SamplerName) technique TechName { \
pass TexturePass { \
VertexShader = compile vs_2_0 ScreenQuadVS(); \
AlphaBlendEnable = false; ZEnable = false; \
PixelShader = compile ps_2_a TexQuadPS(SamplerName); } }
#define TEX_BLEND_TECH(TechName,SamplerName) technique TechName { \
pass TexturePass { \
VertexShader = compile vs_2_0 ScreenQuadVS(); \
ZEnable = false; AlphaBlendEnable = true; \
SrcBlend = SrcAlpha; DestBlend = InvSrcAlpha; \
PixelShader = compile ps_2_a TexQuadPS(SamplerName); } }
// newer HLSL syntax
#define TEX_TECH2(TechName,SamplerName,TargName) technique TechName { \
pass TexturePass < \
string ScriptFunction = "RenderColorTarget0=" (TargName) ";" \
"DrawInternal=Buffer;"; \
> { \
VertexShader = compile vs_2_0 ScreenQuadVS(); \
AlphaBlendEnable = false; ZEnable = false; \
PixelShader = compile ps_2_a TexQuadPS(SamplerName); } }
#define TEX_BLEND_TECH2(TechName,SamplerName) technique TechName { \
pass TexturePass < \
string ScriptFunction = "RenderColorTarget0=" (TargName) ";" \
"DrawInternal=Buffer;"; \
> { \
VertexShader = compile vs_2_0 ScreenQuadVS(); \
ZEnable = false; AlphaBlendEnable = true; \
SrcBlend = SrcAlpha; DestBlend = InvSrcAlpha; \
PixelShader = compile ps_2_a TexQuadPS(SamplerName); } }
#endif /* _QUAD_FXH */
////////////// eof ///
]]> = DEFAULT_BALANCE;
/////////////// prodecural texture /////////////
/*********** texture shader ******/
float4 make_stripe_tex(float2 Pos : POSITION,float ps : PSIZE) : COLOR
{
float v = 0;
float nx = Pos.x+ps; // keep the last column full-on, always
v = nx > Pos.y;
return float4(v.xxxx);
}
// texture declaration
texture _StripeTexture <
string function = "make_stripe_tex";
string UIWidget = "None";
float2 Dimensions = { STRIPE_TEX_SIZE, STRIPE_TEX_SIZE };
>;
sampler2D _StripeSampler = sampler_state
{
Texture = <_StripeTexture>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = CLAMP;
};
////////////////////////////////////////////
// Utility Functions ///////////////////////
////////////////////////////////////////////
// base function: "Balance" is in W term
float stripe(float4 XYZW) { return tex2D(_StripeSampler,XYZW.xw).x; }
float stripe(float4 XYZW,float Balance) {
return stripe(float4(XYZW.xyz,Balance)); }
float stripe(float3 XYZ,float Balance) {
return stripe(float4(XYZ.xyz,Balance)); }
float stripe(float2 XY,float Balance) {
return stripe(float4(XY.xyy,Balance)); }
float stripe(float X,float Balance) {
return stripe(float4(X.xxx,Balance)); }
// use default balance (can't do float4 version, would interfere): //
float stripe(float3 XYZ) {
return stripe(float4(XYZ.xyz,DEFAULT_BALANCE)); }
float stripe(float2 XY) {
return stripe(float4(XY.xyy,DEFAULT_BALANCE)); }
float stripe(float X) {
return stripe(float4(X.xxx,DEFAULT_BALANCE)); }
///////////////////////////////////
// 2D checker ///////////
///////////////////////////////////
float checker2D(float4 XYZW)
{
float stripex = tex2D(_StripeSampler,XYZW.xw).x;
float stripey = tex2D(_StripeSampler,XYZW.yw).x;
return abs(stripex - stripey);
}
// overloads of the above
float checker2D(float4 XYZW,float Balance) {
return checker2D(float4(XYZW.xyz,Balance)); }
float checker2D(float3 XYZ,float Balance) {
return checker2D(float4(XYZ.xyz,Balance)); }
float checker2D(float2 XY,float Balance) {
return checker2D(float4(XY.xyy,Balance)); }
// use default balance ////////////////////////
float checker2D(float3 XYZ) {
return checker2D(float4(XYZ.xyz,DEFAULT_BALANCE)); }
float checker2D(float2 XY) {
return checker2D(float4(XY.xyy,DEFAULT_BALANCE)); }
float checker2D(float X) {
return checker2D(float4(X.xxx,DEFAULT_BALANCE)); }
///////////////////////////////////
// 3D checker /////////////////////
///////////////////////////////////
float checker3D(float4 XYZW)
{
float stripex = tex2D(_StripeSampler,XYZW.xw).x;
float stripey = tex2D(_StripeSampler,XYZW.yw).x;
float stripez = tex2D(_StripeSampler,XYZW.zw).x;
float check = abs(abs(stripex - stripey) - stripez);
return check;
}
// overloads of the above
float checker3D(float3 XYZ,float Balance) {
return checker3D(float4(XYZ.xyz,Balance)); }
float checker3D(float4 XYZW,float Balance) {
return checker3D(float4(XYZW.xyz,Balance)); }
// use default balance ////////////////////////
float checker3D(float3 XYZ) {
return checker3D(float4(XYZ.xyz,DEFAULT_BALANCE)); }
float checker3D(float2 XY) {
return checker3D(float4(XY.xyy,DEFAULT_BALANCE)); }
float checker3D(float X) {
return checker3D(float4(X.xxx,DEFAULT_BALANCE)); }
/////////////
float3 checker3Drgb(float4 XYZW)
{
float3 result;
result.x = tex2D(_StripeSampler,XYZW.xw).x;
result.y = tex2D(_StripeSampler,XYZW.yw).x;
result.z = tex2D(_StripeSampler,XYZW.zw).x;
return result;
}
float3 checker3Drgb(float3 XYZ,float Balance)
{
return checker3Drgb(float4(XYZ.xyz,Balance)); }
float3 checker3Drgb(float3 XYZ)
{
return checker3Drgb(float4(XYZ.xyz,DEFAULT_BALANCE)); }
#endif /* _STRIPE_TEX_FXH_ */
/***************************** eof ***/
]]> = "tiger.x"; // for EffectEdit
#include
/************* UN-TWEAKABLES **************/
float4x4 WorldITXf : WorldInverseTranspose < string UIWidget="None"; >;
float4x4 WvpXf : WorldViewProjection < string UIWidget="None"; >;
float4x4 WorldXf : World < string UIWidget="None"; >;
float4x4 ViewITXf : ViewInverseTranspose < string UIWidget="None"; >;
float4x4 ViewIXf : ViewInverse < string UIWidget="None"; >;
float4x4 WorldViewXf : WorldView < string UIWidget="None"; >;
/************************************************************/
/*** TWEAKABLES *********************************************/
/************************************************************/
float4 LightPos : Position <
string Object = "PointLight";
string Space = "World";
> = {100.0f, 100.0f, 100.0f, 1.0f};
float4 SurfColor1 <
string UIName = "Surface Color 1";
string UIWidget = "Color";
> = {1.0f, 0.4f, 0.0f, 1.0f};
float4 SurfColor2 <
string UIName = "Surface Color 2";
string UIWidget = "Color";
> = {0.0f, 0.2f, 1.0f, 1.0f};
float Scale : UNITSSCALE
<
string units = "inches";
string UIWidget = "slider";
float uimin = 0.001;
float uimax = 40.0;
float uistep = 0.01;
string UIName = "Pattern Scale";
> = 2.0;
float Balance <
string UIWidget = "slider";
float uimin = 0.01;
float uimax = 0.99;
float uistep = 0.01;
string UIName = "Balance";
> = 0.5;
float Shading <
string UIWidget = "slider";
float uimin = 0.0;
float uimax = 1.0;
float uistep = 0.01;
string UIName = "Shading";
> = 0.4;
// pass the transform from world coords to any user-defined coordinate system
// float4x4 UserXf = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};
float4x4 UserXf = {0.5,-0.146447,1.707107,0, 0.5,0.853553,-0.292893,0, -0.707107,0.5,1,0, 0,0,0,1};
/////////////// prodecural texture /////////////
/************* DATA STRUCTS **************/
/* data from application vertex buffer */
struct appdata {
float3 Position : POSITION;
float4 UV : TEXCOORD0;
float4 Normal : NORMAL;
float4 Tangent : TANGENT0;
float4 Binormal : BINORMAL0;
};
/* data passed from vertex shader to pixel shader */
struct vertexOutput {
float4 HPosition : POSITION;
float2 TexCoord : TEXCOORD0;
float3 LightVec : TEXCOORD1;
float3 WorldNormal : TEXCOORD2;
float3 WorldEyeVec : TEXCOORD3;
float3 WorldTangent : TEXCOORD4;
float3 WorldBinorm : TEXCOORD5;
float4 CheckCoords : TEXCOORD6;
float4 BaseColor : COLOR0;
};
/*********** vertex shader ******/
void sharedVS(appdata IN,
out float3 Normal,
out float3 Tangent,
out float3 Binormal,
out float3 LightVec,
out float2 TexCoord,
out float3 EyeVec,
out float4 HPosition,
out float4 Po,
out float4 Pw,
out float4 Pu,
out float4 C)
{
Normal = mul(IN.Normal,WorldITXf).xyz;
Tangent = mul(IN.Tangent,WorldITXf).xyz;
Binormal = mul(IN.Binormal,WorldITXf).xyz;
Po = float4(IN.Position.xyz,1.0);
Pw = mul(Po,WorldXf);
Pu = mul(Pw,UserXf); // P in "user coords"
LightVec = (LightPos - Pw.xyz);
TexCoord = IN.UV.xy;
EyeVec = normalize(ViewITXf[3].xyz - Pw.xyz);
HPosition = mul(Po,WvpXf);
float ldn = dot(normalize(LightVec),normalize(Normal));
ldn = max(0,ldn);
C = lerp(float4(1,1,1,1),ldn.xxxx,Shading);
}
vertexOutput userVS(appdata IN) {
vertexOutput OUT;
float4 Po, Pw, Pu;
sharedVS(IN,OUT.WorldNormal,OUT.WorldTangent,OUT.WorldBinorm,
OUT.LightVec,OUT.TexCoord,OUT.WorldEyeVec,OUT.HPosition,Po,Pw,Pu,
OUT.BaseColor);
OUT.CheckCoords = float4((Scale*Pu).xyz,Balance);
return OUT;
}
vertexOutput worldVS(appdata IN) {
vertexOutput OUT;
float4 Po, Pw, Pu;
sharedVS(IN,OUT.WorldNormal,OUT.WorldTangent,OUT.WorldBinorm,
OUT.LightVec,OUT.TexCoord,OUT.WorldEyeVec,OUT.HPosition,Po,Pw,Pu,
OUT.BaseColor);
OUT.CheckCoords = float4((Scale*Pw).xyz,Balance);
return OUT;
}
/////////
vertexOutput eyeVS(appdata IN) {
vertexOutput OUT;
float4 Po, Pw, Pu;
sharedVS(IN,OUT.WorldNormal,OUT.WorldTangent,OUT.WorldBinorm,
OUT.LightVec,OUT.TexCoord,OUT.WorldEyeVec,OUT.HPosition,Po,Pw,Pu,
OUT.BaseColor);
OUT.CheckCoords = float4((Scale*OUT.HPosition).xyz,Balance);
return OUT;
}
vertexOutput screenVS(appdata IN) {
vertexOutput OUT;
float4 Po, Pw, Pu;
sharedVS(IN,OUT.WorldNormal,OUT.WorldTangent,OUT.WorldBinorm,
OUT.LightVec,OUT.TexCoord,OUT.WorldEyeVec,OUT.HPosition,Po,Pw,Pu,
OUT.BaseColor);
OUT.CheckCoords = float4((Scale*OUT.HPosition).xyz,OUT.HPosition.w);
return OUT;
}
vertexOutput worldViewVS(appdata IN) {
vertexOutput OUT;
float4 Po, Pw, Pu;
sharedVS(IN,OUT.WorldNormal,OUT.WorldTangent,OUT.WorldBinorm,
OUT.LightVec,OUT.TexCoord,OUT.WorldEyeVec,OUT.HPosition,Po,Pw,Pu,
OUT.BaseColor);
OUT.CheckCoords = float4((Scale*mul(Po,WorldViewXf)).xyz,Balance);
return OUT;
}
/////////////
vertexOutput objectVS(appdata IN) {
vertexOutput OUT;
float4 Po, Pw, Pu;
sharedVS(IN,OUT.WorldNormal,OUT.WorldTangent,OUT.WorldBinorm,
OUT.LightVec,OUT.TexCoord,OUT.WorldEyeVec,OUT.HPosition,Po,Pw,Pu,
OUT.BaseColor);
OUT.CheckCoords = float4(Scale*Po.xyz,Balance);
return OUT;
}
vertexOutput uvVS(appdata IN) {
vertexOutput OUT;
float4 Po, Pw, Pu;
sharedVS(IN,OUT.WorldNormal,OUT.WorldTangent,OUT.WorldBinorm,
OUT.LightVec,OUT.TexCoord,OUT.WorldEyeVec,OUT.HPosition,Po,Pw,Pu,
OUT.BaseColor);
OUT.CheckCoords = float4(Scale*IN.UV.xy,Balance,Balance);
return OUT;
}
vertexOutput normalVS(appdata IN) {
vertexOutput OUT;
float4 Po, Pw, Pu;
sharedVS(IN,OUT.WorldNormal,OUT.WorldTangent,OUT.WorldBinorm,
OUT.LightVec,OUT.TexCoord,OUT.WorldEyeVec,OUT.HPosition,Po,Pw,Pu,
OUT.BaseColor);
OUT.CheckCoords = float4(Scale*normalize(OUT.WorldNormal),Balance);
return OUT;
}
/********* pixel shader ********/
/********* pixel shader ********/
/********* pixel shader ********/
// 3d checker
float4 mainPS(vertexOutput IN) :COLOR {
float check = checker3D(IN.CheckCoords);
return IN.BaseColor * lerp(SurfColor1,SurfColor2,check);
}
// 3d checker
float4 screenPS(vertexOutput IN) :COLOR {
float3 sp = float4(IN.CheckCoords.x/IN.CheckCoords.w,IN.CheckCoords.y/IN.CheckCoords.w,0,Balance);
float check = checker2D(sp);
return IN.BaseColor * lerp(SurfColor1,SurfColor2,check);
}
// 2d checker
float4 mainUvPS(vertexOutput IN) :COLOR {
float check = checker2D(IN.CheckCoords);
return IN.BaseColor * lerp(SurfColor1,SurfColor2,check);
}
/****************************************************************/
/****************************************************************/
/******* TECHNIQUES *********************************************/
/****************************************************************/
/****************************************************************/
#define TECH(name,VS,PS) technique name { pass p0 { \
VertexShader = compile vs_2_0 VS (); \
ZEnable = true; ZWriteEnable = true; CullMode = None; \
PixelShader = compile ps_2_0 PS (); } }
TECH(worldSpace, worldVS, mainPS)
TECH(objectSpace, objectVS, mainPS)
TECH(eyeSpace, eyeVS, mainPS)
TECH(screenSpace, screenVS, screenPS)
TECH(worldViewSpace, worldViewVS, mainPS)
TECH(uvSpace, uvVS, mainUvPS)
TECH(userCoordSysSpace, userVS, mainPS)
TECH(normalSpace, normalVS, mainPS)
/***************************** eof ***/
]]>