rendergl.C

Go to the documentation of this file.

// File rendergl.c

#define MODULE_RENDERGL

#include "render.h"
#include "..\shaders\shaders.h"

#include <gl/glaux.h>

#include "..\gl2.h"

#define checkImageWidth  64
#define checkImageHeight 64

extern char gszHomeDir[];

GLuint g_check_texture;  // default texture when no maps can be found
GLuint g_map_texture;
GLuint g_ref_texture;    // reflection map texture
GLuint g_bump_texture;   // bump map texture
GLuint g_tran_texture;
GLuint g_movie_texture;  // default movie texture - this should just be an ordinary texture
GLuint g_env_texture;    // material environmental reflection texture
GLuint g_env3D_texture;  // material environmental reflection texture for 3D shaders
GLuint g_envB_texture;   // material bump texture
GLuint g_envN_texture;   // 2D noise texture
GLuint g_noise_texture;  // 3D noise texture
GLuint g_sky_texture;    // sky_texture for mapped skies

GLubyte checkImage[checkImageWidth][checkImageHeight][3];
GLint DlistID=0;
double DepthScalingGL,FrontDepthGL,BackDepthGL;

static HWND   g_hWnd = NULL;
static HDC    g_hDC  = NULL;
static HGLRC  g_hRC  = NULL;

static HDC m_hDCWnd;                                                    // copy of main window's device context
static HGLRC m_hGLRCWnd;                                                // copy of main window's render context

struct PBuffer  {
  HPBUFFERARB  hPBuffer;
  HDC          hDC;
  HGLRC        hGLRC;
} m_PBuffer;


static BOOL   bDrawToScreen=FALSE,bDrawToFBO=FALSE,bDrawToPbuffer=TRUE;
static BOOL   bFillDepthBuffer=FALSE;
static BOOL   bLoaded=FALSE;
static BOOL   bAntiAliased=FALSE;
static int    nAAsamples=1;

static int g_nWindowWidth;
static int g_nWindowHeight;

// Framebuffer for RenderBuffer
static GLuint g_frameBuffer       = 0;
static GLuint g_depthRenderBuffer = 0;
static GLuint g_colorRenderBuffer = 0;
//static GLuint g_accumRenderBuffer = 0;
//static GLuint g_stencilRenderBuffer = 0;

// FrameBuffer for TextureBuffer
GLuint g_framebufferTexture = -1;
GLuint g_frameBuffer2=0;
GLuint g_depthRenderBuffer2=0;

//int RENDERBUFFER_WIDTH  = 1280;   //OK on FX1100 6800 7600 and X1950
//int RENDERBUFFER_HEIGHT = 1024;
int RENDERBUFFER_WIDTH  = 2048;    // OK on FX1100 6800 and Radeon x1950
int RENDERBUFFER_HEIGHT = 2048;
int TEXTUREBUFFER_WIDTH  = 2048;  // Must be power of 2 on ATI 
int TEXTUREBUFFER_HEIGHT = 2048;
//int RENDERBUFFER_WIDTH  = 4096;  // MAXIMUM on nVidia & ATI
//int RENDERBUFFER_HEIGHT = 4096;
//int TEXTUREBUFFER_WIDTH  = 4096;  
//int TEXTUREBUFFER_HEIGHT = 4096;

static char ClassName[] = "OFX:RENDER:OGL:CLASS";
static WNDCLASSEX winClass; 
static unsigned char *RenderBufferCopy=NULL;
static GLfloat *DepthBufferCopy=NULL;
//static unsigned char *RenderBufferAccu=NULL;

static HWND SetupRenderOpenGL(HWND);
static BOOL InitPBuffer(void);
static void printGCinfo(char *text);
static LRESULT CALLBACK XWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
static void SetMappingQuality(void);
static void makeCheckImageMap(int id);
static long RenderGLtoWGL(long, BOOL );
static long RenderGLtoFBO(long, BOOL );
static void WriteBitmap(long nx, long ny, unsigned char *S, long f, BOOL b32);
static void CopyToDepthBuffer(void);


long RenderGL(long frame, BOOL ppGL){
 long r;
 if(bDrawToScreen){
   printGCinfo("Screen output");
   r=RenderGLtoWGL(frame,ppGL);  // Screen
 }
 else if(bDrawToPbuffer){
   wglMakeCurrent( m_PBuffer.hDC, m_PBuffer.hGLRC );
   printGCinfo("Pbuffer output");
   r=RenderGLtoWGL(frame,ppGL);  // Pbuffer
   wglMakeCurrent( m_hDCWnd, m_hGLRCWnd );
 }
 else{
   r=RenderGLtoFBO(frame,ppGL);  // FBO
 }
 return r;
}

static long RenderGLtoFBO(long frame, BOOL ppGL){
 int  i,aa;
 GLfloat accu;
 // bind to and clear the renderbuffer in which the images will be accumulated.
 glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, g_frameBuffer );
 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, 
                              GL_RENDERBUFFER_EXT, g_colorRenderBuffer );
 //glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,  // Don't bother with depth buffer
 //GL_RENDERBUFFER_EXT, g_depthRenderBuffer );                                 // on this framebuffer (not needed) 
 glViewport( 0, 0, RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT );
 glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
 glClear(GL_COLOR_BUFFER_BIT);
 glFlush();
 DlistID=0;
 accu=1.0;
 printGCinfo("Renderbuffer output");
 for(aa=0;aa<nAAsamples;aa++){ 
   // Render the Scene into a texture attached to a framebuffer
   glBindFramebufferEXT( GL_FRAMEBUFFER_EXT,g_frameBuffer2);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, g_framebufferTexture,0);
   glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_RENDERBUFFER_EXT,g_depthRenderBuffer2);
   if(aa == 0)printGCinfo("FBO output texture");
   RenderCameraView(TRUE,bAntiAliased,aa,nAAsamples,(GLfloat)RENDERBUFFER_WIDTH/(GLfloat)RENDERBUFFER_HEIGHT);
   glFlush();
   if(aa == nAAsamples-1 && DepthBufferCopy != NULL)CopyToDepthBuffer(); // Copy to DepthBuffer if required
   // copy Texturebuffer to renderbuffer depth buffer _ will need scaled????
   //   
   // Render an orthogonal polygon into a renderbuffer attached to a framebuffer
   // this does not need a depth buffer. 
   // For Anti-aliasing, simulate the use of an accumulation buffer (not available for
   // FB0s) by blending the texture.
   glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, g_frameBuffer );
   glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, 
                GL_RENDERBUFFER_EXT, g_colorRenderBuffer );
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);
   glMatrixMode( GL_MODELVIEW );
   glLoadIdentity();
   glViewport( 0, 0, RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT );
   glEnable(GL_BLEND);
   glBlendColor(0.0,0.0,0.0,accu); accu *= 0.5;
   glBlendFunc(GL_CONSTANT_ALPHA,GL_ONE_MINUS_CONSTANT_ALPHA);
   glDepthMask(GL_FALSE);
   glBindTexture( GL_TEXTURE_2D, g_framebufferTexture);
   glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
   glColor4f(1.0,1.0,1.0,1.0);
   glBegin(GL_QUADS);
   glTexCoord2f(0.0,0.0); glVertex3f(0.0,0.0,-1.0); 
   glTexCoord2f(1.0,0.0); glVertex3f(1.0,0.0,-1.0); 
   glTexCoord2f(1.0,1.0); glVertex3f(1.0,1.0,-1.0);
   glTexCoord2f(0.0,1.0); glVertex3f(0.0,1.0,-1.0);
   glEnd();
   glDepthMask(GL_TRUE);
   glBindTexture( GL_TEXTURE_2D,0);
   glDisable(GL_BLEND);
 }
 if(DlistID > 0){glDeleteLists(1,1);DlistID=0;}
 glFlush();
 if(ppGL)PostProcessRenderGL(frame); // Render any postprocesses
 glReadPixels(0,0,RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT,GL_RGBA,GL_UNSIGNED_BYTE,RenderBufferCopy);
 glFlush(); 
 glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
 return 1;
}

static long RenderGLtoWGL(long frame, BOOL ppGL){ // Render to window context - Screen or Pbuffer
 int  i,aa;
 DlistID=0;
 if(nAAsamples > 1)glClear(GL_ACCUM_BUFFER_BIT); 
 for(aa=0;aa<nAAsamples;aa++){ 
   glClearColor(0.0,0.0,0.0,1.0);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
   RenderCameraView(TRUE,bAntiAliased,aa,nAAsamples,(GLfloat)RENDERBUFFER_WIDTH/(GLfloat)RENDERBUFFER_HEIGHT);
   glFlush();
   if(nAAsamples > 1)glAccum(GL_ACCUM,1.0/(GLfloat)nAAsamples);
 }
 if(DlistID > 0){glDeleteLists(1,1);DlistID=0;}
 if(nAAsamples > 1)glAccum(GL_RETURN,1.0);
 glFlush();
 if(ppGL)PostProcessRenderGL(frame); // Render any scene postprocessing
 glReadPixels(0,0,RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT,GL_RGBA,GL_UNSIGNED_BYTE,RenderBufferCopy);
 //{static int c; WriteBitmap(RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT,RenderBufferCopy,c++,TRUE);}
 if(DepthBufferCopy != NULL)CopyToDepthBuffer(); 
 return 1;
}

HWND SetUpGlWindow(HANDLE hInstance, HWND hWndParent, long Xres, long Yres, 
                   BOOL bFullScreen, BOOL bUseFBO, BOOL bCopyToDepthBuffer, long AAlias){
 HWND hParentLocal;
 DWORD windowStyle;
 DWORD windowExtendedStyle = WS_EX_APPWINDOW;
 //if(debug != NULL)fprintf(debug,"HW started AA=%ld Fullscreen=%d UseFBO=%ld Res=(%ld %ld)\n",AAlias,bFullScreen,bUseFBO, Xres,Yres);
 // bFullScreen=FALSE; bUseFBO=TRUE;  // for testing
 if(bLoaded){ // Release the window and re-create
   DestroyWindow(g_hWnd);
   CloseGlWindow();
 }
 bFillDepthBuffer=bCopyToDepthBuffer; 
 //bFillDepthBuffer=FALSE; //  slows things down when on 
 //AAlias=0; // use for testing only
 if(AAlias == 0){bAntiAliased=FALSE; nAAsamples=1;}
 else           {bAntiAliased=TRUE;  nAAsamples=AAlias;}
 winClass.lpszClassName = ClassName;
 winClass.cbSize        = sizeof(WNDCLASSEX);
 winClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
 winClass.lpfnWndProc   = XWindowProc;
 winClass.hInstance     = hInstance;
 winClass.hIcon        = LoadIcon(hInstance, (LPCTSTR)"showicon");
 winClass.hIconSm          = LoadIcon(hInstance, (LPCTSTR)"showicon");
 winClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
 winClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
 winClass.lpszMenuName  = NULL;
 winClass.cbClsExtra    = 0;
 winClass.cbWndExtra    = 0;
 if( !RegisterClassEx(&winClass) )return NULL;
 if(bFullScreen){
   bDrawToScreen=TRUE;  bDrawToFBO=FALSE; bDrawToPbuffer=FALSE;
   windowStyle = WS_POPUP;                              
   windowExtendedStyle |= WS_EX_TOPMOST;
   hParentLocal=HWND_DESKTOP;
   g_nWindowHeight=min(Yres,GetSystemMetrics(SM_CYSCREEN));
   g_nWindowWidth=min(Xres,GetSystemMetrics(SM_CXSCREEN));
   TEXTUREBUFFER_WIDTH=RENDERBUFFER_WIDTH=g_nWindowWidth;  
   TEXTUREBUFFER_HEIGHT=RENDERBUFFER_HEIGHT=g_nWindowHeight;
}
 else{
   bDrawToScreen=FALSE;
   if(bUseFBO){ // frame buffer
     bDrawToFBO=TRUE; bDrawToPbuffer=FALSE;
     RENDERBUFFER_WIDTH=Xres; RENDERBUFFER_HEIGHT=Yres;
     // Note texturebuffer dimensions must be power of 2 on ATI
     TEXTUREBUFFER_WIDTH=TEXTUREBUFFER_HEIGHT=2048;
     if(Xres <= 1024)TEXTUREBUFFER_WIDTH=1024;  else if(Xres > 3500)TEXTUREBUFFER_WIDTH=4096;
     if(Yres <= 1024)TEXTUREBUFFER_HEIGHT=1024; else if(Yres > 3500)TEXTUREBUFFER_HEIGHT=4096;
   }
   else {  // pixel buffer
     bDrawToFBO=FALSE;  bDrawToPbuffer=TRUE;
     RENDERBUFFER_WIDTH=TEXTUREBUFFER_WIDTH=Xres; RENDERBUFFER_HEIGHT=TEXTUREBUFFER_HEIGHT=Yres; 
   }
   windowStyle = WS_POPUP | WS_CAPTION | !WS_SYSMENU | WS_THICKFRAME;
   g_nWindowWidth=480; g_nWindowHeight=320+20;
   hParentLocal=hWndParent;
 }
 g_hWnd = CreateWindowEx(windowExtendedStyle, ClassName, "OpenFX:OpenGL Renderer",windowStyle,
     0, 0, g_nWindowWidth, g_nWindowHeight, hParentLocal, NULL, hInstance, NULL );
 if( g_hWnd == NULL )return NULL;
 //if(SetupRenderOpenGL(g_hWnd) == NULL)return NULL;  // now called from WM_CREATE
 bLoaded=TRUE;
 ShowWindow(g_hWnd,SW_SHOW);
 UpdateWindow(g_hWnd);
 bRenderOpenGL=TRUE;
 return g_hWnd;
}

static HWND SetupRenderOpenGL(HWND hWnd){ 
 unsigned char *movie_image=NULL,movie_file[256];
 unsigned char *env_image=NULL,env_file[256];
 unsigned char *envB_image=NULL,envB_file[256];
 unsigned char *envN_image=NULL,envN_file[256];
 long movie_image_x,movie_image_y;
 long env_image_x,env_image_y;
 long envB_image_x,envB_image_y;
 long envN_image_x,envN_image_y;
 GLenum status;
 // Setup device context
 PIXELFORMATDESCRIPTOR pfd;
 GLuint PixelFormat;
 memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
 pfd.nSize      = sizeof(PIXELFORMATDESCRIPTOR);
 pfd.nVersion   = 1;
 pfd.dwFlags    = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
 pfd.iPixelType = PFD_TYPE_RGBA;
 pfd.cColorBits = 32;
 pfd.cDepthBits = 32;     
 pfd.cAccumBits = 16;      
 pfd.cStencilBits = 1;    
 g_hDC = GetDC(hWnd);
 if((PixelFormat = ChoosePixelFormat( g_hDC, &pfd )) == FALSE){
   MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK);
   return NULL;
 }
 if(SetPixelFormat( g_hDC, PixelFormat, &pfd) == FALSE){
  MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK);
  return NULL;
 }
 g_hRC = wglCreateContext( g_hDC );
 wglMakeCurrent( g_hDC, g_hRC );
 m_hDCWnd = wglGetCurrentDC();
 m_hGLRCWnd = wglGetCurrentContext();

 RenderBufferCopy=NULL; DepthBufferCopy=NULL;
 if((RenderBufferCopy=(unsigned char *)malloc(RENDERBUFFER_WIDTH*RENDERBUFFER_HEIGHT*4)) == NULL)return NULL;
 if(bFillDepthBuffer && (DepthBufferCopy=(GLfloat *)malloc(TEXTUREBUFFER_WIDTH*TEXTUREBUFFER_HEIGHT*sizeof(GLfloat))) == NULL){
   free(RenderBufferCopy); RenderBufferCopy=NULL;
   return NULL;
 }
 //if((RenderBufferAccu=(unsigned char *)malloc(RENDERBUFFER_WIDTH*RENDERBUFFER_HEIGHT*4)) == NULL){
 //  free(RenderBufferCopy); RenderBufferCopy=NULL;
 //  return NULL;
 //}
 memset(RenderBufferCopy,64,RENDERBUFFER_WIDTH*RENDERBUFFER_HEIGHT*4);

 gl2Initialize();
 if(bDrawToPbuffer){   // MUST initialise shaders and lights in the context of the PBUFFER !!!
   InitPBuffer();
   wglMakeCurrent( m_PBuffer.hDC, m_PBuffer.hGLRC );
 } 
 ShadersInit(gszHomeDir,FALSE);
 if(bDrawToFBO){
   // Set up Framebuffer for normal rendering
   glGenFramebuffersEXT(1, &g_frameBuffer);
   glGenRenderbuffersEXT( 1, &g_colorRenderBuffer );  // A colour buffer
   glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, g_colorRenderBuffer );
   glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_RGBA8, RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT ); // this
   // An acumulation buffer for antialiasing !!!!!!!!!NOT YET available
   //glGenRenderbuffersEXT( 1, &g_accumRenderBuffer );
   //glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, g_accumRenderBuffer );
   //glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_RGBA8, RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT );
   // A stencil buffer    !!!!!!!!!NOT YET available
   //glGenRenderbuffersEXT( 1, &g_stencilRenderBuffer );
   //glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, g_stencilRenderBuffer );
   //glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX, RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT );
   // A depth buffer
   glGenRenderbuffersEXT( 1, &g_depthRenderBuffer );  // If need a depth buffer
   glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, g_depthRenderBuffer );
   // We dont need need a depth buffer but set one up anyway (still under test)
   glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT );  //this 
   if(debug != NULL){
     int fb_colours=0,fb_size=0;
     glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT,&fb_colours);
     glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE_EXT,&fb_size);
   //  if(debug != NULL)fprintf(debug,"First FrameBuffer Max color attachments=%ld max renderbuffer_size=%ld\n",fb_colours,fb_size);
   }
   status = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );
   switch( status )     {
     case GL_FRAMEBUFFER_COMPLETE_EXT:
                        //MessageBox(NULL,"GL_FRAMEBUFFER_COMPLETE_EXT!","SUCCESS",MB_OK|MB_ICONEXCLAMATION);
                        break;
     case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
       MessageBox(NULL,"GL_FRAMEBUFFER_UNSUPPORTED_EXT!","ERROR",MB_OK|MB_ICONEXCLAMATION);
       exit(0);
       break;
     default: return NULL;
   }
   // Set up Framebuffer for texture rendering
   glGenFramebuffersEXT(1, &g_frameBuffer2);
   glGenRenderbuffersEXT( 1, &g_depthRenderBuffer2 );  
   glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, g_depthRenderBuffer2 );
   glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT32, TEXTUREBUFFER_WIDTH, TEXTUREBUFFER_HEIGHT );  
   status = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );
   switch( status )     {
     case GL_FRAMEBUFFER_COMPLETE_EXT:
                        //MessageBox(NULL,"GL_FRAMEBUFFER_COMPLETE_EXT!","SUCCESS",MB_OK|MB_ICONEXCLAMATION);
                        break;
     case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
         MessageBox(NULL,"GL_FRAMEBUFFER_UNSUPPORTED_EXT!","ERROR",MB_OK|MB_ICONEXCLAMATION);
         exit(0);
       break;
     default: return NULL;
   }
   glEnable(GL_TEXTURE_2D);  // Create the texture buffer to attach to the FBO
   glGenTextures(1,&g_framebufferTexture );
   glBindTexture(GL_TEXTURE_2D, g_framebufferTexture );
   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, 
              TEXTUREBUFFER_WIDTH, TEXTUREBUFFER_HEIGHT, 
                      0, GL_RGB, GL_UNSIGNED_BYTE, 0 );
   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
   SetMappingQuality(); 
   glBindTexture(GL_TEXTURE_2D,0);
   // End of Framebuffers 
 }

 glActiveTexture(GL_TEXTURE3); 
 glEnable(GL_TEXTURE_2D);
 glActiveTexture(GL_TEXTURE2); 
 glEnable(GL_TEXTURE_2D);
 glActiveTexture(GL_TEXTURE1); 
 glEnable(GL_TEXTURE_2D);
 glActiveTexture(GL_TEXTURE0);
 glEnable(GL_TEXTURE_2D);
 glGenTextures( 1, &g_check_texture );
 glGenTextures( 1, &g_map_texture );
 glGenTextures( 1, &g_bump_texture );
 glGenTextures( 1, &g_ref_texture );
 glGenTextures( 1, &g_tran_texture );
 glGenTextures( 1, &g_movie_texture );
 glGenTextures( 1, &g_env_texture );
 glGenTextures( 1, &g_envB_texture );
 glGenTextures( 1, &g_envN_texture );
 glGenTextures( 1, &g_noise_texture );
 glGenTextures( 1, &g_env3D_texture );
 glGenTextures( 1, &g_sky_texture );
 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glClearDepth(1.0);
 glEnable(GL_DEPTH_TEST);
 glDepthFunc(GL_LEQUAL);  // this is needed for the map blending
 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
 glShadeModel(GL_SMOOTH);
 // make the dummy textures for later use
 glBindTexture(GL_TEXTURE_2D,g_check_texture);
 makeCheckImageMap(0);
 glTexImage2D(GL_TEXTURE_2D, 0, 3, checkImageWidth,
              checkImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
              &checkImage[0][0][0]);
 SetMappingQuality(); // REQUIRED 
 // put something in the texture - needed before making display list
 glBindTexture(GL_TEXTURE_2D,g_map_texture);
 glTexImage2D(GL_TEXTURE_2D, 0, 4, checkImageWidth,
              checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
              NULL); //&checkImage[0][0][0]);
 SetMappingQuality(); // THIS IS NEEDED -see function
 glBindTexture(GL_TEXTURE_2D,g_bump_texture);
 glTexImage2D(GL_TEXTURE_2D, 0, 3, checkImageWidth,
              checkImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
              NULL);
 SetMappingQuality(); // THIS IS NEEDED -see function
 glBindTexture(GL_TEXTURE_2D,g_ref_texture);
 glTexImage2D(GL_TEXTURE_2D, 0, 3, checkImageWidth,
              checkImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
              NULL);
 SetMappingQuality(); // THIS IS NEEDED -see function
 glBindTexture(GL_TEXTURE_2D,g_tran_texture);
 glTexImage2D(GL_TEXTURE_2D, 0, 3, checkImageWidth,
              checkImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
              NULL);
 SetMappingQuality(); 
 glBindTexture(GL_TEXTURE_2D,g_sky_texture);
 glTexImage2D(GL_TEXTURE_2D, 0, 4, checkImageWidth,
              checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
              NULL);
 SetMappingQuality(); 
 // now the default textures
 strcpy(movie_file,gszHomeDir); strcat(movie_file,"movie.bmp");
 if((movie_image=LoadSystemMAP(TRUE,FALSE,movie_file,&movie_image_x,&movie_image_y)) != NULL){
   glBindTexture(GL_TEXTURE_2D,g_movie_texture);
   glTexImage2D(GL_TEXTURE_2D,0,3,
                          movie_image_x,movie_image_y,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)movie_image);
   SetMappingQuality(); // THIS IS NEEDED -see function
   X__Free(movie_image);
 }
 strcpy(env_file,gszHomeDir); strcat(env_file,"genref.bmp");
 if((env_image=LoadSystemMAP(TRUE,FALSE,env_file,&env_image_x,&env_image_y)) != NULL){
   glBindTexture(GL_TEXTURE_2D,g_env_texture);
   glTexImage2D(GL_TEXTURE_2D,0,3,
                          env_image_x,env_image_y,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)env_image);
   SetMappingQuality(); // THIS IS NEEDED -see function
   X__Free(env_image);
 }
 strcpy(envB_file,gszHomeDir); strcat(envB_file,"bumpy.bmp");
 if((envB_image=LoadSystemMAP(TRUE,FALSE,envB_file,&envB_image_x,&envB_image_y)) != NULL){
   glBindTexture(GL_TEXTURE_2D,g_envB_texture);
   glTexImage2D(GL_TEXTURE_2D,0,3,
                          envB_image_x,envB_image_y,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)envB_image);
   SetMappingQuality(); // THIS IS NEEDED -see function
   X__Free(envB_image);
 }
 strcpy(envN_file,gszHomeDir); strcat(envN_file,"noise.bmp"); // random number generator
 if((envN_image=LoadSystemMAP(TRUE,FALSE,envN_file,&envN_image_x,&envN_image_y)) != NULL){
   glBindTexture(GL_TEXTURE_2D,g_envN_texture);
   glTexImage2D(GL_TEXTURE_2D,0,3,
                          envN_image_x,envN_image_y,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)envN_image);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // for the RAN texture use
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // nearest interpolation
//   SetMappingQuality();  // gives linear interpolation
   X__Free(envN_image);
 }
 MakeParticleTextures();
 glBindTexture(GL_TEXTURE_2D,0);
 glDisable(GL_TEXTURE_2D);
 glEnable(GL_TEXTURE_3D);
 glBindTexture(GL_TEXTURE_3D,g_noise_texture);
 CreateNoise3D();

 strcpy(env_file,gszHomeDir); strcat(env_file,"genref.bmp");
 if((env_image=LoadSystemMAP(TRUE,FALSE,env_file,&env_image_x,&env_image_y)) != NULL){
   glBindTexture(GL_TEXTURE_3D,g_env3D_texture);
   glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
   glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB,env_image_x,env_image_y,1, 0, GL_RGB, 
                GL_UNSIGNED_BYTE,(GLvoid *)env_image);
   X__Free(env_image);
 }


 glBindTexture(GL_TEXTURE_3D,0);
 glDisable(GL_TEXTURE_3D);
 glEnable(GL_TEXTURE_2D);
 if(bDrawToPbuffer)wglMakeCurrent( m_hDCWnd, m_hGLRCWnd );
 return hWnd; 
}

void SetUpCorrectContext(BOOL bSetup){
  if(bDrawToPbuffer){
    if(bSetup)wglMakeCurrent( m_PBuffer.hDC, m_PBuffer.hGLRC );
    else      wglMakeCurrent( m_hDCWnd, m_hGLRCWnd );
  }
}

void CloseGlWindow(void){
 if(!bLoaded)return;
 //MessageBox(NULL,"Window Closed",NULL,MB_OK);
 glDisable(GL_TEXTURE_2D);
 glActiveTexture(GL_TEXTURE1); 
 glDisable(GL_TEXTURE_2D);
 glActiveTexture(GL_TEXTURE2); 
 glDisable(GL_TEXTURE_2D);
 glActiveTexture(GL_TEXTURE3); 
 glDisable(GL_TEXTURE_2D);
 glDeleteTextures( 1, &g_check_texture );
 glDeleteTextures( 1, &g_map_texture );
 glDeleteTextures( 1, &g_bump_texture );
 glDeleteTextures( 1, &g_movie_texture );
 glDeleteTextures( 1, &g_env_texture );
 glDeleteTextures( 1, &g_envB_texture );
 glDeleteTextures( 1, &g_envN_texture );
 glDeleteTextures( 1, &g_ref_texture );
 glDeleteTextures( 1, &g_tran_texture );
 glDeleteTextures( 1, &g_sky_texture );
 glDeleteTextures( 1, &g_env3D_texture );
 glDeleteTextures( 1, &g_noise_texture );
 ReleaseParticleTextures();
 if(bDrawToFBO){
   glDeleteFramebuffersEXT(1,  &g_frameBuffer );
   glDeleteRenderbuffersEXT(1, &g_depthRenderBuffer );
   //glDeleteRenderbuffersEXT(1, &g_accumRenderBuffer );
   glDeleteRenderbuffersEXT(1, &g_colorRenderBuffer );
   //glDeleteRenderbuffersEXT(1, &g_stencilRenderBuffer );
   glDeleteTextures( 1, &g_framebufferTexture );
   glDeleteFramebuffersEXT(1,  &g_frameBuffer2 );
   glDeleteRenderbuffersEXT(1, &g_depthRenderBuffer2 );
 }
 if(bDrawToPbuffer){
   if( wglGetCurrentContext() == m_PBuffer.hGLRC )wglMakeCurrent( 0, 0 );
   wglDeleteContext( m_PBuffer.hGLRC );
   wglReleasePbufferDCARB( m_PBuffer.hPBuffer, m_PBuffer.hDC );
   wglDestroyPbufferARB( m_PBuffer.hPBuffer );
 }
 UnloadShaders();
 if( g_hRC != NULL ){
  wglMakeCurrent( NULL, NULL );
  wglDeleteContext( g_hRC );
  g_hRC = NULL;
 }
 if( g_hDC != NULL ){
  ReleaseDC( g_hWnd, g_hDC );
  g_hDC = NULL;
 }
 free(RenderBufferCopy);
 RenderBufferCopy=NULL;
 if(DepthBufferCopy != NULL)free(DepthBufferCopy);
 DepthBufferCopy=NULL;
 //free(RenderBufferAccu);
 //RenderBufferAccu=NULL;
 bLoaded=FALSE;
 bRenderOpenGL=FALSE;
 UnregisterClass( ClassName, winClass.hInstance );
}

static BOOL InitPBuffer(void){
 HDC hPrimaryDevCtx = wglGetCurrentDC();
 int pPixFmtRequirements[] = {
                WGL_DRAW_TO_PBUFFER_ARB, TRUE,      // Enable rendering to buffer
                //WGL_BIND_TO_TEXTURE_RGBA_ARB, TRUE, // Usable as a texture  // not for Anti-alias on nVidia cards // not needed anyway
                WGL_SUPPORT_OPENGL_ARB, TRUE,       // Associate with OpenGL
                WGL_DOUBLE_BUFFER_ARB, FALSE,       // Single-buffered
                WGL_RED_BITS_ARB, 8,                // 8 bits of red minimum
                WGL_GREEN_BITS_ARB, 8,              // 8 bits of green minimum 
                WGL_BLUE_BITS_ARB, 8,               // 8 bits of blue minimum 
                WGL_DEPTH_BITS_ARB, 24,             // 16 bits for depth minimum
    WGL_ACCUM_BITS_ARB, 16,             // Accumulation bits
    WGL_STENCIL_BITS_ARB, 1,
    0                                   // End of list
 };
 int iPixelFormat;
 unsigned int iFormatCount;
 int pBufRequirements [] =      {
                // P-Buffer will bind to a 2D texture
                //WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, // not for Anti-alias on nVidia cards
                // P-Buffer will bind to a texture with format RGBA
                //WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB, // not for Anti-alias on nVidia cards
                0
 };
 wglChoosePixelFormatARB( 
                hPrimaryDevCtx,                     // Device context to query
                (const int*) pPixFmtRequirements,   // List of integer parameters
                NULL,                               // List of float parameters
                1,                                  // Number of formats to return
                &iPixelFormat,                      // The outputted pixel format
                &iFormatCount );                    // Number of outputted formats
 if( iFormatCount == 0 )return FALSE;
        // Now that we have a device context and a pixel format, we can 
        // create the P-Buffer.
 m_PBuffer.hPBuffer = wglCreatePbufferARB( 
        hPrimaryDevCtx,                     // Window device context
                iPixelFormat,                       // Chosen pixel format
                RENDERBUFFER_WIDTH,                 // P-Buffer width
                RENDERBUFFER_HEIGHT,                // P-Buffer height
                pBufRequirements );                 // No extra attributes

 if( m_PBuffer.hPBuffer == NULL )return FALSE;
 m_PBuffer.hDC = wglGetPbufferDCARB( m_PBuffer.hPBuffer );
 m_PBuffer.hGLRC = wglCreateContext( m_PBuffer.hDC );
 //if(debug != NULL)fprintf(debug,"Pbuffer OK\n");
 return TRUE;
}


void CopyGLtoFSB(void){
 int i,j;
 unsigned char *temp;
 fullscreenbuffer *f;
 f=FullScreenBuffer;
 if((temp=(unsigned char *)malloc(ResolutionX*ResolutionY*4)) == NULL)return;
 gluScaleImage(GL_RGBA,RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT,GL_UNSIGNED_BYTE,RenderBufferCopy,
               ResolutionX,ResolutionY,GL_UNSIGNED_BYTE,temp);
 for(i=0,j=ResolutionY-1;i<ResolutionY;i++,j--)
  memcpy((f+j*ResolutionX),(temp+i*ResolutionX*4),ResolutionX*4);
 free(temp);
}

static void CopyToDepthBuffer(void){
 glPixelTransferf(GL_DEPTH_SCALE,10.0);
 glPixelTransferf(GL_DEPTH_BIAS,-9.0);
 glReadPixels(0,0,TEXTUREBUFFER_WIDTH,TEXTUREBUFFER_HEIGHT,GL_DEPTH_COMPONENT,GL_FLOAT,DepthBufferCopy);
 glPixelTransferf(GL_DEPTH_SCALE,1.0);
 glPixelTransferf(GL_DEPTH_BIAS,0.0);
}

void CopyGLtoZbuffer(void){
 if(bFillDepthBuffer && DepthBufferCopy != NULL){
   int i,j,k;
   double *tp,dv,s,a;
   GLfloat *temp,*tf,v,vs;
//unsigned char *p;  // TO VIEW THE DEPTH AS A GREY SCALE  
//p=(unsigned char *)(FullScreenBuffer+ResolutionX*(ResolutionY-1));  
   if((temp=(GLfloat *)malloc(ResolutionX*ResolutionY*sizeof(GLfloat))) == NULL)return;
   a=FrontDepthGL;
   dv=BackDepthGL-FrontDepthGL;
   s=1.0/DepthScalingGL;
   //if(debug != NULL)fprintf(debug,"Copying to zbuffer\n");
   gluScaleImage(GL_DEPTH_COMPONENT,TEXTUREBUFFER_WIDTH,TEXTUREBUFFER_HEIGHT,GL_FLOAT,DepthBufferCopy,
               ResolutionX,ResolutionY,GL_FLOAT,temp);
   // scale and invert for OpenFX depth buffer
   for(i=0,j=ResolutionY-1;i<ResolutionY;i++,j--){
     tp=(fszBuffer+j*ResolutionX);
     tf=(temp+i*ResolutionX);
     for(k=0;k<ResolutionX;k++){
       v = *tf++;  vs=(pow(v,10.0)*dv+a)*s; *tp = vs; tp++;
//*p = *(p+1) = *(p+2) = (unsigned char)((1.0-pow(v,10.0))*255.0); p += 4;
     }
//p -= ResolutionX*8;
   }
   free(temp);
 }
}

static void SetMappingQuality(void){
 glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
 // We MUST tell OGL how the map is to be applied !!!!!!!!
 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}

static void makeCheckImageMap(int id){
 int i, j, c;
 if(id == 0){ /* simple checkered map */
   for (i = 0; i < checkImageWidth; i++) {
     for (j = 0; j < checkImageHeight; j++) {
       c = ((((i&0x8)==0)^((j&0x8))==0))*255;
       checkImage[i][j][0] = (GLubyte) c;
       checkImage[i][j][1] = (GLubyte) c;
       checkImage[i][j][2] = (GLubyte) c;
     }
   }
 }
}

static LRESULT CALLBACK XWindowProc(HWND hWnd, UINT msg,WPARAM wParam,LPARAM lParam){
 switch( msg ){
   case WM_CREATE:
     SetupRenderOpenGL(hWnd);
     break;
   case WM_SIZE:
     g_nWindowWidth  = LOWORD(lParam); 
     g_nWindowHeight = HIWORD(lParam);
     break;
   case WM_CLOSE: break;    // cancel
   case WM_DESTROY: break;
   case WM_PAINT:{
       HDC hDC;
       PAINTSTRUCT  ps;
       hDC = BeginPaint(hWnd, &ps);
       hDC = wglGetCurrentDC();
       if(!bDrawToScreen && bLoaded && RenderBufferCopy != NULL){ // Render the Preview
         glViewport( 0, 0, g_nWindowWidth, g_nWindowHeight );
         glClearColor( 0.0f, 0.0f, 1.0f, 1.0f );
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
         glMatrixMode( GL_PROJECTION );
         glClear( GL_DEPTH_BUFFER_BIT );
         glLoadIdentity();
         glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);
         glRasterPos2f(0.0,0.0);
         glPixelZoom((GLfloat)g_nWindowWidth/(GLfloat)RENDERBUFFER_WIDTH,
                     (GLfloat)g_nWindowHeight /(GLfloat)RENDERBUFFER_HEIGHT);
         glMatrixMode( GL_MODELVIEW );
         glLoadIdentity();
         glDrawPixels(RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT,GL_RGBA,GL_UNSIGNED_BYTE,RenderBufferCopy);
       }
       SwapBuffers(hDC);
       EndPaint(hWnd, &ps); 
     }
     break;
   case WM_KEYDOWN:{
     switch( wParam ){
             case VK_ESCAPE:
         // if(RenderBufferAccu != NULL){
         //   static int c=0;
         //   WriteBitmap(RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT,RenderBufferAccu,c++,TRUE);
         // }
         if(RenderBufferCopy != NULL){
           static int c=0;
           WriteBitmap(RENDERBUFFER_WIDTH, RENDERBUFFER_HEIGHT,RenderBufferCopy,c++,TRUE);
         }
         break;
       }
     }
     break;
   default: return DefWindowProc( hWnd, msg, wParam, lParam );
 }
 return 0;
}

#define PI_ 3.14159265358979323846

/*  accFrustum()
 *  The first 6 arguments are identical to the glFrustum() call.
 *
 *  pixdx and pixdy are anti-alias jitter in pixels.
 *  Set both equal to 0.0 for no anti-alias jitter.
 *  eyedx and eyedy are depth-of field jitter in pixels.
 *  Set both equal to 0.0 for no depth of field effects.
 *
 *  focus is distance from eye to plane in focus.
 *  focus must be greater than, but not equal to 0.0.
 *
 *  Note that accFrustum() calls glTranslatef().  You will
 *  probably want to insure that your ModelView matrix has been
 *  initialized to identity before calling accFrustum().
 */
static void accFrustum(GLdouble left, GLdouble right,
    GLdouble bottom, GLdouble top,
    GLdouble znear, GLdouble zfar, GLdouble pixdx, GLdouble pixdy, 
    GLdouble eyedx, GLdouble eyedy, GLdouble focus)
{
    GLdouble xwsize, ywsize; 
    GLdouble dx, dy;
    GLint viewport[4];

    glGetIntegerv (GL_VIEWPORT, viewport);
 
    xwsize = right - left;
    ywsize = top - bottom;

    dx = -(pixdx*xwsize/(GLdouble) viewport[2] + eyedx*znear/focus);
    dy = -(pixdy*ywsize/(GLdouble) viewport[3] + eyedy*znear/focus);
    
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum (left + dx, right + dx, bottom + dy, top + dy, znear, zfar);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef (-eyedx, -eyedy, 0.0);
}

/*  accPerspective()
 * 
 *  The first 4 arguments are identical to the gluPerspective() call.
 *  pixdx and pixdy are anti-alias jitter in pixels. 
 *  Set both equal to 0.0 for no anti-alias jitter.
 *  eyedx and eyedy are depth-of field jitter in pixels. 
 *  Set both equal to 0.0 for no depth of field effects.
 *
 *  focus is distance from eye to plane in focus. 
 *  focus must be greater than, but not equal to 0.0.
 *
 *  Note that accPerspective() calls accFrustum().
 */
void accPerspective(GLdouble fovy, GLdouble aspect,
    GLdouble znear, GLdouble zfar, GLdouble pixdx, GLdouble pixdy,
    GLdouble eyedx, GLdouble eyedy, GLdouble focus)
{
    GLdouble fov2,left,right,bottom,top;

    fov2 = ((fovy*PI_) / 180.0) / 2.0;

    top = znear / (cos(fov2) / sin(fov2));
    bottom = -top;

    right = top * aspect;
    left = -right;

    accFrustum (left, right, bottom, top, znear, zfar,
    pixdx, pixdy, eyedx, eyedy, focus);
}

static char szOutFileName[255];
static char bmproot[255]="c:\\bmp_";

#define BFT_BITMAP 0x4d42

static void FlipBits(unsigned char *S, long size){
  unsigned char t;
  int i; for(i=0;i<size/4;i++){
    t = *S;
    *S = *(S+2);
    S+=2; *S=t;
    S+=2;
  }
}

static void WriteBitmap(long nx, long ny, unsigned char *S, long f, BOOL b32){
 HANDLE hfbm;
 DWORD dwRead;
 BITMAPFILEHEADER hdr,*lphdr;
 BITMAPINFOHEADER bfi,*lpbi;
 long imagesize,mx;
 if(b32) mx=((nx*32+31)/32) * 4;
 else    mx=((nx*24+31)/32) * 4;
 sprintf(szOutFileName,"%s%0.4ld.bmp",bmproot,f);
 if((hfbm=CreateFile(szOutFileName,GENERIC_WRITE,FILE_SHARE_WRITE,
   NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,
   (HANDLE)NULL)) == INVALID_HANDLE_VALUE){
   MessageBox(NULL,szOutFileName,"File Open Fail",MB_OK);
   MessageBeep(MB_OK);
   return;
 }
 lpbi=&bfi;
 lpbi->biSize=sizeof(BITMAPINFOHEADER);
 lpbi->biWidth=(DWORD)nx;
 lpbi->biHeight=(DWORD)ny;
 lpbi->biPlanes=1;
 if(b32)lpbi->biBitCount=32;
 else   lpbi->biBitCount=24;
 lpbi->biCompression=BI_RGB;
 lpbi->biSizeImage = imagesize = (DWORD)(mx*ny);
 lpbi->biXPelsPerMeter=0;
 lpbi->biYPelsPerMeter=0;
 lpbi->biClrUsed=0;
 lpbi->biClrImportant=0;
 lphdr=&hdr;
 hdr.bfType          = BFT_BITMAP;
 hdr.bfSize          = (sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)
                        + imagesize);
 hdr.bfReserved1     = 0;
 hdr.bfReserved2     = 0;
 hdr.bfOffBits       = (DWORD)sizeof(BITMAPFILEHEADER) + lpbi->biSize;
 WriteFile(hfbm,lphdr,sizeof(BITMAPFILEHEADER),&dwRead,(LPOVERLAPPED)NULL);
 WriteFile(hfbm,lpbi,sizeof(BITMAPINFOHEADER),&dwRead,(LPOVERLAPPED)NULL);
 FlipBits(S,imagesize);
 WriteFile(hfbm,S,imagesize,&dwRead,(LPOVERLAPPED)NULL);
 FlipBits(S,imagesize);
 if(dwRead != imagesize){
   MessageBeep(MB_OK);
   MessageBox(NULL,"Bad write",NULL,MB_OK);
 }
 if(!CloseHandle(hfbm)){
   MessageBeep(MB_OK);
   MessageBox(NULL,"Bad close",NULL,MB_OK);
 }
 return;
}

BOOL ChangeScreenResolution (int width, int height, int bitsPerPixel){
        DEVMODE dmScreenSettings;                                                                                       // Device Mode
        ZeroMemory (&dmScreenSettings, sizeof (DEVMODE));                                       // Make Sure Memory Is Cleared
        dmScreenSettings.dmSize                         = sizeof (DEVMODE);                             // Size Of The Devmode Structure
        dmScreenSettings.dmPelsWidth            = width;                                                // Select Screen Width
        dmScreenSettings.dmPelsHeight           = height;                                               // Select Screen Height
        dmScreenSettings.dmBitsPerPel           = bitsPerPixel;                                 // Select Bits Per Pixel
        dmScreenSettings.dmFields                       = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
        if (ChangeDisplaySettings (&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)        {
                return FALSE;                                                                                                   // Display Change Failed, Return False
        }
        return TRUE;                                                                                                            // Display Change Was Successful, Return True
}

static void printGCinfo(char *text){
 int sb,db,arb,agb,abb,aab; 
 if(debug == NULL)return;
 glGetIntegerv(GL_STENCIL_BITS,&sb);
 glGetIntegerv(GL_DEPTH_BITS,&db);
 glGetIntegerv(GL_ACCUM_BLUE_BITS,&abb);
 glGetIntegerv(GL_ACCUM_GREEN_BITS,&agb);
 glGetIntegerv(GL_ACCUM_RED_BITS,&arb);
 glGetIntegerv(GL_ACCUM_ALPHA_BITS,&aab);
 //fprintf(debug,"[%s] stencil bits %ld  depth bits %ld accum-buffer %ld %ld %ld %ld bit\n",text,sb,db,arb,agb,abb,aab);
 //fprintf(debug,"Output RenderBufferSize size [%ld %ld]\n",RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT);
}

BOOL CheckGPUhardware(HWND hwnd){
 BOOL bOK=TRUE;
 const char *p,*vn,*vv,*r;
 GLint naux,nlights,maxtxsize,maxviewsize[2],maxtxunits,vers;
 HDC hDC;
 HGLRC hRC;
 PIXELFORMATDESCRIPTOR pfd;
 GLuint PixelFormat;
 memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
 pfd.nSize      = sizeof(PIXELFORMATDESCRIPTOR);
 pfd.nVersion   = 1;
 pfd.dwFlags    = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
 pfd.iPixelType = PFD_TYPE_RGBA;
 pfd.cColorBits = 32;
 pfd.cDepthBits = 32;     
 pfd.cAccumBits = 16;      
 pfd.cStencilBits = 1;    
 hDC=GetDC(hwnd);
 if(hDC == NULL)return FALSE;
 if((PixelFormat = ChoosePixelFormat( hDC, &pfd )) == FALSE)return FALSE;
 if(SetPixelFormat(hDC,PixelFormat, &pfd) == FALSE)return FALSE;
 hRC = wglCreateContext(hDC);
 if(hRC == NULL)return FALSE;
 wglMakeCurrent(hDC,hRC);
 vv=glGetString(GL_VERSION);
 vers=vv[0]-48;
 if(vers < 2)bOK=FALSE;
 //if(debug != NULL)fprintf(debug,"Version %ld\n",vers);
 vn=glGetString(GL_VENDOR); 
 r=glGetString(GL_RENDERER); 
 p=glGetString(GL_EXTENSIONS);
 if(strstr(p, "ARB_fragment_program" ) == NULL ||
    strstr(p, "ARB_fragment_shader" ) == NULL ||
    strstr(p, "ARB_shader_objects" ) == NULL ||
    strstr(p, "ARB_vertex_program" ) == NULL ||
    strstr(p, "ARB_vertex_shader" ) == NULL ||
    strstr(p, "EXT_framebuffer_object" ) == NULL)bOK=FALSE; // no framebuffer
 glGetIntegerv(GL_AUX_BUFFERS,&naux);
 glGetIntegerv(GL_MAX_LIGHTS,&nlights);
 glGetIntegerv(GL_MAX_TEXTURE_SIZE,&maxtxsize);
 glGetIntegerv(GL_MAX_TEXTURE_UNITS,&maxtxunits);
 if(maxtxunits < 4)bOK=FALSE;
 glGetIntegerv(GL_MAX_VIEWPORT_DIMS,maxviewsize);
 wglMakeCurrent(NULL,NULL);
 wglDeleteContext(hRC);
 ReleaseDC(hwnd,hDC);
 return bOK;
}