Running custom OpenGL alongside V3d viewer

Hey,

I'm currently working on a viewer for 3D models as part of a larger project. I decided to use OpenCASCADE for visualization, however I'm quite new to the ecosystem. I would like to know how I can render custom OpenGL on top of a 3D viewer.

I've managed to build a basic viewer based on OpenGL and GLFW using two subclasses from AIS_ViewController and Aspect_Window. The model is being rendered using V3d_Viewer and I would like to be able to render custom OpenGL on top of rendered output from V3d_Viewer. I found this article and this guide to upgrading which were a big help in getting some ground work done.

Following some instructions from those resources I created two classes: GLViewGUI, the class that is supposed to perform the custom rendering:

class GLViewGUI : public OpenGl_View {
    DEFINE_STANDARD_RTTI_INLINE(GLViewGUI, OpenGl_View)
  public:
    GLViewGUI (const Handle(Graphic3d_StructureManager)& theMgr,
               const Handle(OpenGl_GraphicDriver)& theDriver,
               const Handle(OpenGl_Caps)& theCaps,
               OpenGl_StateCounter* theCounter)
               : OpenGl_View(theMgr, theDriver, theCaps, theCounter) {
        myRenderParams.Method = Graphic3d_RM_RASTERIZATION;
    };

    void render(Graphic3d_Camera::Projection theProjection,
                OpenGl_FrameBuffer*          theReadDrawFbo,
                OpenGl_FrameBuffer*          theOitAccumFbo,
                const Standard_Boolean       theToDrawImmediate) Standard_OVERRIDE {
        OpenGl_View::render(theProjection, theReadDrawFbo, theOitAccumFbo, theToDrawImmediate);
        if (theToDrawImmediate)
            return;

        const Handle(OpenGl_Context)& aCtx = myWorkspace->GetGlContext();
        GLfloat aVerts[] = { -0.5f, -0.5f, 0.0f,
                              0.5f, -0.5f, 0.0f,
                              0.0f,  0.5f, 0.0f,
        };
        aCtx->core20->glEnableClientState(GL_VERTEX_ARRAY);
        aCtx->core20->glVertexPointer(3, GL_FLOAT * 3, GL_FALSE, aVerts);
        aCtx->core20fwd->glDrawArrays(GL_TRIANGLES, 0, 3);
        aCtx->core20->glDisableClientState(GL_VERTEX_ARRAY);
    }
};

And this GLExtensibleDriver class that allows me to register custom OpenGL_View classes:

class GLExtensibleDriver : public OpenGl_GraphicDriver {
    DEFINE_STANDARD_RTTI_INLINE(GLExtensibleDriver, OpenGl_GraphicDriver)
  public:
    explicit GLExtensibleDriver (const Handle(Aspect_DisplayConnection)& theDisp,
                                 const Standard_Boolean                  theToInitialize = Standard_True)
                                 : OpenGl_GraphicDriver(theDisp, theToInitialize) {};

    Handle(Graphic3d_CView) CreateView (const Handle(Graphic3d_StructureManager)& theMgr) Standard_OVERRIDE {
        Handle(OpenGl_View) aView = new OpenGl_View (theMgr, this, myCaps, &myStateCounter);
        myMapOfView.Add (aView);
        for (NCollection_List<Handle(Graphic3d_Layer)>::Iterator aLayerIter (myLayers); aLayerIter.More(); aLayerIter.Next())
        {
            const Handle(Graphic3d_Layer)& aLayer = aLayerIter.Value();
            aView->InsertLayerAfter (aLayer->LayerId(), aLayer->LayerSettings(), Graphic3d_ZLayerId_UNKNOWN);
        }
        return {aView};
    }

    template<class View> requires std::is_base_of_v<OpenGl_View, View>
    Handle(OpenGl_View) CreateView (const Handle(Graphic3d_StructureManager)& theMgr) {
        Handle(View) aView = new View (theMgr, this, myCaps, &myStateCounter);
        myMapOfView.Add (aView);
        for (NCollection_List<Handle(Graphic3d_Layer)>::Iterator aLayerIter (myLayers); aLayerIter.More(); aLayerIter.Next())
        {
            const Handle(Graphic3d_Layer)& aLayer = aLayerIter.Value();
            aView->InsertLayerAfter (aLayer->LayerId(), aLayer->LayerSettings(), Graphic3d_ZLayerId_UNKNOWN);
        }
        return {aView};
    }

    template<class View> requires std::is_base_of_v<OpenGl_View, View>
    Handle(OpenGl_View) CreateView () {
        Handle(Graphic3d_StructureManager) aStructureManager = new Graphic3d_StructureManager(this);
        return CreateView<View>(aStructureManager);
    }
};

These classes are created and used a follows: On creation:

Handle(GLExtensibleDriver) aGraphicDriver = new GLExtensibleDriver ([Window Class]->GetDisplay(), false);
Handle(V3d_Viewer) aViewer = new V3d_Viewer (aGraphicDriver);
[...]
myView = aViewer->CreateView();
myView->SetImmediateUpdate (false);
myView->SetWindow (myOcctWindow, myOcctWindow->NativeGlContext());
[...]
myContext = new AIS_InteractiveContext (aViewer);
aGUIViewer = aGraphicDriver->CreateView<GLViewGUI>();
aGUIViewer->SetWindow (myOcctWindow, myOcctWindow->NativeGlContext());

On rendering:

while (!glfwWindowShouldClose (myOcctWindow->getGlfwWindow())) {
    glfwWaitEvents();
    if (!myView.IsNull()) {
        glfwPollEvents();
        aGUIViewer->Redraw();
        FlushViewEvents (myContext, myView, true);
    }
}

This whole set-up doesn't work at all however. The first and most pressing issue is that calling aGUIViewer->Redraw() clears the OpenGL back buffer and flips it after drawing. Of course Id like to prevent the redraw from clearing or flipping the buffer. Looking at the source I don't see any easy way to circumvent that.

The second issue is that nothing is being drawn. The OpenGL code that is run inside GLViewGUI::render() gets translated into one glDrawArray call as expected but draws completely arbitrary vertices using textures that have not been bound. I'm generally not very satisfied with the OpenGl_Context.coreXX API. Some functions are missing and some are defined in a weird way I am unable to understand. This might just be a lack of documentation.

Id much appreciate your support!