Sign in to follow this  
Vekta

OpenGL What exactly is an "OpenGL Context"? How does it work?

Recommended Posts

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!

Share this post


Link to post
Share on other sites
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.

Share this post


Link to post
Share on other sites
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.

Share this post


Link to post
Share on other sites
[quote name='V-man' timestamp='1307489840' post='4820735']<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>[/quote]Quite right. ATI driver developers dont need to know what a opengl context is among other things.

Share this post


Link to post
Share on other sites
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.

Share this post


Link to post
Share on other sites
[left][left][size="3"][size="2"][i]If you can define something then you don’t understand it![/i][/size][/size][/left][/left]
[left][left] [/left][/left]
[left][left][size="3"][size="2"]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.[/size][/size][/left][/left]
[left][left] [/left][/left]
[left][left][size="3"][size="2"]An OpenGL [/size][i][size="2"]context[/size][i] [/i][/i][size="2"]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.[/size][/size][/left][/left]
[left][left] [/left][/left]
[left][left][size="3"][size="2"]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.[/size][/size][/left][/left]
[left][left] [/left][/left]
[left][left][size="3"][size="2"]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.[/size][/size] [/left][/left]
[left][left] [/left][/left]
[left][left][size="3"][size="2"]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.[/size][/size] [/left][/left]
[left][left] [/left][/left]
[left][left][size="3"][size="2"]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. [/size][/size] :rolleyes:[/left][/left]

Share this post


Link to post
Share on other sites
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.

[url="http://nehe.gamedev.net/lesson.asp?index=01"]http://nehe.gamedev.net/lesson.asp?index=01[/url]

Share this post


Link to post
Share on other sites
[quote name='swilkewitz' timestamp='1307676925' post='4821581']
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.

[url="http://nehe.gamedev.net/lesson.asp?index=01"]http://nehe.gamedev....on.asp?index=01[/url]
[/quote]

Just remember that following a tutorial is no substitute for reading the documentation. A tutorial shows you how to use a hammer to drive in a nail. If someone then gives you a screw you will think to yourself "this looks a lot like a nail, better use a hammer!". Read the documentation on nails, screws and hammers is all I'm saying :D

Share this post


Link to post
Share on other sites
For your review, I just added this section to the Wiki FAQ
http://www.opengl.org/wiki/FAQ#GL_context

I am keeping it short. I did not go into the actual calls needed since these are OS specific and you can get that info from other parts of the web.

You can give feedback. Modify the Wiki to your liking, etc.

Share this post


Link to post
Share on other sites
No offense V-man, but you didn't write about any important aspect of the rendering context except that we need it in order to execute any GL code. You didn't even answer on your own question (why do we need a window?). Anyway it is good that beginners can read something, although I don't think they really read wiki. It is easier to ask a question on the forum. :)

Share this post


Link to post
Share on other sites
You need a window because that is how it is designed. It is as simple as that. I have made a slight modification to that section.
You can of course modify it or make suggestions right here if you want things worded differently.

[quote]Anyway it is good that beginners can read something, although I don't think they really read wiki.[/quote]
You can say that about any other webpage.
The Wiki is not for stopping people from asking questions.

Before the Wiki was around, people asked questions and received many nice answers and that followed by "Why isn't this documented somewhere?". At some point, whoever manages opengl.org decided that a Wiki would be a good idea.

Share this post


Link to post
Share on other sites
[quote name='V-man' timestamp='1307720994' post='4821743'] You need a window because that is how it is designed. It is as simple as that.[/quote]

No comment. (Or to be more precise, I've already commented such answers)


[quote name='V-man' timestamp='1307720994' post='4821743'] You can of course modify it or make suggestions right here if you want things worded differently. [/quote]

I don't like writing wikis, because they are so impersonal. Although I have to admit that Wikipedia is really great.


Concerning OpenGL rendering context (RC), I think I've said what I have to say. The most important aspects are: what it is, how it can be created, what the scope of RC is, how resources can be shared, profiles and forward compatibility. But since OP hasn't reacted on our posts, we are probably uselessly fiddling. :D

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

  • Announcements

  • Forum Statistics

    • Total Topics
      628402
    • Total Posts
      2982473
  • Similar Content

    • By test opty
      Hi all,
       
      I'm starting OpenGL using a tut on the Web. But at this point I would like to know the primitives needed for creating a window using OpenGL. So on Windows and using MS VS 2017, what is the simplest code required to render a window with the title of "First Rectangle", please?
       
       
    • By DejayHextrix
      Hi, New here. 
      I need some help. My fiance and I like to play this mobile game online that goes by real time. Her and I are always working but when we have free time we like to play this game. We don't always got time throughout the day to Queue Buildings, troops, Upgrades....etc.... 
      I was told to look into DLL Injection and OpenGL/DirectX Hooking. Is this true? Is this what I need to learn? 
      How do I read the Android files, or modify the files, or get the in-game tags/variables for the game I want? 
      Any assistance on this would be most appreciated. I been everywhere and seems no one knows or is to lazy to help me out. It would be nice to have assistance for once. I don't know what I need to learn. 
      So links of topics I need to learn within the comment section would be SOOOOO.....Helpful. Anything to just get me started. 
      Thanks, 
      Dejay Hextrix 
    • By mellinoe
      Hi all,
      First time poster here, although I've been reading posts here for quite a while. This place has been invaluable for learning graphics programming -- thanks for a great resource!
      Right now, I'm working on a graphics abstraction layer for .NET which supports D3D11, Vulkan, and OpenGL at the moment. I have implemented most of my planned features already, and things are working well. Some remaining features that I am planning are Compute Shaders, and some flavor of read-write shader resources. At the moment, my shaders can just get simple read-only access to a uniform (or constant) buffer, a texture, or a sampler. Unfortunately, I'm having a tough time grasping the distinctions between all of the different kinds of read-write resources that are available. In D3D alone, there seem to be 5 or 6 different kinds of resources with similar but different characteristics. On top of that, I get the impression that some of them are more or less "obsoleted" by the newer kinds, and don't have much of a place in modern code. There seem to be a few pivots:
      The data source/destination (buffer or texture) Read-write or read-only Structured or unstructured (?) Ordered vs unordered (?) These are just my observations based on a lot of MSDN and OpenGL doc reading. For my library, I'm not interested in exposing every possibility to the user -- just trying to find a good "middle-ground" that can be represented cleanly across API's which is good enough for common scenarios.
      Can anyone give a sort of "overview" of the different options, and perhaps compare/contrast the concepts between Direct3D, OpenGL, and Vulkan? I'd also be very interested in hearing how other folks have abstracted these concepts in their libraries.
    • By aejt
      I recently started getting into graphics programming (2nd try, first try was many years ago) and I'm working on a 3d rendering engine which I hope to be able to make a 3D game with sooner or later. I have plenty of C++ experience, but not a lot when it comes to graphics, and while it's definitely going much better this time, I'm having trouble figuring out how assets are usually handled by engines.
      I'm not having trouble with handling the GPU resources, but more so with how the resources should be defined and used in the system (materials, models, etc).
      This is my plan now, I've implemented most of it except for the XML parts and factories and those are the ones I'm not sure of at all:
      I have these classes:
      For GPU resources:
      Geometry: holds and manages everything needed to render a geometry: VAO, VBO, EBO. Texture: holds and manages a texture which is loaded into the GPU. Shader: holds and manages a shader which is loaded into the GPU. For assets relying on GPU resources:
      Material: holds a shader resource, multiple texture resources, as well as uniform settings. Mesh: holds a geometry and a material. Model: holds multiple meshes, possibly in a tree structure to more easily support skinning later on? For handling GPU resources:
      ResourceCache<T>: T can be any resource loaded into the GPU. It owns these resources and only hands out handles to them on request (currently string identifiers are used when requesting handles, but all resources are stored in a vector and each handle only contains resource's index in that vector) Resource<T>: The handles given out from ResourceCache. The handles are reference counted and to get the underlying resource you simply deference like with pointers (*handle).  
      And my plan is to define everything into these XML documents to abstract away files:
      Resources.xml for ref-counted GPU resources (geometry, shaders, textures) Resources are assigned names/ids and resource files, and possibly some attributes (what vertex attributes does this geometry have? what vertex attributes does this shader expect? what uniforms does this shader use? and so on) Are reference counted using ResourceCache<T> Assets.xml for assets using the GPU resources (materials, meshes, models) Assets are not reference counted, but they hold handles to ref-counted resources. References the resources defined in Resources.xml by names/ids. The XMLs are loaded into some structure in memory which is then used for loading the resources/assets using factory classes:
      Factory classes for resources:
      For example, a texture factory could contain the texture definitions from the XML containing data about textures in the game, as well as a cache containing all loaded textures. This means it has mappings from each name/id to a file and when asked to load a texture with a name/id, it can look up its path and use a "BinaryLoader" to either load the file and create the resource directly, or asynchronously load the file's data into a queue which then can be read from later to create the resources synchronously in the GL context. These factories only return handles.
      Factory classes for assets:
      Much like for resources, these classes contain the definitions for the assets they can load. For example, with the definition the MaterialFactory will know which shader, textures and possibly uniform a certain material has, and with the help of TextureFactory and ShaderFactory, it can retrieve handles to the resources it needs (Shader + Textures), setup itself from XML data (uniform values), and return a created instance of requested material. These factories return actual instances, not handles (but the instances contain handles).
       
       
      Is this a good or commonly used approach? Is this going to bite me in the ass later on? Are there other more preferable approaches? Is this outside of the scope of a 3d renderer and should be on the engine side? I'd love to receive and kind of advice or suggestions!
      Thanks!
    • By nedondev
      I 'm learning how to create game by using opengl with c/c++ coding, so here is my fist game. In video description also have game contain in Dropbox. May be I will make it better in future.
      Thanks.
  • Popular Now