Sorry your browser is not supported!

texture theTex < string Name=""; >;  

texture g_Tex;
sampler2D s = sampler_state
{
	Texture = <g_Tex>;
};

texture g_Tex;
sampler2D s = sampler_state
{
	Texture = <g_Tex>;
};

float4 Desaturate_Average (float2 texCoords : TEXCOORD0) : COLOR
{
	float4 In = tex2D(s, texCoords);
	float Grey = (In.x + In.y + In.z) / 3.0;
	return float4(Grey, Grey, Grey, In.w);
}

sampler2D s = sampler_state
{
	Texture = <g_Tex>;
	MinFilter = POINT;
	MagFilter = POINT;
	MipFilter = NONE;
};

LOAD EFFECT Filename, Effect Number, Texture Flag

Lee's Tip of the Month - Native Post-Processing

More tips from Lee Bamber

Up until now if you wanted to do post-processing in DBP you had to create
 lots of cameras and execute a FASTSYNC chain or use a DarkSHADER module
 to handle the shader for you. Both of these had drawbacks in that you had
 to either rely on an additional module that duplicated many of the 
internal features of DBP, or have a program that was extremely difficult 
to read and maintain.


Thankfully, through some necessary migration work in the FPSC camp, DBP 
has been given a new built-in feature which allows a third alternative to 
post-processing. For those who are interested to learn about this, 
post-processing is the technique by which you can create things like Bloom 
and Depth Of Field effects to create glows around your bright areas of the 
screen and blur out more distant objects much like a real camera would.


The new addition was the support of the RENDERCOLORTARGET semantic in the
 FX shader effect. Previously this instruction was ignored to keep the 
shader system simple, but the benefit of an elegant coding solution was 
too important to ignore. Thanks to this semantic, you can now declare a 
shader texture like this:


texture Downsample1Img : RENDERCOLORTARGET 
< 
int width = 1024;
int height = 768;
>;

What this means is that you are creating a texture inside the shader which
 will be dynamically created for the purpose of rendering something to it, 
and it will be destroyed when no longer needed. This allows you to 
redirect the output render of a render pass as follows:


pass Downsample
<
string RenderColorTarget = "Downsample1Img";
>
{
ZEnable = False;
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_2_0 PSDownsample( frameSamp );
}

As you can see we can now specify the render target as "Downsample1Img" 
and feed in our original texture which is passed in as "frameSamp". 
Finally when you are ready to render to the actual backbuffer, you simply 
omit the RenderColorTarget declaration and it will revert to its default 
behaviour, so:

pass Final
<
string RenderColorTarget = "";
>
{
ZEnable = False;
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_2_0 PSDownsample( Downsample1Samp );
}

So you can see how the result of the previous process is passed into the 
final iteration where it will be rendered to the backbuffer (our screen). 
For example, to create bloom:


    * take the original frame image, which would until now have been your screen
    * shrink it by rendering it to a smaller texture
    * shrink it again to an even smaller texture (this retains image detail)
    * blur the contents of this smallest texture twice or more
    * add the contents of this final blurred shrunk texture to the original frame image you started with

Bloom Effect

By controlling how much of the colour from the original frame image is 
passed into the process of shrinking and blurring you can control how much 
glow you get in your final screen render. Depth of field works in a 
similar way, with a lengthy series of rendering to secondary internal 
textures, but this time we pass in how far the pixel is away from the 
camera and use that information to decide how much we should blur the 
pixel. Pixels which are closest to the focal point in the scene are 
blurred the least, with the most blur occurring in the distance and in 
some cases when the pixel is very close to the camera.


Thanks to the new feature, you no longer have to create extra cameras to 
hold the render targets as you pass images from one step to the next to 
conduct your full screen effects, and all inside the native DBP support 
for FX effects. This feature will be available in the final U75 update, 
and you will also be able to see the code and shaders for the technique 
when we release the V117 source code of FPS Creator. With post-processing 
only taking about four lines of code now, there is no reason why you 
should not have bloom in your DBP creations with U75. If you want to be 
advised when the U75 is released just subscrive to our Twitter or Facebook 
feeds and we'll announce it as soon as it's live. 

sync on: sync
set display mode desktop width(), desktop height(), 32
reload display pointer

autocam off
position camera 0, 0, -600
point camera 0, 0, 0

` make some objects in the scene
for i = 2 to 10
  make object sphere i, rnd(50) + 20
  position object i, rnd(400) - 200, rnd(300) - 150, rnd(200)
  color object i, rgb(rnd(255), rnd(255), rnd(255))
next i

load camera effect "BlurGG v2.fx", 1, 0
set camera effect 0, 1, 1

null = make vector4(1)
set vector4 1, 1.0/screen width(), 1.0/screen height(), 0, 0
set camera effect constant vector 1, "InvViewSize", 1 ` NB - used by both shaders

` initialise amount of blur
global blurAmount#
blurAmount# = 3.0

repeat
  
  sync camera 0
  paste image 1, 0,1
  `texture screen here will overwrite text
   
  text 20, 20, "FPS = " + str$(screen fps())
  text 20, 50, "Press b/n to increase/decrease amount of blur:   " + str$(blurAmount#, 4)
  text 20, 80, "Press <space> to exit"
  
  controlBlur()
  
  set camera effect constant float 1, "BlurAmount", blurAmount#

until spacekey()