Added FXAA for xrRender_R4(DX11)

Acked-by: Alexey Baula <alexeybaula@gmail.com>

Author: avbaula

res/gamedata/shaders/r3/fxaa.ps

@@ -0,0 +1,26 @@
+#include "common.h"
+
+uniform float4		screen_res;		// Screen resolution (x-Width,y-Height, zw - 1/resolution)
+
+struct	v
+{
+	float3	P		: POSITION;
+	float2	Tex0	: TEXCOORD0;
+};
+
+struct	v2p 
+{
+	float2 	Tex0	: TEXCOORD0;
+	float4 	HPos	: SV_Position;	 
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// Vertex
+v2p  main ( v I )
+{
+ 	v2p O;
+    O.HPos 	= float4	(I.P.x * screen_res.z * 2 - 1, (I.P.y * screen_res.w * 2 - 1)* -1, 0, 1);
+    O.Tex0	= I.Tex0;
+  
+    return O; 
+}

res/gamedata/shaders/r3/fxaa_main.ps

@@ -38,6 +38,8 @@ xr_token qmsaa__atest_token[] = {
 u32 ps_r3_minmax_sm = 3; // = 0;
 xr_token qminmax_sm_token[] = {{"off", 0}, {"on", 1}, {"auto", 2}, {"autodetect", 3}, {nullptr, 0}};
 
+int ps_r3_fxaa = 0;
+
 // “Off”
 // “DX10.0 style [Standard]”
 // “DX10.1 style [Higher quality]”
@@ -875,6 +877,7 @@ void xrRender_initconsole()
 #ifdef DETAIL_RADIUS
     CMD4(CCC_detail_radius, "r__detail_radius", &ps_r__detail_radius, 49, 300);
 #endif
+    CMD4(CCC_Integer, "r3_fxaa", &ps_r3_fxaa, 0, 1);
 
 //  Allow real-time fog config reload
 #if (RENDER == R_R3) || (RENDER == R_R4)

res/gamedata/shaders/r3/fxaa_main.vs

@@ -24,6 +24,8 @@ extern ECORE_API xr_token qmsaa__atest_token[];
 extern ECORE_API u32 ps_r3_minmax_sm; //	=	0;
 extern ECORE_API xr_token qminmax_sm_token[];
 
+extern ECORE_API int ps_r3_fxaa;
+
 extern ENGINE_API int ps_r__Supersample;
 extern ECORE_API int ps_r__LightSleepFrames;
 

src/Layers/xrRender/xrRender_console.cpp

@@ -0,0 +1,22 @@
+#include "stdafx.h"
+#pragma hdrstop
+
+#include "blender_fxaa.h"
+
+CBlender_FXAA::CBlender_FXAA() { description.CLS = 0; }
+CBlender_FXAA::~CBlender_FXAA() { }
+
+void CBlender_FXAA::Compile(CBlender_Compile& C)
+{
+    IBlender::Compile(C);
+
+    switch (C.iElement)
+    {
+    case 0:
+        C.r_Pass("fxaa_main", "fxaa_main", false, FALSE, FALSE);
+        C.r_dx10Texture("s_base0", r2_RT_generic0);
+        C.r_dx10Sampler("smp_rtlinear");
+        C.r_End();
+        break;
+    }
+}

src/Layers/xrRender/xrRender_console.h

@@ -0,0 +1,14 @@
+#pragma once
+
+class CBlender_FXAA : public IBlender
+{
+public:
+    LPCSTR getComment() override { return "FXAA"; }
+    BOOL canBeDetailed() override { return FALSE; }
+    BOOL canBeLMAPped() override { return FALSE; }
+
+    void Compile(CBlender_Compile& C) override;
+
+    CBlender_FXAA();
+    virtual ~CBlender_FXAA();
+};

src/Layers/xrRenderPC_R4/blender_fxaa.cpp

@@ -10,6 +10,7 @@
 #include "blender_bloom_build.h"
 #include "blender_luminance.h"
 #include "blender_ssao.h"
+#include "blender_fxaa.h"
 #include "dx11MinMaxSMBlender.h"
 #include "dx11HDAOCSBlender.h"
 #include "Layers/xrRenderDX10/msaa/dx10MSAABlender.h"
@@ -322,6 +323,9 @@ CRenderTarget::CRenderTarget()
     b_combine = new CBlender_combine();
     b_ssao = new CBlender_SSAO_noMSAA();
 
+    //FXAA
+    b_fxaa = new CBlender_FXAA();
+
     // HDAO
     b_hdao_cs = new CBlender_CS_HDAO();
     if (RImplementation.o.dx10_msaa)
@@ -412,11 +416,12 @@ CRenderTarget::CRenderTarget()
         // generic(LDR) RTs
         rt_Generic_0.create(r2_RT_generic0, w, h, D3DFMT_A8R8G8B8, 1);
         rt_Generic_1.create(r2_RT_generic1, w, h, D3DFMT_A8R8G8B8, 1);
+        rt_Generic.create(r2_RT_generic, w, h, D3DFMT_A8R8G8B8, 1);
+
         if (RImplementation.o.dx10_msaa)
         {
             rt_Generic_0_r.create(r2_RT_generic0_r, w, h, D3DFMT_A8R8G8B8, SampleCount);
             rt_Generic_1_r.create(r2_RT_generic1_r, w, h, D3DFMT_A8R8G8B8, SampleCount);
-            rt_Generic.create(r2_RT_generic, w, h, D3DFMT_A8R8G8B8, 1);
         }
         //	Igor: for volumetric lights
         // rt_Generic_2.create			(r2_RT_generic2,w,h,D3DFMT_A8R8G8B8		);
@@ -652,6 +657,10 @@ CRenderTarget::CRenderTarget()
         s_ssao.create(b_ssao, "r2\\ssao");
     }
 
+    //FXAA
+    s_fxaa.create(b_fxaa, "r3\\fxaa");
+    g_fxaa.create(FVF::F_V, RCache.Vertex.Buffer(), RCache.QuadIB);
+
     // if (RImplementation.o.ssao_blur_on)
     //{
     //	u32		w = Device.dwWidth, h = Device.dwHeight;
@@ -1061,6 +1070,7 @@ CRenderTarget::~CRenderTarget()
     xr_delete(b_accum_point);
     xr_delete(b_accum_direct);
     xr_delete(b_ssao);
+    xr_delete(b_fxaa); //FXAA
 
     if (RImplementation.o.dx10_msaa)
     {

src/Layers/xrRenderPC_R4/blender_fxaa.h

@@ -49,6 +49,7 @@ class CRenderTarget : public IRender_Target
     IBlender* b_accum_reflected_msaa[8];
     IBlender* b_ssao;
     IBlender* b_ssao_msaa[8];
+    IBlender* b_fxaa;
 
     // compute shader for hdao
     IBlender* b_hdao_cs;
@@ -127,6 +128,10 @@ class CRenderTarget : public IRender_Target
     ref_shader s_hdao_cs;
     ref_shader s_hdao_cs_msaa;
 
+    //FXAA
+    ref_shader s_fxaa;
+    ref_geom g_fxaa;
+
     // Accum
     ref_shader s_accum_mask;
     ref_shader s_accum_direct;
@@ -261,6 +266,7 @@ class CRenderTarget : public IRender_Target
     void phase_occq();
     void phase_ssao();
     void phase_hdao();
+    void phase_fxaa();
     void phase_downsamp();
     void phase_wallmarks();
     void phase_smap_direct(light* L, u32 sub_phase);

src/Layers/xrRenderPC_R4/r4_rendertarget.cpp

@@ -0,0 +1,29 @@
+#include "stdafx.h"
+#include "r4_rendertarget.h"
+
+void CRenderTarget::phase_fxaa()
+{
+    u32 Offset = 0;
+    const float _w = float(Device.dwWidth);
+    const float _h = float(Device.dwHeight);
+    const float du = ps_r1_pps_u, dv = ps_r1_pps_v;
+
+    u_setrt(rt_Generic, nullptr, nullptr, HW.pBaseZB);
+
+    FVF::V* pv = (FVF::V*)RCache.Vertex.Lock(4, g_fxaa->vb_stride, Offset);
+    pv->set(du + 0, dv + float(_h), 0, 0, 1);
+    pv++;
+    pv->set(du + 0, dv + 0, 0, 0, 0);
+    pv++;
+    pv->set(du + float(_w), dv + float(_h), 0, 1, 1);
+    pv++;
+    pv->set(du + float(_w), dv + 0, 0, 1, 0);
+    pv++;
+    RCache.Vertex.Unlock(4, g_fxaa->vb_stride);
+
+    RCache.set_Element(s_fxaa->E[0]);
+    RCache.set_Geometry(g_fxaa);
+    RCache.Render(D3DPT_TRIANGLELIST, Offset, 0, 4, 0, 2);
+
+    HW.pContext->CopyResource(rt_Generic_0->pTexture->surface_get(), rt_Generic->pTexture->surface_get());
+}