Nsryjdtyk

So basically I have a cylinder with a base (there is a circle under the cylinder), but there is not circle above. I want to make it a closed cylinder.

Here is the important part from my bool CMyApp::Init() function:

Vertex vert[(N+1)*(M+1) + N+2];   //NxM rectangle for our parametric equation

for (int i=0; i<=N; ++i)

    for (int j=0; j<=M; ++j)

    {

        float u = i/(float)N;

        float v = j/(float)M;



        vert[i + j*(N+1)].p = GetUV(u, v);

        vert[i + j*(N+1)].c = glm::normalize( vert[i + j*(N+1)].p );

    }



vert[(N + 1)*(M + 1)].p = glm::vec3(0, 0, 0); //center point for cone base

vert[(N + 1)*(M + 1)].c = glm::vec3(0, 0, 0);

for (int i = 0; i <= N; i++) {

    vert[(N + 1)*(M + 1) + 1 + i].p = vert[(N)-i].p; //cone base

    vert[(N + 1)*(M + 1) + 1 + i].c = vert[(N)-i].c;

}

Render function:

glDrawElements( GL_TRIANGLES,       

                3*2*(N)*(M),         

                GL_UNSIGNED_SHORT,  

                0);                 



glDrawArrays(GL_TRIANGLE_FAN, (N + 1)*(M + 1) + 1, (N + 2)); //draw cone base

The "cone base" is there because I started this project from a "Draw a cone" project.

How can I make a second circle but above the cylinder?

Edit:
M,N: Const numbers (20 and 10)

My parametric equation (which is a FUNCTION called GetUV() ):

u *= 2*3.1415f;

float cu = cosf(u), su = sinf(u), cv = cosf(v), sv = sinf(v);

float M = 2.f;

float r = 0.5;

float m = v*M;



return glm::vec3(r*sinf(u), m, r*cosf(u));

How I create Indices (inside Init() function):

 GLushort indices[3*2*(N)*(M)];

for (int i=0; i<N; ++i)

    for (int j=0; j<M; ++j)

    {

        indices[6*i + j*3*2*(N) + 0] = (i)      + (j)*  (N+1);

        indices[6*i + j*3*2*(N) + 1] = (i+1)    + (j)*  (N+1);

        indices[6*i + j*3*2*(N) + 2] = (i)      + (j+1)*(N+1);

        indices[6*i + j*3*2*(N) + 3] = (i+1)    + (j)*  (N+1);

        indices[6*i + j*3*2*(N) + 4] = (i+1)    + (j+1)*(N+1);

        indices[6*i + j*3*2*(N) + 5] = (i)      + (j+1)*(N+1);

    }

The easiest way to draw the other circular cap is to just change the model matrix of the circle and make the draw call again. So if you're doing something like this before calling glDrawArrays():

glm::mat4 modelViewMatrix = calculateModelViewMatrix();

glUniformMatrix4fv(modelViewLocation, 1, FALSE, modelViewMatrix);

Do the same thing but translate the modelViewMatrix so that it's at the other end of the cylinder.

So N is number of points on the circle circumference and M is the number of points per height...

LOL in your GetUV you are computing cu,su,cv,sv but not using them, instead you use the same sin and cos call again. if I see it right u=<0,1> maps circumference of the circle/cylinder (XZ plane circle) and v=<0,1> maps the height (Y). But it looks like that the function itself works as should (just slowly than possible) appart of that inaccurate M_PI usage which might cause artifacts.

First problem I see is

vert[i + j*(N+1)].c = glm::normalize( vert[i + j*(N+1)].p );

I would get rid of that line as it will create the cone ... which you do not want anymore (btw. very weird and slow method of cone creation)

Also the i + j*(N+1) is ugly instead I would do:

for (int ix=0,j=0; j<=M; j++)

 for (int i=0; i<=N; i++,ix++)

  {

  float u = i/(float)N;

  float v = j/(float)M;

  vert[ix].p = GetUV(u, v);

  }

Next problem you got is wrong usage of the Draw methods ... as you want a grid of points instead of just 2 circles you divided the stuff into GL_TRIANGLE_FAN and GL_TRIANGLES. That was almost correct but you should have:

2x GL_TRIANGLE_FAN one for each base
1x GL_TRIANGLES or GL_QUADS for the rest

as you want to use indices it is basically simpler/faster to use all as triangles and feed the indices buffer correctly so you got just single draw call. Sadly we do not see the part of code where you are computing the indices ...

Why N+1 and M+1 points? You do not need to duplicate first point in vert you can do it in indices instead...

Hope the VBO related part of the code is correct ...

Also beware that faces of the other circle should have points in reverse order so GL_CULL_FACE will cull of faces correctly ...

[Edit1] C++ example

Anyway if you want to use normals latter on you should also duplicate the caps due to different normal on the edge... If I put all together in my style of coding I got this:

//---------------------------------------------------------------------------

const int M=20;                 // points per circle circumference

const int N=10;                 // point per cylinder height

const int pnts=3*((M*(N+2))+2); // 3* number of points

const int facs=3*M*(N+N+2);     // 3* number of indices

float pnt[pnts];                // (x,y,z) position per each point

float nor[pnts];                // (x,y,z) normal per each point

int fac[facs];                  // (i0,i1,i2) indices per each TRIANGLE

//---------------------------------------------------------------------------

void cylinder_init(float r,float h)

    {

    int i,j,ix,i0,i1,i2,i3;

    float x,y,z,a,da,dz;

    // compute position and normals

    ix=0;

    dz=h/double(N-1);

    da=2.0*M_PI/double(M);

    for (z=-0.5*h,j=0;j<N;j++,z+=dz)    // circles

     for (a=0.0,i=0;i<M;i++,a+=da)

        {

        x=cos(a);

        y=sin(a);

        pnt[ix]=r*x; nor[ix]=x;   ix++;

        pnt[ix]=r*y; nor[ix]=y;   ix++;

        pnt[ix]=z;   nor[ix]=0.0; ix++;

        }

    pnt[ix]= 0.0;   nor[ix]= 0.0; ix++; // top cap

    pnt[ix]= 0.0;   nor[ix]= 0.0; ix++;

    pnt[ix]=+0.5*h; nor[ix]=+1.0; ix++;

    for (j=ix-3*(M+1),i=0;i<M;i++)

        {

        pnt[ix]=pnt[j]; nor[ix]= 0.0; ix++; j++;

        pnt[ix]=pnt[j]; nor[ix]= 0.0; ix++; j++;

        pnt[ix]=pnt[j]; nor[ix]=+1.0; ix++; j++;

        }

    pnt[ix]= 0.0;   nor[ix]= 0.0; ix++; // bottom cap

    pnt[ix]= 0.0;   nor[ix]= 0.0; ix++;

    pnt[ix]=-0.5*h; nor[ix]=-1.0; ix++;

    for (j=0,i=0;i<M;i++)

        {

        pnt[ix]=pnt[j]; nor[ix]= 0.0; ix++; j++;

        pnt[ix]=pnt[j]; nor[ix]= 0.0; ix++; j++;

        pnt[ix]=pnt[j]; nor[ix]=-1.0; ix++; j++;

        }

    // compute triangle indices

    ix=0; i0=M-1; i1=0; i2=i0+M; i3=i1+M;   // circles

    for (j=0;j<N-1;j++,i0+=M,i2+=M)

     for (i=0;i<M;i++,i0=i1,i1++,i2=i3,i3++)

        {

        fac[ix]=i0; ix++;

        fac[ix]=i1; ix++;

        fac[ix]=i2; ix++;

        fac[ix]=i2; ix++;

        fac[ix]=i1; ix++;

        fac[ix]=i3; ix++;

        }

    i2=M*N; i0=i2+M; i1=i2+1;           // top cap

    for (i=0;i<M;i++,i0=i1,i1++)

        {

        fac[ix]=i0; ix++;

        fac[ix]=i1; ix++;

        fac[ix]=i2; ix++;

        }

    i2+=M+1; i0=i2+M; i1=i2+1;          // bottom cap

    for (i=0;i<M;i++,i0=i1,i1++)

        {

        fac[ix]=i2; ix++;

        fac[ix]=i1; ix++;

        fac[ix]=i0; ix++;

        }

    }

//---------------------------------------------------------------------------

And preview:

You just use single draw with GL_TRIANGLES on the whole fac[facs] indices buffer.