Hello All,

               I am new in openGL. I am developing one animation application. The code of one of the function is shown below. The method written in bold letter results in to JVM crash.

              Is there any other way exists to do the same thing without using the glDrawElements function.

***********************
      if (m_Texturing && m_EnvMapOn && normals != null) {
         CQ3DMatrix worldview = new CQ3DMatrix();
         worldview.mul(m_ViewMatrix, m_WorldMatrix);
         for (int i = 0, face = 0; i < nbIndex; i += 3, face++) {
            CQ3DVector normal = new CQ3DVector();

            normal.assign(normals[face]);
            normal.transformNoTrans(worldview);

            if (m_NormalizeNormals) {
               normal.normalize(); // Maybe a scale
            }

            float UV[] = new float[2];

            UV[0] = normal.m_Vector.x * 0.5f + 0.5f;
            UV[1] = normal.m_Vector.y * 0.5f + 0.5f;

            float norm[] = new float[3];
            norm[0] = normals[face].x;
            norm[1] = normals[face].y;
            norm[2] = normals[face].z;

            m_gl.glBegin(GL.GL_TRIANGLES);
            m_gl.glNormal3fv(norm, 0);
            m_gl.glTexCoord3fv(UV, 0);
            norm[0] = vertices[faces[face + faceindex].a].pos.x;
            norm[1] = 0;
            norm[2] = 0;
            m_gl.glVertex3fv(norm, 0);
            norm[0] = vertices[faces[face + faceindex].b].pos.x;
            m_gl.glVertex3fv(norm, 0);
            norm[0] = vertices[faces[face + faceindex].c].pos.x;
            m_gl.glVertex3fv(norm, 0);
            m_gl.glEnd();
         }
         return 0;
      }

      SQ3DVERTEX[] Vertices = prepareVertices(vertices, nbVertices);

      m_gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
      logger.error("GL_VERTEX_ARRAY is enabled.");
      
      FloatBuffer buffer = BufferUtil.newFloatBuffer(Vertices.length * 2);
      if (m_Texturing && !m_GenerateTexCoords) {
         m_gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
         logger.error("GL_TEXTURE_COORD_ARRAY is enabled.");
         for (int Icount = 0; Icount < Vertices.length; Icount++) {
            buffer.put(Vertices[Icount].u);
            buffer.put(Vertices[Icount].v);
         }
         buffer.rewind();
         m_gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, buffer);
      } else {
         m_gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
         logger.error("GL_TEXTURE_COORD_ARRAY is disabled.");
      }

      buffer = BufferUtil.newFloatBuffer(Vertices.length * 3);
      for (int Icount = 0; Icount < Vertices.length; Icount++) {
         buffer.put(Vertices[Icount].pos.x);
         buffer.put(Vertices[Icount].pos.y);
         buffer.put(Vertices[Icount].pos.z);
      }
      buffer.rewind();
      m_gl.glVertexPointer(3, GL.GL_FLOAT, 0, buffer);

      if (normals == null) {
         m_gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
         logger.error("GL_NORMAL_ARRAY is enabled.");
         buffer = BufferUtil.newFloatBuffer(Vertices.length);
         for (int Icount = 0; Icount < Vertices.length; Icount++) {
            buffer.put(Vertices[Icount].normal.x);
         }
         buffer.rewind();
         m_gl.glNormalPointer(GL.GL_FLOAT, 0, buffer);

         ShortBuffer shBuf = BufferUtil.newShortBuffer(faces.length * 3);
         for (int Icount = faceindex; Icount < faces.length; Icount++) {
            shBuf.put((short) faces[Icount].a);
            shBuf.put((short) faces[Icount].b);
            shBuf.put((short) faces[Icount].c);
         }
         shBuf.rewind();
         
         m_gl.glDrawElements(GL.GL_TRIANGLES, (int) nbIndex,GL.GL_UNSIGNED_SHORT, shBuf);         m_gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
         logger.error("GL_NORMAL_ARRAY is disabled.");
      } else {
         m_gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
         logger.error("GL_NORMAL_ARRAY is disabled.");
         m_gl.glBegin(GL.GL_TRIANGLES);
         for (int i = 0, face = 0; i < nbIndex; i += 3) {
            buffer.put(0, normals[face].x);
            buffer.put(1, normals[face].y);
            buffer.put(2, normals[face].z);
            m_gl.glNormal3fv(buffer);
            m_gl.glArrayElement(faces[face + faceindex].a);
            m_gl.glArrayElement(faces[face + faceindex].b);
            m_gl.glArrayElement(faces[face + faceindex].c);
            face++;
         }
         m_gl.glEnd();
         m_gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
         logger.error("GL_NORMAL_ARRAY is enabled.");
      }

      m_gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
      logger.error("GL_VERTEX_ARRAY is disabled.");

      if (m_Texturing && !m_GenerateTexCoords) {
         m_gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
         logger.error("GL_TEXTURE_COORD_ARRAY is disabled.");
      }
      logger.error("");



******************

Regards
Vinod Patel