title: GLSL Shaders: blending, primitive-specific behavior, and discarding a vertex
body: <p>Criteria: I’m using OpenGL with shaders (GLSL) and trying to stay with modern techniques (e.g., trying to stay away from deprecated concepts).</p>
  
  <p>My questions, in a very general sense--see below for more detail—are as follows:</p>
  
  <ol>
  <li>Do shaders allow you to do custom blending that help eliminate z-order transparency issues found when using GL_BLEND? </li>
  <li>Is there a way for a shader to know what type of primitive is being drawn without “manually” passing it some sort of flag?</li>
  <li>Is there a way for a shader to “ignore” or “discard” a vertex (especially when drawing points)?</li>
  </ol>
  
  <p>Background: My application draws points connected with lines in an ortho projection (vertices have varying depth in the projection).  I’ve only recently started using shaders in the project (trying to get away from deprecated concepts).  I understand that standard blending has ordering issues with alpha testing and depth testing: basically, if a “translucent” pixel at a higher z level is drawn first (thus blending with whatever colors were already drawn to that pixel at a lower z level), and an opaque object is then drawn at that pixel but at a lower z level, depth testing prevents changing the pixel that was already drawn for the “higher” z level, thus causing blending issues.  To overcome this, you need to draw opaque items first, then translucent items in ascending z order.  My gut feeling is that shaders wouldn’t provide an (efficient) way to change this behavior—am I wrong?</p>
  
  <p>Further, for speed and convenience, I pass information for each vertex (along with a couple of uniform variables) to the shaders and they use the information to find a subset of the vertices that need special attention.  Without doing a similar set of logic in the app itself (and slowing things down) I can’t know a priori what subset of vericies that is.  Thus I send all vertices to the shader.  However, when I draw “points” I’d like the shader to ignore all the vertices that aren’t in the subset it determines.  I think I can get the effect by setting alpha to zero and using an alpha function in the GL context that will prevent drawing anything with alpha less than, say, 0.01.  However, is there a better or more “correct” glsl way for a shader to say “just ignore this vertex”?</p>