error C2143: syntax error : missing ';' before '*' - c++

Question

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'
#include <sstream>
#include <numeric>
#include <math.h>
#include "Polygon.h"
#define PI 3.14159265
//use standard namespace
using namespace std;
/**************************** 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_ */
Polygon.cpp
#include "Polygon.h"
using namespace std;
Polygon::Polygon(){
sides = 0;
}
Polygon::Polygon(int numberOfSides, double** polyVerticies){
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){
spec_ex = exponent;
}
void Polygon::setSurfaceNormals(double x, double y, double z){
surface_normals[0] = x;
surface_normals[1] = y;
surface_normals[2] = z;
}
void Polygon::setAmbientReflection(double r, double g, double b){
ambient_reflection[0] = r;
ambient_reflection[1] = g;
ambient_reflection[2] = b;
}
void Polygon::setDiffuseReflection(double r, double g, double b){
diffuse_reflection[0] = r;
diffuse_reflection[1] = g;
diffuse_reflection[2] = b;
}
void Polygon::setSpecularReflection(double r, double g, double b){
specular_reflection[0] = r;
specular_reflection[1] = g;
specular_reflection[2] = b;
}
void Polygon::setEmissiveColor(double r, double g, double b){
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;
}
Thanks for any help anyone can offer.

Answer 1

Your Polygon class conflicts with a Polygon function defined in wingdi.h :
WINGDIAPI BOOL WINAPI Polygon(HDC,const POINT*,int);
You could fix this error by putting the Polygon class in a namespace of yours.

Answer 2

Your Error is caused by there being a polygon type already defined in a windows system file. Put your Polygon type in a namespace and fully qualifie it.

Answer 3

From the third error, it looks like there could be a conflicting declaration for "Polygon" in your code. Try enclosing Polygon in a namespace?

Answer 4

I have a feeling the issue at hand here is the last of the errors you listed. Namely:
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'
Try putting your Polygon class in a separate namespace to prevent the name clash. That should clear it up. And reference it by the fully scoped name in application.cpp.

Answer 5

You are naming that class "Polygon" inside a namespace where a class with that name is already present (in wingdi.h). Do you read error message?

Answer 6

This is far too much code. Cut out as much as you can and see whether the error persists, before you post a bolus like this.
I don't have access to VS, so I can't test, but this looks like a namespace problem; your `Polygon` is in conflict with a Microsoft `Polygon`. So use your own namespace and don't say `using namespace std`, it's a scattergun.

Answer 7

You are getting an ambiguous name call of Polygon perhaps?
Would be better if you at least indicated which line is 121
By the way, why do you use arrays rather than vector and why are you overloading operator new?

Answer 8

I also encountered the same error, the reason for the error is that i have declaration and definition a B class in my A.cpp file and use B as
Member variables of A in A.h file. finally i solved this error by declaring class B in my A.h file.