Hello, im in the process of attempting to teach myself OpenGL programming but so far all i've managed to do is become extremely confused. I have a few questions, they are probably pretty silly and i apologize but still, any help would be appreciated!
From my experiments and what i've read before using any OpenGL function calls and such an "OpenGL context" is required. Im a bit puzzled as to what this actually means, my initial thought was that this would just be a window capable of displaying pixel data, but clearly there is something more to it.
What actually defines a window as being an OpenGL context?
How does OpenGL know if a window is a valid OpenGL context?
Lets say on operating system X i've used the native API to create a window, what steps would i then need to take to make it capable of displaying openGL data, do native api's include special openGL settings or something?
Currently im using SFML to abstract the creation of an OpenGL context and it works perfectly but i'd still like to have a at least vague idea of the inner working that are going on...
For example SFML 1.6 does not work with OpenGL 3.0+ whereas SFML 2.0 does, i don't understand this, why is displaying the pixels rendered by OpenGL so complicated that compatibility becomes an issue?
Thank you for any help, and im sorry that my writing is not very good!
What exactly is an "OpenGL Context"? How does it work?
Your GPU draws stuff. Windows owns part of that, your game owns part of that, and your applications such as web browsers own stuff. Say you call glClear() to clear your current drawing frame. It does not clear windows desktop and other stuff. So each time you open a GL application, it needs its own stack of states. Say you call glColor3f(1,1,1) in one instance of your game and then open a 2nd copy of your game calling glColor3f(0,0,0) in the other. There are two contexts and two glColors being tracked separately.
Unless you plan on become a programmer in a team that makes GL drivers and you want to work at nVidia, it doesn't matter what a GL context is.
You just need to 1. setup a pixelformat 2. make a GL context 3. make the GL context current.
SFML, GLUT, freeGLUT, QT, SDL and the many others do that for you.
and render away until you need to destroy resources and destroy the GL context and close the window.
You just need to 1. setup a pixelformat 2. make a GL context 3. make the GL context current.
SFML, GLUT, freeGLUT, QT, SDL and the many others do that for you.
and render away until you need to destroy resources and destroy the GL context and close the window.
<BR>Unless you plan on become a programmer in a team that makes GL drivers and you want to work at nVidia, it doesn't matter what a GL context is.<BR>Quite right. ATI driver developers dont need to know what a opengl context is among other things.
The OpenGL graphics driver has a resource management system, called the OpenGL context. You can think of it as a sandbox for your application to use; where your program stores textures, buffers, meshes, etc. Therefore, each application utilising OpenGL will communicate with the driver and requests their own context, so that the resources are not mixed up between applications. Sometimes you can allocate more than one contexts per application.
Anyway, when a context is created, it is tied to your application's process, usually to the main Window's paint area. Often creating Window paint surface and creating an OpenGL context goes hand in hand. Therefore, destroying the Window may also destroy the context.
1. Create window
2. Create OpenGL context
3. Attach context to window and current process
4. Switch to created context
5. Render stuff
6. Release context
7. Destroy window
This is the general process for setting up OpenGL on most systems. I'm not familiar with X specifically, but I assume the steps would be quite similar.
Anyway, when a context is created, it is tied to your application's process, usually to the main Window's paint area. Often creating Window paint surface and creating an OpenGL context goes hand in hand. Therefore, destroying the Window may also destroy the context.
1. Create window
2. Create OpenGL context
3. Attach context to window and current process
4. Switch to created context
5. Render stuff
6. Release context
7. Destroy window
This is the general process for setting up OpenGL on most systems. I'm not familiar with X specifically, but I assume the steps would be quite similar.
If you can define something then you don’t understand it!
Sadly, nobody before Tachikoma tried to answer to the question. Although it is not crucial for programmers to know how rendering context is implemented, it is important to understand what it is in order to know how to use it.
An OpenGL context is the data structure that collects all states needed by server to render an image. It contains references to buffers, textures, shaders, etc. OpenGL API doesn’t define how rendering context is defined, it is up to the native window system; but none of OpenGL commands can be executed until rendering context is created and made current.
A rendering context should be compatible with a window it will render to. There can be several contexts per application, or even per window. On the other hand, the same context can be used for rendering in multiple windows, but in that case all windows using the same context must have the same pixel format. Now we have come to another important aspect of rendering context: its rendering surface must be adequate for appropriate window. In order to achieve that we have to choose and set appropriate pixel format of the window that have to be created. The rendering surface is the surface to which primitives are drawn. It defines types of buffers that are required for rendering such as a color buffer, depth buffer, and stencil buffer.
Choosing pixel format must be performed in order to verify support for defined pixel format. The system would return ID of appropriate pixel format, or the closest match. Setting pixel format that is not previously returned from the system would almost certainly fail. It is not recommended to set pixel format for the window more than once.
In order to issue any OpenGL command we have to make OpenGL context active (i.e. “current”). By making active we assume binding OpenGL context to a window’s DC. It is done from a certain thread. Only one context can be made current for a single thread at a moment. Calling OpenGL commands from another thread (different from that made the context current) fails. If we want to make use of multithreading update of OpenGL resources, we have to make a share-group. All contexts from the share-group share resources like textures, buffers, etc. Although multithreading update can be useful in some cases, we have to be aware that most OpenGL drivers serialize access to the GPU. OpenGL guarantees that all commands in the single context will be executed in the order in which they are issued, but there is no guarantee for multiple contexts. Since OpenGL 3.2 synchronization is enabled through sync objects.
Prior to OpenGL 3.0, there was just one type of OpenGL rendering contexts; the context that contains full functionality. OpenGL3.0 introduced forward compatibility, and 3.2 introduced concept of profiles. If anyone is interested in further discussion, we could proceed, but I think it is a bit out of the scope of the OP’s question. I was already too comprehensive. 
This isn't a direct answer to your question, but I would recommend the NeHe tutorial for learning openGL. It will take you through creating a Window, setting up openGL, drawing on the Window, and much more.
http://nehe.gamedev.net/lesson.asp?index=01
http://nehe.gamedev.net/lesson.asp?index=01
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
