Order of the Shader

[Lyrical]

hi,

   I was just wondering, I'm just getting used to using shaders but still one thing escapes me. The shader is added to the TVMesh fair enough, when the mesh is rendered is the shader run once or is it run once per vertex/pixel. i'm getting a little confused with this concept.

I presume every vertex and every pixel will be past to the shader one by one and the shader will only be dealing with one vertex or pixel at a single moment. this being repeated until all the vertex/pixels have been processed for the TVMesh.

Please correct me if i'm wrong. I'm just looking for clarification.
Thank you

[JukkaKevät]

Not too fond on the technology, but one thing I know is that the GPU runs several vertices and pixels simultaneously. They aren't called parallel pipelines for nothing! 

From what I understand setting shader to a mesh is only a pointer which gives the graphic hardware knowledge of which instructions to use for the mesh. The shader instructions are compiled into the graphics hardware when the shader is initialized.

-------------------------
www.studiohorisen.com

[Zaknafein]

Conceptually, the vertex shader is executed for each vertex of the mesh, and the pixel shader is executed for each pixel that the mesh occupies on the screen. But like JukkaKevät said, once on the GPU since the same program is applied to all vertices/pixels, it executes whole blocks at once... but it doesn't change anything to the result.

[Waterman]

Also to notice: If/when you create a value in the vs for the vertex currently being processed (say the vertex Y position), and pass it to the ps (vs_output -> ps_input): The pixel shader, for the current pixel being processed, will have that value handy so that if the pixel doesn't hit a vertex directly, the value is interpolated between the 3 values belonging to the triangle the pixel belongs to.

That's for example the way you craete vertex colors in a shader: Calculate a color value for each vertex, then pass to the pixel shader, which will interpolate the colors(values) smoothly over the triangles.

[Raine]

Also to notice: If/when you create a value in the vs for the vertex currently being processed (say the vertex Y position), and pass it to the ps (vs_output -> ps_input): The pixel shader, for the current pixel being processed, will have that value handy so that if the pixel doesn't hit a vertex directly, the value is interpolated between the 3 values belonging to the triangle the pixel belongs to.

That's for example the way you craete vertex colors in a shader: Calculate a color value for each vertex, then pass to the pixel shader, which will interpolate the colors(values) smoothly over the triangles.

I'm sure this can be used in a smart way, but right now I'm out of good ideas.
Is this step free*? (going through the interpolators before the PS?)

* computationally speaking, does it take much time?

[Lyrical]

Thank you for your info, i am slowly getting used to this.


How would i go about moving say the 3rd vetex in a mesh to a new Y position
I have managed to move every vertex to a new Y position and i get a flat mesh
pretty neet but not what i was triing todo.

Say i have a box(as normal) i just want to make the 3rd vertex move up slowly
I am doing this as an excercise.

I suppose my main question is how do you know in the shader which vertex is currently being
processed so you can manually adjust it?

Thanks again

[BlindSide]

Make sure you have the vertex in world space (the vertex comes in in model space, mul it by the world matrix), then move it, then mul it by the viewproj matrix.

[Zaknafein]

Is this step free*? (going through the interpolators before the PS?)
* computationally speaking, does it take much time?

I'd assume it's almost free, because most people don't even know that the nointerpolation keyword exists (an attribute of the vertex shader arguments IIRC), I haven't seen a shader with it yet. Which means that everybody assumes that interpolation is a given feature of pixel shaders.

[Waterman]

I suppose my main question is how do you know in the shader which vertex is currently being
processed so you can manually adjust it?

Thanks again

You don't know. Each vertex carries some information that you gave it when originally creating the mesh (position, texcoord, normal & such). You can use that to determine something about the vertex. You cannot assume any execution order in the shader (except by depth sorting probably, and that's mostly useless to know in vertex shader code). Just think as if there existed a single vertex only. The same shader code executes for each vertex independently of any other vertex.

The vertex shader alters the vertex position. You can additionally do calculations like  vs_output.something = f(vs_input.vertexdata, time, shaderconstants) and pass the result(s) to the pixel shader (which interpolates).

If you want to move the box up, you must pass "time" to the shader and then in the vertex shader write something like vs_output.Position.y = vs_input.Position.y + time * 0.01. And of course do the transform(s) as Blindy said above.

[Lyrical]

Thank you for your responses i'm getting the picture,
I will now be looking for the right book to buy and i know
there are a few post to start looking deeper into HLSL.

Zaks tutorial on the Wiki is Excellent and i've even managed to make the
demo that works brilliantly with all 3 tutorial parts

Thanks again for your input much appreciated.