Jump to content

  • Log In with Google      Sign In   
  • Create Account


#ActualFLeBlanc

Posted 06 October 2012 - 08:28 AM

Look at is as layers of an onion. At the very center you have the graphics hardware. The interface to the hardware (the hardware functions and things that make it tick... or make it go boom, in many cases) are vendor-protected trade secrets. They don't want you mucking with these, really. On top of the hardware sits a vendor-created software layer called a driver. Again, this layer is vendor-protected, but it provides an outward-facing API of sorts, by which an interested party can communicate with the hardware. On top of this layer sits OpenGL and Direct3D. They act as go-betweens in between the application and the driver interface, providing an easy to use interface that is maintained and standardized across hardware vendors so that the application developer can count on some consistency regardless of the hardware his end users are using.
On top of OpenGL and (frequently) Direct3D sit multiple third-party libraries and APIs such as Glut, GLFW, SFML, SDL, etc... The purpose of these libraries is much more varied, and their implementations can be vastly different. One state purpose of them is often to abstract away the details of the underlying API. For example, Ogre, Irrlicht, Urho3D, etc... they all provide API-specific backends upon which sits API-indifferent front-end code. You can select (whether at run-time, at compile-time, or whatever) whether to use Direct3D or OpenGL on the backend, but the front-end code remains the same due to the abstraction layer. The library developer takes care of the specifics of dealing with the different APIs so you don't have to.

Some libraries, though, like SFML deal only with the one API (OpenGL, in this case). However, its stated goals are a bit different than just abstracting away the graphics API. SFML purports to be mainly a 2D library, and so it provides various abstractions to facilitate 2D tasks. Whereas in OpenGL, there is no concrete concept of a sprite (you can do sprites, it just requires building a bit of foundation code), in SFML you can deal in Sprites and Shapes, and all the foundational stuff is done for you.

It's all about abstraction. That's pretty much what games are: layers of software sitting on top of other layers of software that abstract away lower level details, exposing a higher-level interface.

Edit:

There is OpenGL code available (of sorts). Google for Mesa3D. It is an open-source software version of OpenGL. However, the hardware versions are typically also created by the hardware vendor as a convenience for developers, or provided by the operating system. Seeing the source code of OpenGL really isn't a productive thing; it's complex, rife with hardware specifics and implementation dependencies, and just not a useful learning tool.

As far as just using OpenGL in your application (no third party libraries), this is highly dependent upon the OS, as you will need to use OS-specific functions for creating a window, initializing the message queue, obtaining an OpenGL context through OS-specific calls, etc... It's at once both a simple and a complex process, and is a task that is made vastly easier using one of the aforementioned third-party libraries. For example, with SFML you can use the library to create the window and set up OpenGL, then just use basic OpenGL calls from then on. You are not forced to use any of the other abstraction stuff.

Also, by the way, SFML has plenty of tutorials. More than enough to learn the library. Go ahead and work through the 1.6 tutorials as well, since most of that stuff is still relevant, with a few API changes.

#1FLeBlanc

Posted 06 October 2012 - 08:19 AM

Look at is as layers of an onion. At the very center you have the graphics hardware. The interface to the hardware (the hardware functions and things that make it tick... or make it go boom, in many cases) are vendor-protected trade secrets. They don't want you mucking with these, really. On top of the hardware sits a vendor-created software layer called a driver. Again, this layer is vendor-protected, but it provides an outward-facing API of sorts, by which an interested party can communicate with the hardware. On top of this layer sits OpenGL and Direct3D. They act as go-betweens in between the application and the driver interface, providing an easy to use interface that is maintained and standardized across hardware vendors so that the application developer can count on some consistency regardless of the hardware his end users are using.
On top of OpenGL and (frequently) Direct3D sit multiple third-party libraries and APIs such as Glut, GLFW, SFML, SDL, etc... The purpose of these libraries is much more varied, and their implementations can be vastly different. One state purpose of them is often to abstract away the details of the underlying API. For example, Ogre, Irrlicht, Urho3D, etc... they all provide API-specific backends upon which sits API-indifferent front-end code. You can select (whether at run-time, at compile-time, or whatever) whether to use Direct3D or OpenGL on the backend, but the front-end code remains the same due to the abstraction layer. The library developer takes care of the specifics of dealing with the different APIs so you don't have to.

Some libraries, though, like SFML deal only with the one API (OpenGL, in this case). However, its stated goals are a bit different than just abstracting away the graphics API. SFML purports to be mainly a 2D library, and so it provides various abstractions to facilitate 2D tasks. Whereas in OpenGL, there is no concrete concept of a sprite (you can do sprites, it just requires building a bit of foundation code), in SFML you can deal in Sprites and Shapes, and all the foundational stuff is done for you.

It's all about abstraction. That's pretty much what games are: layers of software sitting on top of other layers of software that abstract away lower level details, exposing a higher-level interface.

PARTNERS