Hi everyone, I'm new here, and new to HLSL. I'm hoping that some of you may be able to help me understand some of the parts of graphics programming that i don't understand, or can't really seem to find a good explanation on.

I was writing a simple shader last night and realized that I don't understand what's really going on behind the scenes, but instead I'm just memorizing where code is supposed to go.

If we can please start with something as simple as this:

struct VS_INPUT 
{ float4 mPosition : POSITION; };

struct VS_OUTPUT 
{ float4 mPosition : POSITION; };

float4x4 gWorldMatrix;
float4x4 gViewMatrix;
float4x4 gProjectionMatrix;

VS_OUTPUT vs_main ( VS_INPUT Input )
{
VS_OUTPUT Output;

Output.mPosition = mul(Input.mPosition, gWorldMatrix);
Output.mPosition = mul(Output.mPosition, gViewMatrix);
Output.mPosition = mul(Output.mPosition, gProjectionMatrix);

return Output;
}

I realized that I don't even know what the input and output structs are really doing. For example, they appear to be identical (except for their names, which can be called whatever) I guess I don't understand why we need to declare the same variable twice, and why they look identical.

How does my input struct know that it should contain all the semantics for an object?

Is the output struct only used AFTER the object is *returned* from VS_OUTPUT vs_main()?

wow, that clears up so much!

@lwm, changing up the variables names like that helped immensely, beyond words really. I felt like before I had millions of questions, and now not so much.. Thank you!

There is something else I'm trying to understand, and that's the relationship between the VS_OUTPUT struct and the pixel shaders PS_INPUT struct... I should maybe mention that I'm using RenderMonkey to test my code

I modified lwm's example slightly so I could display a texture on my sphere:

struct VS_INPUT 
{
   float4 positionModelSpace : POSITION;
   float2 textureCoordinate : TEXCOORD0;
};

struct VS_OUTPUT 
{
   float4 positionProjSpace : POSITION;
   float2 objectUVs : TEXCOORD0;
};

float4x4 gWorldMatrix;
float4x4 gViewMatrix;
float4x4 gProjectionMatrix;

VS_OUTPUT vs_main ( VS_INPUT Input )
{
   VS_OUTPUT Output;
   
   float4 positionWorldSpace = mul(Input.positionModelSpace, gWorldMatrix);
   float4 positionViewSpace = mul(positionWorldSpace, gViewMatrix);
   Output.positionProjSpace = mul(positionViewSpace, gProjectionMatrix);
   
   Output.objectUVs = Input.textureCoordinate;

   return Output;
}

...

and then for my pixel shader:

...

sampler2D DiffuseSampler;

struct PS_INPUT
{
   float4 mPosition : POSITION;
   float2 mTexCoord : TEXCOORD0;
};


float4 ps_main(PS_INPUT Input) : COLOR0
{   
   float4 albedo = tex2D(DiffuseSampler, Input.mTexCoord);
   return albedo.rgba;
}

which works great

I just don't understand how VS_OUTPUT is sending information to PS_INPUT

typically you have function calls, which I'm not seeing anywhere. Does this have to do with the shaders "entry points"? I Don't know what these are, and will be the next thing I research

Amazing, thanks again lwm