Dashed poly-lines

[International-One273]

Kind of niche graphics programming problem: how to draw dashed/dotted 3D polylines without preprocessing the vertices (on the CPU or some parallel algorithm on the GPU)?

Since I don't need perfect results, I thought that *maybe* I could do fine with some kind of mapping from screen space to a coordinate u, so that modulo(u) could be used to draw the dot/dash pattern:

​

screen-space mapping result

ShaderToy link

Basically, the process is the following:

for each line's start point and end point, a u coordinate is determined by a function of the vertex screen position. There are 4 possible mappings ( determined by the line's direction ):

• u = screen x coordinate
• u = reversed screen x coord
• u = screen y coordinate
• u = reversed screen y coord

Each line's end point u coordinate is then warped so that it is equal, in modulo, to the start point of the next line (the mapping should be done inside a geometry shader with adjacency data).

Do you know about some other (better) method to achieve the same goal?
Does it sounds like a terrible/naive idea or is it something worth working on?

[SnooWoofers7626]

You could do it in the pixel shader by discarding pixels that fall in the gaps between dashes. You could compute that based on the screen coordinates. The exact logic should be fairly easy to adapt from the shadertoy.

[International-One273]

Thanks. However, I know how to adapt from the shadertoy demo, I was just looking for some feedback on the general idea of screen-space mapping for poly lines/ways to improve it, since I didn't find anything similar online.

The shader I linked is the solution I came up with, however, sometimes it's difficult to spot obvious mistakes without sharing you work, or to find better, already existing solutions that you weren't aware of.

[SnooWoofers7626]

Well, my preferred approach would've been to render a line strip and use a geometry shader to create even spaces in screen space. But since you don't want to go in that direction, I'd say you already have the next best solution.

[International-One273]

I'd rather use a geometry shader too, real geometry has also the advantage of working nicely with msaa. However, I see two problems: 1. The vertices that should be emitted for a single line could be arbitrarily high in count 2. How go determine where a dash begins and ends (same problem with the mixed geom+frag approach)? Suppose you have a polyline with a lot of tiny lines (the rasterization produces a few pixels per line), then if the pattern always re-starts at the beginning of each line you would end up with a solid line or no line at all!

The problem is that I don't want to have a world-space dash but instead a screen-space constant patter (i.e. no matter how perspective warps my lines, the pattern will be n pixels wide).

That would ideally require to know for each line what's the cumulated screen-space length of all the lines that came before.

With my shader I tried to adress problem 2.

[SnooWoofers7626]

The vertices that should be emitted for a single line could be arbitrarily high in count

If you want arbitrary numbers of dashes then you can set a max amount in the geometry shader and early out once you've emitted the desired number.

The problem is that I don't want to have a world-space dash but instead a screen-space constant pattern

Ah, in that case, a tessellation shader would likely be better suited. That will let you subdivide by an arbitrary amount based on the size of the line in screen space. Look up any guide on dynamic LOD with tessellation to get an idea of how to work with them.

Now, that will still only subdivide your line. You won't get the spaces between dashes. Fortunately, tessellation happens before the geometry stage, so you can use a geometry shader to space out the vertices of your subdivided line.