Take the 2-minute tour ×
Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

Im starting to learn opengl, and after 2 days, searching and trying hard, i finally installed all the libraries i need (lol).

So, I'm following this tutorial, and it says to use glfwOpenWindowHint this way:

glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); // 4x antialiasing
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); // We want OpenGL 3.3
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL

But glfwOpenWindow didn't work with this Hint. So I made a little research, and changed the PROFILE parameter to this:

glfwOpenWindowHint(GLFW_OPENGL_PROFILE, 0);

Ok, fine, now works.

My question is if it is a big deal to change the opengl profile, or this will make no difference. And why I can't use GLFW_OPENGL_CORE_PROFILE instead.

share|improve this question
add comment

1 Answer 1

up vote -3 down vote accepted

OpenGL was divided into two profiles, Core and Compatible.

This was done to try to make OpenGL leaner, meaner and cleaner. The intent was to eventually deprecate the comparable profile but after some stink, the Graphics card vendors basically vetoed the idea and so developers simply have to option of using either.

What it comes down to is taste. Core doesn't have many unnecessary functions, and in a way forces you to use modern methods of doing things like vertex buffers. I see this as a positive because it trains you into using the faster, better ways of doing things, however it's also a HUGE negative if your just starting out.

Being able to do things the simple, old, but simple way makes learning GL way easier and as you figure it out and begin to learn the more complex topics you will begin to understand the advantages of using the modern approaches properly.

I say, stick with comparability for now but read into the differences and when possible try to utilize more modern ways of doing things.

In effect, consider the comparability profile like training wheels for a bike, you'd definitely want to start out with them, but eventually they might get in the way and limit performance.

share|improve this answer
    
Yeah, im learning the modern, every one say the old is really bad. But im not using 4+ because its less compatible. Btw, do you know which library includes GLunit type? –  Dhiego Magalhães Feb 18 '13 at 1:46
    
Oahh, nvm, i was going crazy, i was like "omg what is this GLunit?? Can't find it!" and then, i read it again, its actually GLuint :s –  Dhiego Magalhães Feb 18 '13 at 1:53
    
Just in case it passed by you, GLuint is the uint (unsigned int) type. While the size of the latter is platform dependent (e.g. 16, 32, 64 bit), the former, library dependent GLuint is created (typedef-ed) with the platform in mind, so you don't have to worry about it, increasing cross-platform compatibility. –  swalog Feb 18 '13 at 7:40
5  
Compatible mode isn't like training wheels. Compatible is like old time bikes with Humongous front wheel and tinyweeny read wheel. Forget about Compatible, you should start learning Core for the very beginning. –  Zhen Feb 18 '13 at 9:27
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.