the cutting room mirror

ru

view on tcrf.net

Одна из новых игр, включенных в Windows Vista и 7.

Меню Отладки#

To do:
Узнать о работоспособности Скоростного Рендера

Как и другие игры встроенные в Vista и 7, в ней присутствует внутренняя переменная g_debugEnabled

Опции включенные в меню:

  • "Повернуть доску" - переворачивает доску на другую сторону в 3D режиме, но ничего не делает в 2D.
  • "Автоматическая игра" - позволяет наблюдать за игрой двух компьютеров. Если игра была начата - она начнется заново.
  • "Включить вид сверху вниз" - переключает камеру в режим 2D. Переключение обратно в 3D изменит настройки графики на минимальные.
  • "Включить Скоростной Рендер" - судя по всему, эта опция должна была сделать игру быстрее на медленных компьютерах

Поддержка XInput#

Присутствует интересная незадокументированная особенность - поддержка XInput (для геймпадов); если игра обнаруживает подключенный в USB порт контроллер от Xbox 360 - уголок первого игрока на нем загорится, намекая на готовность контроллера к использованию. Возможно, эта функция не была описана ввиду того что Microsoft подумали что люди слишком сильно привыкли к традиционному управлению, и геймпад будет странным выбором. Особенность все же, приятная

Управление#

Кнопка

Действие

Левый аналоговый стик/D-pad/Педали/Триггеры

Двигает курсор. Странно, но они также могут быть использованы в полоске меню.

B/Назад

Отменяет ход.

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();
    }
}