drawing 3d geometrical shapes using opengl , but without glu

[noeska]

Is there an existing unit for drawing 3d geometrical shapes like cube/sphere/cylinder/cone/capsule etc?

Glu cannot be used as i want to draw the shapes using an vertex buffer objects with GL_TRIANGLES .

Also i am trying to write some function doing 3d drawing so far i am only happy with the cube and sphere code, for the cylinder i made several attempts but none of them work like i expect them. My attempt in glmodel is not working nice enough with the sphere shape in order to make a 3d capsule shape.

So thanks in advance for your help.

[User137]

Making actual 3D games is basically impossible without a modelling program. That is why i never generate them runtime. 1) less to code, 2) faster loading times, 3) texture mapping and normals the way i like.

Anyway because i actually created my own modelling program (no longer developed cause its with Delphi), i do have some code to create different objects. This is cylinder for example, just to maybe give hints. If you want to we may try to see what your functions are doing...
Don't remember how that code made texture coordinates but there's a different function to generate normals based on smoothing groups.

function TWorld3D.MakeCylinder(radius,sy: single; sides,segs: integer): word;
var x,y,z: array[1..5] of single; x1,y1,i: integer;
    segA,segY: single;
begin
  result:=New3DObject;
  if sides<3 then sides:=3;
  if segs<1 then segs:=1;
  segA:=2*PI/sides; segY:=sy/segs;
  with o[result] do
    for x1:=0 to sides-1 do begin
      // Cylinder
      for y1:=0 to segs-1 do begin
        x[2]:=radius*cos(x1*segA);
        z[2]:=radius*sin(x1*segA);
        y[2]:=-sy/2+y1*segY;
        x[3]:=radius*cos(x1*segA);
        z[3]:=radius*sin(x1*segA);
        y[3]:=-sy/2+(y1+1)*segY;
        x[4]:=radius*cos((x1+1)*segA);
        z[4]:=radius*sin((x1+1)*segA);
        y[4]:=-sy/2+(y1+1)*segY;
        x[1]:=radius*cos((x1+1)*segA);
        z[1]:=radius*sin((x1+1)*segA);
        y[1]:=-sy/2+y1*segY;       
        o[result].AddFace(x,y,z,4);
      end;
      // Top - Bottom
      for y1:=0 to 1 do begin
        x[1]:=radius*cos(x1*segA);
        z[1]:=radius*sin(x1*segA);
        x[2]:=radius*cos((x1-y1*2+1)*segA);
        z[2]:=radius*sin((x1-y1*2+1)*segA);
        x[3]:=0; z[3]:=0;
        for i:=1 to 3 do y[i]:=-sy/2+y1*sy;
        TFace(f[o[result].AddFace(x,y,z,3)]).smoothGroup:=1;
      end;
    end;
  o[result].UpdateSize;
end;

[vgo]

Here's some old code of mine.

unit mvRenderHelpers;
{**<
	@author(Jani Alanen <http://www.projectminiverse.com>)
	@created(2007-01-27)
	@lastmod(2009-01-07)

	Miscellaneous helper code for rendering .

	History

	Created:
		27.01.2007 (JA)

	Modified:
		07.01.2009 (JA)
		- Renamed to mvRenderHelpers.pas

}
interface

uses
	{$IFDEF USE_SDL}
	GL, GLU,
	{$ELSE}
	dglOpenGL,
	{$ENDIF}
	mvMath;

procedure DrawCube(Size: TFloat);
procedure DrawTorus(MinorRadius, MajorRadius: TFloat; NumMinor, NumMajor: TInt);
procedure DrawSphere(NumMajor, NumMinor: TInt; Radius: TFloat);
procedure DrawCylinder(NumMajor, NumMinor: TInt; Height, Radius: TFloat);
procedure DrawSkewedPyramid(Size: TFloat);
procedure DrawWireSkewedPyramid(Size: TFloat);
procedure DrawTetrahedron(Size: TFloat);
procedure DrawWireTetrahedron(Size: TFloat);
procedure DrawOctahedron(Size: TFloat);
procedure DrawWireOctahedron(Size: TFloat);

implementation

uses
	mvGLUtils, mvGlobal;


procedure DrawCube(Size: TFloat);
const
	// Texture coordinates from bottom left to top right
		TexCoord: array [0..3] of TTexel = ((u: 0; v: 0),
														(u: 1; v: 0),
														(u: 1; v: 1),
														(u: 0; v: 1));
		// Vertices used in cube
		Vertex: array [0..7] of TVertex = ((v:(-1.0, 1.0, 1.0)),		// 0
													  (v:( 1.0, 1.0, 1.0)),		// 1
													  (v:( 1.0,-1.0, 1.0)),		// 2
													  (v:(-1.0,-1.0, 1.0)),		// 3
													  (v:(-1.0, 1.0,-1.0)),		// 4
													  (v:( 1.0, 1.0,-1.0)),		// 5
													  (v:( 1.0,-1.0,-1.0)),		// 6
													  (v:(-1.0,-1.0,-1.0)));	// 7
      // Faces of the cube
		Cube: array [0..5, 0..3] of Integer = ((0, 1, 2, 3),
                                             (1, 5, 6, 2),
                                             (4, 5, 1, 0),
                                             (0, 3, 7, 4),
															(3, 2, 6, 7),
                                             (5, 4, 7, 6));
		// Normals for each face of the cube
      // Angle of normal and face is allways 90 degrees and
      // length is allways 1.0!
		Normals: array [0..5] of TVertex = ((v:( 0.0, 0.0, 1.0)),
														(v:( 1.0, 0.0, 0.0)),
														(v:( 0.0, 1.0, 0.0)),
														(v:(-1.0, 0.0, 0.0)),
														(v:( 0.0,-1.0, 0.0)),
														(v:( 0.0, 0.0,-1.0)));
var
	i, j: Integer;
begin
	{
	// Start rendering quads
	glBegin(GL_QUADS);
	for i := 0 to 5 do
	begin
		// Set normal for this face
		glNormal3fv(@Normals[i][0]);
		for j := 0 to 3 do
		begin
			// Texture coordinates for this vertex in texels
			glTexCoord2f(TexCoord[j, 0], TexCoord[j, 1]);
			// Position for this vertex, object position NOT world position
			glVertex3fv(@Vertex[Cube[i, j]][0]);
		end;
		glCheckForError();
	end;
	// End rendering quads
	glEnd;
	}

	glBegin(GL_QUADS);

	//glColor3f(1, 1, 1);
	glNormal3f( 0.0, 0.0, 1.0);
	glTexCoord2f(0, 0); glVertex3f( Size / 2, Size / 2, Size / 2);
	glTexCoord2f(1, 0); glVertex3f(-Size / 2, Size / 2, Size / 2);
	glTexCoord2f(1, 1); glVertex3f(-Size / 2,-Size / 2, Size / 2);
	glTexCoord2f(0, 1); glVertex3f( Size / 2,-Size / 2, Size / 2);

	//glColor3f(1, 0, 0);
	glNormal3f( 0.0, 0.0,-1.0);
	glTexCoord2f(0, 0); glVertex3f(-Size / 2,-Size / 2,-Size / 2);
	glTexCoord2f(1, 0);glVertex3f(-Size / 2, Size / 2,-Size / 2);
	glTexCoord2f(1, 1); glVertex3f( Size / 2, Size / 2,-Size / 2);
	glTexCoord2f(0, 1); glVertex3f( Size / 2,-Size / 2,-Size / 2);

	//glColor3f(0, 1, 0);
	glNormal3f( 0.0, 1.0, 0.0);
	glTexCoord2f(0, 0); glVertex3f( Size / 2, Size / 2, Size / 2);
	glTexCoord2f(1, 0); glVertex3f( Size / 2, Size / 2,-Size / 2);
	glTexCoord2f(1, 1); glVertex3f(-Size / 2, Size / 2,-Size / 2);
	glTexCoord2f(0, 1); glVertex3f(-Size / 2, Size / 2, Size / 2);

	//glColor3f(0, 0, 1);
	glNormal3f( 0.0,-1.0, 0.0);
	glTexCoord2f(0, 0); glVertex3f(-Size / 2,-Size / 2,-Size / 2);
	glTexCoord2f(1, 0); glVertex3f( Size / 2,-Size / 2,-Size / 2);
	glTexCoord2f(1, 1); glVertex3f( Size / 2,-Size / 2, Size / 2);
	glTexCoord2f(0, 1); glVertex3f(-Size / 2,-Size / 2, Size / 2);

	//glColor3f(0, 1, 1);
	glNormal3f( 1.0, 0.0, 0.0);
	glTexCoord2f(0, 0); glVertex3f( Size / 2, Size / 2, Size / 2);
	glTexCoord2f(1, 0); glVertex3f( Size / 2,-Size / 2, Size / 2);
	glTexCoord2f(1, 1); glVertex3f( Size / 2,-Size / 2,-Size / 2);
	glTexCoord2f(0, 1); glVertex3f( Size / 2, Size / 2,-Size / 2);

	//glColor3f(1, 1, 0);
	glNormal3f(-1.0, 0.0, 0.0);
	glTexCoord2f(0, 0); glVertex3f(-Size / 2,-Size / 2,-Size / 2);
	glTexCoord2f(1, 0); glVertex3f(-Size / 2,-Size / 2, Size / 2);
	glTexCoord2f(1, 1); glVertex3f(-Size / 2, Size / 2, Size / 2);
	glTexCoord2f(0, 1); glVertex3f(-Size / 2, Size / 2,-Size / 2);
	glEnd();

	{
	glVertex3f(-Size + x, Size + y, Size + z);
	glVertex3f( Size + x, Size + y, Size + z);
	glVertex3f( Size + x,-Size + y, Size + z);
	glVertex3f(-Size + x,-Size + y, Size + z);

	glVertex3f( Size + x, Size + y, Size + z);
	glVertex3f( Size + x, Size + y,-Size + z);
	glVertex3f( Size + x,-Size + y,-Size + z);
   glVertex3f( Size + x,-Size + y, Size + z);

	glVertex3f(-Size + x, Size + y,-Size + z);
   glVertex3f( Size + x, Size + y,-Size + z);
   glVertex3f( Size + x, Size + y,-Size + z);
   glVertex3f(-Size + x, Size + y,-Size + z);

   glVertex3f(-Size + x, Size + y,-Size + z);
   glVertex3f(-Size + x,-Size + y, Size + z);
	glVertex3f(-Size + x,-Size + y,-Size + z);
   glVertex3f(-Size + x, Size + y,-Size + z);

   glVertex3f(-Size + x,-Size + y, Size + z);
   glVertex3f( Size + x,-Size + y, Size + z);
   glVertex3f( Size + x,-Size + y,-Size + z);
   glVertex3f(-Size + x,-Size + y,-Size + z);

   glVertex3f( Size + x, Size,-Size + z);
   glVertex3f(-Size + x, Size,-Size + z);
   glVertex3f(-Size + x,-Size,-Size + z);
   glVertex3f( Size + x,-Size,-Size + z);
   }

   //glEnd;
end;

procedure DrawTorus(MinorRadius, MajorRadius: TFloat; NumMinor, NumMajor: TInt);
var
	MajorStep, MinorStep: TFloat;
	i, j: Integer;
   a0, a1, b: TFloat;
   x0, y0, x1, y1, c, r, z: TFloat;
begin
	MajorStep := 2.7 * PI / NumMajor;
   MinorStep := 2.7 * PI / NumMajor;
   for i := 0 to numMajor do
   begin
   	a0 := i * MajorStep;
   	a1 := a0 + MajorStep;
   	x0 := Cos(a0);
   	y0 := Sin(a0);
   	x1 := Cos(a1);
   	y1 := Sin(a1);
   	glBegin(GL_TRIANGLE_STRIP);
   	for j := 0 to numMinor do
     	begin
      	b := j * MinorStep;
         c := Cos(b);
         r := MinorRadius * c + MajorRadius;
			z := MinorRadius * Sin(b);

         glNormal3f(x0 * c, y0 * c, z / MinorRadius);
         glTexCoord2f(i / NumMajor, j / NumMinor);
         glVertex3f(x0 * r, y0 * r, z);

         glNormal3f(x1 * c, y1 * c, z / MinorRadius);
         glTexCoord2f((i + 1) / NumMajor, j / NumMinor);
         glVertex3f(x1 * r, y1 * r, z);
		end;
      glEnd();
	end;
end;

procedure DrawSphere(NumMajor, NumMinor: Integer; Radius: TFloat);
var
	MajorStep, MinorStep: TFloat;
	i, j: Integer;
	a, b, c, r0, r1: TFloat;
   x, y, z0, z1: TFloat;
begin
	MajorStep := (PI / NumMajor);
	MinorStep  := (2.0 * PI / NumMinor);

   for i := 0 to NumMajor do
   begin
   	a := i * MajorStep;
      b := a + MajorStep;
      r0 := radius * Sin(a);
      r1 := radius * Sin(b);
      z0 := radius * Cos(a);
      z1 := radius * Cos(b);

      glBegin(GL_TRIANGLE_STRIP);
      for j := 0 to NumMinor do
      begin
      	c := j * MinorStep;
         x := Cos(c);
         y := Sin(c);

         glNormal3f((x * r0) / radius, (y * r0) / Radius, z0 / Radius);
         glTexCoord2f(j / NumMinor, i / NumMajor);
         glVertex3f(x * r0, y * r0, z0);

         glNormal3f((x * r1) / Radius, (y * r1) / Radius, z1 / Radius);
         glTexCoord2f(j / NumMinor, (i + 1) / NumMajor);
         glVertex3f(x * r1, y * r1, z1);
		end;
   glEnd();
   end;
end;

procedure DrawCylinder(NumMajor, NumMinor: TInt; Height, Radius: TFloat);
var       MajorStep, MinorStep: TFloat;
			 i, j: Integer;
			 a, x, y, z0, z1: TFloat;
begin
	  MajorStep := Height / NumMajor;
	  MinorStep := 2.0 * PI / NumMinor;

	  for i := 0 to NumMajor do
	  begin
			 z0 := 0.5 * Height - i * MajorStep;
			 z1 := z0 - MajorStep;

			 glBegin(GL_TRIANGLE_STRIP);
			 for j := 0 to NumMinor do
			 begin
					a := j * MinorStep;
					x := Radius * Cos(a);
					y := Radius * Sin(a);

					glNormal3f(x / radius, y / radius, 0.0);
					glTexCoord2f(j / numMinor, i / numMajor);
					glVertex3f(x, y, z0);

					glNormal3f(x / radius, y / radius, 0.0);
					glTexCoord2f(j / numMinor, (i + 1) / numMajor);
					glVertex3f(x, y, z1);
			 end;
			 glEnd();
	  end;
end;

procedure DrawSkewedPyramid(Size: TFloat);
begin
	glBegin(GL_TRIANGLES);
	// Back
	glVertex3f(0, Size, -(Size / 2)); // Top
	glVertex3f(Size/2, 0, -(Size / 2)); // Bottom right
	glVertex3f(-Size/2, 0, -(Size / 2)); // Bottom left
	//glVertex3f(0, Size, -(Size / 2));
	glEnd;

	// Left
	glBegin(GL_TRIANGLES);
	glVertex3f(0, 0, (Size / 2)); // Nose
	glVertex3f(0, Size, -(Size / 2));
	glVertex3f(-Size/2, 0, -(Size / 2));

	//glVertex3f(0, 0, (Size / 2));
	glEnd;

	// Right
	glBegin(GL_TRIANGLES);
	glVertex3f(0, Size, -(Size / 2));
	glVertex3f(0, 0, (Size / 2));
	glVertex3f(Size/2, 0, -(Size / 2));
	//glVertex3f(0, Size, -(Size / 2));
	glEnd();

	// Bottom
	glBegin(GL_TRIANGLES);
	glVertex3f(0, 0, (Size / 2));
	glVertex3f(-Size/2, 0, -(Size / 2));
	glVertex3f(Size/2, 0, -(Size / 2));
	//glVertex3f(0, 0, (Size / 2));
	glEnd();
end;

procedure DrawWireSkewedPyramid(Size: TFloat);
begin
	glBegin(GL_LINE_STRIP);
	// Back
	glVertex3f(0, Size, -(Size / 2)); // Top
	glVertex3f(Size/2, 0, -(Size / 2)); // Bottom right
	glVertex3f(-Size/2, 0, -(Size / 2)); // Bottom left
	glVertex3f(0, Size, -(Size / 2));
	glEnd;

	// Left
	glBegin(GL_LINE_STRIP);
	glVertex3f(0, 0, (Size / 2)); // Nose
	glVertex3f(0, Size, -(Size / 2));
	glVertex3f(-Size/2, 0, -(Size / 2));
	glVertex3f(0, 0, (Size / 2));
	glEnd;

	// Right
	glBegin(GL_LINE_STRIP);
	glVertex3f(0, Size, -(Size / 2));
	glVertex3f(0, 0, (Size / 2));
	glVertex3f(Size/2, 0, -(Size / 2));
	glVertex3f(0, Size, -(Size / 2));
	glEnd();

	// Bottom
	glBegin(GL_LINE_STRIP);
	glVertex3f(0, 0, (Size / 2));
	glVertex3f(-Size/2, 0, -(Size / 2));
	glVertex3f(Size/2, 0, -(Size / 2));
	glVertex3f(0, 0, (Size / 2));
	glEnd();
end;

procedure DrawTetrahedron(Size: TFloat);
begin
	{
	glBegin(GL_TRIANGLE_STRIP);
		glVertex3f(0, 2 * (Size / 2), 0);
		glVertex3f(-1 * (Size / 2), 0, 1 * (Size / 2));
		glVertex3f(1 * (Size / 2), 0, 1 * (Size / 2));
		glVertex3f(0, 0, -1.4 * (Size / 2));
		glVertex3f(0, 2 * (Size / 2), 0);
		glVertex3f(-1 * (Size / 2), 0, 1 * (Size / 2));
	glEnd();
	}
	glBegin(GL_TRIANGLE_STRIP);
		glVertex3f(0, 2 * (Size / 2) - 0.5, 0);
		glVertex3f(-1 * (Size / 2), -0.5, 1 * (Size / 2));
		glVertex3f(1 * (Size / 2), -0.5, 1 * (Size / 2));
		glVertex3f(0, -0.5, -1.4 * (Size / 2));
		glVertex3f(0, 2 * (Size / 2) - 0.5, 0);
		glVertex3f(-1 * (Size / 2), -0.5, 1 * (Size / 2));
	glEnd();
end;

procedure DrawWireTetrahedron(Size: TFloat);
begin
	{
	glBegin(GL_LINE_STRIP);
		glVertex3f(0, 2 * (Size / 2), 0);
		glVertex3f(-1 * (Size / 2), 0, 1 * (Size / 2));
		glVertex3f(1 * (Size / 2), 0, 1 * (Size / 2));
		glVertex3f(0, 2 * (Size / 2), 0);

		glVertex3f(0, 2 * (Size / 2), 0);
		glVertex3f(-1 * (Size / 2), 0, 1 * (Size / 2));
		glVertex3f(0, 0, -1.4 * (Size / 2));
		glVertex3f(0, 2 * (Size / 2), 0);

		glVertex3f(0, 0, -1.4 * (Size / 2));
		glVertex3f(0, 2 * (Size / 2), 0);
		glVertex3f(1 * (Size / 2), 0, 1 * (Size / 2));
		glVertex3f(0, 0, -1.4 * (Size / 2));

	glEnd();
	}
	glBegin(GL_LINE_STRIP);
		glVertex3f(0, 2 * (Size / 2) - 0.5, 0);
		glVertex3f(-1 * (Size / 2), -0.5, 1 * (Size / 2));
		glVertex3f(1 * (Size / 2), -0.5, 1 * (Size / 2));
		glVertex3f(0, 2 * (Size / 2) - 0.5, 0);

		glVertex3f(0, 2 * (Size / 2) - 0.5, 0);
		glVertex3f(-1 * (Size / 2), -0.5, 1 * (Size / 2));
		glVertex3f(0, -0.5, -1.4 * (Size / 2));
		glVertex3f(0, 2 * (Size / 2) - 0.5, 0);

		glVertex3f(0, -0.5, -1.4 * (Size / 2));
		glVertex3f(0, 2 * (Size / 2) - 0.5, 0);
		glVertex3f(1 * (Size / 2), -0.5, 1 * (Size / 2));
		glVertex3f(0, -0.5, -1.4 * (Size / 2));

	glEnd();
end;

procedure DrawOctahedron(Size: TFloat);
const
	Vertices: array [0..5] of TVector3f = (
		(v: (0.0, 0.0, 1.0/SQRT2)),
		(v: ( 0.5, 0.5, 0.0)),
		(v: (-0.5, 0.5, 0.0)),
		(v: (-0.5,-0.5, 0.0)),
		(v: (0.5,-0.5, 0.0)),
		(v: (0.0, 0.0, -1.0/SQRT2))
	);
begin
	glScalef(Size, Size, Size);
	glBegin(GL_TRIANGLE_FAN);
		glVertex3fv(@Vertices[0]);
		glVertex3fv(@Vertices[1]);
		glVertex3fv(@Vertices[2]);
		glVertex3fv(@Vertices[3]);
		glVertex3fv(@Vertices[4]);
		glVertex3fv(@Vertices[1]);
	 glEnd();
	 glBegin(GL_TRIANGLE_FAN);
		glVertex3fv(@Vertices[5]);
		glVertex3fv(@Vertices[1]);
		glVertex3fv(@Vertices[4]);
		glVertex3fv(@Vertices[3]);
		glVertex3fv(@Vertices[2]);
		glVertex3fv(@Vertices[1]);
	 glEnd();
end;

procedure DrawWireOctahedron(Size: TFloat);
const
	Vertices: array [0..5] of TVector3f = (
		(v: (0.0, 0.0, 1.0/SQRT2)),
		(v: ( 0.5, 0.5, 0.0)),
		(v: (-0.5, 0.5, 0.0)),
		(v: (-0.5,-0.5, 0.0)),
		(v: (0.5,-0.5, 0.0)),
		(v: (0.0, 0.0, -1.0/SQRT2))
	);
begin
	glScalef(Size, Size, Size);
	glBegin(GL_LINES);
		glVertex3fv(@Vertices[0]);
		glVertex3fv(@Vertices[1]);
		glVertex3fv(@Vertices[0]);
		glVertex3fv(@Vertices[2]);
		glVertex3fv(@Vertices[0]);
		glVertex3fv(@Vertices[3]);
		glVertex3fv(@Vertices[0]);
		glVertex3fv(@Vertices[4]);
		glVertex3fv(@Vertices[0]);
		glVertex3fv(@Vertices[1]);
	glEnd();
	glBegin(GL_LINES);
		glVertex3fv(@Vertices[5]);
		glVertex3fv(@Vertices[1]);
		glVertex3fv(@Vertices[5]);
		glVertex3fv(@Vertices[4]);
		glVertex3fv(@Vertices[5]);
		glVertex3fv(@Vertices[3]);
		glVertex3fv(@Vertices[5]);
		glVertex3fv(@Vertices[2]);
		glVertex3fv(@Vertices[5]);
		glVertex3fv(@Vertices[1]);
	glEnd();
	glBegin(GL_LINE_STRIP);
		glVertex3fv(@Vertices[1]);
		glVertex3fv(@Vertices[4]);
		glVertex3fv(@Vertices[3]);
		glVertex3fv(@Vertices[2]);
		glVertex3fv(@Vertices[1]);
	glEnd();
end;


end.

[code_glitch]

Hey there vgo - that is some mighty good code you've got there if I may say so myself. Would you mind awfully if I included this in Prometheus and added your name to the credits? This is non-commercial use, just so you know.

[michalis]

You can also take a look at sphere/cylinder/cone/cube -> mesh convertion in my engine. The code doesn't do direct rendering (it only converts to a mesh in TNodeIndexedFaceSet instance), and it's a little involved (I have to deal with texture coords, optional over-triangulating for Gouraud shading and such), but maybe it will be useful for some hints anyway. It's LGPL.

https://vrmlengine.svn.sourceforge.n...e_cylinder.inc
https://vrmlengine.svn.sourceforge.n...lnodes_box.inc
https://vrmlengine.svn.sourceforge.n...des_sphere.inc

[code_glitch]

looks like a 3d promethetus is a possibility in the future then. for now though, lets focus on the the three current branches of it

[noeska]

This is what i have sofar (left out all but cylinder related):

unit glShapes;

interface

// Version: MPL 1.1

uses
  DglOpenGL,
  glTypes;

function createPlane(halfExtend: GLfloat;var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GluInt;
function createCube(ax,ay,az: GLfloat;var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GLuint;

function createSphere(numSlices:GLuint; radius: GLfloat; var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GLuint;
function createCylinder(radius: GLFloat; height: GLFloat; var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GLuint;
function createDisk(radius: GLFloat; height: GLFloat; var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GLuint;
function createClosedCylinder(radius: GLFloat; height: GLFloat; var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GLuint;

implementation

uses math;

{------------------------------------------------------------------}
{  Function to create a plane shape                                }
{------------------------------------------------------------------}
function createPlane(halfExtend: GLfloat;var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GluInt;
var
  numVertices: Gluint;
  numIndices: Gluint;
  i: GLuint;

const
  xy_vertices: array[0..15] of GLFloat=
    (		-1.0, -1.0, 0.0, +1.0,
		    +1.0, -1.0, 0.0, +1.0,
		    -1.0, +1.0, 0.0, +1.0,
		    +1.0, +1.0, 0.0, +1.0);
  xy_normals: array[0..11] of GLFloat=
    (		0.0, 0.0, 1.0,
		    0.0, 0.0, 1.0,
		    0.0, 0.0, 1.0,
		    0.0, 0.0, 1.0);
  xy_texCoords: array[0..7] of GLFloat=
    (		0.0, 0.0,
		    1.0, 0.0,
		    0.0, 1.0,
		    1.0, 1.0);
  xy_indices: array[0..5] of GLuint=
    (		0, 1, 2,
		    1, 3, 2);

begin
	numVertices := 4;
	numIndices := 6;

	numberVertices := numVertices;

  SetLength(vertices, 4*numVertices );
  for i := 0 to (4*numVertices) - 1 do
    vertices[i]:=xy_vertices[i];

  for i := 0 to numVertices-1 do
  begin
			vertices[i*4+0] := vertices[i*4+0] * halfExtend;
			vertices[i*4+1] := vertices[i*4+1] * halfExtend;
  end;

  SetLength(normals, 3*numVertices);
  for i := 0 to (3*numVertices) - 1 do
    normals[i]:=xy_normals[i];

  SetLength(texCoords,2*numVertices);
  for i := 0 to (2*numVertices) - 1 do
    texcoords[i]:=xy_texcoords[i];

  SetLength(indices, numIndices);
  for i := 0 to numIndices - 1 do
    indices[i]:=xy_indices[i];

	result := numIndices;
end;


function createCylinder(radius: GLFloat; height: GLFloat; var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GLuint;
var
  i,j: GLuint;
  //CirclePoints: array of TVector3;
  CIRCLE_RESOLUTION : integer;
  WIDTH_RESOLUTION : integer;
  WIDTH : glFloat;
  totalElements : integer;
  MAX_VERTICIES: integer;
  curidx: integer;
  anglestep: GLFloat;
begin

//pff now renders somewhat ok
//TODO: add top and botom look at meshgen sources
//TODO: vary width of circle over height
//so stop using circlepoints

RADIUS := RADIUS /2; //why div 2 is that because i define with instead of radious

  CIRCLE_RESOLUTION := 35;
  WIDTH_RESOLUTION := 10;
  WIDTH := height/2;
  //setlength(CirclePoints,CIRCLE_RESOLUTION);
  
  MAX_VERTICIES := (CIRCLE_RESOLUTION * WIDTH_RESOLUTION);
  numberVertices := MAX_VERTICIES;

   	angleStep := (2.0 * PI) / CIRCLE_RESOLUTION;

  // Circle end-caps
  //for i:=0 to CIRCLE_RESOLUTION-1 do
  //begin
  //  circlePoints[i].x := cos( degtorad( (360.0 / CIRCLE_RESOLUTION) * i ) * RADIUS);
  //  circlePoints[i].y := sin( degtorad( (360.0 / CIRCLE_RESOLUTION) * i ) * RADIUS);
  //end;

  // Vertices
  setlength(vertices, high(vertices) + (CIRCLE_RESOLUTION * WIDTH_RESOLUTION * 4) );

  curidx := 0;

  //TODO: swap i and j to make cone? also make vertices normals in one step

  for i:=0 to CIRCLE_RESOLUTION-1 do
  begin
    for j:=0 to WIDTH_RESOLUTION-1 do
    begin


      //vertices[curidx + 0] := radius * sin ( angleStep * i ) * sin ( angleStep * j );
      //vertices[curidx + 0] := cos( degtorad( (360.0 / CIRCLE_RESOLUTION) * i )) * RADIUS;// + circlePoints[i].y;
      vertices[curidx + 0] := cos( ( anglestep * i )) * RADIUS;// + circlePoints[i].y;

      vertices[curidx + 1] := (WIDTH*j) / (WIDTH_RESOLUTION);//(WIDTH*2) / (WIDTH_RESOLUTION * j);//circlePoints[i].y;//WIDTH / (WIDTH_RESOLUTION * j);
      //vertices[curidx + 2] := sin( degtorad( (360.0 / CIRCLE_RESOLUTION) * i )) * RADIUS;//WIDTH / (WIDTH_RESOLUTION * j);////circlePoints[i].y*WIDTH_RESOLUTION*j; //i * WIDTH_RESOLUTION+j;
      vertices[curidx + 2] := sin( ( anglestep * i )) * RADIUS;//WIDTH / (WIDTH_RESOLUTION * j);////circlePoints[i].y*WIDTH_RESOLUTION*j; //i * WIDTH_RESOLUTION+j;

      vertices[curidx + 3] := 1.0;



      curidx := curidx + 4;



    end;


    //radius := radius - 0.1; //make an spiral ake tape dispensen when on

  end;

  // Indices
  totalElements := CIRCLE_RESOLUTION * WIDTH_RESOLUTION * 6;
  setlength(indices, high(indices) + totalElements);

  curidx :=0;
  for i:=0 to CIRCLE_RESOLUTION-1 do
  begin
    for j:=0 to WIDTH_RESOLUTION-1 do
    begin
      indices[curidx+0]:=(i*WIDTH_RESOLUTION + j + 1) mod MAX_VERTICIES;
      indices[curidx+1]:=(i*WIDTH_RESOLUTION + j) mod MAX_VERTICIES;
      indices[curidx+2]:=((i+1) * WIDTH_RESOLUTION + j) mod MAX_VERTICIES;

      indices[curidx+3]:=(i*WIDTH_RESOLUTION + j + 1) mod MAX_VERTICIES;
      indices[curidx+4]:=((i+1) * WIDTH_RESOLUTION + j) mod MAX_VERTICIES;
      indices[curidx+5]:=((i+1) * WIDTH_RESOLUTION + j + 1) mod MAX_VERTICIES;

      curidx := curidx +6;
    end;
  end;

  // Normals
  setlength(normals, high(normals) + CIRCLE_RESOLUTION * WIDTH_RESOLUTION * 3 );

  curidx := 0;
  for i:=0 to CIRCLE_RESOLUTION-1 do
  begin
    for j:=0 to WIDTH_RESOLUTION-1 do
    begin
      //normals[curidx+0] := (radius * sin ( angleStep * i ) * sin ( angleStep * j ))/radius;
      normals[curidx + 0] := cos( ( anglestep * i ));//cos( degtorad( (360.0 / CIRCLE_RESOLUTION) * i ) );// * RADIUS) / radius;
      normals[curidx + 1] := ((j*WIDTH) / WIDTH_RESOLUTION) /radius;
      normals[curidx + 2] := sin( ( anglestep * i ));//sin( degtorad( (360.0 / CIRCLE_RESOLUTION) * i ) );// * RADIUS) / radius;
      curidx := curidx + 3;
    end;
  end;

  // TexCoords
  setlength(texcoords, high(texcoords) + (CIRCLE_RESOLUTION * WIDTH_RESOLUTION * 2 ));
  curidx := 0;
  for i:=0 to CIRCLE_RESOLUTION-1 do
  begin
    for j:=0 to WIDTH_RESOLUTION-1 do
    begin
      texcoords[curidx + 0] := 0;
      texcoords[curidx + 1] := 0;
      curidx := curidx + 2;
    end;
  end;

  result := totalElements;

end;

function createDisk(radius: GLFloat; height: GLFloat; var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GLuint;
var
  i,j: GLuint;
  CIRCLE_RESOLUTION : integer;
  WIDTH_RESOLUTION : integer;
  WIDTH : glFloat;
  totalElements : integer;
  MAX_VERTICIES: integer;
  curidx: integer;
  anglestep: GLFloat;
  temp: integer;
begin

//stacking is wrong


RADIUS := RADIUS /2; //why div 2 is that because i define with instead of radious

  CIRCLE_RESOLUTION := 35;
  WIDTH_RESOLUTION := 10;
  WIDTH := height/2;

  //WIDTH := 0.5;


  MAX_VERTICIES := (CIRCLE_RESOLUTION * WIDTH_RESOLUTION);
  numberVertices := MAX_VERTICIES;

   	angleStep := (2.0 * PI) / CIRCLE_RESOLUTION;


  // Vertices
  curidx := high(vertices);
  setlength(vertices, high(vertices) + (CIRCLE_RESOLUTION * 4) + (4) );

  //curidx := 0;

  //center point begin close
  vertices[curidx + 0] := 0.0;
  vertices[curidx + 1] := 1.0 * width;
  vertices[curidx + 2] := 0.0;
  vertices[curidx + 3] := 1.0;
  curidx := curidx + 4;

  j:=0;
  for i:=0 to CIRCLE_RESOLUTION-1 do
    begin
        vertices[curidx + 0] := cos( ( anglestep * i )) * RADIUS;
        vertices[curidx + 1] := 1.0 * width;
        vertices[curidx + 2] := sin( ( anglestep * i )) * RADIUS;
        vertices[curidx + 3] := 1.0;
        curidx := curidx + 4;
  end;

  //Indices
  totalElements := (CIRCLE_RESOLUTION * 3);

  curidx := high(indices);
  temp := curidx;
  setlength(indices, high(indices) + totalElements);

  //curidx :=0;
  for i:=0 to CIRCLE_RESOLUTION-1 do
  begin
    Indices[(curidx)+2]:=temp;//0;
    Indices[(curidx)+1]:=temp+(i+1);
    if (i = CIRCLE_RESOLUTION-1) then
      Indices[(curidx)+0]:=temp+1 //1
    else
      Indices[(curidx)+0]:=temp+(i+2);

    curidx := curidx + 3;
  end;

  // Normals
  curidx :=high(normals);
  setlength(normals, high(normals) + (CIRCLE_RESOLUTION * 3) + (3) );

  //curidx := 0;

  normals[curidx + 0] := 0.0;
  normals[curidx + 1] := 1.0;
  normals[curidx + 2] := 0.0;

  curidx := curidx + 3;

  j:=0;
  for i:=0 to CIRCLE_RESOLUTION-1 do
  begin
    normals[curidx + 0] := 0;
    normals[curidx + 1] := 1;
    normals[curidx + 2] := 0;
    curidx := curidx + 3;
  end;

  // TexCoords
  curidx := high(texcoords);
  setlength(texcoords, high(texcoords) + ( CIRCLE_RESOLUTION * 2) );
  //curidx := 0;
  j:=0;
  for i:=0 to CIRCLE_RESOLUTION-1 do
  begin
    texcoords[curidx + 0] := 0;
    texcoords[curidx + 1] := 0;
    curidx := curidx + 2;
  end;

  result := totalElements;

end;

function createClosedCylinder(radius: GLFloat; height: GLFloat; var vertices: GLBufferf;var normals: GLbufferf; var texCoords: GLbufferf; var indices: GLBufferi;var numberVertices: GLuint): GLuint;
var
  total, numofvert: GLUint;
begin
setlength(vertices,1);
setlength(normals,1);
setlength(texCoords,1);
setlength(indices,1);

  total := createCylinder(radius, height, vertices, normals, texCoords, indices,numberVertices);
  numofvert := numberVertices;
  total := total + createDisk(radius, height, vertices, normals, texCoords, indices,numberVertices);
  numberVertices := numberVertices + numofvert;
end;

end.

Drawing an open cylinder works, drawing an disk works, but combining them give lots of unexpected results. The calling of creatdisk is broken in this example it is not intendended to be called on its own, only as part createclosedcylinder.

[User137]

The result of function createClosedCylinder() seems to be undefined... Didn't compiler warn about it?

[vgo]

Hey there vgo - that is some mighty good code you've got there if I may say so myself. Would you mind awfully if I included this in Prometheus and added your name to the credits? This is non-commercial use, just so you know.

Sure, I'm glad the code is useful for someone.