Hi there I followed the instructions to install freeglut and here for glew. I did this on my windows 7 machine and everything worked fine. Then I did the same on my windows 8 machine. I am using VS 2013 on both machines.
It also works and it seems to compile. But following happens:
1. As I created this as an empty console application the console does show up.
2. I can also see the Glut window in the system tray.
The problem is can not click the Glut window and I can't maximize it. There is always only the console in the foreground.
#include "glew.h"// Include the GLUT header file
#include "GL/glut.h" // Include the GLEW header file
#include "string.h"
struct Vector4
{
float x;
float y;
float z;
float w;
};
//GLSizei = Unsigned Integer
bool* const keyStates = new bool[256](); // Create an array of boolean values of length 256 (0-255)
bool* const keySpecialStates = new bool[256](); // Create an array of boolean values of length 256 (0-255)
bool* const keyPreviousStates = new bool[256]();
GLfloat redDiffuseMaterial[] = { 1.0, 0.0, 0.0 };
GLfloat whiteSpecularMaterial[] = { 1.0, 1.0, 1.0 };
GLfloat greenEmissiveMaterial[] = { 0.0, 1.0, 0.0 };
GLfloat blankMaterial[] = { 0.0, 0.0, 0.0 };
GLfloat mShininess[] = { 128 };
GLfloat whiteSpecularLight[] = { 1.0, 1.0, 1.0 };
GLfloat blackAmbientLight[] = { 0.0, 0.0, 0.0 };
GLfloat whiteDiffuseLight[] = { 1.0, 1.0, 1.0 };
bool diffuse = false;
bool emissive = false;
bool specular = false;
bool movingUp = false; // Whether or not we are moving up or down
float yLocation = 0.0f; // Keep track of our position on the y axis.
float yRotationAngle = 0.0f; // The angle of rotation for our object
Vector4 bgColor = { 1.0f, 1.0f, 1.0f, 1.0f };
void renderPrimitive(void)
{
glBegin(GL_QUADS); // Start drawing a quad primitive
//glBegin(GL_LINE_LOOP);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex3f(-1.0f, -1.0f, 0.0f); //Bottom Left
glColor3f(0.0f, 1.0f, 0.0f);
glVertex3f(-1.0f, 1.0f, 0.0f); //Top Left
glColor3f(0.0f, 0.0f, 1.0f);
glVertex3f(1.0f, 1.0f, 0.0f); //Top Right
glColor3f(0.0f, 0.0f, 0.0f);
glVertex3f(1.0f, -1.0f, 0.0f); //Bottom Right
glEnd();
}
void keyOperations(void)
{
if ((!keyStates['e']) && keyPreviousStates['e']) // If the 'a' key has been pressed
{
// Perform 'a' key operations
//exit(0);
/*bgColor.x = 1.0f;
bgColor.y = .0f;
bgColor.z = .0f;*/
}
}
void keySpecialOperations(void)
{
if (keySpecialStates[GLUT_KEY_LEFT]) // If the left arrow key has been pressed
{
// Perform left arrow key operations
}
}
void moveObject(void)
{
if (movingUp) // If we are moving up
{
yLocation -= 0.0025f; // Move up along our yLocation
}
else // Otherwise
{
yLocation += 0.0025f; // Move down along our yLocation
}
if (yLocation < -3.0f) // If we have gone up too far
{
movingUp = false; // Reverse our direction so we are moving down
}
else if (yLocation > 3.0f) // Else if we have gone down too far
{
movingUp = true; // Reverse our direction so we are moving up
}
yRotationAngle += 0.005f; // Increment our rotation value
if (yRotationAngle > 360.0f) // If we have rotated beyond 360 degrees (a full rotation)
{
yRotationAngle = 0.0f; // Subtract 360 degrees off of our rotation
}
}
void light(void)
{
glLightfv(GL_LIGHT0, GL_SPECULAR, whiteSpecularLight);
glLightfv(GL_LIGHT0, GL_AMBIENT, blackAmbientLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteDiffuseLight);
}
void cubeWireCustom(void)
{
glTranslatef(0.0f, yLocation, -5.0f);
glRotatef(yRotationAngle, 0.0f, 1.0f, 0.0f);
glColor4f(1.0f, 0.0f, 0.0f, 0.5f);
glScalef(0.5f, 1.0f, 2.0f);
glutSolidCube(2.0f);
glutWireCube(2.0f);
}
void display(void) {
moveObject();
keyOperations();
keySpecialOperations();
glEnable(GL_BLEND); // Enable the OpenGL Blending functionality
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Set the blend mode to blend our current RGBA with what is already in the buffer
glClearColor(bgColor.x, bgColor.y, bgColor.z, bgColor.w);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Clear the colour buffer (more buffers later on)
glLoadIdentity(); // Load the Identity Matrix to reset our drawing locations
gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
light();
glTranslatef(0.0f, 0.0f, -5.0f); // Push eveything 5 units back into the scene, otherwise we won't see the primitive
//renderPrimitive();
cubeWireCustom();
//renderPrimitive(); //render the primitive
//glutWireCube(2.0f);
//glutWireSphere(2.0f,20,20);
//glutWireTeapot(2.0f);
//glutSolidTeapot(2.0f);
glutSwapBuffers(); //Swap our buffers
memcpy(keyPreviousStates, keyStates, 256 * sizeof(bool));
}
void reshape(int width, int height)
{
glViewport(0, 0, (GLsizei)width, (GLsizei)height); // Set our viewport to the size of our window. (0,0) being bottom left in the window.
glMatrixMode(GL_PROJECTION);
glLoadIdentity(); // Reset the projection matrix to the identity matrix so that we don't get any artifacts (cleaning up)
gluPerspective(60, (GLfloat)width / (GLfloat)height, 1.0, 100.0); // Set the Field of view angle (in degrees), the aspect ratio of our window, and the new and far planes
glMatrixMode(GL_MODELVIEW);
}
void keyPressed(unsigned char key, int x, int y)
{
keyStates[key] = true; //Set the state of the current key to pressed
if (key == 's')
{
if (!specular)
{
specular = true;
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, whiteSpecularMaterial);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mShininess);
}
else if (specular)
{
specular = false;
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, blankMaterial);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, blankMaterial);
}
}
if (key = 'd')
{
if (!diffuse)
{
diffuse = true;
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, redDiffuseMaterial);
}
else if (diffuse)
{
diffuse = false;
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, blankMaterial);
}
}
if (key == 'e')
{
if (!emissive)
{
emissive = true;
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, greenEmissiveMaterial);
}
else if (emissive)
{
emissive = true;
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, blankMaterial);
}
}
}
void keyUp(unsigned char key, int x, int y)
{
keyStates[key] = false; //Set the state of the current key to not pressed
}
void keySpecial(int key, int x, int y)
{
keySpecialStates[key] = true;
}
void keySpecialUp(int key, int x, int y)
{
keySpecialStates[key] = false;
}
void init()
{
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHT0);
}
int main(int argc, char **argv) {
glutInit(&argc, argv); // Initialize GLUT
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); // Set up a basic display buffer (now double buffered)
glutInitWindowSize(500, 500); // Set the width and height of the window
glutInitWindowPosition(2500, 100); // Set the position of the window
glutCreateWindow("Your first OpenGL Window"); // Set the title for the window
init();
glutDisplayFunc(display); // Tell GLUT to use the method "display" for rendering
glutIdleFunc(display); // Tell GLUT to use the method "display" as our idle method as well
glutReshapeFunc(reshape); // Tell GLUT to use the method "reshape" for reshaping
glutKeyboardFunc(keyPressed); // Tell GLUT to use the method "keyPressed" for key presses
glutKeyboardUpFunc(keyUp); // Tell GLUT to use the method "keyUp" for key up events
glutSpecialFunc(keySpecial); // Tell GLUT to use the method "keySpecial" for special key presses
glutSpecialUpFunc(keySpecialUp); // Tell GLUT to use the method "keySpecialUp" for special up key events
glutMainLoop(); // Enter GLUT's main loop
}
Please tell me if you need more information.
