Sign in to follow this  
NathanRidley

OpenGL Abstracting away DirectX, OpenGL, etc.

Recommended Posts

I'm a bit torn. I'm just learning graphics programming, but I want to make sure I use good practices as I go. Typically, when writing a web/business application I would separate the presentation layer from the business layer (typical 3-tier design) and ensure that the different layers are loosely coupled, with a proper separation of concerns between the different components and so forth. That is all old-hat to me, but game programming is new, so I'm trying to work out what might be different than how I'd normally approach things, due to performance concerns and other game-specific problem areas.

 

In my case, I'm using SharpDX, which exposes DirectX via a managed wrapper, and it provides a bunch of really useful classes, such as SharpDX.Vector3, which has a whole lot of handy utility methods, mainly for performing various types of transforms.

 

Despite its usefulness, I feel like I should not use this in my game because it will force me to reference SharpDX which will sting me if I decide to swap in OpenGL for rendering. Or am I thinking too low-level, and really I should be wrapping the actual vertex structures I use as well so that anything dealing directly with a vertex is more of a rendering engine detail?

 

Any tips, advice, pointers to good articles, etc, would be appreciated.

Share this post


Link to post
Share on other sites

Seems the search feature could have come in handy before I posted.

 

Specific to my question:

http://www.gamedev.net/topic/546381-abstracting-graphics-libraries-from-the-game-engine/

 

Similar questions (and answers):

http://www.gamedev.net/index.php?s=16ccd0198d5732e4da4c2d8f3348cc0c&app=googlecse#gsc.tab=0&gsc.q=abstracting

Share this post


Link to post
Share on other sites

I think it's important at this stage to decide if supporting OpenGL in the future is something you actually want to do.

 

A lot of people start out with the idea of supporting OpenGL (or DirectX if they start out with OpenGL) at a later point in time in their rendering engines; this results in them trying to write an abstraction layer on top of their original graphics API which doesn't really do the underlying API any justice.

 

Designing a proper wrapper exposing the functionalities of both APIs to their fullest extent is HARD. It's going to require a complete understanding of both APIs, their designs and their quirks. Add to this that you'll have to design a system which will unify these sometimes completely different beasts into a single API without introducing too much overhead and without sacrificing functionality.

 

If you really do want to support both you could always check out some third party utility libraries for doing vector math and such, I'm sure there'll be plenty of those out there.

 

If support for multiple rendering APIs isn't an absolute must I just wouldn't worry about it and work with the tools provided by SharpDX; no need to put a lot of effort into something which eventually won't have that much of an impact on your end result (ie. your game)

Share this post


Link to post
Share on other sites


I'm just learning graphics programming...

Not to discourage you, but don't worry about abstraction if you are just a beginner. You'll proabably change your design a couple of times even if you're focusing on only one API.

As your graphics understanding improves, so will your design and code quality. 

Share this post


Link to post
Share on other sites

I think it's important at this stage to decide if supporting OpenGL in the future is something you actually want to do.

 

A lot of people start out with the idea of supporting OpenGL (or DirectX if they start out with OpenGL) at a later point in time in their rendering engines; this results in them trying to write an abstraction layer on top of their original graphics API which doesn't really do the underlying API any justice.

 

Designing a proper wrapper exposing the functionalities of both APIs to their fullest extent is HARD. It's going to require a complete understanding of both APIs, their designs and their quirks. Add to this that you'll have to design a system which will unify these sometimes completely different beasts into a single API without introducing too much overhead and without sacrificing functionality.

 

If you really do want to support both you could always check out some third party utility libraries for doing vector math and such, I'm sure there'll be plenty of those out there.

 

If support for multiple rendering APIs isn't an absolute must I just wouldn't worry about it and work with the tools provided by SharpDX; no need to put a lot of effort into something which eventually won't have that much of an impact on your end result (ie. your game)

 

Thanks for the advice, and I think you're right. Back when I was learning to program, I often made the mistake of trying to abstract away too many things without having a proper understanding of the APIs and frameworks with which I was dealing, which usually led to a very poor abstraction and the inferior reinvention of multiple different wheels that already existed. The Windows market is plenty big enough that I should be happy to service that market for my first few games while learning. I can worry about engine abstraction at a later date when I have some decent experience writing games.

 

 


I'm just learning graphics programming...

Not to discourage you, but don't worry about abstraction if you are just a beginner. You'll proabably change your design a couple of times even if you're focusing on only one API.

As your graphics understanding improves, so will your design and code quality. 

 

 

Thanks, and I agree. I'm going to stick with SharpDX and Windows exclusively for now.

Share this post


Link to post
Share on other sites
Hi. Professional game developer with ten years experience here. I totally agree with the previous posters who say that trying to write a good quality abstraction layer between opengl and directx will be an uphill battle and probably not the best use of your time.

Having said that, in your original posting, you mentioned that you were finding the vector math packages of sharpDX handy. Even though you have made the decision not to use an abstraction layer for graphics, that does not mean that you need to tie the non-rendering parts (e.g. your AI code) of the game to SharpDX's math library. While writing your own rendering abstraction layer might be a formidable challenge, writing your own vector math routines is not that hard, or you could probably find some good ones that are not tied to a particular rendering engine. If you avoid tying your entire game to directX math libraries then it would mean that if you do decide to port it to another platform you can just replace your rendering code and the rest of your code will not need to be gutted, everywhere that it uses math routines.

On the other hand it might be the case that the sharpdx math library is separate enough from the rest of sharpdx that it would be possible to use it alongside some other rendering library based on opengl. I'm not familiar enough with sharpdx to know if that's the case, but if the math stuff is a separate DLL then that would be a good sign

Share this post


Link to post
Share on other sites

Hi. Professional game developer with ten years experience here. I totally agree with the previous posters who say that trying to write a good quality abstraction layer between opengl and directx will be an uphill battle and probably not the best use of your time.

Having said that, in your original posting, you mentioned that you were finding the vector math packages of sharpDX handy. Even though you have made the decision not to use an abstraction layer for graphics, that does not mean that you need to tie the non-rendering parts (e.g. your AI code) of the game to SharpDX's math library. While writing your own rendering abstraction layer might be a formidable challenge, writing your own vector math routines is not that hard, or you could probably find some good ones that are not tied to a particular rendering engine. If you avoid tying your entire game to directX math libraries then it would mean that if you do decide to port it to another platform you can just replace your rendering code and the rest of your code will not need to be gutted, everywhere that it uses math routines.

On the other hand it might be the case that the sharpdx math library is separate enough from the rest of sharpdx that it would be possible to use it alongside some other rendering library based on opengl. I'm not familiar enough with sharpdx to know if that's the case, but if the math stuff is a separate DLL then that would be a good sign

 

Cool, thanks for the advice. One concern I had was that to interoperate with DirectX I'd have to use its own math structures, which would mean copying from my own to DX, then going from there, which seems like a wasted step, but I actually now think I'm mistaken, as it looks like I really can copy any data into a buffer; it doesn't need to originate as a DX Vector3 or whatever. While learning though, I'll probably, for now, still stick with SharpDX math structures, then as soon as I'm ready, start using my own, because that will have the added benefit of forcing me to rehash the linear algebra knowledge I've been learning, and mentally associate the different seemingly-abstract operations with their practical applications in 3D programming, which will help drum that knowledge in. All the sources I've been reading/watching so far seem to separate the mathematical principles from the application, which means while i'm trying to learn all the relevant knowledge prerequisites in, say, matrix algebra, i'm not absorbing it as well as I should, because the theory doesn't talk much about how a given operation actually applies in the real world which means all I see is a bunch of abstract operations, many of which don't seem to have any obvious purpose.

Edited by axefrog

Share this post


Link to post
Share on other sites
You shouldn't worry now about the very low risk worst case of a very unlikely event: you aren't actually planning to replace SharpDX with OpenGL-based rendering or to make them coexist; in case you do it, the SharpDX math library might or might not become unsuitable or an inappropriate dependency; if you really need to switch to another math library, a massive round of editing is going to be easy (the mathematical abstractions are fundamentally identical) and a negligible effort compared to porting the graphical side to OpenGL.

Share this post


Link to post
Share on other sites

As the others have mentioned several times, I would also suggest tackling one of the APIs at a time.  If you can write a renderer in one API, then another renderer using the other API, then you will be moderately equipped to design a system for putting the two together.  Also, keep in mind that your designs will surely evolve as you tackle different challenges, so don't be afraid to experiment and shake things up.  Especially if this is a hobby project - don't limit yourself right out of the gate, but rather challenge yourself to make some big steps in the design!

Share this post


Link to post
Share on other sites
I was very similar to you. When I first started using Direct X 7, I wanted to create an abstraction layer so I'd later be able to support other things, maybe even other OS. Well I still think this is a good idea, at the time I was new to graphics programing and just learning DX 7 was a huge task for me. I never ended up supporting any other API, and when I moved to DX8, I scrapped most of the code anyway. (FYI, first attempts usually suck.)

Now that I've written like 5 or 6 different 3D engines, I've finally think I have enough knowledge to do a multiplatform framework. It's working well, but after I finish this game, I'll probably redesign it yet again.

Share this post


Link to post
Share on other sites

As the others have mentioned several times, I would also suggest tackling one of the APIs at a time.  If you can write a renderer in one API, then another renderer using the other API, then you will be moderately equipped to design a system for putting the two together.  Also, keep in mind that your designs will surely evolve as you tackle different challenges, so don't be afraid to experiment and shake things up.  Especially if this is a hobby project - don't limit yourself right out of the gate, but rather challenge yourself to make some big steps in the design!

 

Agreed, and I have sort of come to this conclusion as well. I wouldn't explicitly call what I'm doing a hobby project, as I'd like to do it commrcially, full time in the future, but I have a lot of learning to do first.

 

I was very similar to you. When I first started using Direct X 7, I wanted to create an abstraction layer so I'd later be able to support other things, maybe even other OS. Well I still think this is a good idea, at the time I was new to graphics programing and just learning DX 7 was a huge task for me. I never ended up supporting any other API, and when I moved to DX8, I scrapped most of the code anyway. (FYI, first attempts usually suck.)

Now that I've written like 5 or 6 different 3D engines, I've finally think I have enough knowledge to do a multiplatform framework. It's working well, but after I finish this game, I'll probably redesign it yet again.

 

They say, figuratively, that you do everything at least three times; once to learn how to do it, once to do it, and once to do it properly. The third stage is probably more of an endless series of improvements and rewrites, but such as life in the world of development. I've been through this process repeatedly in web and application development, but 3D graphics programming is a whole new ball game, so it's back to the drawing board, to a large degree.

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
      628354
    • Total Posts
      2982237
  • 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