Here's a quick and dirty hack i wrote you might be able to use. You'll need to add a TGLDirectOpenGL component to your GLScene as well as adding OpenGL1X to your uses list. It's compiled with Delphi 2009, but i don't think there's any difference in code if you're using another version.

[pascal]
{ Draws the Phase }
procedure Phase(Sides: Byte;Rad: Single;Mat: TGLLibMaterial;
const Verts: array of TVector;var rci: TRenderContextInfo);
var
fn,cv,nv,d,u,r: TVector;
Vx: array of TVector;
x,y,y2,z: Single;
i0,i1,i2,i,o: Integer;
begin
SetLength(Vx, Sides*Length(Verts)); // array to hold all phase points
// calclate points
for i:=0 to High(Verts) do begin
if i<High(Verts) then o:=1 else o:=-1;
cv:=Verts[i]; // current position
nv:=Verts[i+o]; // next position
d:=VectorNormalize(VectorSubtract(nv,cv)); // direction vector (normalized)
if o<0 then NegateVector(d); // stops flipping because of reversal. comment out to see
u:=VectorNormalize(VectorCrossProduct(d,XHmgVector )); // up vector (assuming Y is up)
r:=VectorNormalize(VectorCrossProduct(d,u)); // right vector

for o:=0 to Sides-1 do begin
{ divide points equally around phase }
x:=Rad*Sin(DegToRad(o*(360/Sides)))*r[0];
y:=Rad*Cos(DegToRad(o*(360/Sides)))*u[1];
y2:=Rad*Cos(DegToRad(o*(360/Sides)))*u[2];
z:=Rad*Sin(DegToRad(o*(360/Sides)))*r[2];
Vx[(i*Sides)+o]:=VectorMake(cv[0]+x, cv[1]+y, cv[2]+z+y2);
end;
end;

{ draw points }
for i:=0 to High(Verts)-1 do begin
if Assigned(Mat) then mat.Material.Apply(rci);
glBegin(GL_TRIANGLE_STRIP)
for o:=0 to Sides do begin
i0:=((i+1)*Sides)+o mod Sides;
i1:=(i*Sides)+o mod Sides;
i2:=((i+1)*Sides)+((o+1) mod Sides);

{ calculate face normal }
fn:=VectorCrossProduct(VectorSubtract(Vx[i0],Vx[i1]),VectorSubtract(Vx[i0],Vx[i2]));
fn:=VectorNormalize(fn);
glNormal3fv(@fn);

{ un-comment to wrap texture around phase }
glTexCoord2f(0,o/Sides); glVertex3fv(@Vx[i0]);
glTexCoord2f(1,o/Sides); glVertex3fv(@Vx[i1]);

{ un-comment to map texture to each side }
// glTexCoord2f(0,o and 1); glVertex3fv(@Vx[i0]);
// glTexCoord2f(1,o and 1); glVertex3fv(@Vx[i1]);
end;
glEnd;
if Assigned(Mat) then Mat.Material.UnApply(rci);
end;

{ clean up }
SetLength(Vx, 0);
end;
[/pascal]

also on onRender event for TGLDirectOpenGL component:
[pascal]
procedure TForm1.GLDirectOpenGL1Render(Sender: TObject; var rci: TRenderContextInfo);
var
m: TGLLibMaterial;
v: array of TVector;
begin
{ un-comment to disable lighting and culling }
// gldisable(GL_CULL_FACE);
// glDisable(GL_LIGHTING);

{ replace 'test' with the name of your material }
m:=GLMaterialLibrary1.Materials.GetLibMaterialByNa me('test');

{ you can make adjustments to material 'm' before calling the routine
(eg emission/blending/etc)
}
Phase(8, 0.25, m, v, rci); // draw the phase (Sides,Radius,Material,Pos'n array,ContextInfo)

{ clean up needed?}
m:=nil;
SetLength(v,0);

{ un-comment to re-enable lighting and culling (if disabled above) }
// glEnable(GL_LIGHTING);
// glEnable(GL_CULL_FACE);
end;
[/pascal]

I figured as you're already using tglpipes, this method isn't too different except instead of being objects, it's drawn to the buffer. You can adjust the number of sides, radius and segments in the phase so it's fairly flexible. Although it's not setup for splines (from your screenshots they all seemed to be straight lines) it won't take too much modding to incorporate them. it's definitely not perfect, but it kinda works

small app wrapped around the function
Video
Download app

Any problems, let me know.