Scalefx from Retroarch

/*
Copyright (C) 2003 Ryan A. Nunn

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

//
// ** Scale2x **
//
// Homepage: http://scale2x.sourceforge.net/
//
// Adapted by Ryan A. Nunn into Pixel and Vertex Shaders to be used with the 
// Scaling2D entry in the Beyond3D/ATI Shader Competition
//
// Using the following source pixel map
//
// A B C
// D E F
// G H I
//
// and the following dest pixel map (which is the pixel 'E' expanded)
//
// E0 E1
// E2 E3
//
// The Scale2x algorithm works as follows:
// E0 = D == B && B != F && D != H ? D : E;
// E1 = B == F && B != D && F != H ? F : E;
// E2 = D == H && D != B && H != F ? D : E;
// E3 = H == F && D != H && B != F ? F : E;
//
// That can be re-written as this:
// E0 = D == B && B != F && H != D ? D : E;
// E1 = F == B && B != D && H != F ? F : E;
// E2 = D == H && H != F && B != D ? D : E;
// E3 = F == H && H != D && B != F ? F : E;
// 
// As can be seen, there are some fairly obvious patterns
// For the bottom row, pixels B and H are swapped vs the top row
// And for the right column, pixels D and F are swapped vs the left column 
//
// That means, with dependant textures reads, this algorithm can be converted
// into a fairly compact pixel shader
//


#include "Scaling.inc"

// The name of this effect
string name : NAME = "Scale2x";


//
// Techniques
//

// combineTechnique: Final combine steps. Outputs to destination frame buffer
string combineTechique : COMBINETECHNIQUE =  "Scale2x_New";

// preprocessTechnique: PreProcessing steps. Outputs to WorkingTexture
//string preprocessTechique : PREPROCESSTECHNIQUE = "";


// 
// Textures and Samplers
//


//
// Texture Gen Shaders
//


//
// Vertex Shader Output
//

struct VS_OUTPUT_NEW
{
    float4 Position        : POSITION;
    float2 CentreUV        : TEXCOORD0;
    float2 Selector        : TEXCOORD1;
};


//
// Vertex Shader
//

VS_OUTPUT_NEW VS_New(
            float3 Position : POSITION,
            float2 TexCoord : TEXCOORD0)
{
    VS_OUTPUT_NEW Out = (VS_OUTPUT_NEW)0;

    Out.Position = mul(float4(Position, 1), WorldViewProjection);   // Matrix multipliy
    Out.CentreUV = TexCoord;
    Out.Selector = TexCoord*SourceDims;

    return Out;
}


//
// Pixel Shader
//

// Even faster version (Uses dependant texture reads to work)
float4 PS_New ( in VS_OUTPUT_NEW input ) : COLOR
{
//    half2 selector = frac(input.Selector);
    half4 selector = tex2D(ModuloSampler, input.Selector);

    // Invert left and right if we are right
    float2 offset_x = { TexelSize.x, 0 };
    if (selector.x >= 0.5) offset_x = -offset_x;

    // Invert above and below if we are bottom
    float2 offset_y = { 0, TexelSize.y };
    if (selector.y >= 0.5) offset_y = -offset_y;

    half4 L = tex2D(SourceSampler,    input.CentreUV-offset_x);
    half4 R = tex2D(SourceSampler,    input.CentreUV+offset_x);
    half4 A = tex2D(SourceSampler,    input.CentreUV-offset_y);
    half4 B = tex2D(SourceSampler,    input.CentreUV+offset_y);

    bool al    = all(A    == L);
    bool ar    = all(A    == R);
    bool bl    = all(B    == L);

    half4 ret = tex2D(SourceSampler, input.CentreUV);
    if (al && !ar && !bl) ret = L;
    return ret;
}



//
// Technique
//

technique Scale2x_New
{
    pass P0
    {
        // shaders
        VertexShader = compile vs_1_1 VS_New();
        PixelShader  = compile ps_2_0 PS_New();
        AlphaBlendEnable = FALSE;
        ColorWriteEnable = RED|GREEN|BLUE|ALPHA;
        SRGBWRITEENABLE = FALSE;
    }  
}