Evaluate a Cubic Bézier on GPU

Evaluate
a Cubic Bézier on GPU

I’ve made an application as an example for this thread on
how to compute/evaluate a Cubic Bézier Curve using a Geometry Shader. The formula is pretty straightforward as described by this wikipedia
article (look for Cubic Bézier Curve). I will not go over the bézier math or theory. I assume you have some knowledge in shader programming (GLSL is the case) and some math background would help, while not really a need. All that said, let’s get to work.

On this case we will need 4 points: 2 anchor points (the line end points) and 2 control points. The control points won’t really touch the curve, they work more as directional information on the curve itself.

As we need to send this data to the shader i have decided to use  LINES as input primitive, 2 points define a line so it’s perfect, we’ll use that for the 2 anchor points. As for the control points 2 different texture units (glMultiTexCoord3f) attached to the
line’s vertex data will do. Using geometry shaders besides setting the input primitive type we also need to set the output type. LINE_STRIP is fine, as it works perfectly for what we’re doing. That’s all on the application side.

On the vertex shader side it’s pretty simple:

[VERTEX SHADER]
void main( void )
{
gl_FrontColor = gl_Color;
ControlPoint1 = gl_MultiTexCoord0.xyz;
ControlPoint2 = gl_MultiTexCoord1.xyz;
 
gl_Position = gl_Vertex;
}

What the code is doing is sending the data further down the pipeline to the geometry shader, where all the magic happens. At this stage, having both Anchor and Control points we can now define the curve by a given detail. Think of detail as a number of step-points
along the curve which makes it look smoother or flatten (tesselation, subdivision, smoothing, etc).

Both control points are sent by the application for the geometry shader, still, as in the the vertex shader comes before the geometry shader, we will need to send them down on the vertex-shader, otherwise the GS won’t be able to “see” them (i know, hurray for
Cg). We’re now almost done. By using the function from the above link(s) and as shown below we compute the curve with a given detail on the geometry shader, by generating new vertices along the curve purely on the gpu side. I think it to be pretty straightforward
and the code should be self-explanatory.

[GEOMETRY SHADER]
uniform int g_Detail;
varying in vec3 ControlPoint1[];
varying in vec3 ControlPoint2[];
 
// Found in nvidia sdk
vec3 evaluateBezierPosition( vec3 v[4], float t )
{
vec3 p;
float OneMinusT = 1.0 - t;
float b0 = OneMinusT*OneMinusT*OneMinusT;
float b1 = 3.0*t*OneMinusT*OneMinusT;
float b2 = 3.0*t*t*OneMinusT;
float b3 = t*t*t;
return b0*v[0] + b1*v[1] + b2*v[2] + b3*v[3];
}
 
void main()
{
vec3 pos[4];
pos[0] = gl_PositionIn[0].xyz;
pos[1] = ControlPoint1[0];
pos[2] = ControlPoint2[0];
pos[3] = gl_PositionIn[1].xyz;
float OneOverDetail = 1.0 / float(g_Detail-1.0);
for( int i=0; i<g_Detail; i++ )
{
float t = i * OneOverDetail;
vec3 p = evaluateBezierPosition( pos, t );
gl_FrontColor = gl_FrontColorIn[0];
gl_Position = gl_ModelViewProjectionMatrix * vec4( p.xyz, 1.0 );
EmitVertex();
}
 
EndPrimitive();
}

What’s next? That is up to you. You’re not going to leave me with all the work, are you ?

Download the example + source.

You will also need to install Vitamin
0.5.6 as the project is built with it.