一个OpenGL后盾渲染的架构

一个OpenGL后台渲染的架构
/**
 * a dummy window is invisible with message loop
 */
// 内存泄漏检测  
// 在需要检测的地方放置语句:  
//        _CrtDumpMemoryLeaks();  
// 以下3句的次序不能改变  
#define _CRTDBG_MAP_ALLOC     
#include<stdlib.h>  
#include<crtdbg.h>

#include <windows.h>
#include <process.h>

#include <stdio.h>
#include <assert.h>

#define DUMMY_WND_STYLE  (WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_POPUP)

#define DUMMY_WND_WIDTH    500
#define DUMMY_WND_HEIGHT   400

static int loopFlag = 1;

// First of all we should have a backend buffer (a block of pixels array).
// We must ensure this backend is thread safe since we want to fill the OGL
//   frame data into it and then flush it onto the target device.
// Typically this backend buffer is a DIBSection with a valid HDC that is
//   compatiable with target.
typedef struct
{
  CRITICAL_SECTION  __lock;
  int  updateId;
  HWND dummyWnd;

///  DIBSection  bmp;
} BackendBuffer, *BACKEND;

BACKEND BackendBufferCreate (HWND dummyWnd)
{
  BACKEND backend = (BACKEND) malloc(sizeof(BackendBuffer));
  InitializeCriticalSection(&backend->__lock);
  backend->updateId = 0;
  backend->dummyWnd = dummyWnd;

  printf("BackendBufferCreate(): Prepare OGL context\n");

  // Create DIBSection for backend from dummyWnd PixlFormat
  // ...
  printf("BackendBufferCreate(): Create DIBSection for backend\n");

  return backend;
}

void BackendBufferDelete (BACKEND backend)
{
  DeleteCriticalSection(&backend->__lock);

  // Free DIBSection for backend...

  free(backend);
}

typedef void (* pfcb_oglRenderFunc) (void *backend);

static void oglRenderBackend (void *param)
{
  BACKEND backend = (BACKEND) param;
  printf("ogl Render on backend: %d\n", backend->updateId);
 
  // Fill in DIBSection of backend...
  // ...readPixels(...);

  // modify updateId that means the backend has been changed
  backend->updateId++;
  if (backend->updateId > 100000000) {
    backend->updateId = 0;
  }
}

BOOL BackendBufferUpdate (BACKEND backend, pfcb_oglRenderFunc oglRenderFunc)
{
  if (TryEnterCriticalSection(&backend->__lock)) {
    oglRenderFunc(backend);

    LeaveCriticalSection(&backend->__lock);
    // We notice caller update successfully
    return TRUE;
  } else {
    // Something error
    return FALSE;
  }
}

typedef struct
{
  int     updateId;
  BACKEND backend;

  // target device handle: can be HWND or FILE, ...
  HWND    targetWnd;
} TargetSurface, *TARGET;

TARGET TargetSurfaceCreate (HWND targetWnd, HWND hwndBackend)
{
  TARGET tgt = (TargetSurface*) malloc(sizeof(TargetSurface));
  tgt->updateId = -1;
  tgt->backend = BackendBufferCreate(hwndBackend);
  tgt->targetWnd = targetWnd;
  return tgt;
}

void TargetSurfaceDelete (TARGET tgt)
{
  BackendBufferDelete(tgt->backend);
  free(tgt);
}

// Below function should be called in OnDraw() or onRefreshEvent()
//
void TargetSurfaceUpdate (TARGET tgt)
{
  if (tgt->updateId != tgt->backend->updateId) {
    // Only update target when updateId not equal
    if (TryEnterCriticalSection(&tgt->backend->__lock)) {
      // Do update target device job here...BitBlt(...);
      Sleep(20); // We suppose it will cost me 20 msec to update device
      printf("TargetSurface has been updated:%d\n", tgt->updateId);

      // Set update target ok
      tgt->updateId = tgt->backend->updateId;
      LeaveCriticalSection(&tgt->backend->__lock);
    }
  }
}

static void Fire_OnDraw(TARGET target)
{
  TargetSurfaceUpdate(target);
}

static void renderOGLScene (TARGET target)
{
  // target can be convey to OGL render engine
  // OGL render engine can change
  printf("renderOGLScene use target... \n");
 
  if (BackendBufferUpdate(target->backend, oglRenderBackend)) {
    // Fire_OnDraw will trigger systen,
    // and system will call TargetSurfaceUpdate by sequence
    Fire_OnDraw(target);
  }

  // We suppose it takes 10 ms to render OGL
  Sleep(10);
}

static void renderThreadFunc (void *param)
{
  MSG    msg;

  TARGET target = (TARGET) param;

  while (loopFlag) {
    if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
      if (msg.message == WM_QUIT) {
        printf("renderThreadFunc recv a WM_QUIT message\n");
        break ;
      }
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    } else {
      renderOGLScene(target);
    }
  }

  printf("renderThreadFunc quit\n");
}

HWND createDummyWindow (int width, int height)
{
  HWND hwndDummy = CreateWindowA("STATIC",
      "DummyWindowForOpenGLOffScreen",
      DUMMY_WND_STYLE,
      0, 0, width, height,
      0, 0, 0, 0);
  return hwndDummy;
}

UINT createRenderThread (void *param)
{
  UINT threadId = 0;
  HANDLE threadHandle = (HANDLE)_beginthreadex(0, 0,
    (unsigned (__stdcall *)(void *))renderThreadFunc, param, 0, &threadId);
  assert(threadHandle);
  CloseHandle(threadHandle);
  return threadId;
}

int main ()
{
  BOOL   ret;
  HWND   hwndDummy;
  UINT   threadId;

  TARGET target;

  hwndDummy = createDummyWindow(DUMMY_WND_WIDTH, DUMMY_WND_HEIGHT);
  assert(hwndDummy);
  printf("Create dummy window for OGL\n");

  printf("Then create a target for drawing\n");
  target = TargetSurfaceCreate((HWND)123, hwndDummy);
  assert(target);

  threadId = createRenderThread(target);
  printf("Create OGL render thread\n");

  // analogy to do somthing
  Sleep(10000);

  printf("Notify RenderThread to quit\n");
  ret = PostThreadMessage(threadId, WM_QUIT, 0, 0);
  assert(ret);

  // analogy to do somthing
  Sleep(10000);

  printf("Main app shutdown\n");
  TargetSurfaceDelete(target);
  _CrtDumpMemoryLeaks();
  exit(0);
}