{"id":26269,"date":"2015-04-02T07:40:52","date_gmt":"2015-04-02T12:40:52","guid":{"rendered":"http:\/\/www.shamusyoung.com\/twentysidedtale\/?p=26269"},"modified":"2015-04-02T07:40:52","modified_gmt":"2015-04-02T12:40:52","slug":"the-strange-evolution-of-opengl-part-1","status":"publish","type":"post","link":"https:\/\/www.shamusyoung.com\/twentysidedtale\/?p=26269","title":{"rendered":"The Strange Evolution of OpenGL Part 1"},"content":{"rendered":"

Let’s talk about OpenGL. No wait. Don’t hit the back button yet! Let’s talk about OpenGL in a way that non-coders can hopefully follow.<\/em> I’ll even sprinkle some screenshots of my most recent OpenGL project through the article to break up the scary walls of text. It’ll be easy and maybe even funI’ve found that people’s definitions of “fun” are surprisingly flexible!<\/span>.<\/p>\n

OpenGL stands for Open Graphics Library. It was originally devised in 1991. When it comes to talking to your graphics card, OpenGL is one of only two ways to get the job done. If you want to render some polygons, you have to use either Direct X or OpenGLWell, a third option would be to render WITHOUT using the graphics card. This will – no exaggeration – be thousands of times slower. So it’s been years since the last time<\/a> I saw a software-rendered game.<\/span>. Everything else – Unreal Engine, Unity, or any other game Engine – has to go through either DirectX or OpenGL if it wants to make some graphicsAssuming you’re working on a desktop computer. Things are a little different in console world.<\/span>. <\/p>\n

OpenGL pre-dates graphics cards. At least, it pre-dates cards as we understand them today. There were industrial-grade cards in 1991, used by render farms and CAD stations. I don’t know enough about that hardware to know how OpenGL worked at the time, so let’s just ignore all of that stuff while I make broad, hand-wavy gestures. The point is that the world of consumer-grade graphics acceleration sort of grew up around OpenGL, and over time it adapted to give us programmers a way to talk to all that fancy graphics hardware. OpenGL also pre-dates the widespread adoption of C++ as a programming language. Also, it was devised long before multi-threading was part of normal development. This means that OpenGL has a lot of things about it that just don’t make a lot of sense to game developers in 2015. It’s a system that uses crusty old C code, it doesn’t play well with multi-threaded approaches, and it’s filled with legacy systems that nobody is supposed to use anymore. <\/p>\n

This is my game “World of Stone Pillars in a Blue Void With No GamePlay”. Coming soon to Kickstarter!<\/td><\/tr>
This is my game “World of Stone Pillars in a Blue Void With No GamePlay”. Coming soon to Kickstarter!<\/td><\/tr><\/table><\/p>\n

The full story of the rise and fall of OpenGL is much too long to recount here. This is the fullest version of events<\/a> as I’ve been able to find, tucked into the middle of a very long thread on StackExchange. Imagine a world where the only coherent account of the rise of the Ford motor company was from a single user in an r\/automobiles<\/tt> subreddit. That’s what this is like. I’m not even going to try and outline it here. It’s a mad story that involves several hardware companies, Microsoft, a committee, and a lot of bad decisions on the part of everyone. The most important player in that drama was the committee, which is called the ARB.<\/p>\n

The point is: OpenGL has changed quite a bit over the years. As graphics technology changed, the ARB would bolt some new functionality onto the Frankenstein monster of OpenGL and it would shamble onward. That’s fine, inasmuch as adding functionality is what they’re supposed to be doing. But now, 23 years after the release of OpenGL, things are a mess. There are now five ways to do everything, and the four most obvious and straightforward ways are bad and wrong and slow and people will yell at you if they catch you doing them.<\/p>\n

This is a shame, because like most programmers I’m really attracted to “obvious and straightforward” solutions. In the old days, you could sit down and write a dozen or so lines of code that would put some polygons up on the screen. <\/p>\n

The old way:<\/p>\n

    \n
  1. Set up your OpenGL context so you can draw stuff.\n
  2. Position the camera.\n
  3. Specify a few vertices to make a triangle.\n
  4. If you’re feeling creative, you could maybe color them or put a texture map in there, but whatever.\n<\/ol>\n

    The new way:<\/p>\n

      \n
    1. Set up your OpenGL context so you can draw stuff.\n
    2. You’ll need a vertex shader. That’s another whole program witten in GLSL, which looks a bit like C++ but is actually its own language.\n
    3. You’ll also need a fragment shader. Yes, another program.\n
    4. You’ll need to compile both shaders. That is, your program runs some code to turn some other code into a program. It’s very meta.\n
    5. You’ll need to build an interface so your game can talk to the shaders you just wrote.\n
    6. You’ll need to gather up your vertices and pack them into a vertex buffer, along with any data they might need.\n
    7. Explain the format of your vertex data to OpenGL and store that data on the GPUThe graphics card. But you knew that.<\/span>.\n
    8. Position the camera.\n
    9. Draw those triangles you put together a couple of steps ago.\n
    10. If you’re feeling creative, you can re-write your shaders and their interface to support some color or texture. Hope you planned ahead!\n<\/ol>\n

      This list kind of undersells the drastic spike in work required to get something to appear on screen. Every one of these new steps is more difficult on both a conceptual (What is happening here and why do I need to do this?) and programmatic (How do I do this?) sense. If you have any experience with modern gaming engines you’re probably used to ignoring all of this. You’ve most likely got a game engine between you and the fussy details. These steps are difficult to wrap your head around, but they only need to be done once and most people don’t do it at all.<\/p>\n

      Colored lighting! Let’s party like it’s 1999!<\/td><\/tr>
      Colored lighting! Let’s party like it’s 1999!<\/td><\/tr><\/table><\/p>\n

      Note that I’m not really faulting OpenGL for this rise in complexity. The way things are done today is unavoidably difficult. You’ve got your multi-core computer there running a game, and that computer is talking to another fabulously sophisticated computer (the GPU) with hundreds or thousands of cores. Each computer has its own memory and its own native processor language, and as a programmer it’s your job to get these two systems to talk to each other long enough and well enough to make some polygons happen. <\/p>\n

      So that’s what this series is going to be about: How OpenGL used to work, how it works now, and what I think we’ve lost in the transition.<\/p>\n","protected":false},"excerpt":{"rendered":"

      Let’s talk about OpenGL. No wait. Don’t hit the back button yet! Let’s talk about OpenGL in a way that non-coders can hopefully follow. I’ll even sprinkle some screenshots of my most recent OpenGL project through the article to break up the scary walls of text. It’ll be easy and maybe even funI’ve found that […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[66],"tags":[],"class_list":["post-26269","post","type-post","status-publish","format-standard","hentry","category-programming"],"_links":{"self":[{"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=\/wp\/v2\/posts\/26269","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=26269"}],"version-history":[{"count":0,"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=\/wp\/v2\/posts\/26269\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=26269"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=26269"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.shamusyoung.com\/twentysidedtale\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=26269"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}