[III|VC|SA] Screenshots and Other Media

[BooMario]

Hello guys Everyone Awesome Screens

I'm Not Join The Competition And This some Screens

Some pics

Great pics man

Sorry for asking that, but how you got that effect in sky, that light effect? Can you give me a tip? Thanks

[Syphonosis]

 

 

Samp Settings.

 

 

[DK22Pac]

aaand i think i found a cool bug, there has a 'shadow' inside 'shadow' cars. Just go around Area 51 and you'll found this:

This thing was even in III and VC, R* called it "Extra shadows". They are generated for player's car if this car is affected by some kinds of light sources.

[Ivars]

[Houssam Ahmed]

Some More Screens

@gatolino:Nice

@Ivars:Nice

[MasterofStrings]

new enb samp

hohohohoho link

[headmetalbanger]

 

Three quickly pics, sad day, I search a good reflections.

 

 

I found the same picture without my signature to the 'ENB Horror competition' because sometimes save two

 

Edited October 24, 2012 by headmetalbanger

[gatolino]

[Gramps]

Not really playable settings for SAMP .. But looks great.

 

Do you want to release your settings for Newbies Pack v4 due around Halloween?

 

@everyone else

Please PM anything that you want included in NPv4, released @ end of this month

 

Current Stats:

979MB Uncompressed

2,132 Files

395 Folders

Edited October 24, 2012 by methodunderg

[Syphonosis]

[q1206455738]

 

 

[ToMz88]

@Every One: Nice Screens.

 

 

[Gramps]

Anyone else here play BFBC2 (Battlefield Bad Company 2) .. PM me and oksa8

[rabiemehdi]

Yeah i play BF2 (in a new account ^^.. my old one (lvl 31) was deleted)

 

ps : what do you think of my signature

[ridhoyanuarr]

@rabiemehdi - nice signature btw

@ToMz88 - hmm dark enb, i think its nice

@q1206455738 - who's timecycle ? yours ?

@Syphonosis -

@gatolino - so smooth

@headmetalbanger -

----------------------------------------------------------------

 

use streaminiextender, add extra black shadow

 

 

[q1206455738]

@ridhoyanuarr Yes

[Marty McFly]

I only play BF3

[rabiemehdi]

@Marty i have Bf3 but i hate this game , the gameplay is crap compared to BFBC2 <3 (i have bf3 , but i can't connect to my account server problem maybe....

 

 

screenshots coming..

 

Edited October 24, 2012 by rabiemehdi

[Euda]

I also play BF3

[Killersnake]

I only play BF3

Lens flares and blue filter the game... BF3 is fun but BC2 is more fun.

[McPlasma]

@Everyone wow! nice screen

 

 

 

 

[Euda]

 

 

[Ivars]

I only play BF3 

Lens flares and blue filter the game... BF3 is fun but BC2 is more fun.

Have you ever played BF3 in MP not just SP?

 

 

@EUDA: Great pics, btw can you PM me that dof effect?

[rabiemehdi]

Realistic reflection , no world reflection on the car ^^

 

 

Normal reflection :

 

[chsJO]

@EVERYONE - Nice

 

 

edit: I do not know how to install the lens flare.

NFS_The_Run_lensflare

Please tell me how to install

Edited October 24, 2012 by chsJO

[Euda]

 

@EUDA: Great pics, btw can you PM me that dof effect?

Thx. It's on 1st page, "Bokeh DoF"

http://www.mediafire.com/view/?7vzz3se337hqnr7

[Ivars]

 

@EUDA: Great pics, btw can you PM me that dof effect?

Thx. It's on 1st page, "Bokeh DoF"

http://www.mediafire.com/view/?7vzz3se337hqnr7

Really? It doesn't look like that for me.

 

edit;

Edited October 24, 2012 by ivars

[Euda]

Hm...

Maybe I sent the wrong link

 

thats the effect.txt:

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// ENBSeries effect file

// visit http://enbdev.com for updates

// Copyright © 2007-2011 Boris Vorontsov

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 

//+++++++++++++++++++++++++++++

// Internal parameters, can be modified

//+++++++++++++++++++++++++++++

float EBlurSamplingRange = 4.0; // not used

float EApertureScale = 4.0;  // not used

 

//+++++++++++++++++++++++++++++

// External parameters, do not modify

//+++++++++++++++++++++++++++++

// Keyboard controlled temporary variables (in some versions exists in the config file). Press and hold key 1,2,3...8 together with PageUp or PageDown to modify.

// By default all set to 1.0

float4 tempF1; //0,1,2,3

float4 tempF2; //5,6,7,8

float4 tempF3; //9,0

// x=Width, y=1/Width, z=ScreenScaleY, w=1/ScreenScaleY

float4 ScreenSize;

// x=generic timer in range 0..1, period of 16777216 ms (4.6 hours), w=frame time elapsed (in seconds)

float4 Timer;

// Adaptation delta time for focusing

float FadeFactor;

 

// textures

texture2D texColor;

texture2D texDepth;

texture2D texNoise;

texture2D texPalette;

texture2D texFocus; // computed focusing depth

texture2D texCurr; // 4*4 texture for focusing

texture2D texPrev; // 4*4 texture for focusing

 

sampler2D SamplerColor = sampler_state

{

Texture  = <texColor>;

MinFilter = LINEAR;

MagFilter = LINEAR;

MipFilter = NONE;

AddressU  = Mirror;

AddressV  = Mirror;

SRGBTexture = FALSE;

MaxMipLevel = 0;

MipMapLodBias = 0;

};

 

sampler2D SamplerDepth = sampler_state

{

Texture  = <texDepth>;

MinFilter = POINT;

MagFilter = POINT;

MipFilter = NONE;

AddressU  = Clamp;

AddressV  = Clamp;

SRGBTexture = FALSE;

MaxMipLevel = 0;

MipMapLodBias = 0;

};

 

sampler2D SamplerNoise = sampler_state

{

Texture  = <texNoise>;

MinFilter = POINT;

MagFilter = POINT;

MipFilter = NONE;

AddressU  = Wrap;

AddressV  = Wrap;

SRGBTexture = FALSE;

MaxMipLevel = 0;

MipMapLodBias = 0;

};

 

sampler2D SamplerPalette = sampler_state

{

Texture  = <texPalette>;

MinFilter = LINEAR;

MagFilter = LINEAR;

MipFilter = NONE;

AddressU  = Clamp;

AddressV  = Clamp;

SRGBTexture = FALSE;

MaxMipLevel = 0;

MipMapLodBias = 0;

};

 

// for focus computation

sampler2D SamplerCurr = sampler_state

{

Texture  = <texCurr>;

MinFilter = LINEAR;

MagFilter = LINEAR;

MipFilter = LINEAR;

AddressU  = Clamp;

AddressV  = Clamp;

SRGBTexture = FALSE;

MaxMipLevel = 0;

MipMapLodBias = 0;

};

 

// for focus computation

sampler2D SamplerPrev = sampler_state

{

Texture  = <texPrev>;

MinFilter = LINEAR;

MagFilter = LINEAR;

MipFilter = NONE;

AddressU  = Clamp;

AddressV  = Clamp;

SRGBTexture = FALSE;

MaxMipLevel = 0;

MipMapLodBias = 0;

};

// for dof only in PostProcess techniques

sampler2D SamplerFocus = sampler_state

{

Texture  = <texFocus>;

MinFilter = LINEAR;

MagFilter = LINEAR;

MipFilter = 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;

};

 

////////////////////////////////////////////////////////////////////

// Begin focusing (by Boris Vorontsov)

////////////////////////////////////////////////////////////////////

VS_OUTPUT_POST VS_Focus(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;

}

 

//SRCpass1X=ScreenWidth;

//SRCpass1Y=ScreenHeight;

//DESTpass2X=4;

//DESTpass2Y=4;

float4 PS_ReadFocus(VS_OUTPUT_POST IN) : COLOR

{

float res = tex2D(SamplerDepth, 0.5).x;

return res;

}

 

//SRCpass1X=4;

//SRCpass1Y=4;

//DESTpass2X=4;

//DESTpass2Y=4;

float4 PS_WriteFocus(VS_OUTPUT_POST IN) : COLOR

{

float res = 0.0;

float curr = tex2D(SamplerCurr, 0.5).x;

float prev = tex2D(SamplerPrev, 0.5).x;

 

res = lerp(prev, curr, saturate(FadeFactor));// time elapsed factor

res = max(res, 0.0);

 

return res;

}

 

technique ReadFocus

{

pass P0

{

  VertexShader = compile vs_3_0 VS_Focus();

  PixelShader  = compile ps_3_0 PS_ReadFocus();

 

  ZEnable = FALSE;

  CullMode = NONE;

  ALPHATESTENABLE = FALSE;

  SEPARATEALPHABLENDENABLE = FALSE;

  AlphaBlendEnable = FALSE;

  FogEnable = FALSE;

  SRGBWRITEENABLE = FALSE;

}

}

 

technique WriteFocus

{

pass P0

{

  VertexShader = compile vs_3_0 VS_Focus();

  PixelShader  = compile ps_3_0 PS_WriteFocus();

 

  ZEnable = FALSE;

  CullMode = NONE;

  ALPHATESTENABLE = FALSE;

  SEPARATEALPHABLENDENABLE = FALSE;

  AlphaBlendEnable = FALSE;

  FogEnable = FALSE;

  SRGBWRITEENABLE = FALSE;

}

}

////////////////////////////////////////////////////////////////////

// End focusing code

////////////////////////////////////////////////////////////////////

 

/*------------------------------------------------------------------------------

      ENB prepass modification 2.0.5 by Matso

        Credits to Boris Vorontsov

------------------------------------------------------------------------------*/

// Effects enabling options

//#define ENABLE_DOF  1  // comment to disable depth of field

#define ENABLE_FAST_DOF 1  // comment to disable fast depth of field (never use both ENABLE_DOF and ENABLE_FAST_DOF - possible game crash or horrible FPS drop)

//#define ENABLE_SHARP 1  // comment to disable sharpening

//#define ENABLE_CHROMA 1  // comment to disable chromatic aberration (additional chromatic aberration applied beyond depth of field)

 

// Methods enabling options

#define USE_CHROMA_DOF 1  // comment it to disable chromatic aberration sampling in DoF

#define USE_SMOOTH_DOF 1  // comment it to disable smooth DoF

#define USE_BOKEH_DOF 1  // comment it to disable bokeh DoF (experimental)

//#define USE_ANAMFLARE 1  // comment it to disable anamorphic lens flare (not working very well -_-)

#define USE_DOUBLE_BLUR 1  // comment it to disable additional blur

 

// Useful constants

#define SEED  Timer.x

#define PI    3.1415926535897932384626433832795

#define CHROMA_POW  65.0        // the bigger the value, the more visible chomatic aberration effect in DoF

 

// Fast DoF constants

#define DOF_SCALE  2356.1944901923449288469825374596 // PI * 750

#define FIRST_PASS  2 // donnot change it!

#define SECOND_PASS  3 // donnot change it!

#define THIRD_PASS  0 // donnot change it!

#define FOURTH_PASS  1 // donnot change it!

#define DOF(sd,sf)  fApertureScale * smoothstep(fApertureBias, fApertureCutoff, abs(sd - sf))

 

// Chromatic aberration parameters

float3 fvChroma = float3(0.995, 1.000, 1.005); // displacement scales of red, green and blue respectively

float fBaseRadius = 0.9;      // below this radius the effect is less visible

float fFalloffRadius = 1.8;      // over this radius the effects is maximal

float fChromaPower = 1.0;      // power of the chromatic displacement (curve of the 'fvChroma' vector)

 

// Sharpen parameters

float fSharpScale = 0.32;      // intensity of sharpening

float2 fvTexelSize = float2(1.0 / 1920.0, 1.0 / 1080.0); // set your resolution sizes

 

// Depth of field parameters

float fFocusBias = 0.045;      // bigger values for nearsightedness, smaller for farsightedness (lens focal point distance)

float fApertureScale = 0.004;    // governs image blur scale (the bigger value, the stronger blur)

float fApertureCutoff = 0.25;    // manages the smoothness of the DoF (bigger value results in wider depth of field)

float fApertureBias = 0.07;      // distance not taken into account in DoF (try out sub-zero values )

 

// (pseudo-) Bokeh parameters

float fBokehCurve = 8.0;      // the larger the value, the more visible the bokeh effect is

//float fBokehBlurFalloff = 4.0;

float fBokehLight = 0.012;      // governs overall brightness of the outcome

 

// Grain parameters

float fGrainFreq = 2000.0;      // movie grain frequency

float fGrainScale = 0.02;      // effect scale

 

// Anamorphic flare parameters (by default not used)

float fLuminance = 0.85;      // bright pass luminance value

float fBlur = 2000.0;      // blur amount, manages the size of the flare

float fIntensity = 0.25;      // effect intensity

 

/**

* Chromatic aberration function - given texture coordinate and a focus value

* retrieves chromatically distorted color of the pixel. Each of the color

* channels are displaced according to the pixel coordinate and its distance

* from the center of the image. Also the DoF out-of-focus value is applied.

* (http://en.wikipedia.org/wiki/Chromatic_aberration)

*/

float4 ChromaticAberration(float2 tex, float outOfFocus)

{

float d = distance(tex, float2(0.5, 0.5));

float f = smoothstep(fBaseRadius, fFalloffRadius, d + outOfFocus * d);

float3 chroma = pow(f + fvChroma, fChromaPower);

 

float2 tr = ((2.0 * tex - 1.0) * chroma.r) * 0.5 + 0.5;

float2 tg = ((2.0 * tex - 1.0) * chroma.g) * 0.5 + 0.5;

float2 tb = ((2.0 * tex - 1.0) * chroma.b) * 0.5 + 0.5;

 

float3 color = float3(tex2D(SamplerColor, tr).r, tex2D(SamplerColor, tg).g, tex2D(SamplerColor, tb).b) * (1.0 - f);

 

return float4(color, 1.0);

}

 

/**

* Chromatic aberration done accoriding to the focus factor provided.

*/

float4 ChromaticAberrationFocus(float2 tex, float outOfFocus)

{

float3 chroma = pow(fvChroma, CHROMA_POW * outOfFocus);

 

float2 tr = ((2.0 * tex - 1.0) * chroma.r) * 0.5 + 0.5;

float2 tg = ((2.0 * tex - 1.0) * chroma.g) * 0.5 + 0.5;

float2 tb = ((2.0 * tex - 1.0) * chroma.b) * 0.5 + 0.5;

 

float3 color = float3(tex2D(SamplerColor, tr).r, tex2D(SamplerColor, tg).g, tex2D(SamplerColor, tb).b) * (1.0 - outOfFocus);

 

return float4(color, 1.0);

}

 

/**

* Pseudo-random number generator - returns a number generated according to the provided vector.

*/

float Random(float2 co)

{

    return frac(sin(dot(co.xy, float2(12.9898, 78.233))) * 43758.5453);

}

 

/**

* Movie grain function - returns a random, time scaled value for the given pixel coordinate.

*/

float Grain(float3 tex)

{

float r = Random(tex.xy);

float grain = sin(PI * tex.z * r * fGrainFreq) * fGrainScale * r;

return grain;

}

 

/**

* Bright pass - rescales sampled pixel to emboss bright enough value.

*/

float3 BrightPass(float2 tex)

{

float3 c = tex2D(SamplerColor, tex).rgb;

    float3 bC = max(c - float3(fLuminance, fLuminance, fLuminance), 0.0);

    float bright = dot(bC, 1.0);

    bright = smoothstep(0.0f, 0.5, bright);

    return lerp(0.0, c, bright);

}

 

float3 BrightColor(float3 c)

{

    float3 bC = max(c - float3(fLuminance, fLuminance, fLuminance), 0.0);

    float bright = dot(bC, 1.0);

    bright = smoothstep(0.0f, 0.5, bright);

    return lerp(0.0, c, bright);

}

 

/**

* Anamorphic sampling function - scales pixel coordinate

* to stratch the image along one of the axels.

* (http://en.wikipedia.org/wiki/Anamorphosis)

*/

float3 AnamorphicSample(int axis, float2 tex, float blur)

{

tex = 2.0 * tex - 1.0;

if (!axis) tex.x /= -blur;

else tex.y /= -blur;

tex = 0.5 * tex + 0.5;

return BrightPass(tex);

}

 

/**

* Converts pixel color to gray-scale.

*/

float GrayScale(float3 sample)

{

return dot(sample, float3(0.3, 0.59, 0.11));

}

 

///// Shaders ////////////////////////////////////////////////////////////////////////////////

// Vertex shader (Boris code)

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;

}

 

// Sharpen pixel shader (Matso code)

float4 PS_ProcessPass_Sharpen(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR

{

float2 coord = IN.txcoord.xy;

float4 Color = 9.0 * tex2D(SamplerColor, coord.xy);

 

Color -= tex2D(SamplerColor, coord.xy + float2(-fvTexelSize.x, fvTexelSize.y) * fSharpScale);

Color -= tex2D(SamplerColor, coord.xy + float2(0.0, fvTexelSize.y) * fSharpScale);

Color -= tex2D(SamplerColor, coord.xy + float2(fvTexelSize.x, fvTexelSize.y) * fSharpScale);

Color -= tex2D(SamplerColor, coord.xy + float2(fvTexelSize.x, 0.0) * fSharpScale);

Color -= tex2D(SamplerColor, coord.xy + float2(fvTexelSize.x, -fvTexelSize.y) * fSharpScale);

Color -= tex2D(SamplerColor, coord.xy + float2(0.0, -fvTexelSize.y) * fSharpScale);

Color -= tex2D(SamplerColor, coord.xy + float2(-fvTexelSize.x, -fvTexelSize.y) * fSharpScale);

Color -= tex2D(SamplerColor, coord.xy + float2(-fvTexelSize.x, 0.0) * fSharpScale);

 

Color.a = 1.0;

return Color;

}

 

// Anamorphic lens flare pixel shader (Matso code)

float4 PS_ProcessPass_Anamorphic(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR

{

float4 res;

float2 coord = IN.txcoord.xy;

float3 anamFlare = AnamorphicSample(0, coord.xy, fBlur) * float3(0.0, 0.0, 1.0);

res.rgb = anamFlare * fIntensity;

res.a = 1.0;

return res;

}

 

// Fast depth of field pixel shader (Matso code)

float4 PS_ProcessPass_FastDoF(VS_OUTPUT_POST IN, float2 vPos : VPOS, uniform int axis) : COLOR

{

float4 res;

float2 coord = IN.txcoord.xy;

float4 tcol = tex2D(SamplerColor, coord.xy);

float sd = tex2D(SamplerDepth, coord).x;

 

#ifndef USE_SMOOTH_DOF

float sf = tex2D(SamplerDepth, 0.5).x - fFocusBias;

#else

float sf = tex2D(SamplerFocus, 0.5).x - fFocusBias * 2.0;

#endif

float outOfFocus = DOF(sd, sf);

 

float offset[4] = { -1.282, -0.524, 0.524, 1.282 };

float2 tdirs[4] = { float2(1.0, 0.0), float2(0.0, 1.0), float2(0.707, 0.707), float2(-0.707, 0.707) };

//float2 taps[4] = { float2(-1.282, 0.524), float2(0.524, -1.282), float2(-1.282, -0.524), float2(0.524, 1.282) };

float blur = DOF_SCALE * outOfFocus;

#ifdef USE_BOKEH_DOF

float wValue = (1.0 + pow(length(tcol.rgb) + 0.1, fBokehCurve)) * (1.0 - fBokehLight); // special recipe from papa Matso

#else

float wValue = 1.0;

#endif

 

tdirs[axis].x *= fvTexelSize.x;

tdirs[axis].y *= fvTexelSize.y;

 

#ifdef USE_BOKEH_DOF

blur *= 0.25;

#endif

 

for (int i = 0; i < 4; i++)

{

  //float2 t = taps * fvTexelSize;

 

  float2 tdir = offset * tdirs[axis] * blur;

  //float2 tdir = blur * (tdirs[axis] + t);

  coord.xy = IN.txcoord.xy + tdir.xy;

#ifdef USE_CHROMA_DOF

  float4 ct = ChromaticAberrationFocus(coord.xy, outOfFocus);

#else

  float4 ct = tex2D(SamplerColor, coord.xy);

#endif

 

#ifndef USE_BOKEH_DOF

  float w = 1.0 + abs(offset); // weight blur for better effect

#else

  float ds = tex2D(SamplerDepth, coord.xy).x;

  float offs = DOF(ds, sf);

 

#if USE_BOKEH_DOF == 1 // my own pseudo-bokeh weighting

  float b = GrayScale(ct.rgb) + length(ct.rgb) + 0.1;

  float w = pow(b, fBokehCurve) + abs(offset);

#endif

#endif

  tcol += ct * w;

  wValue += w;

}

 

tcol /= wValue;

 

res.xyz = tcol.xyz;

res.w = 1.0;

return res;

}

 

// Chromatic abrration with no DoF (Matso code)

float4 PS_ProcessPass_Chroma(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR

{

float2 coord = IN.txcoord.xy;

float4 result = ChromaticAberration(coord.xy, 0.0);

result.a = 1.0;

return result;

}

 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef ENABLE_SHARP

technique PostProcess

{

  pass P0

  {

  VertexShader = compile vs_3_0 VS_PostProcess();

  PixelShader  = compile ps_3_0 PS_ProcessPass_Sharpen();

 

  DitherEnable = FALSE;

  ZEnable = FALSE;

  CullMode = NONE;

  ALPHATESTENABLE = FALSE;

  SEPARATEALPHABLENDENABLE = FALSE;

  AlphaBlendEnable = FALSE;

  StencilEnable = FALSE;

  FogEnable = FALSE;

  SRGBWRITEENABLE = FALSE;

  }

  #ifdef USE_ANAMFLARE

  pass P1

  {

    AlphaBlendEnable = true;

    SrcBlend = One;

    DestBlend = One;

   

    PixelShader = compile ps_3_0 PS_ProcessPass_Anamorphic();

  }

  #endif

}

#endif

 

#ifndef ENABLE_FAST_DOF

#ifdef ENABLE_CHROMA

  #ifndef ENABLE_SHARP

  technique PostProcess

  #else

  technique PostProcess2

  #endif

  {

  pass P0

  {

    VertexShader = compile vs_3_0 VS_PostProcess();

    PixelShader  = compile ps_3_0 PS_ProcessPass_Chroma();

 

    DitherEnable = FALSE;

    ZEnable = FALSE;

    CullMode = NONE;

    ALPHATESTENABLE = FALSE;

    SEPARATEALPHABLENDENABLE = FALSE;

    AlphaBlendEnable = FALSE;

    StencilEnable = FALSE;

    FogEnable = FALSE;

    SRGBWRITEENABLE = FALSE;

  }

  }

#endif

#endif

 

#ifndef ENABLE_CHROMA

#ifdef ENABLE_FAST_DOF

  #ifndef ENABLE_SHARP

  technique PostProcess

  #else

  technique PostProcess2

  #endif

  {

  pass P0

  {

    VertexShader = compile vs_3_0 VS_PostProcess();

    PixelShader  = compile ps_3_0 PS_ProcessPass_FastDoF(FIRST_PASS);

 

    DitherEnable = FALSE;

    ZEnable = FALSE;

    CullMode = NONE;

    ALPHATESTENABLE = FALSE;

    SEPARATEALPHABLENDENABLE = FALSE;

    AlphaBlendEnable = FALSE;

    StencilEnable = FALSE;

    FogEnable = FALSE;

    SRGBWRITEENABLE = FALSE;

  }

  }

 

  #ifndef ENABLE_SHARP

  technique PostProcess2

  #else

  technique PostProcess3

  #endif

  {

  pass P0

  {

    VertexShader = compile vs_3_0 VS_PostProcess();

    PixelShader  = compile ps_3_0 PS_ProcessPass_FastDoF(SECOND_PASS);

 

    DitherEnable = FALSE;

    ZEnable = FALSE;

    CullMode = NONE;

    ALPHATESTENABLE = FALSE;

    SEPARATEALPHABLENDENABLE = FALSE;

    AlphaBlendEnable = FALSE;

    StencilEnable = FALSE;

    FogEnable = FALSE;

    SRGBWRITEENABLE = FALSE;

  }

  }

 

  #ifdef USE_DOUBLE_BLUR

  #ifndef ENABLE_SHARP

    technique PostProcess3

  #else

    technique PostProcess4

  #endif

  {

    pass P0

    {

    VertexShader = compile vs_3_0 VS_PostProcess();

    PixelShader  = compile ps_3_0 PS_ProcessPass_FastDoF(THIRD_PASS);

 

    DitherEnable = FALSE;

    ZEnable = FALSE;

    CullMode = NONE;

    ALPHATESTENABLE = FALSE;

    SEPARATEALPHABLENDENABLE = FALSE;

    AlphaBlendEnable = FALSE;

    StencilEnable = FALSE;

    FogEnable = FALSE;

    SRGBWRITEENABLE = FALSE;

    }

  }

 

  #ifndef ENABLE_SHARP

    technique PostProcess4

  #else

    technique PostProcess5

  #endif

  {

    pass P0

    {

    VertexShader = compile vs_3_0 VS_PostProcess();

    PixelShader  = compile ps_3_0 PS_ProcessPass_FastDoF(FOURTH_PASS);

 

    DitherEnable = FALSE;

    ZEnable = FALSE;

    CullMode = NONE;

    ALPHATESTENABLE = FALSE;

    SEPARATEALPHABLENDENABLE = FALSE;

    AlphaBlendEnable = FALSE;

    StencilEnable = FALSE;

    FogEnable = FALSE;

    SRGBWRITEENABLE = FALSE;

    }

  }

  #endif

#endif

#endif

 

[GameModder8]

What's wrong? No one has posted his competition screenshot yet

 

I've got a little question on my screenshot. Am I allowed to convert it with a simple image converter from a .bmp to a .jpg file to be able to upload it on imagebam?

[Ivars]

What's wrong? No one has posted his competition screenshot yet

 

I've got a little question on my screenshot. Am I allowed to convert it with a simple image converter from a .bmp to a .jpg file to be able to upload it on imagebam?

Better upload orginal image (bmp) in imageshack for better quality. Jpeg ruins pictures.