C++ OpenGL wrapper: interface similar to fixed pipeline, can export .collada

[Zohar]

I asked the following question here:

https://stackoverflow.com/questions/61991648/c-opengl-wrapper-interface-similar-to-fixed-pipeline-can-export-collada

if anyone wants to discuss it.

I have opengl code that uses the fixed pipeline. Hitting two birds with one stone, I need a wrapper that can help me with the following tasks:

1. Convert the code to the new shader-based pipeline with minimal effort. I have a class that calls opengl functions, such as: glBegin(triangles/lines), glVertex, glPushMatrix, glTranslate, glColor, gluSphere.
2. Ideally, I’d like it to derive from a class that supplies these functions in the base class. Behind the scene, it would use the same high level logic as the fixed pipeline.
3. I’d like to export an opengl scene to .collada to load in an external renderer. Opengl is low level rendering, and it doesn’t have the concept of a scene. For example, this reddit post:

"You realize that you have to write a shim to capture all API calls you are interested in to do that. Then, when finally, a draw call is emitted you have to parse every single vertex and collect the data from all over the memory from the buffers that you have recorded from the APi calls that set up VAOs, VBOs and IBOs. Then you have to parse the shader source code so that you can see which uniforms and vertex attributes contribute to vertex clip coordinate generation. Then you also have to synthesize/guess which outputs are normal, color, texture coordinate and so on from the shader source if the resulting program even have those in .obj file format-wise.

This gets even more complicated if Compute is used to generate data inside the GPU for any of the buffers. If geometry or tessellator is used then you also have to implement one of those so that you get accurate outputs from the vertex processing. TL;DR - you have to write your own OpenGL 4.5 driver that does exactly the same things a real hardware driver would do. Good luck with that."

However, my scene is simple, using the fixed pipeline operations above. I’d like the wrapper to keep track and construct a scene that can be exported.

–

EDIT: Since recommendation is off-topic, I’ll ask the following question. What I need above seems like something obvious that many should have found useful. Since I can’t find a library that accomplishes that, I’m wondering if my approach is unreasonable? More specifically, how do people port their legacy opengl code; do they write the relevant part from scratch, or does everyone implement his own wrapper as I suggested? What about constructing a scene to export to collada?

[GClements]

@Zohar

What I need above seems like something obvious that many should have found useful. Since I can’t find a library that accomplishes that, I’m wondering if my approach is unreasonable? More specifically, how do people port their legacy opengl code; do they write the relevant part from scratch, or does everyone implement his own wrapper as I suggested?

Most people re-write the code. People who write a wrapper write a wrapper which handles their specific requirements and nothing else. A wrapper which can handle the entire fixed-function pipeline is infeasible. So even if you can find a wrapper, it’s probably not going to work for your code.

The thing is, there isn’t all that much “real” software using glBegin/glEnd. Most code which has practical use either used vertex arrays from the outset or has long since been updated to do so.

As for export: typically you’d start from the data structure which you’re using to generate the data for rendering, as that’s likely to be structurally closer to what you need than a sequence of OpenGL commands would be. A wrapper which implements glBegin, glVertex (etc) and glEnd and dumps the data to an OBJ (or similar) file would be fairly straightforward. But exporting uniform state (lighting, materials, texture environment, transformations) is more awkward.

[Zohar]

Thanks for the reply.
Sounds like I’ll need to find the time at some point to write my own thing, and I can’t see an easier way to go about it than what I suggested.