Take the 2-minute tour ×
Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

I am coding in C# using Windows Forms and the SlimDX API to show the effect of a pixel shader. When I am setting the pixel shader, I am getting a black output screen but if I am not using the pixel shader then I am getting my image rendered on the screen. I have the following C# code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using SlimDX.Direct3D9;
using SlimDX;
using SlimDX.Windows;
using System.Drawing;
using System.Threading;

namespace WindowsFormsApplication1
  {
     // Vertex structure.
[StructLayout(LayoutKind.Sequential)]
struct Vertex
{
    public Vector3 Position;
    public float Tu;
    public float Tv;

    public static int SizeBytes
    {
        get { return Marshal.SizeOf(typeof(Vertex)); }
    }

    public static VertexFormat Format
    {
        get { return VertexFormat.Position | VertexFormat.Texture1; }
    }
}


static class Program
{
    public static Device D3DDevice;         // Direct3D device.
    public static VertexBuffer Vertices;    // Vertex buffer object used to hold vertices.
    public static Texture Image;            // Texture object to hold the image loaded from a file.
    public static int time;                 // Used for rotation caculations.
    public static float angle;              // Angle of rottaion.
    public static Form1 Window =new Form1();
    public static  string filepath;
    static VertexShader vertexShader = null;
    static ConstantTable constantTable = null;
    static ImageInformation info;
    [STAThread]
    static void Main()
    {

        filepath = "C:\\Users\\Public\\Pictures\\Sample Pictures\\Garden.jpg";




        info = new ImageInformation();
        info = ImageInformation.FromFile(filepath);

        PresentParameters presentParams = new PresentParameters();

        // Below are the required bare mininum, needed to initialize the D3D device.
        presentParams.BackBufferHeight = info.Height;         // BackBufferHeight, set to  the Window's height.
        presentParams.BackBufferWidth = info.Width+200;          // BackBufferWidth, set to  the Window's width.




        presentParams.Windowed =true; 
        presentParams.DeviceWindowHandle = Window.panel2 .Handle;                       // DeviceWindowHandle, set to  the Window's handle.

        // Create the device.
        D3DDevice = new Device(new Direct3D (), 0, DeviceType.Hardware, Window.Handle, CreateFlags.HardwareVertexProcessing, presentParams);

        // Create the vertex buffer and fill with the triangle vertices. (Non-indexed)
        // Remember 3 vetices for a triangle, 2 tris per quad = 6.
        Vertices = new VertexBuffer(D3DDevice, 6 * Vertex.SizeBytes, Usage.WriteOnly, VertexFormat.None, Pool.Managed);
        DataStream stream = Vertices.Lock(0, 0, LockFlags.None);
        stream.WriteRange(BuildVertexData());
        Vertices.Unlock();

        // Create the texture.

        Image = Texture.FromFile(D3DDevice,filepath );

        // Turn off culling, so we see the front and back of the triangle
        D3DDevice.SetRenderState(RenderState.CullMode, Cull.None);

        // Turn off lighting
        D3DDevice.SetRenderState(RenderState.Lighting, false);


        ShaderBytecode sbcv = ShaderBytecode.CompileFromFile("C:\\Users\\yashwinder singh\\Desktop\\vertexShader.vs", "vs_main", "vs_1_1", ShaderFlags.None);
        constantTable = sbcv.ConstantTable;
        vertexShader = new VertexShader(D3DDevice, sbcv);


        ShaderBytecode sbc = ShaderBytecode.CompileFromFile("C:\\Users\\yashwinder singh\\Desktop\\pixelShader.txt", "ps_main", "ps_3_0", ShaderFlags.None);
        PixelShader ps = new PixelShader(D3DDevice, sbc);

        VertexDeclaration vertexDecl = new VertexDeclaration(D3DDevice, new[] {
                            new VertexElement(0, 0, DeclarationType.Float3, DeclarationMethod.Default, DeclarationUsage.PositionTransformed, 0), 
                            new VertexElement(0, 12, DeclarationType.Float2 , DeclarationMethod.Default, DeclarationUsage.TextureCoordinate , 0), 
                            VertexElement.VertexDeclarationEnd
            });

        Application.EnableVisualStyles();

        MessagePump.Run(Window, () =>
            {
                // Clear the backbuffer to a black color.
                D3DDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);

                // Begin the scene.
                D3DDevice.BeginScene();



                // Setup the world, view and projection matrices.



                //D3DDevice.VertexShader = vertexShader;
                //D3DDevice.PixelShader = ps;

                // Render the vertex buffer.
                D3DDevice.SetStreamSource(0, Vertices, 0, Vertex.SizeBytes);
                D3DDevice.VertexFormat = Vertex.Format;

                // Setup our texture. Using Textures introduces the texture stage states,
                // which govern how Textures get blended together (in the case of multiple
                // Textures) and lighting information.
                D3DDevice.SetTexture(0, Image);


                // Now drawing 2 triangles, for a quad.
                D3DDevice.DrawPrimitives(PrimitiveType.TriangleList   , 0, 2);

                // End the scene.
                D3DDevice.EndScene();

                // Present the backbuffer contents to the screen.
                D3DDevice.Present();

            }); 
        if (Image != null)
            Image.Dispose();

        if (Vertices != null)
            Vertices.Dispose();

        if (D3DDevice != null)
            D3DDevice.Dispose();


    }
    private static Vertex[] BuildVertexData()
    {
        Vertex[] vertexData = new Vertex[6];

        vertexData[0].Position = new Vector3(-1.0f, 1.0f, 0.0f);
        vertexData[0].Tu = 0.0f;
        vertexData[0].Tv = 0.0f;

        vertexData[1].Position = new Vector3(-1.0f, -1.0f, 0.0f);
        vertexData[1].Tu = 0.0f;
        vertexData[1].Tv = 1.0f;

        vertexData[2].Position = new Vector3(1.0f, 1.0f, 0.0f);
        vertexData[2].Tu = 1.0f;
        vertexData[2].Tv = 0.0f;

        vertexData[3].Position = new Vector3(-1.0f, -1.0f, 0.0f);
        vertexData[3].Tu = 0.0f;
        vertexData[3].Tv = 1.0f;

        vertexData[4].Position = new Vector3(1.0f, -1.0f, 0.0f);
        vertexData[4].Tu = 1.0f;
        vertexData[4].Tv = 1.0f;

        vertexData[5].Position = new Vector3(1.0f, 1.0f, 0.0f);
        vertexData[5].Tu = 1.0f;
        vertexData[5].Tv = 0.0f;

        return vertexData;
    }


}
}   

And my pixel shader and vertex shader code are as following

 // Pixel shader input structure
 struct PS_INPUT
 {
    float4 Position   : POSITION;
    float2 Texture    : TEXCOORD0;
  };


 // Pixel shader output structure
struct PS_OUTPUT
 {
    float4 Color   : COLOR0;
 };


// Global variables
 sampler2D Tex0;


 // Name: Simple Pixel Shader
 // Type: Pixel shader
 // Desc: Fetch texture and blend with constant color
 //
 PS_OUTPUT ps_main( in PS_INPUT In )
 {
   PS_OUTPUT Out;                             //create an output pixel

    Out.Color = tex2D(Tex0, In.Texture);       //do a texture lookup

    Out.Color *= float4(0.9f, 0.8f, 0.0f, 1);   //do a simple effect

    return Out;                              //return output pixel
  }



 // Vertex shader input structure
 struct VS_INPUT
 {
    float4 Position   : POSITION;
    float2 Texture    : TEXCOORD0;
  };


  // Vertex shader output structure
  struct VS_OUTPUT
  {
      float4 Position   : POSITION;
      float2 Texture    : TEXCOORD0;
  };


  // Global variables
  float4x4 WorldViewProj;


  // Name: Simple Vertex Shader
  // Type: Vertex shader
  // Desc: Vertex transformation and texture coord pass-through
  //
    VS_OUTPUT vs_main( in VS_INPUT In )
  {
     VS_OUTPUT Out;                      //create an output vertex

     Out.Position = mul(In.Position,
                   WorldViewProj);  //apply vertex transformation
       Out.Texture  = In.Texture;          //copy original texcoords

     return Out;                         //return output vertex
   }

I have done the following Chane to my pixel shader where just i am returning a colour but still it is giving me a black output

// Pixel shader input structure
  struct PS_INPUT
 {
    float4 Position   : POSITION;
    float2 Texture    : TEXCOORD0;
  };


  // Pixel shader output structure
   struct PS_OUTPUT
   {
         float4 Color   : COLOR0;
     };


    // Global variables
  sampler2D Tex0;
   texture2D FirstTexture : register(t0);  

   sampler texsmp : register(s0) = sampler_state  
   {  
      Texture   = <FirstTexture>;  
       }; 

         // Name: Simple Pixel Shader
      // Type: Pixel shader
       // Desc: Fetch texture and blend with constant color
       PS_OUTPUT ps_main( in PS_INPUT In )
       {
           PS_OUTPUT Out;                             //create an output pixel
       Out.Color = float4(1,1,0,1);
       return Out;
      }

Can you please tell me the reason behind this problem

share|improve this question
    
Welcome to the site! –  Josh Petrie Jun 17 '11 at 14:45

2 Answers 2

up vote 4 down vote accepted

You're calling SetTexture in your main program (effectively). This binds the texture to a sampler index, not a named sampler variable in shader code... you're not assigning Tex2D in the shader anything. So when you sample it, you get black (all-zero) and multiplying all-zero the way you do will of course still yield all-zero.

You could confirm this by simply outputting a flat color from the shader instead -- don't multiply by the sampled color -- and you should see something.

To fix this, you could use the Effect interface and call SetTexture on a compiled effect, or you could indicate that your sampler should be bound to register 0 (which is what you're setting the texture to):

texture2D FirstTexture : register(t0);  
sampler texsmp : register(s0) = sampler_state  
{  
    Texture   = <FirstTexture>;  
}; 
share|improve this answer
    
I have done the following change to my pixel shader but again it is giving me a black out put. –  Yashwinder Jun 23 '11 at 12:21
    
is it necessary to use a vertex shader first and then the pixel shader???? –  Yashwinder Jun 25 '11 at 5:46

I think the correct syntax to josh's solution is using

texture2D FirstTexture : register(t0);  
sampler texsmp : register(s0) = sampler_state  
{  
    Texture   = <FirstTexture>;  
};  

Using register(0); (without the "s") will result in a compiler error, see register (DirectX HLSL)

share|improve this answer
    
Thanks! It's been ages since I actually used that syntax so my memory was rusty. I've updated my answer accordingly. Welcome to the site, as well. –  Josh Petrie Jun 20 '11 at 15:36

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.