GTA IV FXAA

[Dragozool]

hey leute ich habe hier was sehr interessantes ;) es gibt für GTA IV ne FXAA Effect.txt ^^ erstellt ne txt datei und setzt das ein ;) und schon habt ihr ein AA was nur 1-2 fps frisst und dabei echt gut aussieht ;)

2 screens ohne FXAA und mit

http://thumbnails48.imagebam.com/13748/ff1096137477411.jpg (http://www.imagebam.com/image/ff1096137477411) http://thumbnails54.imagebam.com/13748/91a38a137477499.jpg (http://www.imagebam.com/image/91a38a137477499)

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//http://enbdev.com
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*
THIS IS HLSL FILE FORMAT FOR EXECUTING ADDITIONAL
POST PROCESSING EFFECTS. MAKE THE COPY BEFORE CHANGING IT!
*/

//keyboard controled variables
float tempF1;
float tempF2;
float tempF3;
float tempF4;
float tempF5;
float tempF6;
float tempF7;
float tempF8;
float tempF9;
float tempF0;

//global variables, already set before executing this code
float ScreenSize; //width of the display resolution (1920 f.e.)
float ScreenScaleY; //screen proportions (1.333 for 1920/1080)

//textures
texture2D texColor;

sampler2D SamplerColor = sampler_state
{
Texture = <texColor>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = NONE;//NONE;
AddressU = Clamp;
AddressV = Clamp;
SRGBTexture=FALSE;
MaxMipLevel=0;
MipMapLodBias=0;
};

struct VS_OUTPUT_POST {
float4 vpos : POSITION;
float2 txcoord : TEXCOORD0;
};

struct VS_INPUT_POST {
float3 pos : POSITION;
float2 txcoord : TEXCOORD0;
};

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
VS_OUTPUT_POST VS_PostProcess(VS_INPUT_POST IN)
{
VS_OUTPUT_POST OUT;

float4 pos=float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0);

OUT.vpos=pos;
OUT.txcoord.xy=IN.txcoord.xy;

return OUT;
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//--------------------Fast Approximate Anti-Aliasing --------------------------
// FXAA v2 CONSOLE by TIMOTHY LOTTES @ NVIDIA
// Ported to ENBSeries by MysTer92 (Svyatoslav Gampel)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
float4 PS_PostProcess(VS_OUTPUT_POST i) : COLOR
{
#define FXAA_SUBPIX_SHIFT (1.0/8.0)
#define FXAA_REDUCE_MIN (1.0/32.0)
#define FXAA_REDUCE_MUL (1.0/16.0)
#define FXAA_SPAN_MAX 15.0

half2 rcpFrame = half2(1/ScreenSize, 1/(ScreenSize/ScreenScaleY));

half4 posPos;
posPos.xy = i.txcoord.xy;
posPos.zw = posPos.xy - (rcpFrame.xy * (0.5 + FXAA_SUBPIX_SHIFT));

half3 rgbNW = tex2D(SamplerColor, posPos.zw ).xyz;
half3 rgbNE = tex2D(SamplerColor, posPos.zw + half2(rcpFrame.x, 0.0) ).xyz;
half3 rgbSW = tex2D(SamplerColor, posPos.zw + half2(0.0, rcpFrame.y) ).xyz;
half3 rgbSE = tex2D(SamplerColor, posPos.zw +rcpFrame.xy ).xyz;
half3 rgbM = tex2D(SamplerColor, posPos.xy).xyz;

half3 luma = half3(0.299, 0.587, 0.114);
half lumaNW = dot(rgbNW, luma);
half lumaNE = dot(rgbNE, luma);
half lumaSW = dot(rgbSW, luma);
half lumaSE = dot(rgbSE, luma);
half lumaM = dot(rgbM, luma);

half lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
half lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));

half2 dir;

half lumaNWNE = lumaNW + lumaNE;
half lumaSWSE = lumaSW + lumaSE;

dir.x = -((lumaNWNE) - (lumaSWSE));
dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));

half dirReduce = max( (lumaSWSE + lumaNWNE) * (0.25 * FXAA_REDUCE_MUL),
FXAA_REDUCE_MIN);
half rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
dir = min(half2( FXAA_SPAN_MAX, FXAA_SPAN_MAX),
max(half2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
dir * rcpDirMin)) * rcpFrame.xy;

half3 rgbA = (1.0/2.0) * (
tex2D(SamplerColor, posPos.xy + dir * (1.0/3.0 - 0.5) ).xyz +
tex2D(SamplerColor, posPos.xy + dir * (2.0/3.0 - 0.5) ).xyz);
half3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
tex2D(SamplerColor, posPos.xy + dir * (0.0/3.0 - 0.5) ).xyz +
tex2D(SamplerColor, posPos.xy + dir * (3.0/3.0 - 0.5) ).xyz);
half lumaB = dot(rgbB, luma);

if((lumaB < lumaMin) || (lumaB > lumaMax))
return half4(rgbA, 1.0);

return float4(rgbB, 1.0);
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//--------------------Fast Approximate Anti-Aliasing Techniques -------------
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
technique PostProcess
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess2
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess3
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess4
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess5
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess6
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess7
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess8
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess9
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess10
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess11
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess12
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess13
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess14
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess15
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}

[Raff]

Goil. Woher stammt das? Aus der aktuellen ENB-Version? :confused:

Schaut ansonsten aus wie MLAA.

MfG,
Raff

[boxleitnerb]

Sieht geil aus, aber wie genau wendet man es nun an?
Was muss mit der Textdatei geschehen?

Schon gefunden. Von Myster92 hier:
http://www.gtaforums.com/index.php?showtopic=417918&st=22880

Man muss die Effect.txt aus der ENB-series mit der neuen ersetzen.

[Dragozool]

du musst die ENB series benutzen damit die effect.txt geladen wird ;) es sollte eine von anfang an vorhanden sein...wenn nicht erstell eine txt datei mit dem namen effect.txt und füge einfach das ein was im spoiler steht ein und starte das game :)

[boxleitnerb]

del plz

[boxleitnerb]

Klappt. Und matscht ÜBELST:

3072x2457@1280x1024 ohne FXAA:
http://www.abload.de/thumb/gtaiv2011-06-2118-01-0h7ja.png (http://www.abload.de/image.php?img=gtaiv2011-06-2118-01-0h7ja.png)

1280x1024 mit FXAA:
http://www.abload.de/thumb/gtaiv2011-06-2117-57-5o7mz.png (http://www.abload.de/image.php?img=gtaiv2011-06-2117-57-5o7mz.png)

Beißt sich das mit etwas? Hab die ENB 0.82beta und Patch 1.0.4.0

Edit:
Muss man das zusätzlich in die bestehende txt einbauen oder darf ausschließlich dieser Text aus deinem Spoiler in der Datei stehen?

[Dragozool]

ich kann das nicht sgaen ob sich der FXAA filter eventuell mit etwas beisst...musst mal probieren ;) aber so wie es bei dir aussieht sollte es nciht sein ^^ schau dir meinen screen an da sollte es so aussehen

[boxleitnerb]

Welche ENB benutzt du? Und was für Settings? (Postprocessing usw.)
Könntest du bitte mal deine ini hochladen oder in einen Spoiler setzen?

[Nightspider]

Ich hoffe das FXAA in Battlefield 3 wird besser aussehen, denn all zu toll sieht das oben ja nicht auf den Bildern aus.
Da hat man doch von Downsampling mehr, mit Hilfe der enb Mod oder? (Zumindest wenn man die Leistung hat)

[Dragozool]

settings sind von mir optimierte settings von jemandem xD schon so abgeändert das ich es nimmer weiss ^^ mit geänderter timecyc usw...kann ich nicht wirklich hochladen da es zu viel ist ^^

wenn nciht deaktivier das ENB AA und probier das mal

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//http://enbdev.com
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*
THIS IS HLSL FILE FORMAT FOR EXECUTING ADDITIONAL
POST PROCESSING EFFECTS. MAKE THE COPY BEFORE CHANGING IT!
*/

//keyboard controled variables
float tempF1;
float tempF2;
float tempF3;
float tempF4;
float tempF5;
float tempF6;
float tempF7;
float tempF8;
float tempF9;
float tempF0;

//global variables, already set before executing this code
float ScreenSize; //width of the display resolution (1920 f.e.)
float ScreenScaleY; //screen proportions (1.333 for 1920/1080)

//textures
texture2D texColor;

sampler2D SamplerColor = sampler_state
{
Texture = <texColor>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = NONE;//NONE;
AddressU = Clamp;
AddressV = Clamp;
SRGBTexture=FALSE;
MaxMipLevel=0;
MipMapLodBias=0;
};

struct VS_OUTPUT_POST {
float4 vpos : POSITION;
float2 txcoord : TEXCOORD0;
};

struct VS_INPUT_POST {
float3 pos : POSITION;
float2 txcoord : TEXCOORD0;
};

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
VS_OUTPUT_POST VS_PostProcess(VS_INPUT_POST IN)
{
VS_OUTPUT_POST OUT;

float4 pos=float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0);

OUT.vpos=pos;
OUT.txcoord.xy=IN.txcoord.xy;

return OUT;
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//--------------------Fast Approximate Anti-Aliasing --------------------------
// FXAA v2 CONSOLE by TIMOTHY LOTTES @ NVIDIA
// Ported to ENBSeries by MysTer92 (Svyatoslav Gampel)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
float4 PS_PostProcess(VS_OUTPUT_POST i) : COLOR
{
#define FXAA_SUBPIX_SHIFT (1.0/8.0)
#define FXAA_REDUCE_MIN (1.0/32.0)
#define FXAA_REDUCE_MUL (1.0/16.0)
#define FXAA_SPAN_MAX 2.0

half2 rcpFrame = half2(1/ScreenSize, 1/(ScreenSize/ScreenScaleY));

half4 posPos;
posPos.xy = i.txcoord.xy;
posPos.zw = posPos.xy - (rcpFrame.xy * (0.5 + FXAA_SUBPIX_SHIFT));

half3 rgbNW = tex2D(SamplerColor, posPos.zw ).xyz;
half3 rgbNE = tex2D(SamplerColor, posPos.zw + half2(rcpFrame.x, 0.0) ).xyz;
half3 rgbSW = tex2D(SamplerColor, posPos.zw + half2(0.0, rcpFrame.y) ).xyz;
half3 rgbSE = tex2D(SamplerColor, posPos.zw +rcpFrame.xy ).xyz;
half3 rgbM = tex2D(SamplerColor, posPos.xy).xyz;

half3 luma = half3(0.299, 0.587, 0.114);
half lumaNW = dot(rgbNW, luma);
half lumaNE = dot(rgbNE, luma);
half lumaSW = dot(rgbSW, luma);
half lumaSE = dot(rgbSE, luma);
half lumaM = dot(rgbM, luma);

half lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
half lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));

half2 dir;

half lumaNWNE = lumaNW + lumaNE;
half lumaSWSE = lumaSW + lumaSE;

dir.x = -((lumaNWNE) - (lumaSWSE));
dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));

half dirReduce = max( (lumaSWSE + lumaNWNE) * (0.25 * FXAA_REDUCE_MUL),
FXAA_REDUCE_MIN);
half rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
dir = min(half2( FXAA_SPAN_MAX, FXAA_SPAN_MAX),
max(half2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
dir * rcpDirMin)) * rcpFrame.xy;

half3 rgbA = (1.0/2.0) * (
tex2D(SamplerColor, posPos.xy + dir * (1.0/3.0 - 0.5) ).xyz +
tex2D(SamplerColor, posPos.xy + dir * (2.0/3.0 - 0.5) ).xyz);
half3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
tex2D(SamplerColor, posPos.xy + dir * (0.0/3.0 - 0.5) ).xyz +
tex2D(SamplerColor, posPos.xy + dir * (3.0/3.0 - 0.5) ).xyz);
half lumaB = dot(rgbB, luma);

if((lumaB < lumaMin) || (lumaB > lumaMax))
return half4(rgbA, 1.0);

return float4(rgbB, 1.0);
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//--------------------Fast Approximate Anti-Aliasing Techniques -------------
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
technique PostProcess
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess2
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess3
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}
technique PostProcess4
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}

[boxleitnerb]

Thx.
Und welche ENB Version? Du brauchst ja nur die Ini hochladen, nicht alles. Die ist klein ;)

Mit der neuen Datei:
http://www.abload.de/thumb/gtaiv2011-06-2118-57-3iuq0.png (http://www.abload.de/image.php?img=gtaiv2011-06-2118-57-3iuq0.png)

Bisschen besser, aber Glättung ist auch schlechter - sieht man besser in Bewegung. Immer noch nicht so gut wie bei dir :(

[Dragozool]

enb is die 0.078 SORA und hier is die ini

[PROXY]
EnableProxyLibrary=true
InitProxyFunctions=false
ProxyLibrary=

[GLOBAL]
AdditionalConfigFile=enbseries2.ini
UseEffect=true
CyclicConfigReading=false
ForceNVidiaCard=true
ForceNVidiaCaps=true

[ENGINE]
ForceDisplaySize=false
ForceAntialiasing=false
ForceDisplayRefreshRate=false
ForceAnisotropicFiltering=false
MaxAnisotropy=16
AntialiasingQuality=2
DisplayRefreshRateHz=60
DisplayWidth=1680
DisplayHeight=1050
ReflectionsForceHighPrecision=true
ReflectionsExtremePrecision=true

[EFFECT]
EnableBloom=true
EnableAmbientOcclusion=false
EnableSkyLighting=false
UseOriginalPostProcessing=false

[INPUT]
KeyUseEffect=123
KeyCombination=16
KeyScreenshot=44
KeyAmbientOcclusion=121

[BLOOD]
ReflectionAmount=1.0
SpecularPower=0.8

[TREE]
LeavesReflectionAmount=0.003
LeavesSpecularPower=0.003
LeavesAmbientAmount=0.45
LeavesColorMultiplier=0.99
LeavesColorPow=1.02

[BUILDING]
WindowLightIntensity=1.5

[LIGHT1] //siren and some internal
LightIntensity=1.5
LightAOAmount=1.4
LightILAmount=0.0
EdgeLighteningAmount=0.0
ColorPow=1.5
LightCurve=1.0

[LIGHT2] //street light
LightIntensity=1.0
LightAOAmount=1
LightILAmount=0
EdgeLighteningAmount=0.3
ColorPow=1.8
LightCurve=1.0

[LIGHT3] //car front light
LightIntensity=1.0
LightAOAmount=0.0
StarsAmount=2.5
StarsIntensity=4.0
LightILAmount=6.0
EdgeLighteningAmount=0.4
ColorPow=1.5
LightCurve=1.0

[LIGHT4] //secondary
LightIntensity=1.0
LightAOAmount=0.0
LightILAmount=4.0
EdgeLighteningAmount=1.0
ColorPow=1.0
LightCurve=1.0

[LIGHT5] //ambient spheres
LightIntensity=1.0
LightAOAmount=0
LightILAmount=1
EdgeLighteningAmount=0.0
ColorPow=2.0
LightCurve=1.0

[LIGHT6] //ambient spheres for omni light
LightIntensity=1.0
LightAOAmount=0
LightILAmount=1
EdgeLighteningAmount=0.0
ColorPow=2.0
LightCurve=1.0

[CARHEADLIGHT]
EmissiveMuliplier=4.0
LightIntensity=1.0

[LIGHTSPRITE]
UseExternalTexture=true
Intensity=0.5
IntensityInReflection=1.0
UseRays=true
RaysNumber=3
RaysIntensity=0.1
RaysRateOfChange=10.0
RaysLength=1.0

[CARWINDOWGLASS]
ReflectionAmount=0.9
SpecularPower=100.0
SpecularAmount=10.0

[CHROME]
ReflectionFront=0.9
ReflectionSide=0.9
SpecularPower=70.0
SideFade=1.0
MetallicAmount=0.0

[WHEELS]
ReflectionFront=1.2
ReflectionSide=2.0
SpecularPower=10.0
SideFade=1.0
MetallicAmount=0.0

[REFLECTION1]
ReflectionFront=0.9
ReflectionSide=0.9
SpecularPower=50.0
SideFade=9.0
MetallicAmount=0.0

[REFLECTION2]
ReflectionFront=0.8
ReflectionSide=1.3
SpecularPower=40.0
SideFade=10.0

[REFLECTION3]
ReflectionFront=0.7
ReflectionSide=1.2
SpecularPower=30.0
SideFade=10.0

[BLOOM]
BloomQuality=0
BlueShiftAmount=0.4
Radius1=0.3
Radius2=0.6
Contrast=1.4

[SSAO_SSIL]
ApplyAntialiasing=true
SamplingQuality=1
SamplingRange=0.5
SizeScale=0.4
SourceTexturesScale=0.4
FilterQuality=1
AOAmount=1.5
ILAmount=0.0
EdgeLighteningAmount=4.0

[SHADOW]
FilterQuality=2

[ADAPTATION]
ForceMinMaxValues=true
AdaptationTime=1.0
AdaptationMin=1.0
AdaptationMax=1.1
AdaptationMinMultiplier=1.0
AdaptationMaxMultiplier=1.0

[ENVIRONMENT]
DirectLightingIntensity=1.15
NightLightingIntensity=1.45
DirectLightingCurve=1.75
ReflectionAmountMultiplier=1.0
SpecularAmountMultiplier=1.0
SpecularPowerMultiplier=1.0
ColorPow=1.8
AmbientSunMultiplier=1.0
AmbientSkyMultiplier=0.7
AmbientSunSaturation=1.0
AmbientSkySaturation=0.7

[SKYLIGHTING]
FilterQuality=0
AmbientSunMix=0.5
AmbientSkyMix=0.5
AmbientContrast=2.0
AmbientMinLevel=1.3

[SKY]
AzimuthHeight=1.0
AzimuthMultiplier=0.5
TopColorMultiplier=0.7
ColorSaturation=0.4
ColorPower=2.5
SunIntensity=1.0
SunMaxBrightness=100.0
SunColorFilterR=1.0
SunColorFilterG=0.9
SunColorFilterB=0.8
SunColorFilterCurve=5.0
SunCoronaCurve=2.0
SunCoronaIntensity=1.5
SunDesaturation=0.7
OverallPower=1.0
OverallIntensity=2.0
CloudsCurve=3.0
CloudsIntensity=1.0
CloudsDesaturation=0.7
CloudsEdgeClamp=0.5
CloudsEdgeIntensity=2.0
CloudsEdgeRange=5.0

[BeetleatWar1977]

Ich hab zwar kein GTA - aber mach doch bitte mal vergleichspics hiermit

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//ENBSeries: boris-vorontsov@yandex.ru, boris-vorontsov.narod.ru
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*
THIS IS HLSL FILE FORMAT FOR EXECUTING ADDITIONAL
POST PROCESSING EFFECTS. MAKE THE COPY BEFORE CHANGING IT!
*/




//keyboard controled variables
float tempF1;
float tempF2;
float tempF3;
float tempF4;
float tempF5;
float tempF6;
float tempF7;
float tempF8;
float tempF9;
float tempF0;


float PassNumber;


//global variables, already set before executing this code
float ScreenSize; //width of the display resolution (1024 f.e.)
float ScreenScaleY; //screen proportions (1.333 for 1024/768)
float4 ScreenBrightness;//rgba(0..1) color of the screen with time dependent inertia
float ScreenBrightnessAdaptation;//(-10..10) for bloom it controls how much to dark in the night or when scene is dark (user defined constant factor)
float bloomPower;//(0..10) actually used for bloom, but may be useful here (user defined constant factor)
float useBloom;//(0 or 1) if bloom enabled by user





float4x4 worldviewproj;




//textures
texture2D texColor;

sampler2D SamplerColor = sampler_state
{
Texture = <texColor>;
MinFilter = POINT;
MagFilter = POINT;
MipFilter = NONE;//NONE;
AddressU = Wrap;
AddressV = Wrap;
SRGBTexture=FALSE;
MaxMipLevel=0;
MaxAnisotropy=16;
MipMapLodBias=0;
};

sampler2D SamplerColorA = sampler_state
{
Texture = <texColor>;
MinFilter = ANISOTROPIC;
MagFilter = ANISOTROPIC;
MipFilter = NONE;//NONE;
AddressU = Wrap;
AddressV = Wrap;
SRGBTexture=FALSE;
MaxMipLevel=0;
MaxAnisotropy=16;
MipMapLodBias=0;
};

struct VS_OUTPUT_POST {
float4 vpos : POSITION;
float2 txcoord : TEXCOORD0;
float2 txcoord2 : TEXCOORD1;
float2 txcoord3 : TEXCOORD2;
float2 txcoord4 : TEXCOORD3;
float2 txcoord5 : TEXCOORD4;
float2 txcoord6 : TEXCOORD5;
float2 txcoord7 : TEXCOORD6;
float2 txcoord8 : TEXCOORD7;
float2 txcoord9 : TEXCOORD8;
};

struct VS_INPUT_POST {
float3 pos : POSITION;
float2 txcoord : TEXCOORD0;
};





//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
VS_OUTPUT_POST VS_PostProcess(VS_INPUT_POST IN)
{
VS_OUTPUT_POST OUT;

float4 pos=float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0);

OUT.vpos=pos;
// OUT.txcoord.xy=IN.txcoord.xy;

float2 ctr = IN.txcoord.xy;// + ((0.5/ScreenSize),((0.5/ScreenSize)/ScreenScaleY));
float2 os = IN.txcoord.xy +((0.5/ScreenSize),((0.5/ScreenSize)/ScreenScaleY));
float2 ox = ((0.9/ScreenSize),0.0);
float2 oy = (0.0,((0.9/ScreenSize)/ScreenScaleY));
OUT.txcoord = os - ox - oy;
OUT.txcoord2 = ctr - oy;
OUT.txcoord3 = os + ox - oy;
OUT.txcoord4 = ctr - ox;
OUT.txcoord5 = ctr + ox;
OUT.txcoord6 = os - ox + oy;
OUT.txcoord7 = ctr + oy;
OUT.txcoord8 = os + ox + oy;
OUT.txcoord9 = IN.txcoord.xy; //IN.txcoord.xy ctr
return OUT;
}






float4 PS_PostProcess(VS_OUTPUT_POST IN) : COLOR
{
float4 res;
float4 origcolor;
float4 origcolor2;
float4 origcolor3;
float4 origcolor4;
float4 origcolor5;
float4 origcolor6;
float4 origcolor7;
float4 origcolor8;
float4 colorori;

origcolor=tex2D(SamplerColorA, IN.txcoord.xy);
origcolor2=tex2D(SamplerColorA, IN.txcoord2.xy);
origcolor3=tex2D(SamplerColorA, IN.txcoord3.xy);
origcolor4=tex2D(SamplerColorA, IN.txcoord4.xy);
origcolor5=tex2D(SamplerColorA, IN.txcoord5.xy);
origcolor6=tex2D(SamplerColorA, IN.txcoord6.xy);
origcolor7=tex2D(SamplerColorA, IN.txcoord7.xy);
origcolor8=tex2D(SamplerColorA, IN.txcoord8.xy);
colorori = tex2D(SamplerColorA, IN.txcoord9.xy );
res=colorori;
float4 step1=abs(colorori-origcolor2);
float4 step2=abs(colorori-origcolor4);
float4 step3=abs(colorori-origcolor5);
float4 step4=abs(colorori-origcolor7);

float4 tcol;
float4 coord=0;
tcol = origcolor+origcolor3+origcolor6+origcolor8;

tcol= tcol /4 ;
float schwelle=0.12;
float4 blur= (clamp((step1+step4+step3+step2)*1.6,schwelle,0.6)-schwelle)*(1.0/(1.0-schwelle));
float4 finalcolor;

finalcolor.r= lerp(colorori.r,tcol.r,blur.r);
finalcolor.g= lerp(colorori.g,tcol.g,blur.g);
finalcolor.b= lerp(colorori.b,tcol.b,blur.b);
finalcolor.a=colorori.a;
res= saturate(finalcolor);
return res;
}




//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
technique PostProcess
{
pass P0
{

VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 PS_PostProcess();


ZEnable=FALSE;
CullMode=NONE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}

[Dragozool]

sorry aber nicht gut ^^ blurrt und glättet sogut wie garnicht...

http://thumbnails42.imagebam.com/13751/086ea4137507438.jpg (http://www.imagebam.com/image/086ea4137507438) http://thumbnails43.imagebam.com/13751/abdae3137507484.jpg (http://www.imagebam.com/image/abdae3137507484)

[dildo4u]

Ich hoffe das FXAA in Battlefield 3 wird besser aussehen, denn all zu toll sieht das oben ja nicht auf den Bildern aus.

Es wird schon längst in den Video's genutzt und es ist Göttlich.

[Dragozool]

das was wir hier benutzen is ein convert von Nvidia ;) es ist in ordnung und vor allem das beste ist es ins configurierbar ;)

[y33H@]

Es wird schon längst in den Video's genutzt und es ist Göttlich.Quelle?

[dargo]

Es wird schon längst in den Video's genutzt und es ist Göttlich.
FXAA und göttlich? Das will ich sehen. Oder du hast eine ganz andere Wahrnehmung von "göttlich".

[Dragozool]

ich sag mal so wenn man es richtig einstellt dann ist FXAA schonmal besser als MSAA da es das gesammte bild glättet aber göttlich ist nur DS und SGSSAA :D

[Raff]

FXAA bleibt verbilligtes SSAA. "Göttlich" kann da nur das Preis-Leistungs-Verhältnis sein, nicht die Qualität.

MfG,
Raff

[Chris Lux]

ich habe selbst das FXAA von nvidia in einem projekt genutzt. aber die bilder hier sehen sehr schlecht aus, als ob es nicht funktioniert. wichtig ist, dass die eingabe-texture fuer den FXAA shader mit bilinearem filter kommen muss, sonst geht es nicht.

[Dragozool]

na dann erstell du doch mal ne effect.txt datei wo du das machst ;) das würde denke ich mal alle glücklich machen ^^

[boxleitnerb]

Also ich krieg es einfach nicht hin. Es blurrt wie blöde mit ENB 0.82 :(

[watugonad00?]

version 3 schon probiert ?

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//http://enbdev.com
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*
THIS IS HLSL FILE FORMAT FOR EXECUTING ADDITIONAL
POST PROCESSING EFFECTS. MAKE THE COPY BEFORE CHANGING IT!
*/

//keyboard controled variables
float tempF1;
float tempF2;
float tempF3;
float tempF4;
float tempF5;
float tempF6;
float tempF7;
float tempF8;
float tempF9;
float tempF0;

//global variables, already set before executing this code
float ScreenSize; //width of the display resolution (1920 f.e.)
float ScreenScaleY; //screen proportions (1.333 for 1920/1080)

//textures
texture2D texColor;

sampler2D SamplerColor = sampler_state
{
Texture = <texColor>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = NONE;//NONE;
AddressU = Clamp;
AddressV = Clamp;
SRGBTexture=FALSE;
MaxMipLevel=0;
MipMapLodBias=0;
};

struct VS_OUTPUT_POST {
float4 vpos : POSITION;
float2 txcoord : TEXCOORD0;
};

struct VS_INPUT_POST {
float3 pos : POSITION;
float2 txcoord : TEXCOORD0;
};

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
VS_OUTPUT_POST VS_PostProcess(VS_INPUT_POST IN)
{
VS_OUTPUT_POST OUT;

float4 pos=float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0);

OUT.vpos=pos;
OUT.txcoord.xy=IN.txcoord.xy;

return OUT;
}


/*============================================================================
FXAA3 QUALITY - PC
NVIDIA FXAA III.8 by TIMOTHY LOTTES
============================================================================*/

#define FXAA_LINEAR 0
#define FXAA_QUALITY__EDGE_THRESHOLD (1.0/16.0)
#define FXAA_QUALITY__EDGE_THRESHOLD_MIN (1.0/16.0)
#define FXAA_QUALITY__SUBPIX_CAP (3.0/4.0)
#define FXAA_QUALITY__SUBPIX_TRIM (1.0/4.0)
#define FXAA_QUALITY__SUBPIX_TRIM_SCALE (1.0/(1.0 - FXAA_QUALITY__SUBPIX_TRIM))
#define FXAA_SEARCH_STEPS 8
#define FXAA_SEARCH_THRESHOLD (1.0/4.0)

float4 FxaaPixelShader(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR
{

#define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))
#define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))

float2 pos = IN.txcoord.xy;

float2 rcpFrame = float2(1/ScreenSize, ScreenScaleY/ScreenSize);
float4 rcpFrameOpt = float4(2/ScreenSize, 2*ScreenScaleY/ScreenSize, 0.5/ScreenSize, 0.5*ScreenScaleY/ScreenSize);

float lumaN = dot(FxaaTexOff(SamplerColor, pos.xy, float2(0, -1), rcpFrame.xy).xyz, float3(0.299, 0.587, 0.114));
float lumaW = dot(FxaaTexOff(SamplerColor, pos.xy, float2(-1, 0), rcpFrame.xy).xyz, float3(0.299, 0.587, 0.114));


float4 rgbyM;
rgbyM.xyz = FxaaTexTop(SamplerColor, pos.xy).xyz;
rgbyM.w = dot(rgbyM.xyz, float3(0.299, 0.587, 0.114));
float lumaE = dot(FxaaTexOff(SamplerColor, pos.xy, float2( 1, 0), rcpFrame.xy).xyz, float3(0.299, 0.587, 0.114));
float lumaS = dot(FxaaTexOff(SamplerColor, pos.xy, float2( 0, 1), rcpFrame.xy).xyz, float3(0.299, 0.587, 0.114));
float lumaM = rgbyM.w;


float rangeMin = min(lumaM, min(min(lumaN, lumaW), min(lumaS, lumaE)));
float rangeMax = max(lumaM, max(max(lumaN, lumaW), max(lumaS, lumaE)));
float range = rangeMax - rangeMin;

if(range < max(FXAA_QUALITY__EDGE_THRESHOLD_MIN, rangeMax * FXAA_QUALITY__EDGE_THRESHOLD)) return rgbyM;


float lumaNW = dot(FxaaTexOff(SamplerColor, pos.xy, float2(-1,-1), rcpFrame.xy).xyz, float3(0.299, 0.587, 0.114));
float lumaNE = dot(FxaaTexOff(SamplerColor, pos.xy, float2( 1,-1), rcpFrame.xy).xyz, float3(0.299, 0.587, 0.114));
float lumaSW = dot(FxaaTexOff(SamplerColor, pos.xy, float2(-1, 1), rcpFrame.xy).xyz, float3(0.299, 0.587, 0.114));
float lumaSE = dot(FxaaTexOff(SamplerColor, pos.xy, float2( 1, 1), rcpFrame.xy).xyz, float3(0.299, 0.587, 0.114));



float lumaL = (lumaN + lumaW + lumaE + lumaS) * 0.25;
float rangeL = abs(lumaL - lumaM);
float blendL = saturate((rangeL / range) - FXAA_QUALITY__SUBPIX_TRIM) * FXAA_QUALITY__SUBPIX_TRIM_SCALE;
blendL = min(FXAA_QUALITY__SUBPIX_CAP, blendL);

float edgeVert = abs(lumaNW + (-2.0 * lumaN) + lumaNE) + 2.0 * abs(lumaW + (-2.0 * lumaM) + lumaE ) + abs(lumaSW + (-2.0 * lumaS) + lumaSE);
float edgeHorz = abs(lumaNW + (-2.0 * lumaW) + lumaSW) + 2.0 * abs(lumaN + (-2.0 * lumaM) + lumaS ) + abs(lumaNE + (-2.0 * lumaE) + lumaSE);
bool horzSpan = edgeHorz >= edgeVert;

float lengthSign = horzSpan ? -rcpFrame.y : -rcpFrame.x;
if(!horzSpan) lumaN = lumaW;
if(!horzSpan) lumaS = lumaE;
float gradientN = abs(lumaN - lumaM);
float gradientS = abs(lumaS - lumaM);
lumaN = (lumaN + lumaM) * 0.5;
lumaS = (lumaS + lumaM) * 0.5;

bool pairN = gradientN >= gradientS;
if(!pairN) lumaN = lumaS;
if(!pairN) gradientN = gradientS;
if(!pairN) lengthSign *= -1.0;
float2 posN;
posN.x = pos.x + (horzSpan ? 0.0 : lengthSign * 0.5);
posN.y = pos.y + (horzSpan ? lengthSign * 0.5 : 0.0);


gradientN *= FXAA_SEARCH_THRESHOLD;

float2 posP = posN;
float2 offNP = horzSpan ?
float2(rcpFrame.x, 0.0) :
float2(0.0f, rcpFrame.y);
float lumaEndN;
float lumaEndP;
bool doneN = false;
bool doneP = false;
posN += offNP * (-1.5);
posP += offNP * ( 1.5);
for(int i = 0; i < FXAA_SEARCH_STEPS; i++)
{
lumaEndN = dot(FxaaTexTop(SamplerColor, posN.xy).xyz, float3(0.299, 0.587, 0.114));
lumaEndP = dot(FxaaTexTop(SamplerColor, posP.xy).xyz, float3(0.299, 0.587, 0.114));
bool doneN2 = abs(lumaEndN - lumaN) >= gradientN;
bool doneP2 = abs(lumaEndP - lumaN) >= gradientN;
if(doneN2 && !doneN) posN += offNP;
if(doneP2 && !doneP) posP -= offNP;
if(doneN2 && doneP2) break;
doneN = doneN2;
doneP = doneP2;
if(!doneN) posN -= offNP * 2.0;
if(!doneP) posP += offNP * 2.0;
}

float dstN = horzSpan ? pos.x - posN.x : pos.y - posN.y;
float dstP = horzSpan ? posP.x - pos.x : posP.y - pos.y;

bool directionN = dstN < dstP;
lumaEndN = directionN ? lumaEndN : lumaEndP;

if(((lumaM - lumaN) < 0.0) == ((lumaEndN - lumaN) < 0.0))
lengthSign = 0.0;

float spanLength = (dstP + dstN);
dstN = directionN ? dstN : dstP;
float subPixelOffset = 0.5 + (dstN * (-1.0/spanLength));
subPixelOffset += blendL * (1.0/8.0);
subPixelOffset *= lengthSign;
float3 rgbF = FxaaTexTop(SamplerColor, float2(pos.x + (horzSpan ? 0.0 : subPixelOffset), pos.y + (horzSpan ? subPixelOffset : 0.0))).xyz;

#if (FXAA_LINEAR == 1)
lumaL *= lumaL;
#endif
float lumaF = dot(rgbF, float3(0.299, 0.587, 0.114)) + (1.0/(65536.0*256.0));
float lumaB = lerp(lumaF, lumaL, blendL);
float scale = min(4.0, lumaB/lumaF);
rgbF *= scale;

return float4(rgbF, lumaM);
}


technique PostProcess
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 FxaaPixelShader();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}

technique PostProcess2
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 FxaaPixelShader();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}

technique PostProcess3
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 FxaaPixelShader();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}

technique PostProcess4
{
pass P0
{
VertexShader = compile vs_3_0 VS_PostProcess();
PixelShader = compile ps_3_0 FxaaPixelShader();

FogEnable=FALSE;
ALPHATESTENABLE=FALSE;
SEPARATEALPHABLENDENABLE=FALSE;
AlphaBlendEnable=FALSE;
FogEnable=FALSE;
SRGBWRITEENABLE=FALSE;
}
}

[san.salvador]

FXAA bleibt verbilligtes SSAA. "Göttlich" kann da nur das Preis-Leistungs-Verhältnis sein, nicht die Qualität.

MfG,
Raff
Wie kann ein Blurfilter verbilligtes SSAA sein?
Ist Hundekot verbilligtes Steak? :ugly:

[Major]

Wie schneidet das FXAA in GTA 4 denn im Vergleich mit ATIs MLAA ab? Es scheint ja weniger Performance zu kosten, lohnt es sich daher eher?

[LuckyD]

Hundekot

Naja, sooo schlecht sieht's jetzt nicht aus. Hab's gestern getestet. Geht scho! Besser als nichts. Und bei meiner Auflösung ist SSAA, denk ich, unmöglich. :wink:

[boxleitnerb]

Also inzwischen hab ich es hingekriegt mit ENB 0.82 dank Hilfe ausm Luxx. 2,8x OGSSAA ist damit jetzt wirklich ganz ruhig bis auf die Schatten. Alleine taugt es imo nicht so.

[watugonad00?]

Wie schneidet das FXAA in GTA 4 denn im Vergleich mit ATIs MLAA ab? Es scheint ja weniger Performance zu kosten, lohnt es sich daher eher?



Why FXAA

Wanted something which handles sub-pixel aliasing better than MLAA, something which didn't require compute, something which runs on DX9 level hardware, and something which runs in a single full-screen pixel shader pass. Basically the simplest and easiest thing to integrate and use.

http://timothylottes.blogspot.com/2011/03/nvidia-fxaa.html
http://timothylottes.blogspot.com/

http://www.geeks3d.com/20110405/fxaa-fast-approximate-anti-aliasing-demo-glsl-opengl-test-radeon-geforce/

[del_4901]

ich habe selbst das FXAA von nvidia in einem projekt genutzt. aber die bilder hier sehen sehr schlecht aus, als ob es nicht funktioniert. wichtig ist, dass die eingabe-texture fuer den FXAA shader mit bilinearem filter kommen muss, sonst geht es nicht.
Man arbeitet hier ja nichtmal mit einem High-Res Depth Buffer, das kann gar nicht funktioniern. Das ist eine schlechte MLAA implementation.

[Chris Lux]

Man arbeitet hier ja nichtmal mit einem High-Res Depth Buffer, das kann gar nicht funktioniern. Das ist eine schlechte MLAA implementation.
have ich irgendwo etwas anderes behauptet?

[del_4901]

have ich irgendwo etwas anderes behauptet?
Du musst dich doch nicht gleich angegriffen fuehlen. Auch wenn hier viele (quallifizierte) Leute das gerne machen, war das in diesem Fall durchaus nicht so beabsichtigt. Ich dachte einfach mein Kommentar passt am besten zu deinem Post.

[Dragozool]

naja wenn ihr so viel ahnung davon habt wieso schreibt ihr nicht einen FXAA code für GTA IV?? davon hätten wir alle am meisten was ;)

[del_4901]

naja wenn ihr so viel ahnung davon habt wieso schreibt ihr nicht einen FXAA code für GTA IV?? davon hätten wir alle am meisten was ;)
Wenn du mich dafuer bezahlst, gern.
Vorher moechte ich dich aber noch darauf hinweisen, das es ohne Zugriff auf den Sourcecode der Engine und die damit verbundenen tiefgreifenden Aenderungen nicht moeglich sein wird.

[Dragozool]

wieso gleich bezahlen die anderen ahben es doch auch aus freien stücken gemacht ^^ es wäre ja schon eine verbesserung wenn ihr euch eventuell den code anschaut der in der effect.txt steht und den eventuell optimiert ;)

[=Floi=]

Es wird schon längst in den Video's genutzt und es ist Göttlich.

das wäre echt ein satz für die signatur. lustig finde ich ja, das es mal nicht von LS kommt. ;D

FXAA ist genau der gleiche fuck wie MLAA bei ati. das können sie wieder begraben.

[hellibelli]

Hallo, bei mir funktioniert das irgendwie nicht.
Habe im Nvidia Inspector das Profil von Grand Theft Auto 4 ausgewählt und dann Toogle FXAA on or off auf 0x00000001 gestellt.

Im Spiel selber sehe ich aber absolut keine Veränderung. Benutze Icenhancer und better City textures.

Ich habe im GTA 4 Hauptverzeichnis eine effect.txt erstellt und den Inhalt von Dragozoll geposteten Link einkopiert.

Muss man den durch drücken einer Taste im Spiel noch aktivieren, oder wie funktioniert das?

[watugonad00?]

bei icenhancer ist fxaa schon von haus aus in der option.txt drinne.

[hellibelli]

Hmm also heisst das ich nur Ice... installieren muss und dann habe ich auch geglättete wände etc..

Leider sehe ich da bei mir nichts von. Es ist alles sehr sehr hell für meinen geschmack zu hell und auch nichts geglättet.

So habe mal in der iceconfig meine Auflösung eingestellt: Native habe ich 1920x1200
Wenn ich jetzt antialaising quality auf 2 setzte, erzwingt dieser bei mir eine andere Auflösung. und zwar habe ich dann eine 3000er auflösung. Damit ist das Spiel nicht wirklich mehr spielbar, da zu ruckelig.

Kann mir niemand einen tip geben, wie ich das grelle licht weg bekomme und die kanten geglättet bekomme ohne Downsampling.






bei icenhancer ist fxaa schon von haus aus in der option.txt drinne.

[RainingBlood]

Kann mir niemand einen tip geben, wie ich das grelle licht weg bekomme und die kanten geglättet bekomme ohne Downsampling.


http://extreme.pcgameshardware.de/gta-grand-theft-auto/163208-gta-4-icenhancer-1-2-anleitung.html