View Single Post
Old 08-12-2013   #1
Jalenxt
Registered User
 
Join Date: Feb 2013
Posts: 4
Jalenxt is an unknown quantity at this point
Enb problem fuzzy static

After 10 seconds this happens, I am using the 1.0.7 patch and my specs are 8gb Kingston hyperx 1600 ddr3, sapphire dual x 7970, i5 4670k. I will type my enbseries and effect in spoilers, 1st spoiler is enbseries and 2nd is effect. Im using LCPDFR, A trainer, realtraffic.asi, ELS, and a few car mods. the 1st 2 pictures are what its supposed to look like but 10 seconds later it gets all grainy and fuzzy as seen in the other 3 pictures.

ENBseries.ini
//ProjectRAGE3
[PROXY]
EnableProxyLibrary=true
InitProxyFunctions=true
ProxyLibrary=d3d9_fxaa.dll

[GLOBAL]
AdditionalConfigFile=
UseEffect=true
CyclicConfigReading=false
ForceNVidiaCard=false
ForceNVidiaCaps=false

[ENGINE]
ForceDisplaySize=false
ForceAntialiasing=false
ForceDisplayRefreshRate=false
ForceAnisotropicFiltering=true
MaxAnisotropy=8
AntialiasingQuality=0
DisplayRefreshRateHz=60
DisplayWidth=1920
DisplayHeight=1080
ReflectionsForceHighPrecision=true
ReflectionsExtremePrecision=true
AntialiasingUpScale=1

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

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

[BLOOD]
ReflectionAmount=0.2
SpecularPower=1

[TREE]
LeavesReflectionAmount=0
LeavesSpecularPower=1
LeavesAmbientAmount=1
LeavesColorMultiplier=1
LeavesColorPow=1.2
LeavesColorFilterR=1
LeavesColorFilterG=1
LeavesColorFilterB=1

[BUILDING]
WindowLightIntensity=0.8

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

[LIGHT2] //street light
LightIntensity=0.9
LightAOAmount=1
LightILAmount=0
EdgeLighteningAmount=1
ColorPow=1.5
LightCurve=1
ColorFilterR=1
ColorFilterG=1
ColorFilterB=1

[LIGHT3]
LightIntensity=0.5
LightAOAmount=1
LightILAmount=1
EdgeLighteningAmount=0
ColorPow=1
LightCurve=0.7

[LIGHT4]
LightIntensity=0.1
LightAOAmount=0
LightILAmount=0
EdgeLighteningAmount=0
ColorPow=0.8
LightCurve=1

[LIGHT5]
LightIntensity=1
LightAOAmount=1
LightILAmount=1
EdgeLighteningAmount=0
ColorPow=1
LightCurve=1

[LIGHT6]
LightIntensity=1
LightAOAmount=1
LightILAmount=1
EdgeLighteningAmount=0
ColorPow=1
LightCurve=1

[CARHEADLIGHT]
EmissiveMuliplier=5
LightIntensity=3

[LIGHTSPRITE]
UseExternalTexture=false
Intensity=0
IntensityInReflection=1
UseRays=false
RaysNumber=0
RaysIntensity=0
RaysRateOfChange=0
RaysLength=0

[CARWINDOWGLASS]
ReflectionAmount=0.4
SpecularPower=100
SpecularAmount=2
OpacityMultiplier=1

[CHROME]
ReflectionFront=3.3
ReflectionSide=5.2
SpecularPower=1
SideFade=0
MetallicAmount=0.1

[WHEELS]
ReflectionFront=0.4
ReflectionSide=0.2
SpecularPower=1
SideFade=1
MetallicAmount=0

[REFLECTION1]
ReflectionFront=1.2
ReflectionSide=1.2
SpecularPower=10
SideFade=1
MetallicAmount=0

[REFLECTION2]
ReflectionFront=0.4
ReflectionSide=0.5
SpecularPower=1
SideFade=1

[REFLECTION3]
ReflectionFront=0.4
ReflectionSide=0.5
SpecularPower=1
SideFade=1

[BLOOM]
BloomQuality=0
BlueShiftAmount=0
Radius1=3
Radius2=13
Contrast=1

[SSAO_SSIL]
ApplyAntialiasing=true
SamplingQuality=0
SamplingRange=0
SizeScale=0.9
SourceTexturesScale=1
FilterQuality=0
AOAmount=1.7
ILAmount=1
EdgeLighteningAmount=0.7

[SHADOW]
FilterQuality=0
CharacterShadowMultiplier=1
CarShadowMultiplier=1

[ADAPTATION]
ForceMinMaxValues=true
AdaptationTime=0.05
AdaptationMin=0.1
AdaptationMax=7
AdaptationMinMultiplier=1
AdaptationMaxMultiplier=1

[ENVIRONMENT]
DirectLightingIntensity=2
NightLightingIntensity=1.8
DirectLightingCurve=3.7
ReflectionAmountMultiplier=1
SpecularAmountMultiplier=1
SpecularPowerMultiplier=1
ColorPow=1.3
AmbientSunMultiplier=1
AmbientSkyMultiplier=1
AmbientSunSaturation=1
AmbientSkySaturation=1

[SKYLIGHTING]
FilterQuality=0
AmbientSunMix=1
AmbientSkyMix=1
AmbientContrast=1
AmbientMinLevel=1

[SKY]
AzimuthHeight=2
AzimuthMultiplier=1.5
AzimuthSunAffectPower=2
AzimuthSunAffectAmount=0
TopColorMultiplier=0.5
ColorSaturation=0
ColorPower=1
SunIntensity=1
SunMaxBrightness=100
SunColorFilterR=0.91
SunColorFilterG=0.92
SunColorFilterB=0.88
SunColorFilterCurve=2.7
SunCoronaCurve=2.7
SunCoronaIntensity=3
SunDesaturation=0
OverallPower=1.3
OverallIntensity=1.2
BrightnessUpperLimitMultiplier=1
CloudsUseCustomTexture=true
CloudsCurve=4
CloudsIntensity=8
CloudsDesaturation=0.025
CloudsEdgeClamp=1
CloudsEdgeIntensity=4
CloudsEdgeRange=24
StarsUseCustomTexture=true
StarsAmount=1
StarsIntensity=1
StarsBrightness=1
MoonIntensity=100
MoonGamma=1
MoonSize=0.05
MoonLightingCurve=1
NightCloudsEdgeClamp=1
NightCloudsEdgeIntensity=1
NightCloudsEdgeRange=1
Enable=true

[PARTICLE]
SoftParticlesEnable=true
SoftParticlesEdgeRange=4

[DETAIL]
DetailMapEnable=true

[COLORCORRECTION]
UsePaletteTexture=true



Effect
//++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++
//ProjectRAGE3
//++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++
/*
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 SamplingRange=2; //sharpening or blurring range
float SharpeningAmount=8;
float ScanLineAmount=0;
float ScanLineRepeat=1; //0.5, 0.3333, 0.25, 0.125, so on
float NoiseAmount=0;

//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;
}
}
.
Jalenxt is offline   Reply With Quote