the cutting room mirror

ko

view on tcrf.net

Windows Vista와 7에서 새로 추가된 게임들 중 하나이다.

디버그 메뉴#

해야할 일:
'Full Speed Render'를 선택했을 때 아무 작업도 안하는지 확인해주세요.

Vista와 7에 수록된 다른 게임들과 비슷하게, 내부에 g_debugEnabled 라는 변수가 존재한다.

이 메뉴는 다음 옵션들을 포함한다:

  • Rotate Board(판 돌리기) - 3D 모드에서는 체스판을 다른 쪽으로 돌리지만, 2D 모드에서는 아무것도 하지 않는다.
  • Self Play(자동 플레이) - 두 컴퓨터 플레이어가 게임을 하는 것을 볼 수 있다. 만약 게임이 이미 진행중인 상태라면, 새로운 게임이 시작된다.
  • Toggle Top Down View(위에서 아래로 쳐다보기) - 2D 모드에서 위로 쳐다보는 모드로 가지만, 3D로 다시 전환될 때는 최저 화질로 설정된다.
  • Toggle Full Speed Render(최고 속도 렌더링) - 아마 느린 컴퓨터에서 게임을 빠르게 진행할 수 있도록 하는 기능인 것 같다.

XInput(게임패드) 지원#

XInput(게임패드)를 지원한다는 이야기는 어디에도 써있지 않지만, 실제로 지원한다. 만약 게임이 Xbox 360 컨트롤러를 USB 포트를 통해 인식한다면, 컨트롤러의 P1 부분이 켜지며, 사용 가능하게 된다. 아마 마이크로소프트가 이 기능이 기존의 조작에 비해 이상하다고 느낀 탓인지 쓰지 않은 것으로 보인다. 그렇다 할지라도, 꽤 갖춰진 소소한 기능이다.

조작#

버튼

효과

왼쪽 아날로그 스틱/D패드/어깨버튼/트리거

커서를 옮긴다. 이상하게도, 메뉴 바를 둘러보는 데도 쓸 수 있다.

B/Back

이전의 이동을 되돌린다.

A/X

커서가 가리키는 칸을 선택한다. 커서로 기물을 가리키고 A/X를 눌러 선택하는 것이다. A/X는 기물을 하이라이트된 칸으로 이동시킨다.

Y/Start

게임 메뉴를 연다.

셰이더 코드#

Chess.dll에서, 12B9358 부분부터 셰이더 코드의 몇 부분이 존재한다.

  • 역자 주: '{'와 '}'가 번역문 내에서 완전히 닫히지 않으면 번역문이 저장이 되지 않는 관계로, 전각문자인 '｛'와 '｝'를 대신 썼습니다. 이 점 양해바라며, 혹시 이 코드를 쓸 일이 있는 경우에는 영어 원문을 참고 바랍니다.
float4x4 World;
float4x4 View;
float4x4 Projection;
texture DecalTexture;
texture GradientTexture;


sampler2D DecalSampler = sampler_state
{
    Texture   = (DecalTexture);
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
    AddressU  = Clamp;
    AddressV  = Clamp;
};


sampler2D DecalSamplerQuick = sampler_state
{
    Texture   = (DecalTexture);
    MinFilter = Point;
    MagFilter = Point;
    MipFilter = Point;
    AddressU  = Clamp;
    AddressV  = Clamp;
};


sampler1D GradientSampler = sampler_state
{
    Texture   = (GradientTexture);
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = None; // oh dear god. don't use mips because it'll sample from the lowest mip level when a triangle as the same texture coords for all 3 verts
    AddressU  = Clamp;
};


sampler2D ScreenSampler = sampler_state
{
    Texture   = (DecalTexture);
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
    AddressU  = Clamp;
    AddressV  = Clamp;
};


sampler2D ScreenSamplerPoint = sampler_state
{
    Texture   = (DecalTexture);
    MinFilter = Point;
    MagFilter = Point;
    MipFilter = Point;
    AddressU  = Clamp;
    AddressV  = Clamp;
};


technique TWorldDecal
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (View);
        ProjectionTransform = (Projection);

        Lighting = false;
        ZEnable = false;
        ZFunc = LessEqual;
        ZWriteEnable = false;

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

        Sampler[0] = (DecalSampler);
        Sampler[1] = (GradientSampler);

        ColorOp[0] = SelectArg1;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = SelectArg2;
        ColorArg1[1] = Texture;
        ColorArg2[1] = Current;
        ColorOp[2] = Disable;

        AlphaOp[0] = SelectArg1;
        AlphaArg1[0] = Texture;
        AlphaArg2[0] = Current;
        AlphaOp[1] = Modulate;
        AlphaArg1[1] = Texture;
        AlphaArg2[1] = Current;
        AlphaOp[2] = Disable;

        VertexShader = null;
        PixelShader = null;
    ｝
｝


technique TWorldDecalQuick
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (View);
        ProjectionTransform = (Projection);

        Lighting = false;
        ZEnable = false;
        ZFunc = LessEqual;
        ZWriteEnable = false;

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

        Sampler[0] = (DecalSamplerQuick);

        ColorOp[0] = SelectArg1;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = Disable;

        AlphaOp[0] = SelectArg1;
        AlphaArg1[0] = Texture;
        AlphaArg2[0] = Current;
        AlphaOp[1] = Disable;

        VertexShader = null;
        PixelShader = null;
    ｝
｝


technique TScreenDecal
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (World);
        ProjectionTransform = (World);

        Lighting = false;
        ZEnable = false;
        ZFunc = Always;
        ZWriteEnable = true;

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

        Sampler[0] = (ScreenSampler);
        Sampler[1] = (GradientSampler);

        ColorOp[0] = SelectArg1;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = SelectArg2;
        ColorArg1[1] = Texture;
        ColorArg2[1] = Current;
        ColorOp[2] = Disable;

        AlphaOp[0] = SelectArg1;
        AlphaArg1[0] = Texture;
        AlphaArg2[0] = Current;
        AlphaOp[1] = Modulate;
        AlphaArg1[1] = Texture;
        AlphaArg2[1] = Current;
        AlphaOp[2] = Disable;

        VertexShader = null;
        PixelShader = null;
    ｝
｝


technique TScreenDecalPoint
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (World);
        ProjectionTransform = (World);

        Lighting = false;
        ZEnable = false;
        ZFunc = Always;
        ZWriteEnable = true;

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

        Sampler[0] = (ScreenSamplerPoint);
        Sampler[1] = (GradientSampler);

        ColorOp[0] = SelectArg1;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = SelectArg2;
        ColorArg1[1] = Texture;
        ColorArg2[1] = Current;
        ColorOp[2] = Disable;

        AlphaOp[0] = SelectArg1;
        AlphaArg1[0] = Texture;
        AlphaArg2[0] = Current;
        AlphaOp[1] = Modulate;
        AlphaArg1[1] = Texture;
        AlphaArg2[1] = Current;
        AlphaOp[2] = Disable;

        VertexShader = null;
        PixelShader = null;
    ｝
｝


technique TScreenDecalImmediate
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (World);
        ProjectionTransform = (World);

        Lighting = false;
        ZEnable = false;
        ZFunc = Always;
        ZWriteEnable = true;

        AlphaBlendEnable = true;
        SrcBlend = One;
        DestBlend = InvSrcAlpha;

        Sampler[0] = (ScreenSampler);
        Sampler[1] = (GradientSampler);

        ColorOp[0] = SelectArg1;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = SelectArg2;
        ColorArg1[1] = Texture;
        ColorArg2[1] = Current;
        ColorOp[1] = Disable;

        AlphaOp[0] = SelectArg1;
        AlphaArg1[0] = Texture;
        AlphaArg2[0] = Current;
        AlphaOp[1] = Modulate;
        AlphaArg1[1] = Texture;
        AlphaArg2[1] = Current;
        AlphaOp[1] = Disable;

        VertexShader = null;
        PixelShader = null;
    ｝
｝
float4x4 WorldViewProjection;
float4x4 WorldView;
float4x4 World;
float4x4 View;
float4x4 ViewInv;
float4x4 Projection;
texture AlbedoTexture;
texture ReflTexture;
texture EnvTexture;
float Alpha;


float EnvironmentContribution = 0.25;
float ReflectionStrength = 0.25;
float TrimReflectionStrength = 0.45;


//-----------------------------------------------------------------------------
sampler2D AlbedoSampler = sampler_state
{ 
    Texture   = (AlbedoTexture);
    MipFilter = Linear; 
    MinFilter = Linear;
    MagFilter = Linear;
    AddressU  = Wrap;
    AddressV  = Wrap;
};


sampler2D ReflSampler = sampler_state
{ 
    Texture   = (ReflTexture);
    MipFilter = Point;
    MinFilter = Point;
    MagFilter = Point;
    AddressU  = Clamp;
    AddressV  = Clamp;
};


samplerCUBE EnvSampler = sampler_state
{ 
    Texture   = (EnvTexture);
    MipFilter = Point; 
    MinFilter = Linear;
    MagFilter = Linear;
};


//-----------------------------------------------------------------------------
struct VS_OUTPUT
{
    float4 Position     : POSITION;     // position of the vertex
    float3 Diffuse      : COLOR0;       // diffuse color of the vertex
    float2 TexCoord     : TEXCOORD0;
    float4 ReflCoord    : TEXCOORD1;
    float3 EnvCoord     : TEXCOORD2;
};


//-----------------------------------------------------------------------------
VS_OUTPUT PieceVS(
    uniform float3 ka,
    uniform float3 kd,
    uniform bool bEnvironment,
    uniform bool bReflections,
    float4 Pos      : POSITION,
    float2 TexCoord : TEXCOORD0,
    float3 Normal   : NORMAL0 )
｛
    VS_OUTPUT Output;

    // Output the vetrex position in projection space
    Output.Position = mul( Pos, WorldViewProjection );

    float3 viewNormal = normalize( mul( Normal, (float3x3) WorldView ) );
    float3 L = mul( worldLight, (float3x3) View );
    float3 N = viewNormal;
    float NdotL = saturate( dot( N, L ) );

    float3 ambient = ka;
    float3 diffuse = kd * NdotL;
    Output.Diffuse = ambient + diffuse;

    Output.TexCoord = TexCoord;

    // note: bReflections does nothing
    Output.ReflCoord = float4( 0, 0, 0, 1 );

    if ( bEnvironment )
    {
        float3 viewPos = normalize( mul( Pos, WorldView ) );
        float3 viewReflect = reflect( viewPos, viewNormal );
        float3 worldReflect = mul( viewReflect, (float3x3) ViewInv );
        Output.EnvCoord = worldReflect;
    }
    else
    {
        Output.EnvCoord = float3( 0, 1, 0 );
    }

    return Output;
｝


//-----------------------------------------------------------------------------
VS_OUTPUT StandardVS(
    uniform bool bEnvironment,
    uniform bool bReflections,
    float4 Pos      : POSITION,
    float2 TexCoord : TEXCOORD0,
    float3 Normal   : NORMAL0 )
｛
    VS_OUTPUT Output;

    // Output the vetrex position in projection space
    Output.Position = mul( Pos, WorldViewProjection );

    // note: diffuse unused
    Output.Diffuse = float3( 1, 1, 1 );

    Output.TexCoord = TexCoord;

    if ( bReflections )
    {
        Output.ReflCoord.x = Output.Position.x * 0.5 + Output.Position.w * 0.5;
        Output.ReflCoord.y = Output.Position.w * 0.5 - Output.Position.y * 0.5;
        Output.ReflCoord.z = Output.Position.w;
        Output.ReflCoord.w = Output.Position.w;
    }
    else
    {
        Output.ReflCoord = float4( 0, 0, 0, 1 );
    }

    if ( bEnvironment )
    ｛
        float3 viewNormal = normalize( mul( Normal, (float3x3) WorldView ) );

        float3 viewPos = normalize( mul( Pos, WorldView ) );
        float3 viewReflect = reflect( viewPos, viewNormal );
        float3 worldReflect = mul( viewReflect, (float3x3) ViewInv );
        Output.EnvCoord = worldReflect;
    ｝
    else
    ｛
        Output.EnvCoord = float3( 0, 1, 0 );
    ｝

    return Output;
｝


//-----------------------------------------------------------------------------
float4 PiecePS( VS_OUTPUT In, uniform bool bAlbedo, uniform bool bEnvironment, uniform bool bReflections, uniform float reflAmount ) : COLOR0
｛
    // note: bReflections does nothing

    if ( bAlbedo )
    ｛
        float3 Albedo = tex2D( AlbedoSampler, In.TexCoord );

        if ( bEnvironment )
        ｛
            float3 Environment = texCUBE( EnvSampler, In.EnvCoord ) * reflAmount;
            Albedo = Albedo * environmentTextureAmount;
            return float4( In.Diffuse * Albedo + Environment, Alpha );
        ｝
        else
        ｛
            return float4( In.Diffuse * Albedo, Alpha );
        ｝
    ｝
    else
    ｛
        if ( bEnvironment )
        ｛
            float3 Environment = texCUBE( EnvSampler, In.EnvCoord ) * reflAmount;
            return float4( In.Diffuse + Environment, Alpha );
        ｝
        else
        ｛
            return float4( In.Diffuse, Alpha );
        ｝
    ｝
｝


//-----------------------------------------------------------------------------
float4 BoardPS( VS_OUTPUT In, uniform bool bEnvironment, uniform bool bReflections ) : COLOR0
｛
    float3 Albedo = tex2D( AlbedoSampler, In.TexCoord );

    if ( bEnvironment )
    ｛
        float3 Environment = texCUBE( EnvSampler, In.EnvCoord ) * EnvironmentContribution;
        if ( bReflections )
        ｛
            float4 Reflections = tex2Dproj( ReflSampler, In.ReflCoord );
            float3 c = lerp( Albedo, Reflections.xyz, Reflections.w * ReflectionStrength );
            return float4( c + Environment, 1 );
        ｝
        else
        ｛
            return float4( Albedo + Environment, 1 );
        ｝
    ｝
    else
    ｛
        if ( bReflections )
        ｛
            float4 Reflections = tex2Dproj( ReflSampler, In.ReflCoord );
            float3 c = lerp( Albedo, Reflections.xyz, Reflections.w * ReflectionStrength );
            return float4( c, 1 );
        ｝
        else
        ｛
            return float4( Albedo, 1 );
        ｝
    ｝
｝


//-----------------------------------------------------------------------------
float4 TablePS( VS_OUTPUT In, uniform bool bEnvironment, uniform bool bReflections ) : COLOR0
｛
    // note: bReflections does nothing

    float3 Albedo = tex2D( AlbedoSampler, In.TexCoord );

    if ( bEnvironment )
    ｛
        float3 Environment = texCUBE( EnvSampler, In.EnvCoord ) * 0.0325;
        return float4( Albedo + Environment, 1 );
    ｝
    else
    ｛
        return float4( Albedo, 1 );
    ｝
｝


//-----------------------------------------------------------------------------
float4 TrimPS( VS_OUTPUT In, uniform bool bEnvironment, uniform bool bReflections ) : COLOR0
｛
    float3 Albedo = trimColor;

    if ( bEnvironment )
    ｛
        float3 Environment = texCUBE( EnvSampler, In.EnvCoord ) * EnvironmentContribution;

        if ( bReflections )
        ｛
            float4 Reflections = tex2Dproj( ReflSampler, In.ReflCoord );
            float3 c = lerp( Albedo, Reflections.xyz, Reflections.w * TrimReflectionStrength );
            return float4( c + Environment, 1 );
        ｝
        else
        ｛
            return float4( Albedo + Environment, 1 );
        ｝
    ｝
    else
    ｛
        if ( bReflections )
        ｛
            float4 Reflections = tex2Dproj( ReflSampler, In.ReflCoord );
            float3 c = lerp( Albedo, Reflections.xyz, Reflections.w * TrimReflectionStrength );
            return float4( c, 1 );
        ｝
        else
        ｛
            return float4( Albedo, 1 );
        ｝
    ｝
｝


//-----------------------------------------------------------------------------
technique TWhite_EnvironmentReflections
｛
    pass P0
    ｛
        AlphaBlendEnable = true;
        SrcBlend = SrcAlpha;
        DestBlend = InvSrcAlpha;

        VertexShader = compile vs_1_1 PieceVS( kaWhite, kdWhite, true, true );
        PixelShader  = compile ps_1_4 PiecePS( pieceAlbedo, true, true, reflWhite );
    ｝
｝


technique TBlack_EnvironmentReflections
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

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

        VertexShader = compile vs_1_1 PieceVS( kaBlack, kdBlack, true, true );
        PixelShader  = compile ps_1_4 PiecePS( pieceAlbedo, true, true, reflBlack );
    ｝
｝


technique TBoard_EnvironmentReflections
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( true, true );
        PixelShader  = compile ps_1_4 BoardPS( true, true );
    ｝
｝


technique TTable_EnvironmentReflections
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( true, true );
        PixelShader  = compile ps_1_1 TablePS( true, true );
    ｝
｝


technique TTrim_EnvironmentReflections
｛
    pass P0
    ｛
        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( true, true );
        PixelShader  = compile ps_1_4 TrimPS( true, true );
    ｝
｝


//-----------------------------------------------------------------------------
technique TWhite_Reflections
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

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

        VertexShader = compile vs_1_1 PieceVS( kaWhite, kdWhite, false, true );
        PixelShader  = compile ps_1_1 PiecePS( pieceAlbedo, false, true, reflWhite );
    ｝
｝


technique TBlack_Reflections
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

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

        VertexShader = compile vs_1_1 PieceVS( kaBlack, kdBlack, false, true );
        PixelShader  = compile ps_1_1 PiecePS( pieceAlbedo, false, true, reflBlack );
    ｝
｝


technique TBoard_Reflections
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( false, true );
        PixelShader  = compile ps_1_4 BoardPS( false, true );
    ｝
｝


technique TTable_Reflections
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( false, true );
        PixelShader  = compile ps_1_4 TablePS( false, true );
    ｝
｝


technique TTrim_Reflections
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( false, true );
        PixelShader  = compile ps_1_4 TrimPS( false, true );
    ｝
｝


//-----------------------------------------------------------------------------
technique TWhite_Environment
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

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

        VertexShader = compile vs_1_1 PieceVS( kaWhite, kdWhite, true, false );
        PixelShader  = compile ps_1_4 PiecePS( pieceAlbedo, true, false, reflWhite );
    ｝
｝


technique TBlack_Environment
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

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

        VertexShader = compile vs_1_1 PieceVS( kaBlack, kdBlack, true, false );
        PixelShader  = compile ps_1_4 PiecePS( pieceAlbedo, true, false, reflBlack );
    ｝
｝


technique TBoard_Environment
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( true, false );
        PixelShader  = compile ps_1_1 BoardPS( true, false );
    ｝
｝


technique TTable_Environment
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( true, false );
        PixelShader  = compile ps_1_1 TablePS( true, false );
    ｝
｝


technique TTrim_Environment
｛
    pass P0
    ｛
        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 StandardVS( true, false );
        PixelShader  = compile ps_1_1 TrimPS( true, false );
    ｝
｝


//-----------------------------------------------------------------------------
technique TWhite
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (View);
        ProjectionTransform = (Projection);

        Lighting = true;
        LightEnable[0] = true;
        LightType[0] = Directional;
        LightDirection[0] = (-worldLight);
        LightAmbient[0] = float4( 0, 0, 0, 0 );
        LightDiffuse[0] = float4( 1, 1, 1, 1 );
        LightSpecular[0] = float4( 1, 1, 1, 1 );
        LightEnable[1] = false;

        Ambient = float4( 1, 1, 1, 1 );
        SpecularEnable = true;

        MaterialAmbient = float4( kaWhite, 1 );
        MaterialDiffuse = float4( kdWhite, 1 );
        MaterialSpecular = float4( 0.15, 0.15, 0.15, 1 );
        MaterialPower = 20.0;
        MaterialEmissive = float4( 0, 0, 0, 0 );

//      AmbientMaterialSource = Material;
//      DiffuseMaterialSource = Material;
//      EmissiveMaterialSource = Material;
//      SpecularMaterialSource = Material;

        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

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

        Sampler[0] = (AlbedoSampler);

        TextureFactor = (Alpha.xxxx);

        ColorOp[0] = COLOROP0;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = Disable;

        AlphaOp[0] = SelectArg1;
        AlphaArg1[0] = TFactor;
        AlphaArg2[0] = Current;
        AlphaOp[1] = Disable;

        VertexShader = null;
        PixelShader  = null;
    ｝
｝


technique TBlack
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (View);
        ProjectionTransform = (Projection);

        Lighting = true;
        LightEnable[0] = true;
        LightType[0] = Directional;
        LightDirection[0] = (-worldLight);
        LightAmbient[0] = float4( 0, 0, 0, 0 );
        LightDiffuse[0] = float4( 1, 1, 1, 1 );
        LightSpecular[0] = float4( 1, 1, 1, 1 );
        LightEnable[1] = false;

        Ambient = float4( 1, 1, 1, 1 );
        SpecularEnable = true;

        MaterialAmbient = float4( kaBlack, 1 );
        MaterialDiffuse = float4( kdBlack, 1 );
        MaterialSpecular = float4( 0.25, 0.25, 0.25, 1 );
        MaterialPower = 20.0;
        MaterialEmissive = float4( 0, 0, 0, 0 );

//      AmbientMaterialSource = Material;
//      DiffuseMaterialSource = Material;
//      EmissiveMaterialSource = Material;
//      SpecularMaterialSource = Material;

        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

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

        Sampler[0] = (AlbedoSampler);

        TextureFactor = (Alpha.xxxx);

        ColorOp[0] = COLOROP0;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = Disable;

        AlphaOp[0] = SelectArg1;
        AlphaArg1[0] = TFactor;
        AlphaArg2[0] = Current;
        AlphaOp[1] = Disable;

        VertexShader = null;
        PixelShader  = null;
    ｝
｝


technique TBoard
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (View);
        ProjectionTransform = (Projection);

        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        Sampler[0] = (AlbedoSampler);

        ColorOp[0] = SelectArg1;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = Disable;

        AlphaOp[0] = Disable;
        AlphaOp[1] = Disable;

        VertexShader = null;
        PixelShader  = null;
    ｝
｝


technique TTable
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (View);
        ProjectionTransform = (Projection);

        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        Sampler[0] = (AlbedoSampler);

        ColorOp[0] = SelectArg1;
        ColorArg1[0] = Texture;
        ColorArg2[0] = Current;
        ColorOp[1] = Disable;

        AlphaOp[0] = Disable;
        AlphaOp[1] = Disable;

        VertexShader = null;
        PixelShader  = null;
    ｝
｝


technique TTrim
｛
    pass P0
    ｛
        WorldTransform[0] = (World);
        ViewTransform = (View);
        ProjectionTransform = (Projection);

        ZEnable = true;
        ZFunc = LessEqual;
        ZWriteEnable = true;

        AlphaBlendEnable = false;

        TextureFactor = (trimColor.xyzz);

        ColorOp[0] = SelectArg1;
        ColorArg1[0] = TFactor;
        ColorArg2[0] = Current;
        ColorOp[1] = Disable;

        AlphaOp[0] = Disable;
        AlphaOp[1] = Disable;

        VertexShader = null;
        PixelShader  = null;
    ｝
｝
float3 kaWhite = float3( 0.260, 0.260, 0.290 );
float3 kdWhite = float3( 0.820, 0.820, 0.850 );
float reflWhite = 0.33;

float3 kaBlack = float3( 0.200, 0.200, 0.200 );
float3 kdBlack = float3( 0.450, 0.450, 0.450 );
float reflBlack = 0.14;

float environmentTextureAmount = 0.6;

float3 worldLight = float3( 0.259, 0.966, 0 ); // 15 degrees over
float3 trimColor = float3( 0.600, 0.580, 0.500 );


bool pieceAlbedo = true;
#define COLOROP0 Modulate


#include "Media\Shaders\MeshCommon.fx"
float3 kaWhite = float3( 0.317, 0.317, 0.317 );
float3 kdWhite = float3( 0.651, 0.651, 0.651 );
float reflWhite = 0.08;

float3 kaBlack = float3( 0.035, 0.045, 0.055 );
float3 kdBlack = float3( 0.165, 0.165, 0.165 );
float reflBlack = 0.17;

float environmentTextureAmount = 1.0;

float3 worldLight = float3( 0.259, 0.966, 0 ); // 15 degrees over
float3 trimColor = float3( 0.600, 0.580, 0.500 );


bool pieceAlbedo = false;
#define COLOROP0 SelectArg2


#include "Media\Shaders\MeshCommon.fx"
float3 kaWhite = float3( 0.317, 0.317, 0.317 );
float3 kdWhite = float3( 0.800, 0.800, 0.800 );
float reflWhite = 0.10;

float3 kaBlack = float3( 0.320, 0.250, 0.220 );
float3 kdBlack = float3( 1.000, 1.000, 1.000 );
float reflBlack = 0.14;

float environmentTextureAmount = 1.0;

float3 worldLight = float3( 0.259, 0.966, 0 ); // 15 degrees over
float3 trimColor = float3( 0.600, 0.580, 0.500 );


bool pieceAlbedo = true;
#define COLOROP0 Modulate


#include "Media\Shaders\MeshCommon.fx"
float4x4 WorldViewProjInv;
texture SkyBoxTexture;


samplerCUBE SkyBoxSampler = sampler_state
{
    Texture   = (SkyBoxTexture);
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
};


struct VS_OUTPUT
{
    float4 Position     : POSITION;
    float3 TexCoord     : TEXCOORD0;
};


VS_OUTPUT SkyBoxVS( float4 Pos : POSITION )
｛
    VS_OUTPUT Output;

    Output.Position = Pos;
    Output.TexCoord = normalize( mul( Pos, WorldViewProjInv ) );

    return Output;
｝


float4 SkyBoxPS( VS_OUTPUT Input ) : COLOR
{
    float3 c = texCUBE( SkyBoxSampler, Input.TexCoord );
    return float4( c, 1 );
}


technique TSkyBox
｛
    pass P0
    ｛
        ZEnable = false;
        AlphaBlendEnable = false;

        VertexShader = compile vs_1_1 SkyBoxVS();
        PixelShader = compile ps_1_1 SkyBoxPS();
    ｝
｝