1411 lines
46 KiB
C++
1411 lines
46 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (ASSIMP)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2008, ASSIMP Development Team
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the following
|
|
conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the ASSIMP team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the ASSIMP Development Team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "assimp_view.h"
|
|
|
|
|
|
namespace AssimpView
|
|
{
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
std::string g_szNormalsShader = std::string(
|
|
|
|
// World * View * Projection matrix\n"
|
|
// NOTE: Assume that the material uses a WorldViewProjection matrix\n"
|
|
"float4x4 WorldViewProjection : WORLDVIEWPROJECTION;\n"
|
|
"float4 OUTPUT_COLOR;\n"
|
|
|
|
// Vertex shader input structure
|
|
"struct VS_INPUT\n"
|
|
"{\n"
|
|
"// Position\n"
|
|
"float3 Position : POSITION;\n"
|
|
"};\n"
|
|
|
|
// Vertex shader output structure for pixel shader usage
|
|
"struct VS_OUTPUT\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"};\n"
|
|
|
|
// Vertex shader output structure for FixedFunction usage
|
|
"struct VS_OUTPUT_FF\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"float4 Color : COLOR;\n"
|
|
"};\n"
|
|
|
|
// Vertex shader for rendering normals using pixel shader
|
|
"VS_OUTPUT RenderNormalsVS(VS_INPUT IN)\n"
|
|
"{\n"
|
|
"// Initialize the output structure with zero\n"
|
|
"VS_OUTPUT Out = (VS_OUTPUT)0;\n"
|
|
|
|
"// Multiply with the WorldViewProjection matrix\n"
|
|
"Out.Position = mul(float4(IN.Position,1.0f),WorldViewProjection);\n"
|
|
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// Vertex shader for rendering normals using fixed function pipeline
|
|
"VS_OUTPUT_FF RenderNormalsVS_FF(VS_INPUT IN)\n"
|
|
"{\n"
|
|
"VS_OUTPUT_FF Out;\n"
|
|
"Out.Position = mul(float4(IN.Position,1.0f),WorldViewProjection);\n"
|
|
"Out.Color = OUTPUT_COLOR;\n"
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// Pixel shader
|
|
"float4 RenderNormalsPS() : COLOR\n"
|
|
"{\n"
|
|
"return OUTPUT_COLOR;\n"
|
|
"}\n"
|
|
|
|
// Technique for the normal rendering effect (ps_2_0)
|
|
"technique RenderNormals\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
"PixelShader = compile ps_2_0 RenderNormalsPS();\n"
|
|
"VertexShader = compile vs_2_0 RenderNormalsVS();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// Technique for the normal rendering effect (fixed function)
|
|
"technique RenderNormals_FF\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
"VertexShader = compile vs_2_0 RenderNormalsVS_FF();\n"
|
|
"ColorOp[0] = SelectArg1;\n"
|
|
"ColorArg0[0] = Diffuse;\n"
|
|
"AlphaOp[0] = SelectArg1;\n"
|
|
"AlphaArg0[0] = Diffuse;\n"
|
|
"}\n"
|
|
"};\n"
|
|
);
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
std::string g_szSkyboxShader = std::string(
|
|
|
|
// Sampler and texture for the skybox
|
|
"textureCUBE lw_tex_envmap;\n"
|
|
"samplerCUBE EnvironmentMapSampler = sampler_state\n"
|
|
"{\n"
|
|
"Texture = (lw_tex_envmap);\n"
|
|
"AddressU = CLAMP;\n"
|
|
"AddressV = CLAMP;\n"
|
|
"AddressW = CLAMP;\n"
|
|
|
|
"MAGFILTER = linear;\n"
|
|
"MINFILTER = linear;\n"
|
|
"};\n"
|
|
|
|
// World * View * Projection matrix\n"
|
|
// NOTE: Assume that the material uses a WorldViewProjection matrix\n"
|
|
"float4x4 WorldViewProjection : WORLDVIEWPROJECTION;\n"
|
|
|
|
// Vertex shader input structure
|
|
"struct VS_INPUT\n"
|
|
"{\n"
|
|
"float3 Position : POSITION;\n"
|
|
"float3 Texture0 : TEXCOORD0;\n"
|
|
"};\n"
|
|
|
|
// Vertex shader output structure
|
|
"struct VS_OUTPUT\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"float3 Texture0 : TEXCOORD0;\n"
|
|
"};\n"
|
|
|
|
// Vertex shader
|
|
"VS_OUTPUT RenderSkyBoxVS(VS_INPUT IN)\n"
|
|
"{\n"
|
|
"VS_OUTPUT Out;\n"
|
|
|
|
// Multiply with the WorldViewProjection matrix
|
|
"Out.Position = mul(float4(IN.Position,1.0f),WorldViewProjection);\n"
|
|
|
|
// Set z to w to ensure z becomes 1.0 after the division through w occurs
|
|
"Out.Position.z = Out.Position.w;\n"
|
|
|
|
// Simply pass through texture coordinates
|
|
"Out.Texture0 = IN.Texture0;\n"
|
|
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// Pixel shader
|
|
"float4 RenderSkyBoxPS(float3 Texture0 : TEXCOORD0) : COLOR\n"
|
|
"{\n"
|
|
// Lookup the skybox texture
|
|
"return texCUBE(EnvironmentMapSampler,Texture0) ;\n"
|
|
"}\n"
|
|
|
|
// Technique for the skybox shader (ps_2_0)
|
|
"technique RenderSkyBox\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"ZWriteEnable = FALSE;\n"
|
|
"FogEnable = FALSE;\n"
|
|
"CullMode = NONE;\n"
|
|
|
|
"PixelShader = compile ps_2_0 RenderSkyBoxPS();\n"
|
|
"VertexShader = compile vs_2_0 RenderSkyBoxVS();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// -------------- same for static background image -----------------
|
|
"texture TEXTURE_2D;\n"
|
|
"sampler TEXTURE_SAMPLER = sampler_state\n"
|
|
"{\n"
|
|
"Texture = (TEXTURE_2D);\n"
|
|
"};\n"
|
|
|
|
"struct VS_OUTPUT2\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"float2 TexCoord0 : TEXCOORD0;\n"
|
|
"};\n"
|
|
|
|
"VS_OUTPUT2 RenderImageVS(float4 INPosition : POSITION, float2 INTexCoord0 : TEXCOORD0 )\n"
|
|
"{\n"
|
|
"VS_OUTPUT2 Out;\n"
|
|
|
|
"Out.Position.xy = INPosition.xy;\n"
|
|
"Out.Position.z = Out._Position.w = 1.0f;\n"
|
|
"Out.TexCoord0 = INTexCoord0;\n"
|
|
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
"float4 RenderImagePS(float2 IN : TEXCOORD0) : COLOR\n"
|
|
"{\n"
|
|
"return tex2D(TEXTURE_SAMPLER,IN);\n"
|
|
"}\n"
|
|
|
|
// Technique for the background image shader (ps_2_0)
|
|
"technique RenderImage2D\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"ZWriteEnable = FALSE;\n"
|
|
"FogEnable = FALSE;\n"
|
|
"CullMode = NONE;\n"
|
|
|
|
"PixelShader = compile ps_2_0 RenderImagePS();\n"
|
|
"VertexShader = compile vs_2_0 RenderImageVS();\n"
|
|
"}\n"
|
|
"};\n"
|
|
);
|
|
|
|
std::string g_szDefaultShader = std::string(
|
|
|
|
// World * View * Projection matrix
|
|
// NOTE: Assume that the material uses a WorldViewProjection matrix
|
|
"float4x4 WorldViewProjection : WORLDVIEWPROJECTION;\n"
|
|
"float4x4 World : WORLD;\n"
|
|
"float4x3 WorldInverseTranspose : WORLDINVERSETRANSPOSE;\n"
|
|
|
|
// light colors
|
|
"float3 afLightColor[5];\n"
|
|
// light direction
|
|
"float3 afLightDir[5];\n"
|
|
|
|
// position of the camera in worldspace\n"
|
|
"float3 vCameraPos : CAMERAPOSITION;\n"
|
|
|
|
// Bone matrices
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4x3 gBoneMatrix[60]; \n"
|
|
"#endif // AV_SKINNING \n"
|
|
|
|
// Vertex shader input structure
|
|
"struct VS_INPUT\n"
|
|
"{\n"
|
|
"float3 Position : POSITION;\n"
|
|
"float3 Normal : NORMAL;\n"
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4 BlendIndices : BLENDINDICES;\n"
|
|
"float4 BlendWeights : BLENDWEIGHT;\n"
|
|
"#endif // AV_SKINNING \n"
|
|
"};\n"
|
|
|
|
// Vertex shader output structure for pixel shader usage
|
|
"struct VS_OUTPUT\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"float3 ViewDir : TEXCOORD0;\n"
|
|
"float3 Normal : TEXCOORD1;\n"
|
|
"};\n"
|
|
|
|
// Vertex shader output structure for fixed function
|
|
"struct VS_OUTPUT_FF\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"float4 Color : COLOR;\n"
|
|
"};\n"
|
|
|
|
// Vertex shader for pixel shader usage
|
|
"VS_OUTPUT DefaultVShader(VS_INPUT IN)\n"
|
|
"{\n"
|
|
"VS_OUTPUT Out;\n"
|
|
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4 weights = IN.BlendWeights; \n"
|
|
"weights.w = 1.0f - dot( weights.xyz, float3( 1, 1, 1)); \n"
|
|
"float3 objPos = mul( IN.Position, gBoneMatrix[IN.BlendIndices.x]) * weights.x; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.y]) * weights.y; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.z]) * weights.z; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.w]) * weights.w; \n"
|
|
"#else \n"
|
|
"float3 objPos = IN.Position; \n"
|
|
"#endif // AV_SKINNING \n"
|
|
|
|
// Multiply with the WorldViewProjection matrix
|
|
"Out.Position = mul( float4( objPos, 1.0f), WorldViewProjection);\n"
|
|
"float3 WorldPos = mul( float4( objPos, 1.0f), World);\n"
|
|
"Out.ViewDir = vCameraPos - WorldPos;\n"
|
|
"Out.Normal = mul(IN.Normal,WorldInverseTranspose);\n"
|
|
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// Vertex shader for fixed function pipeline
|
|
"VS_OUTPUT_FF DefaultVShader_FF(VS_INPUT IN)\n"
|
|
"{\n"
|
|
"VS_OUTPUT_FF Out;\n"
|
|
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4 weights = IN.BlendWeights; \n"
|
|
"weights.w = 1.0f - dot( weights.xyz, float3( 1, 1, 1)); \n"
|
|
"float3 objPos = mul( IN.Position, gBoneMatrix[IN.BlendIndices.x]) * weights.x; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.y]) * weights.y; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.z]) * weights.z; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.w]) * weights.w; \n"
|
|
"#else \n"
|
|
"float3 objPos = IN.Position; \n"
|
|
"#endif // AV_SKINNING \n"
|
|
|
|
// Multiply with the WorldViewProjection matrix
|
|
"Out.Position = mul( float4( objPos, 1.0f), WorldViewProjection);\n"
|
|
|
|
"float3 worldNormal = normalize( mul( IN.Normal, (float3x3) WorldInverseTranspose)); \n"
|
|
|
|
// per-vertex lighting. We simply assume light colors of unused lights to be black
|
|
"Out.Color = float4( 0.2f, 0.2f, 0.2f, 1.0f); \n"
|
|
"for( int a = 0; a < 2; a++)\n"
|
|
" Out.Color.rgb += saturate( dot( afLightDir[a], worldNormal)) * afLightColor[a].rgb; \n"
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// Pixel shader for one light
|
|
"float4 DefaultPShaderSpecular_D1(VS_OUTPUT IN) : COLOR\n"
|
|
"{\n"
|
|
"float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
|
|
|
|
"float3 Normal = normalize(IN.Normal);\n"
|
|
"float3 ViewDir = normalize(IN.ViewDir);\n"
|
|
|
|
"{\n"
|
|
"float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (Normal,afLightDir[0]);\n"
|
|
"float fHalfLambert = L1*L1;\n"
|
|
"OUT.rgb += afLightColor[0] * (fHalfLambert +\n"
|
|
"saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,ViewDir),9));\n"
|
|
"}\n"
|
|
"return OUT;\n"
|
|
"}\n"
|
|
|
|
// Pixel shader for two lights
|
|
"float4 DefaultPShaderSpecular_D2(VS_OUTPUT IN) : COLOR\n"
|
|
"{\n"
|
|
"float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
|
|
|
|
"float3 Normal = normalize(IN.Normal);\n"
|
|
"float3 ViewDir = normalize(IN.ViewDir);\n"
|
|
|
|
"{\n"
|
|
"float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (ViewDir,Normal);\n"
|
|
"float fHalfLambert = L1*L1;\n"
|
|
"OUT.rgb += afLightColor[0] * (fHalfLambert +\n"
|
|
"saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,afLightDir[0]),9));\n"
|
|
"}\n"
|
|
"{\n"
|
|
"float L1 = dot(Normal,afLightDir[1]) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (ViewDir,Normal);\n"
|
|
"float fHalfLambert = L1*L1;\n"
|
|
"OUT.rgb += afLightColor[1] * (fHalfLambert +\n"
|
|
"saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,afLightDir[1]),9));\n"
|
|
"}\n"
|
|
"return OUT;\n"
|
|
"}\n"
|
|
// ----------------------------------------------------------------------------
|
|
"float4 DefaultPShaderSpecular_PS20_D1(VS_OUTPUT IN) : COLOR\n"
|
|
"{\n"
|
|
"float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
|
|
|
|
"float3 Normal = normalize(IN.Normal);\n"
|
|
"float3 ViewDir = normalize(IN.ViewDir);\n"
|
|
|
|
"{\n"
|
|
"float L1 = dot(Normal,afLightDir[0]);\n"
|
|
"float3 Reflect = reflect (Normal,afLightDir[0]);\n"
|
|
"OUT.rgb += afLightColor[0] * ((L1) +\n"
|
|
"pow(dot(Reflect,ViewDir),9));\n"
|
|
"}\n"
|
|
|
|
"return OUT;\n"
|
|
"}\n"
|
|
// ----------------------------------------------------------------------------
|
|
"float4 DefaultPShaderSpecular_PS20_D2(VS_OUTPUT IN) : COLOR\n"
|
|
"{\n"
|
|
"float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
|
|
|
|
"float3 Normal = normalize(IN.Normal);\n"
|
|
"float3 ViewDir = normalize(IN.ViewDir);\n"
|
|
|
|
"{\n"
|
|
"float L1 = dot(Normal,afLightDir[0]);\n"
|
|
"float3 Reflect = reflect (Normal,afLightDir[0]);\n"
|
|
"OUT.rgb += afLightColor[0] * ((L1) +\n"
|
|
"pow(dot(Reflect,ViewDir),9));\n"
|
|
"}\n"
|
|
"{\n"
|
|
"float L1 = dot(Normal,afLightDir[1]);\n"
|
|
"float3 Reflect = reflect (Normal,afLightDir[1]);\n"
|
|
"OUT.rgb += afLightColor[1] * ((L1) +\n"
|
|
"pow(dot(Reflect,ViewDir),9));\n"
|
|
"}\n"
|
|
"return OUT;\n"
|
|
"}\n"
|
|
|
|
|
|
// Technique for the default effect
|
|
"technique DefaultFXSpecular_D1\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
"PixelShader = compile ps_3_0 DefaultPShaderSpecular_D1();\n"
|
|
"VertexShader = compile vs_3_0 DefaultVShader();\n"
|
|
"}\n"
|
|
"};\n"
|
|
"technique DefaultFXSpecular_D2\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
"PixelShader = compile ps_3_0 DefaultPShaderSpecular_D2();\n"
|
|
"VertexShader = compile vs_3_0 DefaultVShader();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// Technique for the default effect (ps_2_0)
|
|
"technique DefaultFXSpecular_PS20_D1\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
"PixelShader = compile ps_2_0 DefaultPShaderSpecular_PS20_D1();\n"
|
|
"VertexShader = compile vs_2_0 DefaultVShader();\n"
|
|
"}\n"
|
|
"};\n"
|
|
"technique DefaultFXSpecular_PS20_D2\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
"PixelShader = compile ps_2_0 DefaultPShaderSpecular_PS20_D2();\n"
|
|
"VertexShader = compile vs_2_0 DefaultVShader();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// Technique for the default effect using the fixed function pixel pipeline
|
|
"technique DefaultFXSpecular_FF\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
"VertexShader = compile vs_2_0 DefaultVShader_FF();\n"
|
|
"ColorOp[0] = SelectArg1;\n"
|
|
"ColorArg0[0] = Diffuse;\n"
|
|
"AlphaOp[0] = SelectArg1;\n"
|
|
"AlphaArg0[0] = Diffuse;\n"
|
|
"}\n"
|
|
"};\n"
|
|
);
|
|
|
|
|
|
std::string g_szMaterialShader = std::string(
|
|
|
|
// World * View * Projection matrix
|
|
// NOTE: Assume that the material uses a WorldViewProjection matrix
|
|
"float4x4 WorldViewProjection : WORLDVIEWPROJECTION;\n"
|
|
"float4x4 World : WORLD;\n"
|
|
"float4x3 WorldInverseTranspose : WORLDINVERSETRANSPOSE;\n"
|
|
|
|
"#ifndef AV_DISABLESSS\n"
|
|
"float4x3 ViewProj;\n"
|
|
"float4x3 InvViewProj;\n"
|
|
"#endif\n"
|
|
|
|
"float4 DIFFUSE_COLOR;\n"
|
|
"float4 SPECULAR_COLOR;\n"
|
|
"float4 AMBIENT_COLOR;\n"
|
|
"float4 EMISSIVE_COLOR;\n"
|
|
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"float SPECULARITY;\n"
|
|
"float SPECULAR_STRENGTH;\n"
|
|
"#endif\n"
|
|
"#ifdef AV_OPACITY\n"
|
|
"float TRANSPARENCY;\n"
|
|
"#endif\n"
|
|
|
|
// light colors (diffuse and specular)
|
|
"float4 afLightColor[5];\n"
|
|
"float4 afLightColorAmbient[5];\n"
|
|
|
|
// light direction
|
|
"float3 afLightDir[5];\n"
|
|
|
|
// position of the camera in worldspace
|
|
"float3 vCameraPos : CAMERAPOSITION;\n"
|
|
|
|
// Bone matrices
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4x3 gBoneMatrix[60]; \n"
|
|
"#endif // AV_SKINNING \n"
|
|
|
|
"#ifdef AV_DIFFUSE_TEXTURE\n"
|
|
"texture DIFFUSE_TEXTURE;\n"
|
|
"sampler DIFFUSE_SAMPLER\n"
|
|
"{\n"
|
|
"Texture = <DIFFUSE_TEXTURE>;\n"
|
|
"MinFilter=LINEAR;\n"
|
|
"MagFilter=LINEAR;\n"
|
|
"MipFilter=LINEAR;\n"
|
|
"};\n"
|
|
"#endif // AV_DIFFUSE_TEXTUR\n"
|
|
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"texture SPECULAR_TEXTURE;\n"
|
|
"sampler SPECULAR_SAMPLER\n"
|
|
"{\n"
|
|
"Texture = <SPECULAR_TEXTURE>;\n"
|
|
"MinFilter=LINEAR;\n"
|
|
"MagFilter=LINEAR;\n"
|
|
"MipFilter=LINEAR;\n"
|
|
"};\n"
|
|
"#endif // AV_SPECULAR_TEXTUR\n"
|
|
|
|
"#ifdef AV_AMBIENT_TEXTURE\n"
|
|
"texture AMBIENT_TEXTURE;\n"
|
|
"sampler AMBIENT_SAMPLER\n"
|
|
"{\n"
|
|
"Texture = <AMBIENT_TEXTURE>;\n"
|
|
"MinFilter=LINEAR;\n"
|
|
"MagFilter=LINEAR;\n"
|
|
"MipFilter=LINEAR;\n"
|
|
"};\n"
|
|
"#endif // AV_AMBIENT_TEXTUR\n"
|
|
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"texture OPACITY_TEXTURE;\n"
|
|
"sampler OPACITY_SAMPLER\n"
|
|
"{\n"
|
|
"Texture = <OPACITY_TEXTURE>;\n"
|
|
"MinFilter=LINEAR;\n"
|
|
"MagFilter=LINEAR;\n"
|
|
"MipFilter=LINEAR;\n"
|
|
"};\n"
|
|
"#endif // AV_OPACITY_TEXTURE\n"
|
|
|
|
"#ifdef AV_EMISSIVE_TEXTURE\n"
|
|
"texture EMISSIVE_TEXTURE;\n"
|
|
"sampler EMISSIVE_SAMPLER\n"
|
|
"{\n"
|
|
"Texture = <EMISSIVE_TEXTURE>;\n"
|
|
"MinFilter=LINEAR;\n"
|
|
"MagFilter=LINEAR;\n"
|
|
"MipFilter=LINEAR;\n"
|
|
"};\n"
|
|
"#endif // AV_EMISSIVE_TEXTUR\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"texture NORMAL_TEXTURE;\n"
|
|
"sampler NORMAL_SAMPLER\n"
|
|
"{\n"
|
|
"Texture = <NORMAL_TEXTURE>;\n"
|
|
"MinFilter=LINEAR;\n"
|
|
"MagFilter=LINEAR;\n"
|
|
"MipFilter=LINEAR;\n"
|
|
"};\n"
|
|
"#endif // AV_NORMAL_TEXTURE\n"
|
|
|
|
"#ifdef AV_SKYBOX_LOOKUP\n"
|
|
"textureCUBE lw_tex_envmap;\n"
|
|
"samplerCUBE EnvironmentMapSampler = sampler_state\n"
|
|
"{\n"
|
|
"Texture = (lw_tex_envmap);\n"
|
|
"AddressU = CLAMP;\n"
|
|
"AddressV = CLAMP;\n"
|
|
"AddressW = CLAMP;\n"
|
|
|
|
"MAGFILTER = linear;\n"
|
|
"MINFILTER = linear;\n"
|
|
"};\n"
|
|
"#endif // AV_SKYBOX_LOOKUP\n"
|
|
|
|
// Vertex shader input structure
|
|
"struct VS_INPUT\n"
|
|
"{\n"
|
|
"float3 Position : POSITION;\n"
|
|
"float3 Normal : NORMAL;\n"
|
|
"float4 Color : COLOR0;\n"
|
|
"float3 Tangent : TANGENT;\n"
|
|
"float3 Bitangent : BINORMAL;\n"
|
|
"float2 TexCoord0 : TEXCOORD0;\n"
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4 BlendIndices : BLENDINDICES;\n"
|
|
"float4 BlendWeights : BLENDWEIGHT;\n"
|
|
"#endif // AV_SKINNING \n"
|
|
"};\n"
|
|
|
|
// Vertex shader output structure for pixel shader usage
|
|
"struct VS_OUTPUT\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"float3 ViewDir : TEXCOORD0;\n"
|
|
|
|
"float4 Color : COLOR0;\n"
|
|
|
|
"#ifndef AV_NORMAL_TEXTURE\n"
|
|
"float3 Normal : TEXCOORD1;\n"
|
|
"#endif\n"
|
|
|
|
"float2 TexCoord0 : TEXCOORD2;\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float3 Light0 : TEXCOORD3;\n"
|
|
"float3 Light1 : TEXCOORD4;\n"
|
|
"#endif\n"
|
|
"};\n"
|
|
|
|
// Vertex shader output structure for fixed function pixel pipeline
|
|
"struct VS_OUTPUT_FF\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"float4 DiffuseColor : COLOR0;\n"
|
|
"float4 SpecularColor : COLOR1;\n"
|
|
"float2 TexCoord0 : TEXCOORD0;\n"
|
|
"};\n"
|
|
|
|
|
|
// Selective SuperSampling in screenspace for reflection lookups
|
|
"#ifndef AV_SKYBOX_LOOKUP\n"
|
|
"#define AV_DISABLESSS\n"
|
|
"#endif\n"
|
|
"#ifndef AV_DISABLESSS\n"
|
|
"float3 GetSSSCubeMap(float3 Reflect)\n"
|
|
"{\n"
|
|
// compute the reflection vector in screen space\n"
|
|
"float3 ScreenReflect = mul(Reflect,ViewProj);\n"
|
|
|
|
// compute the gradients of the reflection vector\n"
|
|
"float3 fDX = ddx(ScreenReflect);\n"
|
|
"float3 fDY = ddy(ScreenReflect);\n"
|
|
|
|
// take the center step and calculate gradients for it\n"
|
|
"float3 fColor = texCUBE(EnvironmentMapSampler,Reflect).rgb;\n"
|
|
|
|
// Take 10 samples around the center step \n"
|
|
"fColor += texCUBEgrad(EnvironmentMapSampler,mul( ScreenReflect + (0.4f * 2.0 / 3.5) * fDX + (0.4f * 2.0 / 3.5) * fDY, InvViewProj),fDX,fDY).rgb;\n"
|
|
"fColor += texCUBEgrad(EnvironmentMapSampler,mul( ScreenReflect + (0.4f * 3.0 / 3.5) * fDX + (0.4f *-1.0 / 3.5) * fDY, InvViewProj),fDX,fDY).rgb;\n"
|
|
"fColor += texCUBEgrad(EnvironmentMapSampler,mul( ScreenReflect + (0.4f * 1.0 / 3.5) * fDX + (0.4f *-3.0 / 3.5) * fDY, InvViewProj),fDX,fDY).rgb;\n"
|
|
"fColor += texCUBEgrad(EnvironmentMapSampler,mul( ScreenReflect + (0.4f *-2.0 / 3.5) * fDX + (0.4f *-2.0 / 3.5) * fDY, InvViewProj),fDX,fDY).rgb;\n"
|
|
"fColor += texCUBEgrad(EnvironmentMapSampler,mul( ScreenReflect + (0.4f *-3.0 / 3.5) * fDX + (0.4f * 1.0 / 3.5) * fDY, InvViewProj),fDX,fDY).rgb;\n"
|
|
"fColor += texCUBEgrad(EnvironmentMapSampler,mul( ScreenReflect + (0.4f *-1.0 / 3.5) * fDX + (0.4f * 3.0 / 3.5) * fDY, InvViewProj),fDX,fDY).rgb;\n"
|
|
"fColor /= 7;\n"
|
|
"return fColor;\n"
|
|
"}\n"
|
|
"#else\n"
|
|
"#define GetSSSCubeMap(_refl) (texCUBElod(EnvironmentMapSampler,float4(_refl,0.0f)).rgb) \n"
|
|
"#endif\n"
|
|
|
|
// bugfix: if normal mapping is active we have the reflection
|
|
// vector in tangent, not in world space. Would need the inverse
|
|
// of the TSM matrix in the pixel shader (or world space tangent mapping)
|
|
// Simply disable realtime reflection for normal mapping.
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"#undef GetSSSCubeMap\n"
|
|
"#define GetSSSCubeMap(_refl) (float3(1.0f,1.0f,1.0f))\n"
|
|
"#endif\n"
|
|
|
|
|
|
// Vertex shader for pixel shader usage and one light
|
|
"VS_OUTPUT MaterialVShader_D1(VS_INPUT IN)\n"
|
|
"{\n"
|
|
"VS_OUTPUT Out = (VS_OUTPUT)0;\n"
|
|
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4 weights = IN.BlendWeights; \n"
|
|
"weights.w = 1.0f - dot( weights.xyz, float3( 1, 1, 1)); \n"
|
|
"float3 objPos = mul( IN.Position, gBoneMatrix[IN.BlendIndices.x]) * weights.x; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.y]) * weights.y; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.z]) * weights.z; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.w]) * weights.w; \n"
|
|
"#else \n"
|
|
"float3 objPos = IN.Position; \n"
|
|
"#endif // AV_SKINNING \n"
|
|
|
|
// Multiply with the WorldViewProjection matrix
|
|
"Out.Position = mul( float4( objPos, 1.0f), WorldViewProjection);\n"
|
|
"float3 WorldPos = mul( float4( objPos, 1.0f), World);\n"
|
|
"Out.TexCoord0 = IN.TexCoord0;\n"
|
|
"Out.Color = IN.Color;\n"
|
|
|
|
"#ifndef AV_NORMAL_TEXTURE\n"
|
|
"Out.ViewDir = vCameraPos - WorldPos;\n"
|
|
"Out.Normal = mul(IN.Normal,WorldInverseTranspose);\n"
|
|
"#endif\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float3x3 TBNMatrix = float3x3(IN.Tangent, IN.Bitangent, IN.Normal);\n"
|
|
"float3x3 WTTS = mul(TBNMatrix, (float3x3)WorldInverseTranspose);\n"
|
|
"Out.Light0 = normalize(mul(WTTS, afLightDir[0] ));\n"
|
|
"Out.ViewDir = normalize(mul(WTTS, (vCameraPos - WorldPos)));\n"
|
|
"#endif\n"
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// Vertex shader for pixel shader usage and two lights
|
|
"VS_OUTPUT MaterialVShader_D2(VS_INPUT IN)\n"
|
|
"{\n"
|
|
"VS_OUTPUT Out = (VS_OUTPUT)0;\n"
|
|
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4 weights = IN.BlendWeights; \n"
|
|
"weights.w = 1.0f - dot( weights.xyz, float3( 1, 1, 1)); \n"
|
|
"float3 objPos = mul( IN.Position, gBoneMatrix[IN.BlendIndices.x]) * weights.x; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.y]) * weights.y; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.z]) * weights.z; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.w]) * weights.w; \n"
|
|
"#else \n"
|
|
"float3 objPos = IN.Position; \n"
|
|
"#endif // AV_SKINNING \n"
|
|
|
|
// Multiply with the WorldViewProjection matrix
|
|
"Out.Position = mul( float4( objPos, 1.0f), WorldViewProjection);\n"
|
|
"float3 WorldPos = mul( float4( objPos, 1.0f), World);\n"
|
|
"Out.TexCoord0 = IN.TexCoord0;\n"
|
|
"Out.Color = IN.Color;\n"
|
|
|
|
"#ifndef AV_NORMAL_TEXTURE\n"
|
|
"Out.ViewDir = vCameraPos - WorldPos;\n"
|
|
"Out.Normal = mul(IN.Normal,WorldInverseTranspose);\n"
|
|
"#endif\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float3x3 TBNMatrix = float3x3(IN.Tangent, IN.Bitangent, IN.Normal);\n"
|
|
"float3x3 WTTS = mul(TBNMatrix, (float3x3)WorldInverseTranspose);\n"
|
|
"Out.Light0 = normalize(mul(WTTS, afLightDir[0] ));\n"
|
|
"Out.Light1 = normalize(mul(WTTS, afLightDir[1] ));\n"
|
|
"Out.ViewDir = normalize(mul(WTTS, (vCameraPos - WorldPos)));\n"
|
|
"#endif\n"
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// Vertex shader for zero to five lights using the fixed function pixel pipeline
|
|
"VS_OUTPUT_FF MaterialVShader_FF(VS_INPUT IN)\n"
|
|
"{\n"
|
|
"VS_OUTPUT_FF Out = (VS_OUTPUT_FF)0;\n"
|
|
|
|
"#ifdef AV_SKINNING \n"
|
|
"float4 weights = IN.BlendWeights; \n"
|
|
"weights.w = 1.0f - dot( weights.xyz, float3( 1, 1, 1)); \n"
|
|
"float3 objPos = mul( IN.Position, gBoneMatrix[IN.BlendIndices.x]) * weights.x; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.y]) * weights.y; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.z]) * weights.z; \n"
|
|
"objPos += mul( IN.Position, gBoneMatrix[IN.BlendIndices.w]) * weights.w; \n"
|
|
"#else \n"
|
|
"float3 objPos = IN.Position; \n"
|
|
"#endif // AV_SKINNING \n"
|
|
|
|
// Multiply with the WorldViewProjection matrix
|
|
"Out.Position = mul( float4( objPos, 1.0f), WorldViewProjection);\n"
|
|
"float3 worldPos = mul( float4( objPos, 1.0f), World);\n"
|
|
"float3 worldNormal = normalize( mul( IN.Normal, (float3x3) WorldInverseTranspose)); \n"
|
|
"Out.TexCoord0 = IN.TexCoord0;\n"
|
|
|
|
// calculate per-vertex diffuse lighting including ambient part
|
|
"float4 diffuseColor = float4( 0.0f, 0.0f, 0.0f, 1.0f); \n"
|
|
"for( int a = 0; a < 2; a++) \n"
|
|
" diffuseColor.rgb += saturate( dot( afLightDir[a], worldNormal)) * afLightColor[a].rgb; \n"
|
|
// factor in material properties and a bit of ambient lighting
|
|
"Out.DiffuseColor = diffuseColor * DIFFUSE_COLOR + float4( 0.2f, 0.2f, 0.2f, 1.0f) * AMBIENT_COLOR; ; \n"
|
|
|
|
// and specular including emissive part
|
|
"float4 specularColor = float4( 0.0f, 0.0f, 0.0f, 1.0f); \n"
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"float3 viewDir = normalize( worldPos - vCameraPos); \n"
|
|
"for( int a = 0; a < 2; a++) \n"
|
|
"{ \n"
|
|
" float3 reflDir = reflect( afLightDir[a], worldNormal); \n"
|
|
" float specIntensity = pow( saturate( dot( reflDir, viewDir)), SPECULARITY) * SPECULAR_STRENGTH; \n"
|
|
" specularColor.rgb += afLightColor[a] * specIntensity; \n"
|
|
"} \n"
|
|
"#endif // AV_SPECULAR_COMPONENT\n"
|
|
// factor in material properties and the emissive part
|
|
"Out.SpecularColor = specularColor * SPECULAR_COLOR + EMISSIVE_COLOR; \n"
|
|
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
|
|
// Pixel shader - one light
|
|
"float4 MaterialPShaderSpecular_D1(VS_OUTPUT IN) : COLOR\n"
|
|
"{\n"
|
|
"float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float3 IN_Light0 = normalize(IN.Light0);\n"
|
|
"float3 Normal = normalize(2.0f * tex2D(NORMAL_SAMPLER, IN.TexCoord0).rgb - 1.0f);\n"
|
|
"#else\n"
|
|
"float3 Normal = normalize(IN.Normal);\n"
|
|
"#endif \n"
|
|
"float3 ViewDir = normalize(IN.ViewDir);\n"
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"float3 Reflect = -normalize(reflect (ViewDir,Normal));\n"
|
|
"#endif // !AV_SPECULAR_COMPONENT\n"
|
|
|
|
"{\n"
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float L1 = dot(Normal,IN_Light0) * 0.5f + 0.5f;\n"
|
|
"#define AV_LIGHT_0 IN_Light0\n"
|
|
// would need to convert the reflection vector into world space ....
|
|
// simply let it ...
|
|
"#else\n"
|
|
"float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
|
|
"#define AV_LIGHT_0 afLightDir[0]\n"
|
|
"#endif\n"
|
|
"float fHalfLambert = L1*L1;\n"
|
|
"#ifdef AV_DIFFUSE_TEXTURE\n"
|
|
"OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert * IN.Color.rgb +\n"
|
|
"#else\n"
|
|
"OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * fHalfLambert * IN.Color.rgb +\n"
|
|
"#endif // !AV_DIFFUSE_TEXTURE\n"
|
|
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"#ifndef AV_SKYBOX_LOOKUP\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#else\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#endif // !AV_SKYBOX_LOOKUP\n"
|
|
"#endif // !AV_SPECULAR_COMPONENT\n"
|
|
|
|
"#ifdef AV_AMBIENT_TEXTURE\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
|
|
"#else\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb + \n"
|
|
"#endif // !AV_AMBIENT_TEXTURE\n"
|
|
"#ifdef AV_EMISSIVE_TEXTURE\n"
|
|
"EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
|
|
"#else \n"
|
|
"EMISSIVE_COLOR.rgb;\n"
|
|
"#endif // !AV_EMISSIVE_TEXTURE\n"
|
|
"}\n"
|
|
"#ifdef AV_OPACITY\n"
|
|
"OUT.a = TRANSPARENCY;\n"
|
|
"#endif\n"
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"OUT.a *= tex2D(OPACITY_SAMPLER,IN.TexCoord0). AV_OPACITY_TEXTURE_REGISTER_MASK;\n"
|
|
"#endif\n"
|
|
"return OUT;\n"
|
|
|
|
"#undef AV_LIGHT_0\n"
|
|
"}\n"
|
|
|
|
// Pixel shader - two lights
|
|
"float4 MaterialPShaderSpecular_D2(VS_OUTPUT IN) : COLOR\n"
|
|
"{\n"
|
|
"float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float3 IN_Light0 = normalize(IN.Light0);\n"
|
|
"float3 IN_Light1 = normalize(IN.Light1);\n"
|
|
"float3 Normal = normalize(2.0f * tex2D(NORMAL_SAMPLER, IN.TexCoord0).rgb - 1.0f);\n"
|
|
"#else\n"
|
|
"float3 Normal = normalize(IN.Normal);\n"
|
|
"#endif \n"
|
|
"float3 ViewDir = normalize(IN.ViewDir);\n"
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"float3 Reflect = -normalize(reflect (ViewDir,Normal));\n"
|
|
"#endif // !AV_SPECULAR_COMPONENT\n"
|
|
|
|
"{\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float L1 = dot(Normal,IN_Light0) * 0.5f + 0.5f;\n"
|
|
"#define AV_LIGHT_0 IN_Light0\n"
|
|
"#else\n"
|
|
"float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
|
|
"#define AV_LIGHT_0 afLightDir[0]\n"
|
|
"#endif\n"
|
|
"float fHalfLambert = L1*L1;\n"
|
|
|
|
"#ifdef AV_DIFFUSE_TEXTURE\n"
|
|
"OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert * IN.Color.rgb +\n"
|
|
"#else\n"
|
|
"OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * fHalfLambert * IN.Color.rgb +\n"
|
|
"#endif // !AV_DIFFUSE_TEXTURE\n"
|
|
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"#ifndef AV_SKYBOX_LOOKUP\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#else\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#endif // !AV_SKYBOX_LOOKUP\n"
|
|
"#endif // !AV_SPECULAR_COMPONENT\n"
|
|
"#ifdef AV_AMBIENT_TEXTURE\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb + \n"
|
|
"#else\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb + \n"
|
|
"#endif // !AV_AMBIENT_TEXTURE\n"
|
|
"#ifdef AV_EMISSIVE_TEXTURE\n"
|
|
"EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
|
|
"#else \n"
|
|
"EMISSIVE_COLOR.rgb;\n"
|
|
"#endif // !AV_EMISSIVE_TEXTURE\n"
|
|
"}\n"
|
|
"{\n"
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float L1 = dot(Normal,IN_Light1) * 0.5f + 0.5f;\n"
|
|
"#define AV_LIGHT_1 IN_Light1\n"
|
|
"#else\n"
|
|
"float L1 = dot(Normal,afLightDir[1]) * 0.5f + 0.5f;\n"
|
|
"#define AV_LIGHT_1 afLightDir[1]\n"
|
|
"#endif\n"
|
|
"float fHalfLambert = L1*L1;\n"
|
|
"#ifdef AV_DIFFUSE_TEXTURE\n"
|
|
"OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert * IN.Color.rgb +\n"
|
|
"#else\n"
|
|
"OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * fHalfLambert * IN.Color.rgb +\n"
|
|
"#endif // !AV_DIFFUSE_TEXTURE\n"
|
|
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"#ifndef AV_SKYBOX_LOOKUP\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#else\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#endif // !AV_SKYBOX_LOOKUP\n"
|
|
"#endif // !AV_SPECULAR_COMPONENT\n"
|
|
"#ifdef AV_AMBIENT_TEXTURE\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb + \n"
|
|
"#else\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb + \n"
|
|
"#endif // !AV_AMBIENT_TEXTURE\n"
|
|
"#ifdef AV_EMISSIVE_TEXTURE\n"
|
|
"EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
|
|
"#else \n"
|
|
"EMISSIVE_COLOR.rgb;\n"
|
|
"#endif // !AV_EMISSIVE_TEXTURE\n"
|
|
"}\n"
|
|
"#ifdef AV_OPACITY\n"
|
|
"OUT.a = TRANSPARENCY;\n"
|
|
"#endif\n"
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"OUT.a *= tex2D(OPACITY_SAMPLER,IN.TexCoord0). AV_OPACITY_TEXTURE_REGISTER_MASK;\n"
|
|
"#endif\n"
|
|
"return OUT;\n"
|
|
|
|
"#undef AV_LIGHT_0\n"
|
|
"#undef AV_LIGHT_1\n"
|
|
"}\n"
|
|
|
|
// Same pixel shader again, one light
|
|
"float4 MaterialPShaderSpecular_PS20_D1(VS_OUTPUT IN) : COLOR\n"
|
|
"{\n"
|
|
"float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float3 IN_Light0 = normalize(IN.Light0);\n"
|
|
"float3 Normal = normalize(2.0f * tex2D(NORMAL_SAMPLER, IN.TexCoord0).rgb - 1.0f);\n"
|
|
"#else\n"
|
|
"float3 Normal = normalize(IN.Normal);\n"
|
|
"#endif \n"
|
|
"float3 ViewDir = normalize(IN.ViewDir);\n"
|
|
|
|
"{\n"
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float L1 = dot(Normal,IN_Light0) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (Normal,IN_Light0);\n"
|
|
"#else\n"
|
|
"float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (Normal,afLightDir[0]);\n"
|
|
"#endif\n"
|
|
"#ifdef AV_DIFFUSE_TEXTURE\n"
|
|
"OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
|
|
"#else\n"
|
|
"OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
|
|
"#endif // !AV_DIFFUSE_TEXTURE\n"
|
|
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#endif // !AV_SPECULAR_COMPONENT\n"
|
|
"#ifdef AV_AMBIENT_TEXTURE\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
|
|
"#else\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb +\n"
|
|
"#endif // !AV_AMBIENT_TEXTURE\n"
|
|
"#ifdef AV_EMISSIVE_TEXTURE\n"
|
|
"EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
|
|
"#else \n"
|
|
"EMISSIVE_COLOR.rgb;\n"
|
|
"#endif // !AV_EMISSIVE_TEXTURE\n"
|
|
"}\n"
|
|
|
|
"#ifdef AV_OPACITY\n"
|
|
"OUT.a = TRANSPARENCY;\n"
|
|
"#endif\n"
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"OUT.a *= tex2D(OPACITY_SAMPLER,IN.TexCoord0). AV_OPACITY_TEXTURE_REGISTER_MASK;\n"
|
|
"#endif\n"
|
|
"return OUT;\n"
|
|
"}\n"
|
|
|
|
// Same pixel shader again, two lights
|
|
"float4 MaterialPShaderSpecular_PS20_D2(VS_OUTPUT IN) : COLOR\n"
|
|
"{\n"
|
|
"float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
|
|
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float3 IN_Light0 = normalize(IN.Light0);\n"
|
|
"float3 IN_Light1 = normalize(IN.Light1);\n"
|
|
"float3 Normal = normalize(2.0f * tex2D(NORMAL_SAMPLER, IN.TexCoord0) - 1.0f);\n"
|
|
"#else\n"
|
|
"float3 Normal = normalize(IN.Normal);\n"
|
|
"#endif \n"
|
|
"float3 ViewDir = normalize(IN.ViewDir);\n"
|
|
|
|
"{\n"
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float L1 = dot(Normal,IN_Light0) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (Normal,IN_Light0);\n"
|
|
"#else\n"
|
|
"float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (Normal,afLightDir[0]);\n"
|
|
"#endif\n"
|
|
"#ifdef AV_DIFFUSE_TEXTURE\n"
|
|
"OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
|
|
"#else\n"
|
|
"OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
|
|
"#endif // !AV_DIFFUSE_TEXTURE\n"
|
|
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#endif // !AV_SPECULAR_COMPONENT\n"
|
|
"#ifdef AV_AMBIENT_TEXTURE\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
|
|
"#else\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb +\n"
|
|
"#endif // !AV_AMBIENT_TEXTURE\n"
|
|
"#ifdef AV_EMISSIVE_TEXTURE\n"
|
|
"EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
|
|
"#else \n"
|
|
"EMISSIVE_COLOR.rgb;\n"
|
|
"#endif // !AV_EMISSIVE_TEXTURE\n"
|
|
"}\n"
|
|
"{\n"
|
|
"#ifdef AV_NORMAL_TEXTURE\n"
|
|
"float L1 = dot(Normal,IN_Light1) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (Normal,IN_Light1);\n"
|
|
"#else\n"
|
|
"float L1 = dot(Normal,afLightDir[1]) * 0.5f + 0.5f;\n"
|
|
"float3 Reflect = reflect (Normal,afLightDir[1]);\n"
|
|
"#endif\n"
|
|
"#ifdef AV_DIFFUSE_TEXTURE\n"
|
|
"OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
|
|
"#else\n"
|
|
"OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
|
|
"#endif // !AV_DIFFUSE_TEXTURE\n"
|
|
|
|
"#ifdef AV_SPECULAR_COMPONENT\n"
|
|
"#ifdef AV_SPECULAR_TEXTURE\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
|
|
"#else\n"
|
|
"SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
|
|
"#endif // !AV_SPECULAR_TEXTURE\n"
|
|
"#endif // !AV_SPECULAR_COMPONENT\n"
|
|
"#ifdef AV_AMBIENT_TEXTURE\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
|
|
"#else\n"
|
|
"AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb + \n"
|
|
"#endif // !AV_AMBIENT_TEXTURE\n"
|
|
"#ifdef AV_EMISSIVE_TEXTURE\n"
|
|
"EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
|
|
"#else \n"
|
|
"EMISSIVE_COLOR.rgb;\n"
|
|
"#endif // !AV_EMISSIVE_TEXTURE\n"
|
|
"}\n"
|
|
|
|
"#ifdef AV_OPACITY\n"
|
|
"OUT.a = TRANSPARENCY;\n"
|
|
"#endif\n"
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"OUT.a *= tex2D(OPACITY_SAMPLER,IN.TexCoord0). AV_OPACITY_TEXTURE_REGISTER_MASK;\n"
|
|
"#endif\n"
|
|
"return OUT;\n"
|
|
"}\n"
|
|
|
|
|
|
// Technique for the material effect
|
|
"technique MaterialFXSpecular_D1\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"AlphaBlendEnable=TRUE;"
|
|
"SrcBlend = srcalpha;\n"
|
|
"DestBlend = invsrcalpha;\n"
|
|
"#else\n"
|
|
"#ifdef AV_OPACITY\n"
|
|
"AlphaBlendEnable=TRUE;"
|
|
"SrcBlend = srcalpha;\n"
|
|
"DestBlend = invsrcalpha;\n"
|
|
"#endif \n"
|
|
"#endif\n"
|
|
|
|
"PixelShader = compile ps_3_0 MaterialPShaderSpecular_D1();\n"
|
|
"VertexShader = compile vs_3_0 MaterialVShader_D1();\n"
|
|
"}\n"
|
|
"};\n"
|
|
"technique MaterialFXSpecular_D2\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"AlphaBlendEnable=TRUE;"
|
|
"SrcBlend = srcalpha;\n"
|
|
"DestBlend = invsrcalpha;\n"
|
|
"#else\n"
|
|
"#ifdef AV_OPACITY\n"
|
|
"AlphaBlendEnable=TRUE;"
|
|
"SrcBlend = srcalpha;\n"
|
|
"DestBlend = invsrcalpha;\n"
|
|
"#endif \n"
|
|
"#endif\n"
|
|
|
|
"PixelShader = compile ps_3_0 MaterialPShaderSpecular_D2();\n"
|
|
"VertexShader = compile vs_3_0 MaterialVShader_D2();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// Technique for the material effect (ps_2_0)
|
|
"technique MaterialFXSpecular_PS20_D1\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"AlphaBlendEnable=TRUE;"
|
|
"SrcBlend = srcalpha;\n"
|
|
"DestBlend = invsrcalpha;\n"
|
|
"#else\n"
|
|
"#ifdef AV_OPACITY\n"
|
|
"AlphaBlendEnable=TRUE;"
|
|
"SrcBlend = srcalpha;\n"
|
|
"DestBlend = invsrcalpha;\n"
|
|
"#endif \n"
|
|
"#endif\n"
|
|
|
|
"PixelShader = compile ps_2_0 MaterialPShaderSpecular_PS20_D1();\n"
|
|
"VertexShader = compile vs_2_0 MaterialVShader_D1();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
"technique MaterialFXSpecular_PS20_D2\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
|
|
"#ifdef AV_OPACITY_TEXTURE\n"
|
|
"AlphaBlendEnable=TRUE;"
|
|
"SrcBlend = srcalpha;\n"
|
|
"DestBlend = invsrcalpha;\n"
|
|
"#else\n"
|
|
"#ifdef AV_OPACITY\n"
|
|
"AlphaBlendEnable=TRUE;"
|
|
"SrcBlend = srcalpha;\n"
|
|
"DestBlend = invsrcalpha;\n"
|
|
"#endif \n"
|
|
"#endif\n"
|
|
|
|
"PixelShader = compile ps_2_0 MaterialPShaderSpecular_PS20_D2();\n"
|
|
"VertexShader = compile vs_2_0 MaterialVShader_D2();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// Technique for the material effect using fixed function pixel pipeline
|
|
"technique MaterialFX_FF\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"CullMode=none;\n"
|
|
"SpecularEnable = true; \n"
|
|
"VertexShader = compile vs_2_0 MaterialVShader_FF();\n"
|
|
"ColorOp[0] = Modulate;\n"
|
|
"ColorArg0[0] = Texture;\n"
|
|
"ColorArg1[0] = Diffuse;\n"
|
|
"AlphaOp[0] = Modulate;\n"
|
|
"AlphaArg0[0] = Texture;\n"
|
|
"AlphaArg1[0] = Diffuse;\n"
|
|
"}\n"
|
|
"};\n"
|
|
);
|
|
|
|
std::string g_szPassThroughShader = std::string(
|
|
"texture TEXTURE_2D;\n"
|
|
"sampler TEXTURE_SAMPLER = sampler_state\n"
|
|
"{\n"
|
|
"Texture = (TEXTURE_2D);\n"
|
|
"};\n"
|
|
|
|
// Vertex Shader output for pixel shader usage
|
|
"struct VS_OUTPUT\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"float2 TexCoord0 : TEXCOORD0;\n"
|
|
"};\n"
|
|
|
|
// vertex shader for pixel shader usage
|
|
"VS_OUTPUT DefaultVShader(float4 INPosition : POSITION, float2 INTexCoord0 : TEXCOORD0 )\n"
|
|
"{\n"
|
|
"VS_OUTPUT Out;\n"
|
|
|
|
"Out.Position = INPosition;\n"
|
|
"Out.TexCoord0 = INTexCoord0;\n"
|
|
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// simply lookup a texture
|
|
"float4 PassThrough_PS(float2 IN : TEXCOORD0) : COLOR\n"
|
|
"{\n"
|
|
" return tex2D(TEXTURE_SAMPLER,IN);\n"
|
|
"}\n"
|
|
|
|
// visualize the alpha channel (in black) -> use a
|
|
"float4 PassThroughAlphaA_PS(float2 IN : TEXCOORD0) : COLOR\n"
|
|
"{\n"
|
|
" return float4(0.0f,0.0f,0.0f,tex2D(TEXTURE_SAMPLER,IN).a);\n"
|
|
"}\n"
|
|
|
|
// visualize the alpha channel (in black) -> use r
|
|
"float4 PassThroughAlphaR_PS(float2 IN : TEXCOORD0) : COLOR\n"
|
|
"{\n"
|
|
" return float4(0.0f,0.0f,0.0f,tex2D(TEXTURE_SAMPLER,IN).r);\n"
|
|
"}\n"
|
|
|
|
// Simple pass-through technique
|
|
"technique PassThrough\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"FillMode=Solid;\n"
|
|
"ZEnable = FALSE;\n"
|
|
"CullMode = none;\n"
|
|
"AlphaBlendEnable = TRUE;\n"
|
|
"SrcBlend =srcalpha;\n"
|
|
"DestBlend =invsrcalpha;\n"
|
|
"PixelShader = compile ps_2_0 PassThrough_PS();\n"
|
|
"VertexShader = compile vs_2_0 DefaultVShader();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// Pass-through technique which visualizes the texture's alpha channel
|
|
"technique PassThroughAlphaFromA\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"FillMode=Solid;\n"
|
|
"ZEnable = FALSE;\n"
|
|
"CullMode = none;\n"
|
|
"AlphaBlendEnable = TRUE;\n"
|
|
"SrcBlend =srcalpha;\n"
|
|
"DestBlend =invsrcalpha;\n"
|
|
"PixelShader = compile ps_2_0 PassThroughAlphaA_PS();\n"
|
|
"VertexShader = compile vs_2_0 DefaultVShader();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// Pass-through technique which visualizes the texture's red channel
|
|
"technique PassThroughAlphaFromR\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"FillMode=Solid;\n"
|
|
"ZEnable = FALSE;\n"
|
|
"CullMode = none;\n"
|
|
"AlphaBlendEnable = TRUE;\n"
|
|
"SrcBlend =srcalpha;\n"
|
|
"DestBlend =invsrcalpha;\n"
|
|
"PixelShader = compile ps_2_0 PassThroughAlphaR_PS();\n"
|
|
"VertexShader = compile vs_2_0 DefaultVShader();\n"
|
|
"}\n"
|
|
"};\n"
|
|
|
|
// technique for fixed function pixel pipeline
|
|
"technique PassThrough_FF\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"ZEnable = FALSE;\n"
|
|
"CullMode = none;\n"
|
|
"AlphaBlendEnable = TRUE;\n"
|
|
"SrcBlend =srcalpha;\n"
|
|
"DestBlend =invsrcalpha;\n"
|
|
"VertexShader = compile vs_2_0 DefaultVShader();\n"
|
|
"ColorOp[0] = SelectArg1;\n"
|
|
"ColorArg0[0] = Texture;\n"
|
|
"AlphaOp[0] = SelectArg1;\n"
|
|
"AlphaArg0[0] = Texture;\n"
|
|
"}\n"
|
|
"};\n"
|
|
);
|
|
|
|
std::string g_szCheckerBackgroundShader = std::string(
|
|
|
|
// the two colors used to draw the checker pattern
|
|
"float3 COLOR_ONE = float3(0.4f,0.4f,0.4f);\n"
|
|
"float3 COLOR_TWO = float3(0.6f,0.6f,0.6f);\n"
|
|
|
|
// size of a square in both x and y direction
|
|
"float SQUARE_SIZE = 10.0f;\n"
|
|
|
|
// vertex shader output structure
|
|
"struct VS_OUTPUT\n"
|
|
"{\n"
|
|
"float4 Position : POSITION;\n"
|
|
"};\n"
|
|
|
|
// vertex shader
|
|
"VS_OUTPUT DefaultVShader(float4 INPosition : POSITION, float2 INTexCoord0 : TEXCOORD0 )\n"
|
|
"{\n"
|
|
"VS_OUTPUT Out;\n"
|
|
|
|
"Out.Position = INPosition;\n"
|
|
"return Out;\n"
|
|
"}\n"
|
|
|
|
// pixel shader
|
|
"float4 MakePattern_PS(float2 IN : VPOS) : COLOR\n"
|
|
"{\n"
|
|
"float2 fDiv = IN / SQUARE_SIZE;\n"
|
|
"float3 fColor = COLOR_ONE;\n"
|
|
"if (0 == round(fmod(round(fDiv.x),2)))\n"
|
|
"{\n"
|
|
" if (0 == round(fmod(round(fDiv.y),2))) fColor = COLOR_TWO;\n"
|
|
"}\n"
|
|
"else if (0 != round(fmod(round(fDiv.y),2)))fColor = COLOR_TWO;\n"
|
|
"return float4(fColor,1.0f);"
|
|
"}\n"
|
|
|
|
// technique to generate a pattern
|
|
"technique MakePattern\n"
|
|
"{\n"
|
|
"pass p0\n"
|
|
"{\n"
|
|
"FillMode=Solid;\n"
|
|
"ZEnable = FALSE;\n"
|
|
"CullMode = none;\n"
|
|
"PixelShader = compile ps_3_0 MakePattern_PS();\n"
|
|
"VertexShader = compile vs_3_0 DefaultVShader();\n"
|
|
"}\n"
|
|
"};\n"
|
|
);
|
|
}; |