Ok, I'm not new to C++ but I am used to running a g++ compiler vs Microsoft's VS C++. I understand what this error should mean. It should mean that I'm missing a ';' on the line before or in the class Polygon. I can't seem to find anything wrong. g++ compiles the code without error. It seems like the Polygon Class isn't being loaded. Can anyone please show me what I'm missing please. I have the Application.cpp, Polygon.h, and Polygon.cpp below.

Application.cpp throwing errors but if I can fix the first others will follow:

application.cpp(121) : error C2143: syntax error : missing ';' before '*'
application.cpp(121) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
application.cpp(121) : error C2365: 'Polygon' : redefinition; previous definition was 'function'
c:\program files\microsoft sdks\windows\v6.0a\include\wingdi.h(4203) : see declaration of 'Polygon'
application.cpp(121) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
application.cpp(149) : error C2061: syntax error : identifier 'Polygon'
application.cpp(166) : error C2065: 'temp' : undeclared identifier
application.cpp(166) : error C2061: syntax error : identifier 'Polygon'
application.cpp(169) : error C2065: 'temp' : undeclared identifier
application.cpp(173) : error C2065: 'temp' : undeclared identifier
application.cpp(190) : error C2061: syntax error : identifier 'Polygon'
application.cpp(191) : error C2227: left of '->setAmbientReflection' must point to class/struct/union/generic type
type is 'int *'
application.cpp(192) : error C2227: left of '->setDiffuseReflection' must point to class/struct/union/generic type
type is 'int *'
application.cpp(193) : error C2227: left of '->setSpecularReflection' must point to class/struct/union/generic type
type is 'int *'
application.cpp(194) : error C2227: left of '->setEmissiveColor' must point to class/struct/union/generic type
type is 'int *'
application.cpp(195) : error C2227: left of '->setSurfaceNormals' must point to class/struct/union/generic type
type is 'int *'
application.cpp(196) : error C2227: left of '->setSpecularExponent' must point to class/struct/union/generic type
type is 'int *'
application.cpp(398) : error C2227: left of '->getSpecularReflection' must point to class/struct/union/generic type
type is 'int *'
application.cpp(422) : error C2227: left of '->getSpecularReflection' must point to class/struct/union/generic type
type is 'int *'
application.cpp(444) : error C2227: left of '->getSpecularExponent' must point to class/struct/union/generic type
type is 'int *'
application.cpp(447) : error C2227: left of '->setSpecularExponent' must point to class/struct/union/generic type
type is 'int *'
application.cpp(449) : error C2227: left of '->setSpecularExponent' must point to class/struct/union/generic type
type is 'int *'
application.cpp(464) : error C2227: left of '->getSpecularExponent' must point to class/struct/union/generic type
type is 'int *'
application.cpp(467) : error C2227: left of '->setSpecularExponent' must point to class/struct/union/generic type
type is 'int *'
application.cpp(469) : error C2227: left of '->setSpecularExponent' must point to class/struct/union/generic type
type is 'int *'
application.cpp(496) : error C2227: left of '->getEmissiveColor' must point to class/struct/union/generic type
type is 'int *'
application.cpp(540) : error C2227: left of '->getEmissiveColor' must point to class/struct/union/generic type
type is 'int *'
application.cpp(601) : error C2227: left of '->getAmbientReflection' must point to class/struct/union/generic type
type is 'int *'
application.cpp(602) : error C2227: left of '->getDiffuseReflection' must point to class/struct/union/generic type
type is 'int *'
application.cpp(603) : error C2227: left of '->getEmissiveColor' must point to class/struct/union/generic type
type is 'int *'
application.cpp(604) : error C2227: left of '->getSpecularReflection' must point to class/struct/union/generic type
type is 'int *'
application.cpp(610) : error C2227: left of '->getSides' must point to class/struct/union/generic type
type is 'int *'
application.cpp(616) : error C2227: left of '->getSpecularExponent' must point to class/struct/union/generic type
type is 'int *'
application.cpp(622) : error C2227: left of '->getSurfaceNormals' must point to class/struct/union/generic type
type is 'int *'
application.cpp(623) : error C2227: left of '->getVertex' must point to class/struct/union/generic type
type is 'int *'

//includes depending if on a Mac or Wintel Machine
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

//includes for Strings and Streams
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <numeric>
#include <math.h>
#include "Polygon.h"

#define PI 3.14159265

//use standard namespace
using namespace std;

//class Polygon;

/**************************** Window Variables ****************************/

double _window_height			= 500;
double _window_width			= 500;
double _window_position_x		= 0;
double _window_position_y		= 0;

string _window_title ("Assignment 5");

/**************************** Object Variables ****************************/

int _my_shape					= 0;
GLint _object_shine 			= 40;
double _object_y_rotation		= 0;

GLfloat ambient_reflection[3]	= {1.0, 1.0, 1.0};
GLfloat diffuse_reflection[3]	= {1.0, 1.0, 1.0};
GLfloat specular_reflection[3]	= {1.0, 1.0, 1.0};
GLfloat emissive_color[3]		= {0.0, 0.0, 0.0};
int specular_exponent			= 0;

/*************************** Lighting Variables ***************************/

//Global Light settings

GLfloat _global_ambient_light[] = {0.5, 0.5, 0.5, 1.0};
GLfloat _global_diffuse_light[] = {0.7, 0.7, 0.7, 1.0};

int rotation_int 				= 0;
int rotation_angle				= 90;
int _CAMERA_DISTANCE			= 2;

//Light 0 Settings

GLfloat _z_axis_rotations[8][4]	= {{(_CAMERA_DISTANCE*cos((90)*PI/180)), (_CAMERA_DISTANCE*sin((90)*PI/180)), 0.0, 1.0},
									{(_CAMERA_DISTANCE*cos((45)*PI/180)), (_CAMERA_DISTANCE*sin((45)*PI/180)), 0.0, 1.0},
									{(_CAMERA_DISTANCE*cos((0)*PI/180)), (_CAMERA_DISTANCE*sin((0)*PI/180)), 0.0, 1.0},
									{(_CAMERA_DISTANCE*cos((315)*PI/180)), (_CAMERA_DISTANCE*sin((315)*PI/180)), 0.0, 1.0},
									{(_CAMERA_DISTANCE*cos((270)*PI/180)), (_CAMERA_DISTANCE*sin((270)*PI/180)), 0.0, 1.0},
									{(_CAMERA_DISTANCE*cos((225)*PI/180)), (_CAMERA_DISTANCE*sin((225)*PI/180)), 0.0, 1.0},
									{(_CAMERA_DISTANCE*cos((180)*PI/180)), (_CAMERA_DISTANCE*sin((180)*PI/180)), 0.0, 1.0},
									{(_CAMERA_DISTANCE*cos((135)*PI/180)), (_CAMERA_DISTANCE*sin((135)*PI/180)), 0.0, 1.0}};

GLfloat _ambient_0_light[] 		= {0.3f, 0.3f, 0.3f, 1.0f};
GLfloat _diffuse_0_light[] 		= {0.6f, 0.6f, 0.6f, 1.0f};
GLfloat _specular_0_light[] 	= {0.6f, 0.6f, 0.6f, 1.0f};
GLfloat _specular_0_property[] 	= {0.6f, 0.6f, 0.6f, 1.0f};


//Light 1 Settings

// Green Spotlight with narrow angle
GLfloat _light_1_position[] 	= {2.0, 0.0, -0.5, 1.0};
GLfloat _diffuse_1_light[] 		= {0.2, 0.4, 0.9, 1.0};
GLfloat _spot_1_direction[] 	= {-0.3, -2.0, -0.3};


//Light 2 Settings

// Red Spotlight with wide angle
GLfloat _light_2_position[] 	= {0.3, -0.5, 4.0, 1.0};
GLfloat _diffuse_2_light[] 		= {1.0, 0.2, 0.6, 1.0};
GLfloat _spot_2_direction[] 	= {0.3, -0.5, -2.0};

GLfloat _cutoff 				= 90.0;

GLfloat _AMBIENT_CONSTANT		= 0.1;
GLfloat _DIFFUSE_CONSTANT		= 0.1;
GLfloat _EMISSION_CONSTANT		= 0.05;
GLfloat _SPECULAR_CONSTANT		= 0.1;
int _SPECULAR_EXPONENT_CONSTANT = 1;
int _CUTOFF_CONSTANT			= 1;


/*************************** Shading Variables ***************************/

bool _shade_model_smooth		= true;


/**************************** File Variables *****************************/

//Error String printed if the file is not found
string _FILE_OPEN_ERROR = "Error: File could not be found or opened.";

//Error String printed if the file is not formed correctly
string _CHOICE_INVALID_ERROR = "Error: The choice you made was not one that is defined.";

/** for file reading **/
//The Array for holding all the Polygons
Polygon** _Polygons;
//the current size of the Polygon Array
int _polygons_max = 10;
//the current element for processing in the Polygon Array
int _polygons_current = 0;


/* ReadFromFile
 *
 * This method will ask a filename from the user and either return to
 * the user a file not found error or will read in from the file the
 * coordinates and place them in the coordinate array, while also setting
 * the number of lines that make up a shape.
 */
void ReadFromFile(){

	ifstream input; //  input file stream
	string filename = ""; //  used to store filename
	string line = ""; // temporary storage for reading lines at a time

	//	cout << "Type a filename and press Enter: ";
	//	cin >> filename;
	//cout << "Type a filename and press Enter: dodecahedron.dat" << endl;
	filename = "dodec.dat";//"dodecahedron.dat"; //should be 36 polygons

	input.open (filename.c_str(), ifstream::in);//try to open the file
	if(input.is_open()){ //check if file is open

		_Polygons = new Polygon*[_polygons_max];

		double _light_settings[12] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
		int SH = 0;
		double _normals[3] = {0.0, 0.0, 0.0};

		int _coordinate_count = 0;
		int _coordinate_max = 4;
		double** _coordinates = new double*[_coordinate_max];


		while (input.good()){ //not eof or failbit

			/* Ensure space is available */
			if(_polygons_current >= _polygons_max){

				_polygons_max = _polygons_max * 2; //double max size
				Polygon** temp = new Polygon*[_polygons_max]; //create bigger array

				for (int j = 0; j <_polygons_current; j++) {
					temp[j] = _Polygons[j]; // copy values to new array.
				}

				delete [] _Polygons; //free old array memory
				_Polygons = temp; //transfer polygons
			}

			getline(input, line); //get the line from input

			string::size_type _last_pos = line.find_first_not_of(" ", 0);
			string::size_type _pos = line.find_first_of(" ", _last_pos);

			if((line.substr(_last_pos, _pos - _last_pos)).c_str()[0] == '#'){ //comment
				//do nothing for this line
			}else if((line.substr(_last_pos, _pos - _last_pos)).c_str()[0] == 'J' ||
					(line.substr(_last_pos, _pos - _last_pos)).c_str()[0] == 'j'){ //polygon start

				if(_coordinate_count != 0){

					//cout << "Polygon #" << _polygons_current << endl;

					_Polygons[_polygons_current] = new Polygon(_coordinate_count, _coordinates);
					_Polygons[_polygons_current]->setAmbientReflection(_light_settings[0], _light_settings[1], _light_settings[2]);
					_Polygons[_polygons_current]->setDiffuseReflection(_light_settings[3], _light_settings[4], _light_settings[5]);
					_Polygons[_polygons_current]->setSpecularReflection(_light_settings[6], _light_settings[7], _light_settings[8]);
					_Polygons[_polygons_current]->setEmissiveColor(_light_settings[9], _light_settings[10], _light_settings[11]);
					_Polygons[_polygons_current]->setSurfaceNormals(_normals[0], _normals[1], _normals[2]);
					_Polygons[_polygons_current]->setSpecularExponent(SH);

					for(int i=0; i<_coordinate_count; i++){
						delete _coordinates[i];
					}

					_coordinate_count = 0;
					_polygons_current++;
				}

				if(line.find_first_not_of(" ", _pos) != string::npos){

					for(int i=0; i<12; i++){
						_last_pos = line.find_first_not_of(" ", _pos);
						_pos = line.find_first_of(" ", _last_pos);
						_light_settings[i] = atof(line.substr(_last_pos, _pos - _last_pos).c_str());
					}

					_last_pos = line.find_first_not_of(" ", _pos);
					_pos = line.find_first_of(" ", _last_pos);
					SH = atoi(line.substr(_last_pos, _pos - _last_pos).c_str());

					for(int i=0; i<3; i++){
						_last_pos = line.find_first_not_of(" ", _pos);
						_pos = line.find_first_of(" ", _last_pos);
						_normals[i] = atof(line.substr(_last_pos, _pos - _last_pos).c_str());
					}
				}

			}else{

				/* Ensure space is available */
				if(_coordinate_count >= _coordinate_max){

					_coordinate_max = _coordinate_max * 2; //double max size
					double** temp = new double*[_coordinate_max]; //create bigger array

					for (int i = 0; i < _coordinate_count; i++) {
						temp[i] = new double[3];
						temp[i][0] = _coordinates[i][0]; // copy values to new array.
						temp[i][1] = _coordinates[i][1];
						temp[i][2] = _coordinates[i][3];
					}

					delete [] _coordinates; //free old array memory
					_coordinates = temp; //transfer polygons
				}

				_coordinates[_coordinate_count] = new double[3];

				for(int i=0; i<3; i++){
					_coordinates[_coordinate_count][i] = atof(line.substr(_last_pos, _pos - _last_pos).c_str());
					_last_pos = line.find_first_not_of(" ", _pos);
					_pos = line.find_first_of(" ", _last_pos);
				}
				_coordinate_count++;
			}
		}

		input.close();

	}else{

		//if the file could not be opened output to the screen the error
		cout << _FILE_OPEN_ERROR;
		exit(0);
	}
}


/* InitializeWindow
 *
 * Initializes the GLUT Library settings and creates a window for the
 * program to be displayed in.
 *
 */
void InitializeWindow(int argc, char** argv){

	glutInit(&argc,argv); /* Initialize GLUT */
	glutInitDisplayMode( GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH );/* Specify display mode */
	glutInitWindowSize(_window_width, _window_height); /* Set window size */
	glutInitWindowPosition(_window_position_x, _window_position_y); /* Set window position */
	glutCreateWindow(_window_title.c_str()); /* Create Window */
}


/* InitializeEnvironment
 *
 * Initializes the Glut environment in which the drawing is to be done.
 */
void InitializeEnvironment(){

	glClearColor (0.0, 0.0, 0.0, 0.0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, _global_ambient_light);
	glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, _global_diffuse_light);

	glLoadIdentity();
	glLightfv(GL_LIGHT0, GL_POSITION, _z_axis_rotations[0]);
	glLightfv(GL_LIGHT0, GL_SPECULAR, _specular_0_light);
	glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, _cutoff);
	glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0);

	glLoadIdentity();
	glLightfv(GL_LIGHT1, GL_POSITION, _light_1_position);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, _diffuse_1_light);
	//
	//	glLoadIdentity();
	//	glLightfv(GL_LIGHT2, GL_POSITION, light3_position);
	//	glLightfv(GL_LIGHT2, GL_DIFFUSE, light3_diffuse_light);

	glEnable(GL_LIGHTING);
	glEnable(GL_DEPTH_TEST);

	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHT1);

	if(_my_shape == 1){
		glFrontFace(GL_CW);
	}else{
		glFrontFace(GL_CCW);
	}

	glEnable(GL_CULL_FACE);

}

// In the main method we registered this method as the callback function for
// Keyboard input.  Anytime a key is pressed the ascii value of the key and
// the x and y positions of the mouse cursor within the window are passed to
// this function.
void Keyboard(unsigned char key, int x, int y) {

	switch (key) {
	case '1':
		glEnable(GL_LIGHT0);
		break;
	case '2':
		glEnable(GL_LIGHT1);
		break;
	case '+': /* Increase the cutoff angle of the positional light. */
		if(_cutoff == 90){
			_cutoff = 180;
		}else if((_cutoff-_CUTOFF_CONSTANT) > 180){
			_cutoff = 180;
		}else{
			_cutoff += _CUTOFF_CONSTANT;
		}
		glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, _cutoff);
		break;
	case '-': /* Decrease the cutoff angle of the positional light. */
		if(_cutoff == 180){
			_cutoff = 90;
		}else if((_cutoff-_CUTOFF_CONSTANT) < 0){
			_cutoff = 0;
		}else{
			_cutoff -= _CUTOFF_CONSTANT;
		}
		glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, _cutoff);
		break;
	case '0': /* Turn off the directional and positional light. */
		glDisable(GL_LIGHT0);
		glDisable(GL_LIGHT1);
		break;
	case 'a': /* Decrease the ambient light. */
		if(_global_ambient_light[0]>0){
			_global_ambient_light[0] = _global_ambient_light[1] = _global_ambient_light[2] -= _AMBIENT_CONSTANT;
			glLightModelfv(GL_LIGHT_MODEL_AMBIENT, _global_ambient_light);
		}
		break;
	case 'A': /* Increase the ambient light. */
		if(_global_ambient_light[0]<1){
			_global_ambient_light[0] = _global_ambient_light[1] = _global_ambient_light[2] += _AMBIENT_CONSTANT;
			glLightModelfv(GL_LIGHT_MODEL_AMBIENT, _global_ambient_light);
		}
		break;
	case 'd': /* Decrease the diffuse light. */
		if(_global_diffuse_light[0]>0){
			_global_diffuse_light[0] = _global_diffuse_light[1] = _global_diffuse_light[2] -= _DIFFUSE_CONSTANT;
			glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, _global_diffuse_light);
		}
		break;
	case 'D': /* Increase the diffuse light. */
		if(_global_diffuse_light[0]<1){
			_global_diffuse_light[0] = _global_diffuse_light[1] = _global_diffuse_light[2] += _DIFFUSE_CONSTANT;
			glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, _global_diffuse_light);
		}
		break;
	case 's': /* Decrease the specular component of the positional light. */
		if(_my_shape != 1){
			for(int i=0; i<3; i++){
				if((specular_reflection[i]-_SPECULAR_CONSTANT) < -1.0){
					specular_reflection[i] = -1.0;
				}else{
					specular_reflection[i] -= _SPECULAR_CONSTANT;
				}
			}
		}else{
			for(int i=0; i < _polygons_current; i++){ //Over all Polygons

				double* sr = _Polygons[i]->getSpecularReflection();

				for(int j=0; j<3; j++){
					if((sr[j]-_SPECULAR_CONSTANT) < -1.0){
						sr[j] = -1.0;
					}else{
						sr[j] -= _SPECULAR_CONSTANT;
					}
				}
			}
		}
		break;
	case 'S': /* Increase the specular component of the positional light. */
		if(_my_shape != 1){
			for(int i=0; i<3; i++){
				if((specular_reflection[i]+_SPECULAR_CONSTANT) > 1.0){
					specular_reflection[i] = 1.0;
				}else{
					specular_reflection[i] += _SPECULAR_CONSTANT;
				}
			}
		}else{
			for(int i=0; i < _polygons_current; i++){ //Over all Polygons

				double* sr = _Polygons[i]->getSpecularReflection();

				for(int j=0; j<3; j++){
					if((sr[j]+_SPECULAR_CONSTANT) > 1.0){
						sr[j] = 1.0;
					}else{
						sr[j] += _SPECULAR_CONSTANT;
					}
				}
			}
		}
		break;
	case 'h': /* Decrease the shininess of the object. */
		if(_my_shape != 1){
			if((specular_exponent-_SPECULAR_EXPONENT_CONSTANT) < 0){
				specular_exponent = 0;
			}else{
				specular_exponent-=_SPECULAR_EXPONENT_CONSTANT;
			}
		}else{
			for(int i=0; i < _polygons_current; i++){ //Over all Polygons

				int sh = _Polygons[i]->getSpecularExponent();

				if((sh-_SPECULAR_EXPONENT_CONSTANT) < 0){
					_Polygons[i]->setSpecularExponent(0);
				}else{
					_Polygons[i]->setSpecularExponent(sh-_SPECULAR_EXPONENT_CONSTANT);
				}
			}
		}
		break;
	case 'H': /* Increase the shininess of the object. */
		if(_my_shape != 1){
			if((specular_exponent+_SPECULAR_EXPONENT_CONSTANT) > 128){
				specular_exponent = 128;
			}else{
				specular_exponent+=_SPECULAR_EXPONENT_CONSTANT;
			}
		}else{
			for(int i=0; i < _polygons_current; i++){ //Over all Polygons

				int sh = _Polygons[i]->getSpecularExponent();

				if((sh+_SPECULAR_EXPONENT_CONSTANT) > 128){
					_Polygons[i]->setSpecularExponent(128);
				}else{
					_Polygons[i]->setSpecularExponent(sh+_SPECULAR_EXPONENT_CONSTANT);
				}
			}
		}
		break;
	case 'e': /* Decrease the emissive light of the object. */
		if(_my_shape != 1){
			if((emissive_color[0]-_EMISSION_CONSTANT) < 0){
				emissive_color[0] = 0;
			}else{
				emissive_color[0] -= _EMISSION_CONSTANT;
			}

			if((emissive_color[1]-_EMISSION_CONSTANT) < 0){
				emissive_color[1] = 0;
			}else{
				emissive_color[1] -= _EMISSION_CONSTANT;
			}

			if((emissive_color[2]-_EMISSION_CONSTANT) < 0){
				emissive_color[2] = 0;
			}else{
				emissive_color[2] -= _EMISSION_CONSTANT;
			}
		}else{
			for(int i=0; i < _polygons_current; i++){ //Over all Polygons

				double* ep = _Polygons[i]->getEmissiveColor();

				if((ep[0]-_EMISSION_CONSTANT) < 0){
					ep[0] = 0;
				}else{
					ep[0] -= _EMISSION_CONSTANT;
				}

				if((ep[1]-_EMISSION_CONSTANT) < 0){
					ep[1] = 0;
				}else{
					ep[1] -= _EMISSION_CONSTANT;
				}

				if((ep[2]-_EMISSION_CONSTANT) < 0){
					ep[2] = 0;
				}else{
					ep[2] -= _EMISSION_CONSTANT;
				}
			}
		}
		break;
	case 'E': /* Increase the emissive light of the object. */
		if(_my_shape != 1){
			if((emissive_color[0]+_EMISSION_CONSTANT) > 1){
				emissive_color[0] = 1;
			}else{
				emissive_color[0] += _EMISSION_CONSTANT;
			}

			if((emissive_color[1]+_EMISSION_CONSTANT) > 1){
				emissive_color[1] = 1;
			}else{
				emissive_color[1] += _EMISSION_CONSTANT;
			}

			if((emissive_color[2]+_EMISSION_CONSTANT) > 1){
				emissive_color[2] = 1;
			}else{
				emissive_color[2] += _EMISSION_CONSTANT;
			}
		}else{
			for(int i=0; i < _polygons_current; i++){ //Over all Polygons

				double* ep = _Polygons[i]->getEmissiveColor();

				if((ep[0]+_EMISSION_CONSTANT) > 1){
					ep[0] = 1;
				}else{
					ep[0] += _EMISSION_CONSTANT;
				}

				if((ep[1]+_EMISSION_CONSTANT) > 1){
					ep[1] = 1;
				}else{
					ep[1] += _EMISSION_CONSTANT;
				}

				if((ep[2]+_EMISSION_CONSTANT) > 1){
					ep[2] = 1;
				}else{
					ep[2] += _EMISSION_CONSTANT;
				}
			}
		}
		break;
	case 'p': /* Rotate the positional light about the Z-axis */
		glLoadIdentity();
		if(rotation_int == 7){
			rotation_int = 0;
		}else{
			rotation_int++;
		}
		glLightfv(GL_LIGHT0, GL_POSITION, _z_axis_rotations[rotation_int]);
		break;
	case 'P': /* Rotate the positional light about the Z-axis */
		glLoadIdentity();
		if(rotation_int == 0){
			rotation_int = 7;
		}else{
			rotation_int--;
		}
		glLightfv(GL_LIGHT0, GL_POSITION, _z_axis_rotations[rotation_int]);
		break;
	case 'o': /* Rotate the objects around the Y-axis : negative */
		_object_y_rotation -= 15.0;
		break;
	case 'O': /* Rotate the objects around the Y-axis : positive */
		_object_y_rotation += 15.0;
		break;
	case 'q': case 'Q': /* Quit the program */
		exit(0);
	}

	//Call redisplay to draw changes
	glutPostRedisplay();
}


void DrawFromFile(){

	glPushMatrix();

	for(int i=0; i < _polygons_current; i++){ //Over all Polygons

		double* ap = _Polygons[i]->getAmbientReflection();
		double* dp = _Polygons[i]->getDiffuseReflection();
		double* ep = _Polygons[i]->getEmissiveColor();
		double* sp = _Polygons[i]->getSpecularReflection();
		GLfloat amt[] = {ap[0], ap[1], ap[2], 1};
		GLfloat dif[] = {dp[0], dp[1], dp[2], 1};
		GLfloat emc[] = {ep[0], ep[1], ep[2], 1};
		GLfloat spc[] = {sp[0], sp[1], sp[2], 1};

		int _p_sides = _Polygons[i]->getSides();

		glMaterialfv(GL_FRONT, GL_AMBIENT, amt);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, dif);
		glMaterialfv(GL_FRONT, GL_EMISSION, emc);
		glMaterialfv(GL_FRONT, GL_SPECULAR, spc);
		glMateriali(GL_FRONT, GL_SHININESS, _Polygons[i]->getSpecularExponent());

		glBegin(GL_POLYGON);

		for(int j=0; j < _p_sides; j++){

			glNormal3dv(_Polygons[i]->getSurfaceNormals());
			glVertex3dv(_Polygons[i]->getVertex(j));
		}

		glEnd();

	}

	glPopMatrix();

}

void Display(void){

	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
	glShadeModel (GL_SMOOTH);

	//Perspective data here
	glMatrixMode(GL_PROJECTION);
	gluPerspective(45, 1, 0, 2);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glPushMatrix();

	switch(_my_shape){

	case 1:
		glTranslated(0, 0, -1);
		glRotated(_object_y_rotation, 0, 1, 0);
		DrawFromFile();
		break;
	case 2:
		glMaterialfv(GL_FRONT, GL_AMBIENT, ambient_reflection);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse_reflection);
		glMaterialfv(GL_FRONT, GL_EMISSION, emissive_color);
		glMaterialfv(GL_FRONT, GL_SPECULAR, specular_reflection);
		glMateriali(GL_FRONT, GL_SHININESS, specular_exponent);
		glRotated(_object_y_rotation, 0, 1, 0);
		glutSolidTeapot(0.8);
		break;
	case 3:
		glMaterialfv(GL_FRONT, GL_AMBIENT, ambient_reflection);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse_reflection);
		glMaterialfv(GL_FRONT, GL_EMISSION, emissive_color);
		glMaterialfv(GL_FRONT, GL_SPECULAR, specular_reflection);
		glMateriali(GL_FRONT, GL_SHININESS, specular_exponent);
		glRotated(_object_y_rotation, 0, 1, 0);
		glutSolidIcosahedron();
		break;
	case 4:
		glMaterialfv(GL_FRONT, GL_AMBIENT, ambient_reflection);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse_reflection);
		glMaterialfv(GL_FRONT, GL_EMISSION, emissive_color);
		glMaterialfv(GL_FRONT, GL_SPECULAR, specular_reflection);
		glMateriali(GL_FRONT, GL_SHININESS, specular_exponent);
		glRotated(_object_y_rotation, 0, 1, 0);
		glutSolidTorus(0.3, 0.8, 10, 30);
		break;
	default:
		cout << _CHOICE_INVALID_ERROR << endl;
		exit(1);
		break;
	}

	glPopMatrix();

	glFlush();

}


int PollUser(){

	int choice = 0;

	cout << "Use the menu below to pick a shape to draw:" << endl << endl;
	cout << "1: Dodecahedron (Drawn from file)" << endl;
	cout << "2: Teapot (GLUT drawn)" << endl;
	cout << "3: Icosahedron (GLUT drawn)" << endl;
	cout << "4: Torus (GLUT drawn)" << endl;
	cout << endl << "Enter choice: ";
	cin >> choice;

	return choice;
}

int main(int argc, char** argv){

	_my_shape = PollUser();
	InitializeWindow(argc, argv); /* Initialize window */
	InitializeEnvironment(); /* Initialize other parameter */
	glutDisplayFunc(Display); /* Redisplay callback event handling */
	glutKeyboardFunc(Keyboard); /* Keyboard callback function */

	ReadFromFile(); /* Read from file */

	glutMainLoop(); /* Start glut functions */

	return 0;
}

Polygon.h

#ifndef POLYGON_H_
#define POLYGON_H_

#include <iostream>
#include <cstdlib>
#include <new>

class Polygon {
public:
	Polygon();
	Polygon(int, double**);
	virtual ~Polygon();
	void *operator new(size_t size);
	void operator delete(void *p);
	void *operator new[](size_t size);
	void operator delete[](void *p);
	double* getVertex(int);
	void setSpecularExponent(int);
	void setSurfaceNormals(double,double,double);
	void setAmbientReflection(double,double,double);
	void setDiffuseReflection(double,double,double);
	void setSpecularReflection(double,double,double);
	void setEmissiveColor(double,double,double);
	int getSides(void);
	int getSpecularExponent(void);
	double* getSurfaceNormals(void);
	double* getAmbientReflection(void);
	double* getDiffuseReflection(void);
	double* getSpecularReflection(void);
	double* getEmissiveColor(void);


private:
	double** verticies;
	double surface_normals[3];
	double ambient_reflection[3];
	double diffuse_reflection[3];
	double specular_reflection[3];
	double emissive_color[3];
	int sides;
	int spec_ex;
};

#endif /* POLYGON_H_ */

and Polygon.cpp

#include "Polygon.h"

using namespace std;

Polygon::Polygon(){

	//cout << "New empty Polygon." << endl;

	sides = 0;
}

Polygon::Polygon(int numberOfSides, double** polyVerticies){

	//cout << "New Polygon with " << numberOfSides << " sides." << endl;

	sides = numberOfSides;
	verticies = new double*[numberOfSides];

	for(int n=0; n<numberOfSides; n++){
		verticies[n] = new double[3];
		verticies[n][0] = polyVerticies[n][0];
		verticies[n][1] = polyVerticies[n][1];
		verticies[n][2] = polyVerticies[n][2];
	}
}

void *Polygon::operator new(size_t size){

	void *p;

	p =  malloc(size);
	if(!p) {
		bad_alloc ba;
		throw ba;
	}
	return p;
}

void Polygon::operator delete(void *p){

	free(p);
}

// new overloaded for loc arrays.
void *Polygon::operator new[](size_t size){

	void *p;

	p =  malloc(size);
	if(!p) {
		bad_alloc ba;
		throw ba;
	}
	return p;
}

void Polygon::operator delete[](void *p){

	free(p);
}

void Polygon::setSpecularExponent(int exponent){

	//cout << "Specular Exponent: " << spec_ex << endl;

	spec_ex = exponent;
}

void Polygon::setSurfaceNormals(double x, double y, double z){

	//cout << "Surface Normals: x-" << x << ", y-" << y << ", z-" << z << endl;

	surface_normals[0] = x;
	surface_normals[1] = y;
	surface_normals[2] = z;
}

void Polygon::setAmbientReflection(double r, double g, double b){

	//cout << "Ambient Reflection: r-" << r << ", g-" << g << ", b-" << b << endl;

	ambient_reflection[0] = r;
	ambient_reflection[1] = g;
	ambient_reflection[2] = b;
}

void Polygon::setDiffuseReflection(double r, double g, double b){

	//cout << "Diffuse Reflection: r-" << r << ", g-" << g << ", b-" << b << endl;

	diffuse_reflection[0] = r;
	diffuse_reflection[1] = g;
	diffuse_reflection[2] = b;
}

void Polygon::setSpecularReflection(double r, double g, double b){

	//cout << "Specular Reflection: r-" << r << ", g-" << g << ", b-" << b << endl;

	specular_reflection[0] = r;
	specular_reflection[1] = g;
	specular_reflection[2] = b;
}

void Polygon::setEmissiveColor(double r, double g, double b){

	//cout << "Emissive Color: r-" << r << ", g-" << g << ", b-" << b << endl;

	emissive_color[0] = r;
	emissive_color[1] = g;
	emissive_color[2] = b;
}

double* Polygon::getVertex(int index){

	if(index < sides){

		double* _temp = new double[3];

		_temp[0] = verticies[index][0];
		_temp[1] = verticies[index][1];
		_temp[2] = verticies[index][2];

		return _temp;
	}

	return new double;
}

int Polygon::getSides(){

	return sides;
}

int Polygon::getSpecularExponent(){

	return spec_ex;
}

double* Polygon::getSurfaceNormals(){

	return surface_normals;
}

double* Polygon::getAmbientReflection(){

	return ambient_reflection;
}

double* Polygon::getDiffuseReflection(){

	return diffuse_reflection;
}

double* Polygon::getSpecularReflection(){

	return specular_reflection;
}

double* Polygon::getEmissiveColor(){

	return emissive_color;
}

Polygon::~Polygon() {
	delete[] verticies;
}

Way too much to see whats going on and the line numbers are off with your errors. Try to create a small program that uses your polygon class in a similar way to see whats going on with it.

Plus this is C++ why not use a vector (or another STL container) to hold your polygons in rather than a dynamic array.

Way too much to see whats going on and the line numbers are off with your errors. Try to create a small program that uses your polygon class in a similar way to see whats going on with it.

Plus this is C++ why not use a vector (or another STL container) to hold your polygons in rather than a dynamic array.

Thanks, but it's a namespace issue. Microsoft includes extra libraries in the std package.

This question has already been answered. Start a new discussion instead.