Jump to content
  • Advertisement
Sign in to follow this  
alt3

[.net] [fixed] pixel shader that take not in account input texture

This topic is 3398 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hi i'm wondering the following code render an empty texture:
            postProcesses.SetValue("g_txSrcColor", intermediateRenderTexture);

            postProcesses.Technique = "PostProcessdoNothing";

            int numPasses = postProcesses.Begin(0);

            for (int passe = 0; passe < numPasses; passe++)
            {
                device.SetRenderTarget(0, backbufferColor);
                device.Clear(ClearFlags.Target, System.Drawing.Color.BlueViolet, 1.0f, 0);

                postProcesses.BeginPass(passe);
                device.SetStreamSource(0, iVertexBuffer, 0);
                device.VertexFormat = PPVERT.FVF;
                device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
                postProcesses.EndPass();
            }

            postProcesses.End();


the intermediateRenderTexture looks like as input: intermediateRenderTexture the code for postProcesses FX is the following:
texture g_txSrcColor;
sampler2D g_samSrcColor =
sampler_state
{
    Texture = <g_txSrcColor>;
    AddressU = Clamp;
    AddressV = Clamp;
    MinFilter = Point;
    MagFilter = Linear;
    MipFilter = Linear;
};
//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSNothing
// Desc: Performs post-processing effect that do nothing
//-----------------------------------------------------------------------------

float4 PostProcessPSNothing(float2 Tex : TEXCOORD0) : COLOR
{
    return tex2D( g_samSrcColor, Tex.xy);
}

//-------------------------------------
// Technique: PostProcessdoNothing
// Desc: Performs post-processing effect that do nothing

technique PostProcessdoNothing
{
    pass p0
    {
        VertexShader = null;
        PixelShader = compile ps_2_0 PostProcessPSNothing();
        ZEnable = false;
    }
}



backbufferColor Can anyone help me to find what's wrong ? Thanks in advance, alt3. Edit: i'm using c#, .net 2.0, mdx1.1, vs2008, and there is no particular trick about renderState. iVertexBuffer and PPVERT.FVF is a simple quad and its vertexformat (position, textured) [Edited by - alt3 on April 26, 2009 8:50:14 AM]

Share this post


Link to post
Share on other sites
Advertisement
First, don't use mdx. It's deprecated, obsolete, and just plain sucks. Use Xna or SlimDX instead.

Some ideas:
- Why are you clearing with each pass?
- Make sure the quad you're rendering the post processing to has it's texture coordinates defined. Better yet, render it to a sprite. There's information on the internet about how to use a custom pixel shader with sprites.
- Make sure the vertices' FVF is defined correctly.

That's all I can think of based on what you've shown us.

Share this post


Link to post
Share on other sites
Thanks for your response.

Quote:
Original post by gharen2
First, don't use mdx. It's deprecated, obsolete, and just plain sucks. Use Xna or SlimDX instead.

How much load does i expect to have in case of switch to XNA or SlimDX ?


Quote:
Original post by gharen2
- Why are you clearing with each pass?

It is of course unecessary. However, theses lines of code are taken from old code of mine that worked. After a refactor, i've got this problem, and i've tried to have the same behaviour as before, as a testing point of view.

Quote:
Original post by gharen2
- Make sure the quad you're rendering the post processing to has it's texture coordinates defined. Better yet, render it to a sprite. There's information on the internet about how to use a custom pixel shader with sprites.
- Make sure the vertices' FVF is defined correctly.[/qu

OK, i'll check that.
All seems to be good:

public struct PPVERT
{
public Vector4 Position;
public float tu, tv;
public float tu2, tv2;
public static readonly VertexFormats FVF = VertexFormats.PositionW | VertexFormats.Texture2;

public static VertexElement[] Decl =
{
new VertexElement(0,0,DeclarationType.Float4, DeclarationMethod.Default, DeclarationUsage.PositionTransformed, 0),
new VertexElement(0,16,DeclarationType.Float4, DeclarationMethod.Default, DeclarationUsage.TextureCoordinate, 0),
new VertexElement(0,24,DeclarationType.Float4, DeclarationMethod.Default, DeclarationUsage.TextureCoordinate, 1),
VertexElement.VertexDeclarationEnd
};
}

private static void applyPostProcesses()
{
SurfaceDescription backBufferDesc = backbufferColor.Description;

VertexBuffer vertexBuffer = new VertexBuffer(
typeof(PPVERT),
4,
device,
Usage.WriteOnly,
PPVERT.FVF,
Pool.Default);


PPVERT[] quad = (PPVERT[])vertexBuffer.Lock(0, 0);

{
quad[0] = new PPVERT();
quad[0].Position = new Vector4(0.0f, 0.0f, 1.0f, 1.0f);
quad[0].tu = 0.0f;
quad[0].tv = 0.0f;
quad[0].tu2 = 0.0f;
quad[0].tv2 = 0.0f;

quad[1] = new PPVERT();
quad[1].Position = new Vector4(0.0f, backBufferDesc.Height, 1.0f, 1.0f);
quad[1].tu = 0.0f;
quad[1].tv = 1.0f;
quad[1].tu2 = 0.0f;
quad[1].tv2 = 1.0f;

quad[2] = new PPVERT();
quad[2].Position = new Vector4(backBufferDesc.Width, 0.0f, 1.0f, 1.0f);
quad[2].tu = 1.0f;
quad[2].tv = 0.0f;
quad[2].tu2 = 1.0f;
quad[2].tv2 = 0.0f;

quad[3] = new PPVERT();
quad[3].Position = new Vector4(backBufferDesc.Width, backBufferDesc.Height, 1.0f, 1.0f);
quad[3].tu = 1.0f;
quad[3].tv = 1.0f;
quad[3].tu2 = 1.0f;
quad[3].tv2 = 1.0f;
}

vertexBuffer.Unlock();

PerformSinglePostProcess(vertexBuffer);//, quad);

vertexBuffer.Dispose();
}

private static void PerformSinglePostProcess(VertexBuffer iVertexBuffer)//, PPVERT[] quad)
{
device.VertexDeclaration = new VertexDeclaration(device, PPVERT.Decl);

postProcesses.SetValue("g_txSrcColor", intermediateRenderTexture);

TextureLoader.Save("d:\\tmp\\intermediateRenderTexture.png", ImageFileFormat.Png, intermediateRenderTexture);
SurfaceLoader.Save("d:\\tmp\\intermediateRenderTarget.png", ImageFileFormat.Png, intermediateRenderTarget);
// Validated techniques:
// * PostProcessInvert
// * PostProcessGreenExtraction
// * PostProcessMoreColor
// * PostProcessMultiSampleBlur
// * PostProcessMultiSampleSharp
// * PostProcessEmboss
// * PostProcessdoNothing
// * PostProcessBloomH
// * PostProcessBloomV
// * PostProcessTVization
postProcesses.Technique = "PostProcessdoNothing";


device.SetRenderTarget(0, backbufferColor);
//device.SetRenderTarget(0, intermediateRenderTarget);

device.Clear(ClearFlags.Target, System.Drawing.Color.BlueViolet, 1.0f, 0);

int numPasses = postProcesses.Begin(0);

for (int passe = 0; passe < numPasses; passe++)
{

postProcesses.BeginPass(passe);
device.SetStreamSource(0, iVertexBuffer, 0);
device.VertexFormat = PPVERT.FVF;
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
postProcesses.EndPass();
}

postProcesses.End();
SurfaceLoader.Save("d:\\tmp\\backbufferColor.png", ImageFileFormat.Png, backbufferColor);
}




[Edited by - alt3 on April 18, 2009 9:23:51 AM]

Share this post


Link to post
Share on other sites
Seem to be shader technique issue.
I don't really understand since these technique are working in another environment, as FX Composer.

Here is the code of the debugged techniques:

// ----------------------------------------------------------------------------
// Samplers & textures
//

texture g_txSrcColor;
texture g_txSrcNormal;
texture g_txSrcPosition;
texture g_txSrcVelocity;

texture g_txSceneColor;
texture g_txSceneNormal;
texture g_txScenePosition;
texture g_txSceneVelocity;

sampler2D g_samSrcColor =
sampler_state
{
Texture = <g_txSrcColor>;
AddressU = Clamp;
AddressV = Clamp;
MinFilter = Point;
MagFilter = Linear;
MipFilter = Linear;
};
sampler2D g_samSrcNormal =
sampler_state
{
Texture = <g_txSrcNormal>;
AddressU = Clamp;
AddressV = Clamp;
MinFilter = Point;
MagFilter = Linear;
MipFilter = Linear;
};
sampler2D g_samSrcPosition =
sampler_state
{
Texture = <g_txSrcPosition>;
AddressU = Clamp;
AddressV = Clamp;
MinFilter = Point;
MagFilter = Linear;
MipFilter = Linear;
};
sampler2D g_samSrcVelocity =
sampler_state
{
Texture = <g_txSrcVelocity>;
AddressU = Clamp;
AddressV = Clamp;
MinFilter = Point;
MagFilter = Linear;
MipFilter = Linear;
};

sampler2D g_samSceneColor = sampler_state
{
Texture = <g_txSceneColor>;
AddressU = Clamp;
AddressV = Clamp;
MinFilter = Point;
MagFilter = Linear;
MipFilter = Linear;
};
sampler2D g_samSceneNormal = sampler_state
{
Texture = <g_txSceneNormal>;
AddressU = Clamp;
AddressV = Clamp;
MinFilter = Point;
MagFilter = Linear;
MipFilter = Linear;
};
sampler2D g_samScenePosition = sampler_state
{
Texture = <g_txScenePosition>;
AddressU = Clamp;
AddressV = Clamp;
MinFilter = Point;
MagFilter = Linear;
MipFilter = Linear;
};
sampler2D g_samSceneVelocity = sampler_state
{
Texture = <g_txSceneVelocity>;
AddressU = Clamp;
AddressV = Clamp;
MinFilter = Point;
MagFilter = Linear;
MipFilter = Linear;
};

// ----------------------------------------------------------------------------
// Vertex shader related
//

struct VS_INPUT
{
float4 screenPos : POSITION;
float4 texture0 : TEXCOORD0;
};

struct VS_OUTPUT
{
float4 hposition : POSITION;
float4 Tex : TEXCOORD0;
};

VS_OUTPUT PostProcessVS(VS_INPUT IN)
{
VS_OUTPUT OUT;

OUT.hposition = IN.screenPos;

OUT.hposition.x = (OUT.hposition.x - 150)/150 ;
OUT.hposition.y = (150 - OUT.hposition.y)/150 ;

OUT.Tex = IN.texture0;

return OUT;
}

// ----------------------------------------------------------------------------
// Globales & variables
//

static const int g_cKernelSize = 13;

float2 TexelKernel[g_cKernelSize]
<
string ConvertPixelsToTexels = "PixelKernel";
>;

static const float BlurWeights[g_cKernelSize] =
{
0.002216,
0.008764,
0.026995,
0.064759,
0.120985,
0.176033,
0.199471,
0.176033,
0.120985,
0.064759,
0.026995,
0.008764,
0.002216,
};

float BloomScale = 1.5f;

// ----------------------------------------------------------------------------
// Effects & Techniques
//

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSTVization
//-----------------------------------------------------------------------------

float4 PostProcessPSTVization(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
float4 Color;

Color = tex2D( g_samSrcColor, IN.Tex.xy);

float Mult;

if (vPos.y%2 == 0)
{
Mult = 2.0;
}
else
{
Mult = 1.0;
}

Color.r = Color.r * Mult;
Color.g = Color.g * Mult;
Color.b = Color.b * Mult;

return Color;
}

//-------------------------------------
// Technique: PostProcessTVization


technique PostProcessTVization
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSTVization();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSInvert
// Desc: Performs post-processing effect that converts a colored image to
// its inverse.
//-----------------------------------------------------------------------------

float4 PostProcessPSInvert(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
return 1.0f - tex2D( g_samSrcColor, IN.Tex.xy);
}

//-------------------------------------
// Technique: PostProcessInvert
// Desc: Performs post-processing effect that converts a colored image to
// its inverse.

technique PostProcessInvert
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSInvert();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSGreenExtraction
// Desc: Performs post-processing effect that converts a colored image to
// conserve only green component.
//-----------------------------------------------------------------------------

float4 PostProcessPSGreenExtraction(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
float4 Color;

Color = tex2D( g_samSrcColor, IN.Tex.xy);

Color.r = 0.0;
Color.b = 0.0;

return Color;
}

//-------------------------------------
// Technique: PostProcessGreenExtraction
// Desc: Performs post-processing effect that converts a colored image to
// conserve only green component.

technique PostProcessGreenExtraction
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSGreenExtraction();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSMoreColor
// Desc: Performs post-processing effect that converts a colored image to
// multiply color value.
//-----------------------------------------------------------------------------

float4 PostProcessPSMoreColor(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
return tex2D( g_samSrcColor, IN.Tex.xy)*2;
}

//-------------------------------------
// Technique: PostProcessMoreColor
// Desc: Performs post-processing effect that converts a colored image to
// multiply color value.

technique PostProcessMoreColor
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSMoreColor();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSMultiSampleBlur
// Desc: Performs post-processing effect that blur an image
//-----------------------------------------------------------------------------

float4 PostProcessPSMultiSampleBlur(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
float4 Color;

Color = tex2D( g_samSrcColor, IN.Tex.xy);
Color += tex2D( g_samSrcColor, IN.Tex.xy+0.001);
Color += tex2D( g_samSrcColor, IN.Tex.xy+0.002);
Color += tex2D( g_samSrcColor, IN.Tex.xy+0.003);

Color = Color / 4;

return Color;
}

//-------------------------------------
// Technique: PostProcessMultiSampleBlur
// Desc: Performs post-processing effect that blur an image

technique PostProcessMultiSampleBlur
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSMultiSampleBlur();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSMultiSampleSharp
// Desc: Performs post-processing effect that sharp an image
//-----------------------------------------------------------------------------

float4 PostProcessPSMultiSampleSharp(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
float4 Color;

Color = tex2D( g_samSrcColor, IN.Tex.xy);
Color -= tex2D( g_samSrcColor, IN.Tex.xy+0.0001)*10.0f;
Color += tex2D( g_samSrcColor, IN.Tex.xy-0.0001)*10.0f;

return Color;
}

//-------------------------------------
// Technique: PostProcessMultiSampleSharp
// Desc: Performs post-processing effect that sharp an image

technique PostProcessMultiSampleSharp
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSMultiSampleSharp();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSEmboss
// Desc: Performs post-processing effect that emboss an image
//-----------------------------------------------------------------------------

float4 PostProcessPSEmboss(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
float4 Color;

Color.a = 1.0f;
Color.rgb = 0.5f;
Color -= tex2D( g_samSrcColor, IN.Tex.xy-0.001)*2.0f;
Color += tex2D( g_samSrcColor, IN.Tex.xy+0.001)*2.0f;
Color.rgb = (Color.r+Color.g+Color.b)/3.0f;

return Color;
}

//-------------------------------------
// Technique: PostProcessEmboss
// Desc: Performs post-processing effect emboss emboss an image

technique PostProcessEmboss
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSEmboss();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}


//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSNothing
// Desc: Performs post-processing effect that do nothing
//-----------------------------------------------------------------------------

float4 PostProcessPSNothing(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
return tex2D( g_samSrcColor, IN.Tex.xy);
}

//-------------------------------------
// Technique: PostProcessdoNothing
// Desc: Performs post-processing effect that do nothing

technique PostProcessdoNothing
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSNothing();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSBloomH
// Desc: Performs post-processing effect that bloom horizontaly
//-----------------------------------------------------------------------------

float4 PostProcessPSBloomH(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
float4 Color = 0;

for (int i = 0; i < g_cKernelSize; i++)
{
Color += tex2D( g_samSrcColor, IN.Tex + TexelKernel.xy ) * BlurWeights;
}

return Color * BloomScale;
}

//-----------------------------------------------------------------------------
// Technique: PostProcessBloomH
// Desc: Performs post-processing effect that bloom horizontaly

technique PostProcessBloomH
<
string Parameter0 = "BloomScale";
float4 Parameter0Def = float4( 1.5f, 0, 0, 0 );
int Parameter0Size = 1;
string Parameter0Desc = " (float)";
>
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSBloomH();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}

//-----------------------------------------------------------------------------
// Pixel Shader: PostProcessPSBloomV
// Desc: Performs post-processing effect that bloom vertically
//-----------------------------------------------------------------------------
float4 PostProcessPSBloomV(VS_OUTPUT IN, float2 vPos: VPOS) : COLOR0
{
float4 Color = 0;

for (int i = 0; i < g_cKernelSize; i++)
{
Color += tex2D( g_samSrcColor, IN.Tex + TexelKernel.xy ) * BlurWeights;
}

return Color * BloomScale;
}


//-------------------------------------
// Technique: PostProcessBloomV
// Desc: Performs post-processing effect that bloom vertically

technique PostProcessBloomV
<
string Parameter0 = "BloomScale";
float4 Parameter0Def = float4( 1.5f, 0, 0, 0 );
int Parameter0Size = 1;
string Parameter0Desc = " (float)";
>
{
pass p0
{
VertexShader = compile vs_3_0 PostProcessVS();
PixelShader = compile ps_3_0 PostProcessPSBloomV();

AlphaBlendEnable = false;
ZEnable = false;
CullMode = None;
FillMode = Solid; // (even if wireframe is turned on)
}
}



Thanks for reading.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!