the cutting room mirror

es

view on tcrf.net

Uno De los nuevos Juegos Incluidos En Windows Vista Y 7.

To do:
Comprueba si el render de Velocidad completa hace algo

Como la mayoría de otros juegos enviados con Vista y 7, tiene un interno llamado g_debugEnabled.

Las opciones incluidas en el menu son:

  • Rotar tablero: gira el tablero hacia el otro lado en la vista 3D, pero no hace nada en la vista 2D.
  • Self Play: vea un juego jugado por dos jugadores de computadora. Si un juego ya comenzó, el juego comenzará uno nuevo.
  • Alternar vista de arriba hacia abajo: va a la vista de arriba hacia abajo en 2D, pero volver a la vista en 3D hará que la configuración gráfica se reduzca a la configuración de 3D de menor calidad.
  • Alternar renderizado a máxima velocidad: supuestamente haría que el juego se ejecutara más rápido en computadoras más lentas

XInput Support#

Una característica interesante que no está documentada en ninguna parte (menú de ayuda) es la compatibilidad con XInput (gamepad): si el juego detecta un controlador Xbox 360 conectado a un puerto USB, la esquina P1 del controlador se iluminará, lo que significa que el controlador puede ser usado. Posiblemente indocumentado porque Microsoft pensó que la gente estaba demasiado acostumbrada a los controles tradicionales y que un gamepad sería extraño de usar. No obstante, es una pequeña característica interesante.

Controles#

Botón

Efecto

Analógico izquierdo/D-pad/Botones de hombro/Triggers

Mueve el cursor. Extrañamente, tambien puede usarse para navegar la barra del menu.

B/Reversa

Deshace el movimiento previo.

A/X

Selecciona El Cuadrado Del Cursor, Esta encendido. Moviendo el cursor en una pieza y presionando A/X lo selecciona. Presionando A/X en una de las the destacadas piezas mueve la pieza alli.

Y/Start

Abre el menú del juego.

Código de shader#

En "Chess.dll", hay vario secciónes del código de shader en 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 = Nada; // Oh Dios mio. no use mips porque tomará muestras desde el nivel más bajo de mip cuando un triángulo tenga las mismas coordenadas de textura para las 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 (nota: bReflections hace nada)
    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 (nota: difuso sin usar)
    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
{
    // (nota: bReflections hace nada)

    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
{
    // nota: bReflections hace nada

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