Creating Texture as Background Image

They say give a man a fish and he will feed himself for a day; give him a fishing net and he'll feed himself for life.

I'm not just going to put my code on the web for download just yet for 2 reasons.

1. It doesn't work properly yet (as per my previous hastily written post).
2. It won't explain the basis of the solution.

Somewhere around OCC version 5, an alternate form of the SetWindow call was introduced into the API. Its documented in the Visual3d_View.cdl as

SetWindow ( me : mutable;
AWindow : Window from Aspect;
AContext: RenderingContext from Aspect;
ADisplayCB: GraphicCallbackProc from Aspect;
AClientData: Address from Standard
)
---Level: Public
---Purpose: Associates the window and context
-- to the view .
-- If is not NULL the graphic context is used
-- directly to draw something in this view.
-- Otherwise an internal context is created.
-- If is not NULL then a user display CB is
-- call at the end of the OCC graphic traversal and just
-- before the swap of buffers. The is pass
-- to this call back.
-- No new association if the window is already defined.
-- Category: Methods to modify the class definition
-- Warning: Raises ViewDefinitionError if it is impossible
-- to associate a view and a window.
-- (association already done or another problem)
-- Modifies the viewmapping of the associated view
-- when it calls the SetRatio method.
raises ViewDefinitionError from Visual3d is static;
---Purpose:
-- After this call, each view is mapped in an unique window.

In the Windows world, the Aspect_RenderingContex is a direct map to the HGLRC. This enables you re-use an existing OpenGL rendering context - but the function does execute another choosePixelFormat on Windows when called. In the Qt world this means you can actually re-use the OpenGL context within the QGLWidget. However you can provide the function with a zero value for AContext, in which case the viewer will construct its own rendering context as normal.

The function also enables you to register a callback procedure that will be called in the OCC rendering loop just before the final call to swapbuffers, irrespective of which rendering context you provide - the makeCurrent will already be called. For the interested, you can see the call back function being called in "call_togl_redraw" in opengl_togl_redraw.c.

The call back function itself need to math the prototype

int foo (Aspect_Drawable drawable, void* aPointer, Aspect_GraphicCallbackStruct* data)

This cannot be implemenented as a directly as class member function because it doesn't contain the magic "this" pointer. However it can be implemented a static class function, and we can implement the this pointer via the void* aPointer. The Aspect_Drawable contains some stuff that mignt be useful but for now I've just implemented it to provide the necessary padding.

The following segments are based on my QtOCC implementation (v0.6) but should be applicable to any presentation viewer framework.

First create 2 function prototypes in your header file - I've used the following in QtOCCViewWidget.h

static int CallBack (Aspect_Drawable, void*, Aspect_GraphicCallbackStruct*);

and

void paintOCC();

(Note I originally used paintGL() instead of paintOCC() but this resulted in both OCC and Qt calling the method)

To register the call back, I changed the initialize() method to read

#ifdef WNT
HGLRC rc = wglGetCurrentContext();

myWindow = new WNT_Window( Handle(Graphic3d_WNTGraphicDevice)
::DownCast(myContext->CurrentViewer()->Device() ), (int)hi, (int)lo);
myView->SetWindow( myWindow, rc , CallBack, this );
#else
myWindow = new Xw_Window( Handle(Graphic3d_GraphicDevice)
::DownCast(myContext->CurrentViewer()->Device() ), (int)hi, (int) lo,
Xw_WQ_SAMEQUALITY,
Quantity_NOC_BLACK);
myView->SetWindow( myWindow );
#endif // WNT

// Set my window (Hwnd) into the OCC view
// myView->SetWindow( myWindow );

Note that I'm only affecting the Windows (WNT) version here. If you just use HGLRC rc = 0 then OCC creates the rendering context but still registers the call back.

The line "myView->SetWindow( myWindow, rc , CallBack, this);" registers the Callback function and passes the objects "this" pointers as the Aspect_GraphicCallbackStruct*.

Next I implement the callback routine in the class implementation. This routine has access to all the class members and methods but is not bound to a specific object instance. Here's the implemenation

int QtOCCViewWidget::CallBack (Aspect_Drawable drawable,
void* aPointer,
Aspect_GraphicCallbackStruct* data)
{
QtOCCViewWidget *aWidget = (QtOCCViewWidget *) aPointer;
aWidget->paintOCC();
return 0;
}

Finally I implement the paintOCC() routine - this is where the OpenGL gurus can start practising their skills. By default objects you draw here will be placed in the current OCC world space. To get a gradient background however I remap the screen to a bi-unit cube with a glOrtho, clamping the depth buffer from z=1 to z=-1 and place a GL_QUAD with a greyish gradient. Here's my current implementation.

void QtOCCViewWidget::paintOCC()
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, 1.0, -1.0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE) ;
glShadeModel(GL_SMOOTH);
//glDisable(GL_LIGHTING);
glBegin(GL_QUADS);
{
glColor4f(0.1, 0.1, 0.1, 1.0);
glVertex3d( -1.0, -1.0, 1.0);
glVertex3d( 1.0, -1.0, 1.0);
glColor4f(0.9, 0.9, 0.9, 1.0);
glVertex3d( 1.0, 1.0, 1.0);
glVertex3d( -1.0, 1.0, 1.0);
}
glEnd();
}

(Another note - still not sure whether my glOrtho is correct yet, but it works!)

That should be pretty much it, except (as you can see from the glBlendFunc) I'm finding a problem, probably in the alpha colour components where the state of the rendering context id different with and without a AIS_Shape being drawn thats affect rendering of my grids. I've enabled debugging in the OCC openGL code and I am wading through GLIntercept logs to see if I can identify a fix.

Hope this makes sense. Any comments are gratefully received.

Enjoy

Pete