Now, remember why we added those libraries? It was because they handled creating a window and OpenGL context. It's time we put that to use, so let's go ahead and open up the project in Visual Studio. Replace your "Main.cpp" code with the following code:

#include "Include\freeglut\freeglut.h"
#include <iostream>

int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA);
	glutInitWindowPosition(400, 150);	// optional
	glutInitWindowSize(800, 600);		// optional
	glutCreateWindow("Hello World");
	
	glutMainLoop();
	
	return 0;
}#include "Include\glfw\glfw3.h"
#include <iostream>

int main(int argc, char **argv)
{
	glfwInit();
	GLFWwindow* window = glfwCreateWindow(800, 600, "Hello World", nullptr, nullptr);
	glfwMakeContextCurrent(window);
	
	while(!glfwWindowShouldClose(window)) // Main Loop
	{
		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	glfwTerminate();

	return 0;
}#include "Include\sfml\include\SFML\window.hpp"
#include <iostream>
		
int main(int argc, char **argv)
{
	sf::Window window;
	sf::ContextSettings settings;

	window.create(sf::VideoMode(800, 600), "Hello World", sf::Style::Close, settings);

	while(window.isOpen())
	{
		sf::Event windowEvent;
		while (window.pollEvent(windowEvent))
		{
			switch (windowEvent.type)
			{
				case sf::Event::Closed:
					window.close();
					break;
			}
		}
	}

	return 0;
}

If you compile and run this, you should have a window and console appear. Closing one will close the other. If that does not happen, check your code and ensure you properly added FreeGLUTGLFWSFML to your project.

Now let's talk about these functions:

• glutInit initializes the GLUT library. This is required before you can start using any of the GLUT functions.
• glutInitDisplayMode determines the OpenGL display mode for the created window, separating the different options with the bitwise OR (looks like: |)
  • GLUT_DEPTH tells OpenGL we want a depth buffer (Z buffer) which helps determine what color to draw a pixel when two objects are overlapping.
  • GLUT_DOUBLE tells OpenGL we want double buffering to prevent flickering. OpenGL will draw to the back buffer and then swap this back buffer with the front buffer.
  • GLUT_RGBA tells OpenGL how to allocate a 32-bit Framebuffer for the four 8-bit color channels: Red, Green, Blue, and Alpha.
• glutInitWindowPosition the position of the window on the screen. Arguments are given in pixels.
• glutInitWindowSize the width and height of our window. Arguments are given in pixels.
• glutCreateWindow will create the actual window. The argument will be the window's name. This function also returns the window id.
• glutMainLoop enters the GLUT processing loop, interrupted only by callbacks.
• glfwInit() initializes the GLFW library, which is required before you can start using any of the GLFW functions.
• glfwCreateWindow(800, 600, "HelloWorld", nullptr, nullptr) is fairly straightforward, as it creates a window object via GLFW (and returns a pointer to said window object) given a width, height, and title. The other two parameters are monitor (a pointer to the monitor you're targetting if you want to be specific) and a pointer to a shared GLFWwindow. For our purposes, we don't need them so passing in nullptr is totally fine.
• You can also use glfwWindowHint() before creating the window to change settings (such as whether or not is is resizable, fullscreen, etc.)
• glfwMakeContextCurrent(window) makes the OpenGL context current for the given window. Once this line completes, we are able to start using the OpenGL API.
• One of the things you'll be doing here is creating a while loop to handle your main program loop. Essentially, glfwWindowShouldClose(window) will continue to return false (thus the ! making it true) until GLFW determines that the window must close. You can set this variable with glfwSetWindowShouldClose(window, GL_TRUE) as well.
• glfwSwapBuffers(window) swaps between back buffer and front buffer. Remember that we are using double buffering.
• You can use glfwSwapInterval(1) (or any number) to set the number of frames to wait until swapping buffers, known as "vsync". By default, this is set to zero, so every frame the buffer swaps. On faster machines, these frames aren't seen as the screen does not update as fast so many CPU/GPU cycles are wasted. Sometimes this can lead to screen tearing too. Typically, it's worth setting the swap interval to 1.
• glfwPollEvents() is the way that GLFW communicates with the window system to receive events. Typically, this is done every frame after buffer swapping. You must do this regularly while you have visible windows, or your window will freeze up (as Windows OS will think it's frozen). This example uses polling, which processes only events that have already been received and then returns immediately. You can also use glfwWaitEvents() to halt the program until you have received an event. This is useful when you don't want to render until you receive input, like an editing tool.
• glfwTerminate() cleans up anything GLFW related.
• window.create takes uses SFML to make a window. The first parameter is an sf::VideoMode parameter, which you can use to set the width and height of the window. The second parameter is the name of the window. The third parameter is the style of the window and takes an enum that describes the type of window that you want to make; in this case, it is a window with a close button. The fourth parameter takes in the context settings which we'll just pass in as-is for now (you can use the context settings to set up antialiasing, for example).
• One of the things you'll be doing here is creating a while loop to handle your main program loop. Essentially, window.isOpen() will continue to return true until the window is no longer open.
• There's a inner while loop that checks window.pollEvent(windowEvent), which will return true if there are any events on the queue and false if there are none. So basically, it will run through each event, assign that event to our windowEvent variable, and then inside it checks the windowEvent.type to see if it matches the "Closed" event. If it does, we tell it to close the window with window.close(). This same switch statement will be used later to determine the types of future events and how to handle them.

Now let's draw a blank screen with a solid color on it. In order to do this, we'll have to create a render() function that does the drawing. In the main method, we call glEnable(GL_DEPTH_TEST) to enable depth testing on the video card. Sometimes, you don't need this test and you can disable it in the render function.

You will also need to register the callback function for render (this tells FreeGLUT that this is the function that does the drawing), so call glutDisplayFunc(render). In the while loop, before glfwSwapBuffers, add a call to render(). In the outer while loop, after the inner while loop (so after the end curly brace for the window.pollEvent loop), add a call to render(). It should look like this:

#include "Include\freeglut\freeglut.h"
#include <iostream>

void render()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClearColor(0.0, 1.0, 0.0, 1.0);//clear green

	glutSwapBuffers();
}

int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA);
	glutInitWindowPosition(400, 150);	// optional
	glutInitWindowSize(800, 600);		// optional
	glutCreateWindow("Hello World");
	
	glEnable(GL_DEPTH_TEST);
	
	glutDisplayFunc(render);
	
	glutMainLoop();
	
	return 0;
}#include "Include\glfw\glfw3.h"
#include <iostream>

void render()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClearColor(0.0, 1.0, 0.0, 1.0);//clear green
}

int main(int argc, char **argv)
{
	glfwInit();
	GLFWwindow* window = glfwCreateWindow(800, 600, "HelloWorld", nullptr, nullptr);
	glfwMakeContextCurrent(window);
	
	while(!glfwWindowShouldClose(window)) // Main Loop
	{
		render();
		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	glfwTerminate();

	return 0;
}#include "Include\sfml\include\SFML\window.hpp"
#include <iostream>

void render()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClearColor(0.0, 1.0, 0.0, 1.0);//clear green
	
	window.display();
}
		
int main(int argc, char **argv)
{
	sf::Window window;
	sf::ContextSettings settings;

	window.create(sf::VideoMode(800, 600), "Hello World", sf::Style::Close, settings);

	while(window.isOpen())
	{
		sf::Event windowEvent;
		while (window.pollEvent(windowEvent))
		{
			switch (windowEvent.type)
			{
				case sf::Event::Closed:
					window.close();
					break;
			}
		}
		
		render();
	}

	return 0;
}

In the render function, not much is necessary:

• glClear tells OpenGL to clear its buffers. In our case Depth and Color. To clear them simultaneously we OR them
• glClearColor specifies clear values for color buffers. These values must be between 0.0 and 1.0. Arguments are : red, green, blue, alpha.
• glutSwapBuffers swaps between back buffer and front buffer. Remember that we are using double buffering.
• window.display() swaps between back buffer and front buffer. Remember that we are using double buffering.
• This will clear the screen to the color specified and then swap the buffers so that it comes to the front. (Remember: You draw to the back buffer, then swap it in.)

And there you have it, a screen cleared to a color (in this case, we've chosen green).

Up until this point, we haven't used GLEW once. We don't need it yet, but it will be useful to familiarize yourself with it. In order to do this, you'll need to add the include statement at the top. Add #include "Include\glew\glew.h" to the top of your program. If you used the static library for GLEW, you will also need to include a #define GLEW_STATIC at the top. Right underneath the glfwMakeContextCurrent(window)glutCreateWindow() call, insert the following lines:

glewInit();

printf("OpenGL version supported by this platform: (%s)\n", glGetString(GL_VERSION));
if (glewIsSupported("GL_VERSION_4_5"))
{
	std::cout << "OpenGL Version is 4.5\n";
}
else
{
	std::cout << "OpenGL 4.5 is not supported\n";
}

The printf (which does not technically require GLEW) will tell you your maximum OpenGL version supported. The if statement checks to see if your graphics card is compatible with OpenGL Version 4.5 and then displays the result. You could easily change GL_VERSION_4_5 to earlier versions to test those too (such as GL_VERSION_4_0 for 4.0). It's okay if yours is not compatible with the latest version of OpenGL, it's just good to be aware of which version you're working with.

If you were not able to get it to compile and run, be sure you properly added GLEW to your project and have your code written correctly. If you're ready to move on, it's time to draw our first triangle.