• Advertisement
Sign in to follow this  

OpenGL How to abstract OpenGL or DirectX specific things from classes specific to rendering

This topic is 1767 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

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.

Share this post


Link to post
Share on other sites
Advertisement

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

Share this post


Link to post
Share on other sites

  • 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.

Share this post


Link to post
Share on other sites

 

  • 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;
};

Share this post


Link to post
Share on other sites

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.

Share this post


Link to post
Share on other sites

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.

Share this post


Link to post
Share on other sites

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.

Share this post


Link to post
Share on other sites

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.

Share this post


Link to post
Share on other sites

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.

Share this post


Link to post
Share on other sites

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

Share this post


Link to post
Share on other sites

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?

Share this post


Link to post
Share on other sites

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.

Share this post


Link to post
Share on other sites

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

Share this post


Link to post
Share on other sites

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

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
  • Advertisement
  • Popular Now

  • Advertisement
  • Similar Content

    • By Balma Alparisi
      i got error 1282 in my code.
      sf::ContextSettings settings; settings.majorVersion = 4; settings.minorVersion = 5; settings.attributeFlags = settings.Core; sf::Window window; window.create(sf::VideoMode(1600, 900), "Texture Unit Rectangle", sf::Style::Close, settings); window.setActive(true); window.setVerticalSyncEnabled(true); glewInit(); GLuint shaderProgram = createShaderProgram("FX/Rectangle.vss", "FX/Rectangle.fss"); float vertex[] = { -0.5f,0.5f,0.0f, 0.0f,0.0f, -0.5f,-0.5f,0.0f, 0.0f,1.0f, 0.5f,0.5f,0.0f, 1.0f,0.0f, 0.5,-0.5f,0.0f, 1.0f,1.0f, }; GLuint indices[] = { 0,1,2, 1,2,3, }; GLuint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW); GLuint ebo; glGenBuffers(1, &ebo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(float) * 5, (void*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 2, GL_FLOAT, false, sizeof(float) * 5, (void*)(sizeof(float) * 3)); glEnableVertexAttribArray(1); GLuint texture[2]; glGenTextures(2, texture); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); sf::Image* imageOne = new sf::Image; bool isImageOneLoaded = imageOne->loadFromFile("Texture/container.jpg"); if (isImageOneLoaded) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageOne->getSize().x, imageOne->getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageOne->getPixelsPtr()); glGenerateMipmap(GL_TEXTURE_2D); } delete imageOne; glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture[1]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); sf::Image* imageTwo = new sf::Image; bool isImageTwoLoaded = imageTwo->loadFromFile("Texture/awesomeface.png"); if (isImageTwoLoaded) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageTwo->getSize().x, imageTwo->getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageTwo->getPixelsPtr()); glGenerateMipmap(GL_TEXTURE_2D); } delete imageTwo; glUniform1i(glGetUniformLocation(shaderProgram, "inTextureOne"), 0); glUniform1i(glGetUniformLocation(shaderProgram, "inTextureTwo"), 1); GLenum error = glGetError(); std::cout << error << std::endl; sf::Event event; bool isRunning = true; while (isRunning) { while (window.pollEvent(event)) { if (event.type == event.Closed) { isRunning = false; } } glClear(GL_COLOR_BUFFER_BIT); if (isImageOneLoaded && isImageTwoLoaded) { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture[0]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture[1]); glUseProgram(shaderProgram); } glBindVertexArray(vao); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr); glBindVertexArray(0); window.display(); } glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); glDeleteBuffers(1, &ebo); glDeleteProgram(shaderProgram); glDeleteTextures(2,texture); return 0; } and this is the vertex shader
      #version 450 core layout(location=0) in vec3 inPos; layout(location=1) in vec2 inTexCoord; out vec2 TexCoord; void main() { gl_Position=vec4(inPos,1.0); TexCoord=inTexCoord; } and the fragment shader
      #version 450 core in vec2 TexCoord; uniform sampler2D inTextureOne; uniform sampler2D inTextureTwo; out vec4 FragmentColor; void main() { FragmentColor=mix(texture(inTextureOne,TexCoord),texture(inTextureTwo,TexCoord),0.2); } I was expecting awesomeface.png on top of container.jpg

    • By khawk
      We've just released all of the source code for the NeHe OpenGL lessons on our Github page at https://github.com/gamedev-net/nehe-opengl. code - 43 total platforms, configurations, and languages are included.
      Now operated by GameDev.net, NeHe is located at http://nehe.gamedev.net where it has been a valuable resource for developers wanting to learn OpenGL and graphics programming.

      View full story
    • By TheChubu
      The Khronos™ Group, an open consortium of leading hardware and software companies, announces from the SIGGRAPH 2017 Conference the immediate public availability of the OpenGL® 4.6 specification. OpenGL 4.6 integrates the functionality of numerous ARB and EXT extensions created by Khronos members AMD, Intel, and NVIDIA into core, including the capability to ingest SPIR-V™ shaders.
      SPIR-V is a Khronos-defined standard intermediate language for parallel compute and graphics, which enables content creators to simplify their shader authoring and management pipelines while providing significant source shading language flexibility. OpenGL 4.6 adds support for ingesting SPIR-V shaders to the core specification, guaranteeing that SPIR-V shaders will be widely supported by OpenGL implementations.
      OpenGL 4.6 adds the functionality of these ARB extensions to OpenGL’s core specification:
      GL_ARB_gl_spirv and GL_ARB_spirv_extensions to standardize SPIR-V support for OpenGL GL_ARB_indirect_parameters and GL_ARB_shader_draw_parameters for reducing the CPU overhead associated with rendering batches of geometry GL_ARB_pipeline_statistics_query and GL_ARB_transform_feedback_overflow_querystandardize OpenGL support for features available in Direct3D GL_ARB_texture_filter_anisotropic (based on GL_EXT_texture_filter_anisotropic) brings previously IP encumbered functionality into OpenGL to improve the visual quality of textured scenes GL_ARB_polygon_offset_clamp (based on GL_EXT_polygon_offset_clamp) suppresses a common visual artifact known as a “light leak” associated with rendering shadows GL_ARB_shader_atomic_counter_ops and GL_ARB_shader_group_vote add shader intrinsics supported by all desktop vendors to improve functionality and performance GL_KHR_no_error reduces driver overhead by allowing the application to indicate that it expects error-free operation so errors need not be generated In addition to the above features being added to OpenGL 4.6, the following are being released as extensions:
      GL_KHR_parallel_shader_compile allows applications to launch multiple shader compile threads to improve shader compile throughput WGL_ARB_create_context_no_error and GXL_ARB_create_context_no_error allow no error contexts to be created with WGL or GLX that support the GL_KHR_no_error extension “I’m proud to announce OpenGL 4.6 as the most feature-rich version of OpenGL yet. We've brought together the most popular, widely-supported extensions into a new core specification to give OpenGL developers and end users an improved baseline feature set. This includes resolving previous intellectual property roadblocks to bringing anisotropic texture filtering and polygon offset clamping into the core specification to enable widespread implementation and usage,” said Piers Daniell, chair of the OpenGL Working Group at Khronos. “The OpenGL working group will continue to respond to market needs and work with GPU vendors to ensure OpenGL remains a viable and evolving graphics API for all its customers and users across many vital industries.“
      The OpenGL 4.6 specification can be found at https://khronos.org/registry/OpenGL/index_gl.php. The GLSL to SPIR-V compiler glslang has been updated with GLSL 4.60 support, and can be found at https://github.com/KhronosGroup/glslang.
      Sophisticated graphics applications will also benefit from a set of newly released extensions for both OpenGL and OpenGL ES to enable interoperability with Vulkan and Direct3D. These extensions are named:
      GL_EXT_memory_object GL_EXT_memory_object_fd GL_EXT_memory_object_win32 GL_EXT_semaphore GL_EXT_semaphore_fd GL_EXT_semaphore_win32 GL_EXT_win32_keyed_mutex They can be found at: https://khronos.org/registry/OpenGL/index_gl.php
      Industry Support for OpenGL 4.6
      “With OpenGL 4.6 our customers have an improved set of core features available on our full range of OpenGL 4.x capable GPUs. These features provide improved rendering quality, performance and functionality. As the graphics industry’s most popular API, we fully support OpenGL and will continue to work closely with the Khronos Group on the development of new OpenGL specifications and extensions for our customers. NVIDIA has released beta OpenGL 4.6 drivers today at https://developer.nvidia.com/opengl-driver so developers can use these new features right away,” said Bob Pette, vice president, Professional Graphics at NVIDIA.
      "OpenGL 4.6 will be the first OpenGL release where conformant open source implementations based on the Mesa project will be deliverable in a reasonable timeframe after release. The open sourcing of the OpenGL conformance test suite and ongoing work between Khronos and X.org will also allow for non-vendor led open source implementations to achieve conformance in the near future," said David Airlie, senior principal engineer at Red Hat, and developer on Mesa/X.org projects.

      View full story
    • By _OskaR
      Hi,
      I have an OpenGL application but without possibility to wite own shaders.
      I need to perform small VS modification - is possible to do it in an alternative way? Do we have apps or driver modifictions which will catch the shader sent to GPU and override it?
    • By xhcao
      Does sync be needed to read texture content after access texture image in compute shader?
      My simple code is as below,
      glUseProgram(program.get());
      glBindImageTexture(0, texture[0], 0, GL_FALSE, 3, GL_READ_ONLY, GL_R32UI);
      glBindImageTexture(1, texture[1], 0, GL_FALSE, 4, GL_WRITE_ONLY, GL_R32UI);
      glDispatchCompute(1, 1, 1);
      // Does sync be needed here?
      glUseProgram(0);
      glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
      glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                     GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, texture[1], 0);
      glReadPixels(0, 0, kWidth, kHeight, GL_RED_INTEGER, GL_UNSIGNED_INT, outputValues);
       
      Compute shader is very simple, imageLoad content from texture[0], and imageStore content to texture[1]. Does need to sync after dispatchCompute?
  • Advertisement