I have drawn a triangle mesh with 10000 vertices(100x100) and it will be a grass ground. I used gldrawelements() for it. I have looked all day and still can&#39;t understand how to calculate the normals for this. Does each vertex have its own normals or does each triangle have its own normals? Can someone point me in the right direction on how to edit my code to incorporate normals?

    struct vertices {
    	GLfloat x;
    	GLfloat y;
    	GLfloat z;
    }vertices[10000];
    
    GLuint indices[60000];
    
    /*
    99..9999
    98..9998
    ........
    01..9901
    00..9900
    */
    
    void CreateEnvironment() {
    	int count=0;
    	for (float x=0;x&lt;10.0;x+=.1) {
    		for (float z=0;z&lt;10.0;z+=.1) {
    			vertices[count].x=x;
    			vertices[count].y=0;
    			vertices[count].z=z;
    			count++;
    		}
    	}
    	count=0;
    	for (GLuint a=0;a&lt;99;a++){
    		for (GLuint b=0;b&lt;99;b++){
    			GLuint v1=(a*100)+b;indices[count]=v1;count++;
    			GLuint v2=(a*100)+b+1;indices[count]=v2;count++;
    			GLuint v3=(a*100)+b+100;indices[count]=v3;count++;
    		}
    	}
    	count=30000;
    	for (GLuint a=0;a&lt;99;a++){
    		for (GLuint b=0;b&lt;99;b++){
    			indices[count]=(a*100)+b+100;count++;//9998
    			indices[count]=(a*100)+b+1;count++;//9899
    			indices[count]=(a*100)+b+101;count++;//9999
    		}
    	}
    }
    
    void ShowEnvironment(){
    	//ground
    	glPushMatrix();
    	GLfloat GroundAmbient[]={0.0,0.5,0.0,1.0};
    	glMaterialfv(GL_FRONT,GL_AMBIENT,GroundAmbient);
    	glEnableClientState(GL_VERTEX_ARRAY);
    	glIndexPointer( GL_UNSIGNED_BYTE, 0, indices );
    	glVertexPointer(3,GL_FLOAT,0,vertices);
    	glDrawElements(GL_TRIANGLES,60000,GL_UNSIGNED_INT,indices);
    	glDisableClientState(GL_VERTEX_ARRAY);
    	glPopMatrix();
    }

EDIT 1
Here is the code I have written out. I just used arrays instead of vectors and I stored all of the normals in the struct called normals. It still doesn&#39;t work however. I get an unhandled exception at *indices.

    struct Normals {
    	GLfloat x;
    	GLfloat y;
    	GLfloat z;
    }normals[20000];
    Normals* normal = normals;
    //***************************************ENVIRONMENT*************************************************************************
    struct vertices {
    	GLfloat x;
    	GLfloat y;
    	GLfloat z;
    }vertices[10000];
    
    GLuint indices[59403];
    
    /*
    99..9999
    98..9998
    ........
    01..9901
    00..9900
    */
    
    void CreateEnvironment() {
    	int count=0;
    	for (float x=0;x&lt;10.0;x+=.1) {
    		for (float z=0;z&lt;10.0;z+=.1) {
    			vertices[count].x=x;
    			vertices[count].y=rand()%2-2;;
    			vertices[count].z=z;
    			count++;
    		}
    	}
    	//calculate normals 
    	GLfloat vector1[3];//XYZ
    	GLfloat vector2[3];//XYZ
    	count=0;
    	for (int x=0;x&lt;9900;x+=100){
    		for (int z=0;z&lt;99;z++){
    			vector1[0]= vertices[x+z].x-vertices[x+z+1].x;//vector1x
    			vector1[1]= vertices[x+z].y-vertices[x+z+1].y;//vector1y
    			vector1[2]= vertices[x+z].z-vertices[x+z+1].z;//vector1z
    			vector2[0]= vertices[x+z+1].x-vertices[x+z+100].x;//vector2x
    			vector2[1]= vertices[x+z+1].y-vertices[x+z+100].y;//vector2y
    			vector2[2]= vertices[x+z+1].z-vertices[x+z+100].z;//vector2z
    			normals[count].x= vector1[1] * vector2[2]-vector1[2]*vector2[1];
    			normals[count].y= vector1[2] * vector2[0] - vector1[0] * vector2[2];
    			normals[count].z= vector1[0] * vector2[1] - vector1[1] * vector2[0];count++;
    		}
    	}
    	count=10000;
    	for (int x=100;x&lt;10000;x+=100){
    		for (int z=0;z&lt;99;z++){
    			vector1[0]= vertices[x+z].x-vertices[x+z+1].x;//vector1x -- JUST ARRAYS
    			vector1[1]= vertices[x+z].y-vertices[x+z+1].y;//vector1y
    			vector1[2]= vertices[x+z].z-vertices[x+z+1].z;//vector1z
    			vector2[0]= vertices[x+z+1].x-vertices[x+z-100].x;//vector2x
    			vector2[1]= vertices[x+z+1].y-vertices[x+z-100].y;//vector2y
    			vector2[2]= vertices[x+z+1].z-vertices[x+z-100].z;//vector2z
    			normals[count].x= vector1[1] * vector2[2]-vector1[2]*vector2[1];
    			normals[count].y= vector1[2] * vector2[0] - vector1[0] * vector2[2];
    			normals[count].z= vector1[0] * vector2[1] - vector1[1] * vector2[0];count++;
    		}
    	}
    
    	count=0;
    	for (GLuint a=0;a&lt;99;a++){
    		for (GLuint b=0;b&lt;99;b++){
    			GLuint v1=(a*100)+b;indices[count]=v1;count++;
    			GLuint v2=(a*100)+b+1;indices[count]=v2;count++;
    			GLuint v3=(a*100)+b+100;indices[count]=v3;count++;
    		}
    	}
    	count=30000;
    	for (GLuint a=0;a&lt;99;a++){
    		for (GLuint b=0;b&lt;99;b++){
    			indices[count]=(a*100)+b+100;count++;//9998
    			indices[count]=(a*100)+b+1;count++;//9899
    			indices[count]=(a*100)+b+101;count++;//9999
    		}
    	}
    }
    
    void ShowEnvironment(){
    	//ground
    	glPushMatrix();
    	GLfloat GroundAmbient[]={0.0,0.5,0.0,1.0};
    	GLfloat GroundDiffuse[]={1.0,0.0,0.0,1.0};
    	glMaterialfv(GL_FRONT,GL_AMBIENT,GroundAmbient);
    	glMaterialfv(GL_FRONT,GL_DIFFUSE,GroundDiffuse);
    	glEnableClientState(GL_VERTEX_ARRAY);
    	glEnableClientState(GL_NORMAL_ARRAY);
    	glNormalPointer( GL_FLOAT, 0, normal);
    	glVertexPointer(3,GL_FLOAT,0,vertices);
    	glDrawElements(GL_TRIANGLES,60000,GL_UNSIGNED_INT,indices);
    	glDisableClientState(GL_VERTEX_ARRAY);
    	glDisableClientState(GL_NORMAL_ARRAY);
    	glPopMatrix();
    }
    //***************************************************************************************************************************

All Normals Solutions on Gang of Coders

Total of 1 Normals Solutions

Calculating normals in a triangle mesh