Примеры использования Nvidia FXAA (сглаживание шейдеров) в XNA 4.0 winforms? - PullRequest
Новая
       3

Примеры использования Nvidia FXAA (сглаживание шейдеров) в XNA 4.0 winforms?

6 голосов
/ 07 октября 2011

Я использую элемент управления формой этого примера XNA 4.0 в приложении, которое я пишу: http://creators.xna.com/en-US/sample/winforms_series1

Если вы не знакомы с FXAA, посетите сайт создателя: http://timothylottes.blogspot.com/2011/03/nvidia-fxaa.html

Я потратил довольно много времени, пытаясь выяснить, использовать ли это без какой-либо удачи (пока ...). Это правда, что у меня совсем нет опыта работы с графическим программированием, но в настоящее время у меня действительно работает хорошее приложение, оно выглядит очень плохо с зубчатыми линиями. Я знаю о встроенном методе для AA, но не работает для меня и моего ноутбука. Поэтому мой запрос касается использования FXAA, а не встроенных методов.

На данный момент: У меня есть файл заголовка FXAA 3.11 в моем проекте Content. У меня есть общий файл FX, сгенерированный Visual Studio, с несколькими вещами вроде: 

#define FXAA_PC_CONSOLE 1
#define FXAA_HLSL_5 1
#define FXAA_QUALITY__PRESET 12
#include "Includes/Fxaa3_11.h"

Я просто прошу здесь посмотреть, может ли кто-нибудь предоставить примеры XNA 4.0, в частности, с использованием этого метода пользовательских форм Windows.

Я ценю любую помощь, которую кто-то может оказать.

Редактировать 3: Я пытался понять, как заставить работать FXAA с тех пор, как опубликовал это сообщение. Я нашел это: http://www.gamedev.net/topic/609638-fxaa-help/page__st__20 и это: http://fxaa -pp-inject.assembla.me / багажник / DirectX9 / shader.fx

Я сократил FXAA до голого типа FXAA_PC_CONSOLE, и он компилируется. Мне просто нужно выяснить параметр fxaaConsolePosPos, который является верхней левой и нижней правой позицией каждого пикселя. В любом случае, похоже, что FXAA_PC_CONSOLE может работать с шейдерной моделью 2.0, которую мне нужно использовать с REACH и XNA на основе winforms.

Ответы [ 2 ]

6 голосов
/ 12 октября 2011

Так что я понял это, по крайней мере, используя меньшую версию FXAA, предназначенную для консолей и младших компьютеров.Я не могу гарантировать, что мои параметры для кода шейдера верны, но я вижу заметную разницу, когда он работает.

Вот полное решение с моим нарезанным шейдером и частями кода C # XNA 4.0:

Сначала код шейдера (поместите его в файл .fx в вашем подпроекте Content): обратите внимание, что я заменил tex2Dlod на tex2D согласно предположению, что SM2.0 не поддерживает первый тип 

#define FxaaBool bool
#define FxaaDiscard clip(-1)
#define FxaaFloat float
#define FxaaFloat2 float2
#define FxaaFloat3 float3
#define FxaaFloat4 float4
#define FxaaHalf half
#define FxaaHalf2 half2
#define FxaaHalf3 half3
#define FxaaHalf4 half4
#define FxaaSat(x) saturate(x)

#define FxaaInt2 float2
#define FxaaTex sampler2D
#define FxaaTexTop(t, p) tex2D(t, float4(p, 0.0, 0.0))
#define FxaaTexOff(t, p, o, r) tex2D(t, float4(p + (o * r), 0, 0))

FxaaFloat FxaaLuma(FxaaFloat4 rgba) { 
    rgba.w = dot(rgba.rgb, FxaaFloat3(0.299, 0.587, 0.114));
return  rgba.w; }

/*============================================================================
                         FXAA3 CONSOLE - PC VERSION
============================================================================*/
FxaaFloat4 FxaaPixelShader(
    FxaaFloat2 pos,
    FxaaFloat4 fxaaConsolePosPos,
    FxaaTex tex,
    FxaaFloat4 fxaaConsoleRcpFrameOpt,
    FxaaFloat4 fxaaConsoleRcpFrameOpt2,
    FxaaFloat fxaaConsoleEdgeSharpness,
    FxaaFloat fxaaConsoleEdgeThreshold,
    FxaaFloat fxaaConsoleEdgeThresholdMin) {
    FxaaFloat lumaNw = FxaaLuma(FxaaTexTop(tex, fxaaConsolePosPos.xy));
    FxaaFloat lumaSw = FxaaLuma(FxaaTexTop(tex, fxaaConsolePosPos.xw));
    FxaaFloat lumaNe = FxaaLuma(FxaaTexTop(tex, fxaaConsolePosPos.zy));
    FxaaFloat lumaSe = FxaaLuma(FxaaTexTop(tex, fxaaConsolePosPos.zw));
    FxaaFloat4 rgbyM = FxaaTexTop(tex, pos.xy);
    #if (FXAA_GREEN_AS_LUMA == 0)
        FxaaFloat lumaM = rgbyM.w;
    #else
        FxaaFloat lumaM = rgbyM.y;
    #endif
    FxaaFloat lumaMaxNwSw = max(lumaNw, lumaSw);
    lumaNe += 1.0/384.0;
    FxaaFloat lumaMinNwSw = min(lumaNw, lumaSw);
    FxaaFloat lumaMaxNeSe = max(lumaNe, lumaSe);
    FxaaFloat lumaMinNeSe = min(lumaNe, lumaSe);
    FxaaFloat lumaMax = max(lumaMaxNeSe, lumaMaxNwSw);
    FxaaFloat lumaMin = min(lumaMinNeSe, lumaMinNwSw);
    FxaaFloat lumaMaxScaled = lumaMax * fxaaConsoleEdgeThreshold;
    FxaaFloat lumaMinM = min(lumaMin, lumaM);
    FxaaFloat lumaMaxScaledClamped = max(fxaaConsoleEdgeThresholdMin, lumaMaxScaled);
    FxaaFloat lumaMaxM = max(lumaMax, lumaM);
    FxaaFloat dirSwMinusNe = lumaSw - lumaNe;
    FxaaFloat lumaMaxSubMinM = lumaMaxM - lumaMinM;
    FxaaFloat dirSeMinusNw = lumaSe - lumaNw;
    if(lumaMaxSubMinM < lumaMaxScaledClamped) return rgbyM;
    FxaaFloat2 dir;
    dir.x = dirSwMinusNe + dirSeMinusNw;
    dir.y = dirSwMinusNe - dirSeMinusNw;
    FxaaFloat2 dir1 = normalize(dir.xy);
    FxaaFloat4 rgbyN1 = FxaaTexTop(tex, pos.xy - dir1 * fxaaConsoleRcpFrameOpt.zw);
    FxaaFloat4 rgbyP1 = FxaaTexTop(tex, pos.xy + dir1 * fxaaConsoleRcpFrameOpt.zw);
    FxaaFloat dirAbsMinTimesC = min(abs(dir1.x), abs(dir1.y)) * fxaaConsoleEdgeSharpness;
    FxaaFloat2 dir2 = clamp(dir1.xy / dirAbsMinTimesC, -2.0, 2.0);
    FxaaFloat4 rgbyN2 = FxaaTexTop(tex, pos.xy - dir2 * fxaaConsoleRcpFrameOpt2.zw);
    FxaaFloat4 rgbyP2 = FxaaTexTop(tex, pos.xy + dir2 * fxaaConsoleRcpFrameOpt2.zw);
    FxaaFloat4 rgbyA = rgbyN1 + rgbyP1;
    FxaaFloat4 rgbyB = ((rgbyN2 + rgbyP2) * 0.25) + (rgbyA * 0.25);
    #if (FXAA_GREEN_AS_LUMA == 0)
        FxaaBool twoTap = (rgbyB.w < lumaMin) || (rgbyB.w > lumaMax);
    #else
        FxaaBool twoTap = (rgbyB.y < lumaMin) || (rgbyB.y > lumaMax);
    #endif
    if(twoTap) rgbyB.xyz = rgbyA.xyz * 0.5;
    return rgbyB; 
}
/*==========================================================================*/

uniform extern float SCREEN_WIDTH;
uniform extern float SCREEN_HEIGHT;
uniform extern texture gScreenTexture;

sampler screenSampler = sampler_state
{
    Texture = <gScreenTexture>;
    /*MinFilter = LINEAR;
    MagFilter = LINEAR;
    MipFilter = LINEAR;
    AddressU = Clamp;
    AddressV = Clamp;*/
};

float4 PixelShaderFunction(float2 tc : TEXCOORD0) : COLOR0
{
    float pixelWidth = (1 / SCREEN_WIDTH);
    float pixelHeight = (1 / SCREEN_HEIGHT);

    float2 pixelCenter = float2(tc.x - pixelWidth, tc.y - pixelHeight);
    float4 fxaaConsolePosPos = float4(tc.x, tc.y, tc.x + pixelWidth, tc.y + pixelHeight);

    return FxaaPixelShader(
        pixelCenter,
        fxaaConsolePosPos,
        screenSampler,
        float4(-0.50 / SCREEN_WIDTH, -0.50 / SCREEN_HEIGHT, 0.50 / SCREEN_WIDTH, 0.50 / SCREEN_HEIGHT),
        float4(-2.0 / SCREEN_WIDTH, -2.0 / SCREEN_HEIGHT, 2.0 / SCREEN_WIDTH, 2.0 / SCREEN_HEIGHT),
        8.0,
        0.125,
        0.05);
}

technique ppfxaa
{
    pass Pass1
    {
        PixelShader = compile ps_2_0 PixelShaderFunction();
    }
}

Вот фрагмент кода C-sharp для примененияшейдер: 

//..........................................
//these objects are used in managing the FXAA operation

//FXAA objects (anti-aliasing)
RenderTarget2D renderTarget;
SpriteBatch spriteBatch;
Effect fxaaAntialiasing;

//..........................................
//initialize the render target and set effect parameters

//code to handle a final antialiasing using a pixel shader
renderTarget = new RenderTarget2D(
    GraphicsDevice,
    GraphicsDevice.PresentationParameters.BackBufferWidth,
    GraphicsDevice.PresentationParameters.BackBufferHeight,
    false,
    GraphicsDevice.PresentationParameters.BackBufferFormat,
    DepthFormat.Depth24);

spriteBatch = new SpriteBatch(GraphicsDevice);
fxaaAntialiasing = content.Load<Effect>("sfxaa");
fxaaAntialiasing.CurrentTechnique = fxaaAntialiasing.Techniques["ppfxaa"];
fxaaAntialiasing.Parameters["SCREEN_WIDTH"].SetValue(renderTarget.Width);
fxaaAntialiasing.Parameters["SCREEN_HEIGHT"].SetValue(renderTarget.Height);
fxaaAntialiasing.Parameters["gScreenTexture"].SetValue(renderTarget as Texture2D);


//..........................................
//this should happen in your Draw() method

//change to our offscreen render target
GraphicsDevice.SetRenderTarget(renderTarget);
GraphicsDevice.Clear(Color.CornflowerBlue);

//
//draw all of your models and such here...
//

GraphicsDevice.SetRenderTarget(null);
GraphicsDevice.Clear(Color.Black);

//this where the shader antialiasing happens to the frame we just filled with content
spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend,
    SamplerState.LinearClamp, DepthStencilState.Default, 
    RasterizerState.CullNone, fxaaAntialiasing);

//draw the buffer we made to the screen
spriteBatch.Draw(renderTarget as Texture2D, 
    new Rectangle(0, 0, renderTarget.Width, renderTarget.Height), 
    Color.White);

spriteBatch.End();
0 голосов
/ 24 августа 2013

Я недавно внедрил эту технику в свою игру, но по некоторым причинам мои края все еще остаются "неровными". Есть ли способ изменить код где-нибудь, чтобы смягчить неровные края? Спасибо.

...