17 replies to this topic

[pinebanana]

I'm not sure if this has been posted before.

 

I'm just not sure how I should abstract OpenGL or DirectX specific things from classes specific to rendering. Such as shaders, texture objects, vertex buffer objects, etc.

 

For example:

 

Let's say there is a Texture2D class, that is used to refer to textures stored on the GPU. The problem is: storing the specific GLuint (or whatever the alternative for DX is) within the Texture2D object directly, which would make my code very dependent to OpenGL. I've thought of a couple alternatives:

 

Option 1:

 

 

Store an unsigned integer inside the Texture object, (not actually the GLuint), which will resemble an index of the actual OpenGL/DX specific data. Which will most likely be present inside a TextureLoader class. Where the Renderer will have a TextureLoader, and may be accessed through a getter.

 

Here is what I mean:

 

Texture2d (this is a basic data structure)
     - width/height
     - index
Texture2dLoader (abstract)
     - loadTexture(const Image&) : Texture2d
     - destroyTexture(Texture& texture)
OglTexture2dLoader : TextureLoader
    - loadTexture(const Image&) : Texture2d // override
    - destroyTexture(Texture& texture) // override
    - vector<GLuint> textures // dynamic array, appended to when loading texture 

 

Here are the pros/cons that I've thought of from this design.

 

Pros:

• Simple, non dependant on OpenGL or DirectX
• Easy to make another implementation

Cons:

• Requires manual deletion, therefore:
• If Texture object goes out of scope, there will be no way of deleting texture manually

 

Option 2:

 

Make an abstract TextureHandler class, which will have specific OpenGL/DX in the derived class

 

Texture2dHandler (abstract)

     - virtual destructor

Texture2d (this is a basic data structure)

     - width/height

     - handler : unique_ptr<Texture2dHandler>

OglTexture2dHandler : TextureHandler

     - GLuint id

     - (destructor)

Texture2dLoader (abstract)

     - loadTexture(const Image&) : Texture2d

     - destroyTexture(Texture& texture)

OglTexture2dLoader : TextureLoader

    - loadTexture(const Image&) : Texture2d // override

    - destroyTexture(Texture& texture) // override

 

Pros:

• Allows for RAII

Cons:

• Handler requires to be allocated on the heap

 

The same issue is also applied to shaders, buffer objects (such as VBOs), and whatever else, and therefore this will be present all over my code. Does anyone have personal experience with this? What option should I go for?

 

This is really bugging my mind. Thanks for reading.

[Aressera]

Here's how my engine handles this, I haven't been able to come up with anything else that's any more flexible or simple.

 

The classes which abstract the main interface to the graphics API:

• DeviceManager - Enumerates all available 'devices' i.e. OpenGL, DirectX 10, DirectX 11, etc
• GraphicsDevice - implements a graphics API interface (i.e. OpenGL), creates a context for the particular device.
• GraphicsContext - main interface which handles GPU object creation (textures, buffers, shaders, etc), as well as submitting draw calls/state changes to the API. Also handles window system interaction. I have an OpenGLContext subclass and will soon have a DirectX10Context, and later others.
  • Call context->createTexture2D( image, texture format...) and like methods for other types to create context GPU objects from generic data.
  • Call context->draw( vertex buffer, index buffer, shader program ) to draw stuff.

These interfaces provide a way to get access to an underlying API in a uniform manner. Since all APIs wrap hardware functionality for buffers, textures, and shaders, there ends up being a common set of abstractions for different hardware data types:

 

• Texture - virtual interface for interactions with the texture system. Handles 1D, 2D, 3D, and cube textures and any other common texture parameters. Implemented by OpenGLTexture which provides the OpenGL implementation for the texture, including any API-specific data (GLint texture ID, for example).
• HardwareBuffer - virtual interface for vertex buffers, index buffers, and constant buffers. Provides buffer memory mapping, read/write access. Implemented by OpenGLHardwareBuffer.
• Shader -  virtual interface for shader creation. Takes source code and shader type/language (vertex/fragment, glsl/cg/hlsl), then compiles it. Implemented by OpenGLShader.
• ShaderProgram - virtual interface for shader programs. User attaches Shader objects to the program and then link them. Allows users to access the input variables for the linked shader program. Implemented by OpenGLShaderProgram.

In practice it is a little tricky to define good interfaces for these classes, but it can be done. All of these classes are wrapped in reference-counted smart pointers.

Edited by Aressera, 10 March 2013 - 02:43 AM.

[pinebanana]

• Texture - virtual interface for interactions with the texture system. Handles 1D, 2D, 3D, and cube textures and any other common texture parameters. Implemented by OpenGLTexture which provides the OpenGL implementation for the texture, including any API-specific data (GLint texture ID, for example).

 

How does your Texture class handle 1D, 2D, 3D, and cube textures? Do you have multiple sub-classing?

 

And... Hm... The Hardware types seems familiar on how Ogre3D has designed them.

[Aressera]

 

• Texture - virtual interface for interactions with the texture system. Handles 1D, 2D, 3D, and cube textures and any other common texture parameters. Implemented by OpenGLTexture which provides the OpenGL implementation for the texture, including any API-specific data (GLint texture ID, for example).

 

How does your Texture class handle 1D, 2D, 3D, and cube textures? Do you have multiple sub-classing?

 

And... Hm... The Hardware types seems familiar on how Ogre3D has designed them.

 

Here's a basic outline of the most important methods

class Texture
{
	public:
	
	virtual Size getNumberOfDimensions() const = 0;
	virtual Size getSize( Index dimensionIndex ) const = 0;
	
	// Returns 1 for most textures, 6 for cube map textures.
	virtual Size getNumberOfFaces() const = 0;
	virtual Bool isACubeMap() const = 0;

	// Gets image for face/mipmap level in output image parameter.
	virtual Bool getImage( Image& image, TextureFace face = FRONT, Index mimapLevel = 0 ) const = 0;
	
	// Replaces texture's image for the given face/mipmap.
	virtual Bool setImage( const Image& image, TextureFace face = FRONT, Index mimapLevel = 0 ) = 0;
	
	// Replaces part of the texture at the specified position/face/mipmap level.
	virtual Bool updateImage( const Image& image, const Vector3i& position, TextureFace face = FRONT, Index mimapLevel = 0 ) = 0;
};

[mhagain]

I don't think this is a good design - you're basically going too low and trying to build what looks and smells a lot like a fairly thin wrapper around each API.  The problem with that approach is that there are areas at a higher level where the APIs need to be handled differently - D3D input layouts (or vertex declarations) vs GL vertex attrib arrays, GL linked program objects vs D3D separate shaders, uniforms being part of the program object state in GL vs that not being the case in D3D, the ever-dreaded bind-to-modify in GL, different buffer update strategies, etc.  These (and others) will repeatedly trip you up with such a fairly thin wrapper, and you're going to find the abstraction leaks and bubbles up into your main program code, where you'll be having to do API-specific things as well.  That's not the point of an abstraction layer; you may as well be using the raw APIs with a bunch of #ifdefs instead.

 

If you want to abstract you should go up higher - abstract at the level of "material", "render surface", and so forth.  That way all that your main program code has to bother with is setting parameters and submitting stuff for drawing, whereas your abstraction layer can handle the API-specific parts of doing so in a way that your main code doesn't need to even know about.

[Aressera]

If you want to abstract you should go up higher - abstract at the level of "material", "render surface", and so forth.  That way all that your main program code has to bother with is setting parameters and submitting stuff for drawing, whereas your abstraction layer can handle the API-specific parts of doing so in a way that your main code doesn't need to even know about.

 

You're right, there have to be a couple different levels of abstraction which I omitted for simplicity. What I've described above is just that, a thin wrapper around each API's low level functionality. On top of that is built a material/mesh/object management system that might have API-specific code too, though I think it's not too hard to keep it at a minimum.

[pinebanana]

If you want to abstract you should go up higher - abstract at the level of "material", "render surface", and so forth.  That way all that your main program code has to bother with is setting parameters and submitting stuff for drawing, whereas your abstraction layer can handle the API-specific parts of doing so in a way that your main code doesn't need to even know about.

I'm not exactly sure what you mean? Could you elaborate? Or give an example.

[Seabolt]

He's saying that instead of wrapping around each graphics primitive, (Textures, Render Targets, etc), you should only wrap around the high level use of those types. So if you only write a material class, then you'll simultaneously wrap around textures, shaders, texture samplers, etc, and only provide one access point for your application.

That being said, I disagree with it. I prefer to have managers around each primitive to allow for more flexibility, then build my higher level abstractions on top of that. For example, my engine will define an base ShaderManager. Then the platform will define another ShaderManager, (ShaderManagerOGL). Then I have a similar abstraction called Shader and ShaderOGL. It's responsibility is to effectively communicate with the manager. Then I have a Material and MaterialOGL class that is responsible for maintaining a ShaderOGL and to do whatever setup is necessary to use that shader. Then finally I have a RenderComponent/OGL class that is responsible for setting up materials, vertex buffers, and VAOs and so on and so forth.

My current engine support DirectX9, DirectX11, and OpenGL 2.0-3.3. I'm currently working on an OpenGL ES 2.0 port of my engine, and it still allows the flexibility I need to best leverage my platform.

[allingm]

I would check out Hummus' "Framework 3". http://www.humus.name/index.php?page=3D

[ill]

I've been storing void* (ugh) in my texture and mesh and shader objects.

 

I have a frontend and a backend.  I supply the instance of the backend that would load a texture and now the void* points to some OpenGL specific data.  If I want to free it I go through the backend and have the backend free it.  Basically only the backend knows the format of the void* data and just typecasts the void* to that.

 

I haven't worked with DirectX yet so I'm not sure how things are stored, so I decided not to go with unsigned ints for things in case DirectX stored them completely differently.

[Promit]

For example:

 

Let's say there is a Texture2D class, that is used to refer to textures stored on the GPU. The problem is: storing the specific GLuint (or whatever the alternative for DX is) within the Texture2D object directly, which would make my code very dependent to OpenGL.

RED ALERT.

 

The very first step to abstracting across APIs is being familiar with several of them. You apparently are not. The very first step to writing abstract code is understanding what is being abstracted and at what layer the abstraction needs to exist. It also requires some perspective on common functionality within the APIs and from the point of view of the client code. Reusability and abstraction DO NOT exist in a vacuum and you can't simply make them up based on some general ideas of what constitutes an API's objects.

 

More generally speaking, creating an abstracted layer that can do D3D or OGL internally isn't about papering over whether it's a GLuint or an IDirect3DTexture* underneath. Those things are trivial, stupid issues. Some judicious use of the preprocessor and API specific files will solve those issues. No, the hard part in creating these abstractions is behavior and implied assumptions. There is a lot of devil in the details type stuff that can take some careful stepping to navigate. Simple example: OpenGL has the vertex array object (VAO), which encapsulates a client state (enabled attrib bits and bound VBOs). You'll have one per object, more or less. That doesn't exist in D3D 9. Instead there is a separate set of stream sources, and a vertex declaration which is typically shared heavily. It can get messier if you want to handle constant buffer APIs (D3D 11, GL 4.2). Render states are handled differently in GL than D3D9 than D3D11. And a nasty one for OpenGL based engines: D3D requires everything to be funneled through a device pointer, which is not necessary in GL. If your GL abstraction assumes it can change pipeline states without an external reference, you'll wind up patching in globals to support D3D. And this is all just a small slice.

 

It IS doable, and it is even doable with low level wrapping. But the lower level you get, the more intricate the behavioral details and implied assumptions become. More familiarity with the potential APIs (GL 2.x, GL 3.x, GL 4.x, D3D9, D3D11, D3D Xbox, PS3, etc) is needed. The advice to do the abstraction with very high level objects is a good one. It yields a fair bit of control to the underlying API and can create an annoying amount of duplicate or similar code across implementations. But it is more likely to be robust in the face of many different hardware APIs.

[ill]

Phew, after reading what you posted, I feel like the way I did it would handle all of those cases.

[pinebanana]

t IS doable, and it is even doable with low level wrapping. But the lower level you get, the more intricate the behavioral details and implied assumptions become. More familiarity with the potential APIs (GL 2.x, GL 3.x, GL 4.x, D3D9, D3D11, D3D Xbox, PS3, etc) is needed. The advice to do the abstraction with very high level objects is a good one. It yields a fair bit of control to the underlying API and can create an annoying amount of duplicate or similar code across implementations. But it is more likely to be robust in the face of many different hardware APIs.

Hm... it seems I'm in over my head about this situation. Perhaps instead of thinking too much about it, I'll just do it and see with experience the limitations about the design I will use.

 

 

 

For example:

 

Let's say there is a Texture2D class, that is used to refer to textures stored on the GPU. The problem is: storing the specific GLuint (or whatever the alternative for DX is) within the Texture2D object directly, which would make my code very dependent to OpenGL.

RED ALERT.

 

The very first step to abstracting across APIs is being familiar with several of them. You apparently are not. The very first step to writing abstract code is understanding what is being abstracted and at what layer the abstraction needs to exist. It also requires some perspective on common functionality within the APIs and from the point of view of the client code. Reusability and abstraction DO NOT exist in a vacuum and you can't simply make them up based on some general ideas of what constitutes an API's objects.

 

More generally speaking, creating an abstracted layer that can do D3D or OGL internally isn't about papering over whether it's a GLuint or an IDirect3DTexture* underneath. Those things are trivial, stupid issues. Some judicious use of the preprocessor and API specific files will solve those issues. No, the hard part in creating these abstractions is behavior and implied assumptions. There is a lot of devil in the details type stuff that can take some careful stepping to navigate. Simple example: OpenGL has the vertex array object (VAO), which encapsulates a client state (enabled attrib bits and bound VBOs). You'll have one per object, more or less. That doesn't exist in D3D 9. Instead there is a separate set of stream sources, and a vertex declaration which is typically shared heavily. It can get messier if you want to handle constant buffer APIs (D3D 11, GL 4.2). Render states are handled differently in GL than D3D9 than D3D11. And a nasty one for OpenGL based engines: D3D requires everything to be funneled through a device pointer, which is not necessary in GL. If your GL abstraction assumes it can change pipeline states without an external reference, you'll wind up patching in globals to support D3D. And this is all just a small slice.

 

 I don't know a lot D3D, but I assumed (from what I heard) that the concepts are very similar to OpenGL. i.e. Texture objects for DX. I did know about the D3D device, which I could easily just pass to if I create a renderer, could I not?

[Seabolt]

At a high level, sure there are a lot of similarities. In practice they are vastly different implementations. 

[mhagain]

Both possess texture objects for sure, but there are two major differences and a third more subtle difference.

 

First major difference is that D3D has no equivalent whatsoever to the glActiveTexture call.  In GL you select a currently active texture unit and all subsequent GL calls that affect texture state will affect the state for that unit.  This model doesn't exist at all in D3D - instead the texture stage to be affected is passed as a parameter to all texture state calls.

 

Second one is that GL has texture binding points - GL_TEXTURE_2D, GL_TEXTURE_3D, etc.  Each texture unit has a full set of binding points and multiple textures can be bound to a single texture unit by binding one to each binding point.  Again, state changes must specify the binding point to be affected.  D3D doesn't have these binding points at all; it's one texture stage, one texture.

 

The more subtle one is that if you want to create or subsequently modify a texture in GL you must glBindTexture it first.  glTexImage/glTexSubImage calls only affect the currently bound texture.  D3D doesn't have this requirement - instead you operate directly on the texture object itself without needing a SetTexture call before doing so.  State changes for drawing are going to affect modification/creation and vice-versa in GL but not in D3D.  (This also applies to buffer objects in GL vs D3D too).

 

So by going to too low a level, these API difference are all things that your program is going to have to be aware of, which means that the abstraction bubbles up into your main program code.  This kind of difference exists throughout the two APIs - you'll have similar problems with shaders and shader uniforms, for example, and again the abstraction will bubble up to your main program code.  So your main program code will end up having to be aware of which API it's using, what it can and cannot do in each, what the differences are for handling objects, etc.  At that point you've no longer got an abstraction, you've got a set of thin wrappers with your main program code doing all the heavy work.

[french_hustler]

I would check out Hummus' "Framework 3". http://www.humus.name/index.php?page=3D

+1 on this.  His engine is a great example on how to abstract the rendering pipeline.  He has different pipelines for dx, opengl, and even for handheld devices.

[ill]

Wow that actually looks pretty awesome.  I'll have to take a good look at that.

[metsfan]

How does your Texture class handle 1D, 2D, 3D, and cube textures? Do you have multiple sub-classing?

 

For this, what I've done is create an enumeration for the texture types, arguments, filters, ect that I want to support.  Then, in each API-specific texture class, I define an array of values which map to my custom enumeration, and put -1 where the value is unsupported.  It seems to work pretty well for me at the moment.  

For instance, for texture type I would have an enum:

enum TextureType
{
  TextureType1D,
  TextureType2D,
  TextureType3D
}

 

 

Then my mapping for OpenGL would be

 

static const int GLTextureType[3] = 
{
  GL_TEXTURE_1D,
  GL_TEXTURE_2D,
  -1 // 3D Textures are not supported
}

Edited by metsfan, 18 March 2013 - 10:34 AM.