gldesign1.c

Go to the documentation of this file.

/* --
OpenFX Modelling, Animation and Rendering Package
-- */

/* file GLDESIGN1.C  The DLL that provided OpenGL support for the designer */

#define _DSCRUCT_SUB 1

#include "gldesign1.h"

extern unsigned char *LoadMAP(char *InFile, long *xx,long *yy);
extern void CreateNoise3D(void);

void Make3dDisplayListProg(void);

#define MAPDELTA 0.3333333

extern SelXs,SelYs,SelXc,SelYc;
extern GLfloat up_angle,round_angle;
extern GLfloat gbRed,gbGreen,gbBlue;
extern GLfloat gwRed,gwGreen,gwBlue;
extern GLfloat near_plane,far_plane,vertex_scale,ortho_width;
extern GLint listID,mode,bounding_box,current_map;
extern BOOL  Mapped,Update,Fastest,Clamped,
      Cmaterial,AttenuateLight,TwoSided,
      ScrollBars,bDrawMapping,bOverlayWire,bOverlayWireHidden,bSelectOnlyInView,
      bThickWire,bNurbsWireOnly,
      bStereo,bStereoDraw,bShaders,bOrtho,bDrawSelection,
      bCanUseShaders;
extern char gszBMPfile[],gszBMPdir[],gszRootDir[];
extern GLMAP    *glMapList;
extern long     NglMapList;
extern int      *Tool;

extern GLuint g_check_texture;
extern GLuint g_map_texture;
extern GLuint g_movie_texture;
extern GLuint g_env_texture;
extern GLuint g_bump_texture;
extern GLuint g_ref_texture;
extern GLuint g_tran_texture;
extern GLuint g_envB_texture;
extern GLuint g_noise_texture;
extern GLubyte checkImage[checkImageWidth][checkImageHeight][3];

void PrepareStereo(double, double, double, double, 
                   double, double, double, double, 
                   double, double, double);
void Make3dDisplayList(void);
void DrawSelectionBox(HWND);
void DrawGlNurbs(GLfloat);
void DrawProjectMapRectangle(void);
void makeCheckImageMap(int id);
void GetMappingCoordS(int id, vector n, vector dx, vector dy, vector p0, long *pv,
                 GLfloat * a, GLfloat * b);
void GetMappingCoordP(int id, vector n, vector x, vector y, vector p0,
                             long *pv,
                             GLfloat *a, GLfloat *b);
void GetMappingCoordC(int id, vector n, vector x, vector y, vector p0,
                long *pv,
                GLfloat *a, GLfloat *b);
void GetMapNormal(int k, vector mP, vector mX, vector mY,
                         vector mN);
BOOL normalise(GLfloat *v);
BOOL Normalize(point x,point y,point z, GLfloat *n);
BOOL inview(vertex  *vp);
void  FixUpMapEdge(GLfloat alpha[]);
void TextureWithAlpha(long x, long y, unsigned char *pin, unsigned char alpha, BOOL, 
                      unsigned char,unsigned char, unsigned char);
static void DrawMappedPolys(GLfloat scale, normal *nv);
BOOL CheckGPUhardware(HWND hwnd);

RECT oldrect;


BOOL bSetupPixelFormat(HDC hDC){
 static PIXELFORMATDESCRIPTOR pfd = {
   sizeof(PIXELFORMATDESCRIPTOR),  // size of this pfd
   1,                              // version number
   PFD_DRAW_TO_WINDOW |            // support window
   PFD_SUPPORT_OPENGL |            // support OpenGL
   PFD_DOUBLEBUFFER,               // double buffered
   PFD_TYPE_RGBA,                  // RGBA type
   24,                             // 24-bit color depth
   0, 0, 0, 0, 0, 0,               // color bits ignored
   0,                              // no alpha buffer
   0,                              // shift bit ignored
   0,                              // no accumulation buffer
   0, 0, 0, 0,                     // accum bits ignored
   32,                             // 32-bit z-buffer
   0,                              // no stencil buffer
   0,                              // no auxiliary buffer
   PFD_MAIN_PLANE,                 // main layer
   0,                              // reserved
   0, 0, 0                         // layer masks ignored
 };
 int pixelformat;
 if (bStereo){
   pfd.dwFlags |= PFD_STEREO;
 }
 if ( (pixelformat = ChoosePixelFormat(hDC, &pfd)) == 0 ){
   MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK);
   return FALSE;
 }
 if (SetPixelFormat(hDC, pixelformat, &pfd) == FALSE) {
   MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK);
   return FALSE;
 }
 if (bStereo){
   pixelformat = GetPixelFormat (hDC);
   DescribePixelFormat (hDC, pixelformat, sizeof (PIXELFORMATDESCRIPTOR), &pfd);
   if (!(pfd.dwFlags & PFD_STEREO)){
     MessageBox (NULL, "GLDESIGN.DLL: Stereo mode not supported by this hardware.", "Stereo init error", MB_OK | MB_ICONINFORMATION);
     bStereoDraw=FALSE;
   }
   else bStereoDraw=TRUE;
 }
 return TRUE;
}


void SetMappingQuality(void){
 GLfloat parameter3[]={GL_SPHERE_MAP};
 if(Clamped){
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 }
 else{
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 }
 glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 //To allow for reflection mapping
 glTexGenfv(GL_S,GL_TEXTURE_GEN_MODE,parameter3);  
 glTexGenfv(GL_T,GL_TEXTURE_GEN_MODE,parameter3);

 // We MUST tell OGL how the map is to be applied !!!!!!!!
 // glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 // glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 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;
     }
   }
 }
}

GLvoid initialize(HWND hWnd){
 GLfloat   aspect;
 GLfloat d[]={1.0,1.0,1.0,1.0};
 GLfloat a[]={0.2,0.2,0.2,1.0};
 GLfloat s[]={1.0,1.0,1.0,1.0};
 GLfloat p[]={0.0,0.0,1.0,0.0};
 unsigned char *movie_image=NULL,movie_file[256];
 unsigned char *env_image=NULL,env_file[256];
 unsigned char *envB_image=NULL,envB_file[256];
 long movie_image_x,movie_image_y;
 long env_image_x,env_image_y;
 long envB_image_x,envB_image_y;
 if(bCanUseShaders)ShadersInit(gszRootDir,TRUE);
 if(AttenuateLight)p[3]=1.0;
 else              p[3]=0.0;
 GetClientRect(hWnd, &oldrect);
 glClearColor(gbRed,gbGreen,gbBlue,1.0);
 glMatrixMode(GL_PROJECTION);
 aspect = (GLfloat) oldrect.right / (GLfloat)oldrect.bottom;;
 near_plane = 1.5; far_plane = 9.5;
 if(bOrtho)glOrtho(-ortho_width*0.5*aspect, ortho_width*0.5*aspect,
                   -ortho_width*0.5, ortho_width*0.5, near_plane,far_plane); 
 else      gluPerspective( 45.0, aspect, near_plane, far_plane);
 glMatrixMode( GL_MODELVIEW );
 glLoadIdentity();
 glClearDepth(1.0);
 glEnable(GL_DEPTH_TEST);
 glDepthFunc(GL_LEQUAL);  // this is needed for the map blending
 if(TwoSided)glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
 else        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_FALSE);
 glEnable(GL_LIGHT0);
 glLightfv(GL_LIGHT0,GL_DIFFUSE,d);
 glLightfv(GL_LIGHT0,GL_AMBIENT,a);
 glLightfv(GL_LIGHT0,GL_SPECULAR,s);
 glLightfv(GL_LIGHT0,GL_POSITION,p);
 glLightf(GL_LIGHT0,GL_LINEAR_ATTENUATION,0.15);
 glLightf(GL_LIGHT0,GL_QUADRATIC_ATTENUATION,0.05);
 glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
 // make the dummy texture for missing maps
 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,
              &checkImage[0][0][0]);
 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,
              &checkImage[0][0][0]);
 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,
              &checkImage[0][0][0]);
 SetMappingQuality(); // THIS IS NEEDED -see function
 strcpy(movie_file,gszRootDir); strcat(movie_file,"movie.bmp");
 if((movie_image=LoadMAP(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,gszRootDir); strcat(env_file,"genref.bmp");
 if((env_image=LoadMAP(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,gszRootDir); strcat(envB_file,"bumpy.bmp");
 if((envB_image=LoadMAP(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);
 }
 glBindTexture(GL_TEXTURE_2D,0);
 glDisable(GL_TEXTURE_2D);
 if(bCanUseShaders){
   glEnable(GL_TEXTURE_3D);
   glBindTexture(GL_TEXTURE_3D,g_noise_texture);
   CreateNoise3D();
   glBindTexture(GL_TEXTURE_3D,0);
   glDisable(GL_TEXTURE_3D);
 }
 glEnable(GL_TEXTURE_2D);
}

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;
}

void PrepareStereo(double dfLeftBorder, double dfRightBorder, 
    double dfBottomBorder, double dfTopBorder, double dfNearBorder, 
    double dfFarBorder, double dfTargetPlane, double dfCameraToTargetDistance, 
    double dfStereoMagnitudeAdj, double dfParallaxBalanceAdj, 
    double dfEyePosition){
    double dfXRange, dfYRange;
    double dfXMidpoint, dfYMidpoint;
    double dfCameraPlane;
    double dfNearClipDistance, dfFarClipDistance;
    double dfStereoCameraOffset;
    double dfFrustumAsymmetry;
    double n_over_d;
    double FrustumTop, FrustumBottom, FrustumLeft, FrustumRight;

    // the X & Y axis ranges, in the target Z plane
    dfXRange = dfRightBorder - dfLeftBorder;
    dfYRange = dfTopBorder - dfBottomBorder;  

    // midpoints of the X & Y axis ranges
    dfXMidpoint = (dfRightBorder + dfLeftBorder) / 2.0;  
    dfYMidpoint = (dfTopBorder + dfBottomBorder) / 2.0;  

    // convert clipping plane positions to distances in front of camera
    dfCameraPlane = dfTargetPlane + dfCameraToTargetDistance;
    dfNearClipDistance = dfCameraPlane - dfNearBorder;
    dfFarClipDistance  = dfCameraPlane - dfFarBorder;

    // Determine the stereoscopic camera offset. A good rule of thumb is 
    //      for the overall camera separation to equal about 7% of the 
    //      window's X-axis range in the XY-plane of the target 
    //      ("target" being mid-object or the center of interest in the 
    //      scene). 
    dfStereoCameraOffset = dfXRange * STEREO_MAGNITUDE_CONSTANT * 
        dfStereoMagnitudeAdj;
    dfStereoCameraOffset /= 2.0;  // offset each camera by half the overall sep
    dfStereoCameraOffset *= dfEyePosition; 
            
    // Determine the amount by which the projection frustum will be made
    //      asymmetrical in order to affect a nice parallax balance between
    //      negative parallax (popping out of the display) and positive 
    //      parallax (residing behind the display surface). With no frustum
    //      asymmetry, everything resides in negative parallax.
    dfFrustumAsymmetry = -dfStereoCameraOffset * dfParallaxBalanceAdj;

    // since glFrustum() maps the window borders based on the near clipping 
    //      plane rather than the target plane, X and Y range values need 
    //      to be adjusted by the ratio of those two distances
    n_over_d = dfNearClipDistance / dfCameraToTargetDistance;
    dfXRange *= n_over_d;
    dfYRange *= n_over_d;
    dfFrustumAsymmetry *= n_over_d;
            
    // determine the shape of the projection frustum; note that if 
    //      FrustumRight doesn't equal -FrustumLeft, that makes this an
    //      asymmetric frustum projection
    FrustumTop = dfYRange / 2.0;
    FrustumBottom = -dfYRange / 2.0;
    FrustumRight = (dfXRange / 2.0) + dfFrustumAsymmetry;
    FrustumLeft = (-dfXRange / 2.0) + dfFrustumAsymmetry;

    // glMatrixMode(GL_PROJECTION) needs to have been called already

    glLoadIdentity();  // obtain a vanilla trans matrix to modify

    // this matrix transformation performs the actual persp projection
    glFrustum (FrustumLeft, FrustumRight, FrustumBottom, FrustumTop, 
        dfNearClipDistance, dfFarClipDistance);

    // this matrix transformation does two things: Translates the stereo 
    //      camera towards the left (left camera) or the right (right 
    //      camera), and also offsets the entire geometry such that the 
    //      virtual camera is at (0.0, 0.0, 0.0) where glFrustum() expects 
    //      it to be
    glTranslated (-dfXMidpoint - dfStereoCameraOffset, -dfYMidpoint, 
        -dfCameraPlane);
}

GLvoid drawScene(HWND hWnd,BOOL shaded){
 HDC hDC;
 if (bStereoDraw){
    glFlush ();
    glDrawBuffer (GL_BACK);
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDrawBuffer (GL_BACK_LEFT);
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
        glTranslated (0.0, 0.0, 2.0);
          PrepareStereo(-3.2, 3.2, -2.4, 2.4, 8.0, -8.0,//3.0, -3.0, // X,Y,Z coord range
                        1.0, 14.5,//1.75, 14.5, //Z-coord of zero-parallax "target", camera-target dist
                        STEREO_MAGNITUDE_ADJUSTMENT, PARALLAX_BALANCE_ADJUSTMENT, 
                        -1.0);  // left eye position
    glMatrixMode (GL_MODELVIEW);
    glLoadIdentity ();
    glRotatef(up_angle,1.0,0.0,0.0);
    glRotatef(round_angle,0.0,1.0,0.0);
    //glScalef(scale_view,scale_view,scale_view);
    glCallList(1);
    if(bDrawMapping)DrawProjectMapRectangle();
    glPopMatrix ();
    if(bDrawSelection)DrawSelectionBox(hWnd);
    glClear (GL_DEPTH_BUFFER_BIT);
    glFlush ();
    glDrawBuffer (GL_BACK_RIGHT);
    glMatrixMode (GL_PROJECTION);    
        glLoadIdentity ();
        glTranslated (0.0, 0.0, 2.0);
        PrepareStereo(-3.2, 3.2, -2.4, 2.4, 8.0, -8.0,//3.0, -3.0, // X,Y,Z coord range
            1.0, 14.5,//1.75, 14.5, //Z-coord of zero-parallax "target", camera-target dist
            STEREO_MAGNITUDE_ADJUSTMENT, PARALLAX_BALANCE_ADJUSTMENT, 
            1.0);  // right eye position
    glMatrixMode (GL_MODELVIEW);
    glCallList(1);
    if(bDrawMapping)DrawProjectMapRectangle();
    glPopMatrix ();
    if(bDrawSelection)DrawSelectionBox(hWnd);
    glFinish();
    hDC = wglGetCurrentDC();
    SwapBuffers(hDC);
 }
 else{
   glDrawBuffer(GL_BACK);
   // glDrawBuffer(GL_FRONT);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glShadeModel(GL_SMOOTH);
   glPushMatrix();
   glLoadIdentity();
   glTranslatef(0.0, 0.0, -5.0);
   glRotatef(up_angle,1.0,0.0,0.0);
   glRotatef(round_angle,0.0,1.0,0.0);
   //glScalef(scale_view,scale_view,scale_view);
   glCallList(1);
   if(bDrawMapping)DrawProjectMapRectangle();
   glPopMatrix();
   if(bDrawSelection)DrawSelectionBox(hWnd);
   glFinish();
   hDC = wglGetCurrentDC();
   SwapBuffers(hDC);
 }
 return;
}

GLvoid resize(HWND hWnd){
 RECT    rect;
 GLfloat aspect;
 GetClientRect(hWnd, &rect);
 glViewport(0, 0, rect.right, rect.bottom);
 oldrect.right = rect.right;
 oldrect.bottom = rect.bottom;
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 aspect = (GLfloat) oldrect.right / oldrect.bottom;
 if(bOrtho)glOrtho(-ortho_width*0.5*aspect, ortho_width*0.5*aspect,
                   -ortho_width*0.5,ortho_width*0.5, near_plane,far_plane); 
 else      gluPerspective( 45.0, aspect, near_plane, far_plane);
 glMatrixMode( GL_MODELVIEW );
 glLoadIdentity();
}

void Ortho2Dto3D(int x, int y, GLfloat *xx, GLfloat *yy){
 GLfloat w,h,aspect;
 w=(GLfloat)oldrect.right; h=(GLfloat)oldrect.bottom;
 aspect=w/h;
 *xx = (-ortho_width*0.5+((GLfloat)x)/w*ortho_width)*aspect;
 *yy = ( ortho_width*0.5-((GLfloat)y)/h*ortho_width);
}

void Ortho3Dto2D(int *x, int *y, GLfloat xx, GLfloat yy){ // NOT TESTED
 GLfloat w,h,aspect;
 w=(GLfloat)oldrect.right; h=(GLfloat)oldrect.bottom;
 aspect=w/h;
 *x =  (int)((xx+ortho_width*0.5)/ortho_width/aspect * w);
 *y =  (int)(h-(yy+ortho_width*0.5)/ortho_width * h);
}

void DrawProjectMapRectangle(void){
 long i;
 GLfloat x1,y1,z1,x2,y2,z2,scale,dscale=0.05;
 point dx,dy,d;
 if(nImaps > 0 && current_map < nImaps){
   glPushMatrix();
   i=current_map;
   scale=vertex_scale/TVsizeX;
   VECSUB(iMap[i].X,iMap[i].P,dx)
   VECSUB(iMap[i].Y,iMap[i].P,dy)
   VECSUM(iMap[i].X,dy,d)
   // Transparent
   glEnable(GL_BLEND);
   glDepthMask(GL_FALSE);
   glBlendFunc(GL_SRC_ALPHA,GL_ONE);
   glColor4f(1.0, 1.0, 1.0,0.3);
   glBegin(GL_QUADS);
   x1=((GLfloat)(iMap[i].P[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].P[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].P[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].X[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].X[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].X[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(d[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(d[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(d[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].Y[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].Y[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].Y[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   glEnd();
   glDepthMask(GL_TRUE);
   glDisable(GL_BLEND);
   //end transparent
   glLineWidth(4.0);
   glBegin(GL_LINES);
   glColor3f(0.0, 1.0, 0.0);
   x1=((GLfloat)(iMap[i].Y[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].Y[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].Y[2]-TVpointZ-TVsizeZ/2))*scale;
   x2=((GLfloat)(iMap[i].P[0]-TVpointX-TVsizeX/2))*scale;
   y2=((GLfloat)(iMap[i].P[1]-TVpointY-TVsizeY/2))*scale;
   z2=((GLfloat)(iMap[i].P[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   glVertex3f(x2,z2,-y2);
   x1=((GLfloat)(iMap[i].X[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].X[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].X[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x2,z2,-y2);
   glVertex3f(x1,z1,-y1);
   x2=((GLfloat)(d[0]-TVpointX-TVsizeX/2))*scale;
   y2=((GLfloat)(d[1]-TVpointY-TVsizeY/2))*scale;
   z2=((GLfloat)(d[2]-TVpointZ-TVsizeZ/2))*scale;
   glEnd();
   glLineWidth(1.0);
   glBegin(GL_LINES);
   glVertex3f(x1,z1,-y1);
   glVertex3f(x2,z2,-y2);
   x1=((GLfloat)(iMap[i].Y[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].Y[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].Y[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x2,z2,-y2);
   glVertex3f(x1,z1,-y1);
   glEnd();
   VECSCALE(dscale,(GLfloat)dx,dx)
   VECSCALE(dscale,(GLfloat)dy,dy)
   glBegin(GL_LINE_LOOP);
   x1=((GLfloat)(iMap[i].P[0]-dx[0]-dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].P[1]-dx[1]-dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].P[2]-dx[2]-dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].P[0]+dx[0]-dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].P[1]+dx[1]-dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].P[2]+dx[2]-dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].P[0]+dx[0]+dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].P[1]+dx[1]+dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].P[2]+dx[2]+dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].P[0]-dx[0]+dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].P[1]-dx[1]+dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].P[2]-dx[2]+dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   glEnd();
   glBegin(GL_LINE_LOOP);
   x1=((GLfloat)(iMap[i].Y[0]-dx[0]-dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].Y[1]-dx[1]-dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].Y[2]-dx[2]-dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].Y[0]+dx[0]-dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].Y[1]+dx[1]-dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].Y[2]+dx[2]-dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].Y[0]+dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].Y[1]+dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].Y[2]+dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   glEnd();
   VECSCALE(0.5,(GLfloat)dx,dx)
   VECSCALE(0.5,(GLfloat)dy,dy)
   glBegin(GL_LINE_LOOP);
   x1=((GLfloat)(iMap[i].X[0]-dx[0]-dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].X[1]-dx[1]-dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].X[2]-dx[2]-dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].X[0]+dx[0]-dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].X[1]+dx[1]-dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].X[2]+dx[2]-dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].X[0]+dx[0]+dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].X[1]+dx[1]+dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].X[2]+dx[2]+dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   x1=((GLfloat)(iMap[i].X[0]-dx[0]+dy[0]-TVpointX-TVsizeX/2))*scale;
   y1=((GLfloat)(iMap[i].X[1]-dx[1]+dy[1]-TVpointY-TVsizeY/2))*scale;
   z1=((GLfloat)(iMap[i].X[2]-dx[2]+dy[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x1,z1,-y1);
   glEnd();
   glLineWidth(1.0);
   glPopMatrix();
 }
 return;
}

void DrawModelEdges(void){
 GLfloat x,y,z,scale;
 edge *ep;
 vertex *v1,*v2;
 int i;
 if(Nedge == 0 && Nnurbs == 0)return;
 glPushMatrix();
 if(bThickWire)glLineWidth(2.0);
 else          glLineWidth(1.0);
 glBegin(GL_LINES);
 glColor3f(gwRed,gwGreen,gwBlue);
 scale=vertex_scale/TVsizeX;
 ep=MainEp; if(Nedge > 0)for(i=0;i<Nedge;i++){
   v1=(MainVp+ep->V[0]);
   v2=(MainVp+ep->V[1]);
   if(bOverlayWireHidden && (v1->status == HIDDEN || v2->status == HIDDEN))goto BYPASS;
   x=((GLfloat)(v1->xyz[0]-TVpointX-TVsizeX/2))*scale;
   y=((GLfloat)(v1->xyz[1]-TVpointY-TVsizeY/2))*scale;
   z=((GLfloat)(v1->xyz[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x,z,-y);
   x=((GLfloat)(v2->xyz[0]-TVpointX-TVsizeX/2))*scale;
   y=((GLfloat)(v2->xyz[1]-TVpointY-TVsizeY/2))*scale;
   z=((GLfloat)(v2->xyz[2]-TVpointZ-TVsizeZ/2))*scale;
   glVertex3f(x,z,-y);
   BYPASS:
   ep++;
 }
 glEnd();
 glLineWidth(1.0);
 DrawGlNurbs(GLU_OUTLINE_PATCH);
 glPopMatrix();
}

void DrawSelectionBox(HWND hWnd){
 GLfloat xs,ys,xe,ye,z;
 z = -near_plane;
 glPushMatrix();
 glLoadIdentity();
 glLineWidth(2.0);
 if(*Tool == SELECTOR)glColor3f(1.0,1.0,0.0);
 else                 glColor3f(1.0,0.0,0.0);
 Ortho2Dto3D(SelXs,SelYs,&xs,&ys);
 Ortho2Dto3D(SelXc,SelYc,&xe,&ye);
//xs=ys=-1.0; xe=ye=1.0;
 glBegin(GL_LINES);
 glVertex3f(xs,ys,z); glVertex3f(xe,ys,z);
 glVertex3f(xe,ys,z); glVertex3f(xe,ye,z);
 glVertex3f(xe,ye,z); glVertex3f(xs,ye,z);
 glVertex3f(xs,ye,z); glVertex3f(xs,ys,z);
 glEnd();
 glLineWidth(1.0);
 glPopMatrix();
}

void TextureWithAlpha(long x, long y, unsigned char *pin, unsigned char alpha, BOOL bDecal,
                      unsigned char r, unsigned char g, unsigned char b){  // no border
  unsigned char *pout,*p;
  long i,j;
  pout=X__Malloc(x*y*4); p=pout;
  for(i=0;i<y;i++)for(j=0;j<x;j++){
    *p++ = *pin++;
    *p++ = *pin++;
    *p++ = *pin++;
    if(bDecal){
      if(*(p-3) == r && *(p-2) == g && *(p-1) == b)*p++ = 0;
      else  *p++ = alpha;
    }
    else  *p++ = alpha;
  }
  glTexImage2D(GL_TEXTURE_2D,0,4,x,y,0,GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid *)pout);
  X__Free(pout);
}

void Make3dDisplayList(void){
 GLfloat x,y,z,scale,n[3],color[4],*spec_color,
         glos_color[]={1.0,1.0,1.0,1.0},
         dark_color[]={0.0,0.0,0.0,1.0},
         black[]={0.1,0.1,0.1,1.0},
         dull[]={0.0},
         shiny[]={100.0},dot;
 face *fp;
 vertex *v,*v1,*v2,*v0;
 normal *nv;
 int i,j,k,m,Vi,V[3];
 if(Nface == 0 && Nnurbs == 0){
   if(listID > 0){glDeleteLists(1,1);listID=0;}
   return;
 }

 if(Nvert > 0){
   if((nv=(normal *)X__Malloc(sizeof(normal)*Nvert)) == NULL){
     return;
   }
   for(i=0;i<Nvert;i++)nv[i][0]=nv[i][1]=nv[i][2]=0.0;
 }
 fp=MainFp; if(Nface > 0)for(i=0;i<Nface;i++){  // calculate the vertex normals
   V[0]=fp->V[0]; V[1]=fp->V[1]; V[2]=fp->V[2];
   v0=(MainVp+V[0]); v1=(MainVp+V[1]); v2=(MainVp+V[2]);
   if(inview(v0) || inview(v1) || inview(v2)){
     if(Normalize(v0->xyz,v1->xyz,v2->xyz,n)){
       for(j=0;j<3;j++){
         dot=DOT(nv[V[j]],n);
         if(dot >  1.e-5){
           VECSUM(nv[V[j]],n,nv[V[j]])
         }
         else if(dot < -1.e-5){
           VECSUB(nv[V[j]],n,nv[V[j]])
         }
         else{
           VECSUM(nv[V[j]],n,nv[V[j]])
         }

       }
     }
   }
   fp++;
 }
 if(Nvert > 0)for(i=0;i<Nvert;i++)normalise(nv[i]);

 if(listID > 0){glDeleteLists(1,1);listID=0;}
 glNewList(1,GL_COMPILE);
 
 color[3]=1.0; color[0]=1.0; color[1]=1.0; color[2]=1.0;
 scale=vertex_scale/TVsizeX;
 glEnable(GL_LIGHTING);
 glEnable(GL_COLOR_MATERIAL);
 glBegin(GL_TRIANGLES);
 glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,shiny);
 glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,glos_color);
 fp=MainFp; if(Nface > 0)for(i=0;i<Nface;i++,fp++){
   //   if(Mapped && fp->imagemap >= 0)continue; | DO draw the mapped polygons these will be blended in later
   if(fp->material  >= 0)continue;          // materials in this pass
   v0=(MainVp+fp->V[0]); v1=(MainVp+fp->V[1]); v2=(MainVp+fp->V[2]);
   if(inview(v0) || inview(v1) || inview(v2)){
       color[0]=(GLfloat)fp->color[0]/255.0;
       color[1]=(GLfloat)fp->color[1]/255.0;
       color[2]=(GLfloat)fp->color[2]/255.0;
       glColor4fv(color);
       if(Normalize(v0->xyz,v1->xyz,v2->xyz,n)){
         for(j=0;j<3;j++){
           Vi=fp->V[j]; v=(MainVp+Vi);
           x=((GLfloat)(v->xyz[0]-TVpointX-TVsizeX/2))*scale;
           y=((GLfloat)(v->xyz[1]-TVpointY-TVsizeY/2))*scale;
           z=((GLfloat)(v->xyz[2]-TVpointZ-TVsizeZ/2))*scale;
           if(fp->bSmooth){ /* smoothed */
             dot=DOT(nv[Vi],n);
             if(dot  <    0.0)glNormal3f(-nv[Vi][0],-nv[Vi][2], nv[Vi][1]);
             else             glNormal3f( nv[Vi][0], nv[Vi][2],-nv[Vi][1]);
           }
           else{/* not smoothed */
             glNormal3f( n[0], n[2],-n[1]);
           }
           glVertex3f(x,z,-y);
         }
       }
   }
 }
 glEnd();
 glDisable(GL_COLOR_MATERIAL);

 DrawGlNurbs(GLU_FILL);

 if(nMats > 0 && Nface > 0){ // render the materials
   int pass;
   color[0]=1.0; color[1]=1.0; color[2]=1.0;
   glEnable(GL_COLOR_MATERIAL);
   glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
   for(pass=0;pass<2;pass++) // render transparency last
   for(k=0;k<nMats;k++){
     if(pass == 0 && iMat[k].transp > 0)continue;
     if(pass == 1 && iMat[k].transp == 0)continue;
     for(i=0;i<3;i++)color[i]=(GLfloat)iMat[k].mcolour1[i]/255.0;
     // set gl properites for this face
     glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,shiny);
     glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,glos_color);
     if(iMat[k].transp > 0){ // Set transparent blending
       glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,dull);
       glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,dark_color);
       glEnable(GL_BLEND);
       glDepthMask(GL_FALSE);
       glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
       color[3]=(1.0 - (GLfloat)iMat[k].transp / 255.0);
     }
     else color[3]=1.0;
     glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,color);
     glColor4fv(color);

     glBegin(GL_TRIANGLES);
     fp=MainFp; if(Nface > 0)for(i=0;i<Nface;i++,fp++){ // daw the mapped polys
       if(fp->material != k /* || (Mapped && fp->imagemap >= 0) */ || fp->material < 0)continue; //skip
       v0=(MainVp+fp->V[0]); v1=(MainVp+fp->V[1]); v2=(MainVp+fp->V[2]);
       if(inview(v0) || inview(v1) || inview(v2)){
         if(Normalize(v0->xyz,v1->xyz,v2->xyz,n)){
           for(j=0;j<3;j++){
             Vi=fp->V[j]; v=(MainVp+Vi);
             x=((GLfloat)(v->xyz[0]-TVpointX-TVsizeX/2))*scale;
             y=((GLfloat)(v->xyz[1]-TVpointY-TVsizeY/2))*scale;
             z=((GLfloat)(v->xyz[2]-TVpointZ-TVsizeZ/2))*scale; 
            if(iMat[k].bSmooth){ /* smoothed */
               dot=DOT(nv[Vi],n);
               if(fabs(dot) < 0.5)glNormal3f(n[0],n[2],-n[1]);
               else if(dot  < 0.0)glNormal3f(-nv[Vi][0],-nv[Vi][2], nv[Vi][1]);
               else               glNormal3f( nv[Vi][0], nv[Vi][2],-nv[Vi][1]);
             }
             else{/* not smoothed */
               glNormal3f( n[0], n[2],-n[1]);
             }
             glVertex3f(x,z,-y);
           }
         }
       }
     }
     glEnd();
     // any material attributes that need to be undone ?
     if(iMat[k].transp > 0){ // Set transparent blending
       glDepthMask(GL_TRUE);
       glDisable(GL_BLEND);
     }
   }
   glEnable(GL_COLOR_MATERIAL);
 }
 // Finally the mapping - ALPHA blend it in !!!
 glEnable(GL_BLEND);
 glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 if(Mapped && Nface > 0)DrawMappedPolys(scale,nv);
 glDisable(GL_BLEND);

 glDisable(GL_LIGHTING);
 bThickWire=TRUE;
 if(bOverlayWire)DrawModelEdges();
 bThickWire=FALSE;

 glEndList();
 listID=1;

 X__Free(nv);
 return;
}

static void DrawMappedPolys(GLfloat scale, normal *nv){  
 GLfloat mixColour[4]={0.0,0.0,0.0,0.0};
 GLfloat x,y,z,n[3],
         dot;
 face *fp;
 vertex *v,*v1,*v2,*v0;
 int i,j,k,m,Vi;
 BOOL refmap;
 int brushID;
 vector mN,mX,mY,mP;
 GLfloat alpha[3],beta[3];
 GLfloat bc[4]={0.0,0.0,0.0,0.0};

 if(nImaps > 0)for(k=0;k<nImaps;k++){       // loop over all maps
   GetMapNormal(k,mP,mX,mY,mN);
   if(glMapList != NULL && k < NglMapList){
     refmap=FALSE;

     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D,0);
     if(iMap[k].s == 1){    // .sp  
       if(glMapList[k].bMovie)glBindTexture(GL_TEXTURE_2D,g_movie_texture);
       else if(glMapList[k].pixels != NULL){
         glBindTexture(GL_TEXTURE_2D,g_map_texture);
         TextureWithAlpha(glMapList[k].x,glMapList[k].y,glMapList[k].pixels,255,
         iMap[k].bDecal,iMap[k].k_colour[0],iMap[k].k_colour[1],iMap[k].k_colour[2]);
       }
       else glBindTexture(GL_TEXTURE_2D,g_check_texture);
       if(iMap[k].bTiled){
         if(iMap[k].Map == PLANE_MOZIAC || iMap[k].Map == CYLINDER_MOZIAC){
           glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT);
           glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_MIRRORED_REPEAT);
         }
         else{
           glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
           glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
         }
       }
       else{
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
       } 
       glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
       glTexEnvf(GL_TEXTURE_ENV,GL_COMBINE_RGB,GL_INTERPOLATE);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC0_RGB,GL_TEXTURE);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND0_RGB,GL_SRC_COLOR);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC1_RGB,GL_PREVIOUS);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND1_RGB,GL_SRC_COLOR);
       if(iMap[k].bShaded)
         mixColour[3]=((GLfloat)iMap[k].sp)*0.005;  
       else
         mixColour[3]=((GLfloat)iMap[k].sp)*0.01; 
       glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,mixColour);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC2_RGB,GL_CONSTANT);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND2_RGB,GL_SRC_ALPHA);
     }

     glActiveTexture(GL_TEXTURE1);
     glBindTexture(GL_TEXTURE_2D,0);
     if(iMap[k].r == 1){
       if(glMapList[k].bMovieR){
         glBindTexture(GL_TEXTURE_2D,g_movie_texture);
       }
       else if(glMapList[k].pixelsR != NULL){
         glBindTexture(GL_TEXTURE_2D,g_ref_texture);
         glTexImage2D(GL_TEXTURE_2D,0,3,
                          glMapList[k].xR,glMapList[k].yR,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)glMapList[k].pixelsR);
       }
       else glBindTexture(GL_TEXTURE_2D,g_check_texture);
       refmap=TRUE;
       glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP);  // for reflection
       glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP);
       glEnable(GL_TEXTURE_GEN_S);
       glEnable(GL_TEXTURE_GEN_T);
       glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
       glTexEnvf(GL_TEXTURE_ENV,GL_COMBINE_RGB,GL_INTERPOLATE);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC0_RGB,GL_TEXTURE);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND0_RGB,GL_SRC_COLOR);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC1_RGB,GL_PREVIOUS);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND1_RGB,GL_SRC_COLOR);
       mixColour[3]=((GLfloat)iMap[k].rp)*0.01;   // ( a value of 0 => No reflection.)
       glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,mixColour);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC2_RGB,GL_CONSTANT);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND2_RGB,GL_SRC_ALPHA);
     }

     glActiveTexture(GL_TEXTURE2);
     glBindTexture(GL_TEXTURE_2D,0);
     if(iMap[k].b == 1){   
       if(glMapList[k].bMovie)glBindTexture(GL_TEXTURE_2D,g_movie_texture);
       else if(glMapList[k].pixelsB != NULL){
         glBindTexture(GL_TEXTURE_2D,g_bump_texture);
         glTexImage2D(GL_TEXTURE_2D,0,3,
                          glMapList[k].xB,glMapList[k].yB,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)glMapList[k].pixelsB);
       }
       else glBindTexture(GL_TEXTURE_2D,g_check_texture);
       if(iMap[k].bTiled){
         if(iMap[k].Map == PLANE_MOZIAC || iMap[k].Map == CYLINDER_MOZIAC){
           glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT);
           glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_MIRRORED_REPEAT);
         }
         else{
           glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
           glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
         }
       }
       else{
         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR,bc);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
       } 
       glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
       glTexEnvf(GL_TEXTURE_ENV,GL_COMBINE_RGB,GL_INTERPOLATE);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC0_RGB,GL_TEXTURE);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND0_RGB,GL_SRC_COLOR);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC1_RGB,GL_PREVIOUS);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND1_RGB,GL_SRC_COLOR);
       mixColour[3]=((GLfloat)iMap[k].bp)*0.0025;  // 0 = no mix 1 = full mix
       glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,mixColour);
       glTexEnvf(GL_TEXTURE_ENV,GL_SRC2_RGB,GL_CONSTANT);
       glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND2_RGB,GL_SRC_ALPHA);
     }
     // loop over all materials to get the border colour
     // any basic colour attributes will just appear as a grey border

     glActiveTexture(GL_TEXTURE0); 
     m = -1; 
     matloop:
     glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
     glEnable(GL_COLOR_MATERIAL);
     glBegin(GL_TRIANGLES);
     fp=MainFp; if(Nface > 0)for(i=0;i<Nface;i++,fp++){
       if(fp->imagemap < 0)continue; /* if not mapped */
       if(m >= 0 && fp->material != m)continue; // not this material
       if(m == -1 && fp->material >= 0)continue; // or this basic one
       brushID=fp->imagemap;
       if(brushID != k)continue;         /* skip if not this map */

       if(iMap[k].bShaded){
         // work out a color mix so that it blends from background colour to mid grey
         GLfloat ff,mc[3];
         ff=((GLfloat)iMap[k].sp)*0.01;  // simulate dimming 
         if(m == -1)for(j=0;j<3;j++)mc[j]=(GLfloat)(fp->color[j])/255.0;
         else       for(j=0;j<3;j++)mc[j]=(GLfloat)(iMat[m].mcolour1[j])/255.0;
         for(j=0;j<3;j++)mc[j] = mc[j]*(1.0-ff); //   + 0.5*ff; // so mix with black
         glColor3fv(mc);
       }
       else{
         if(m == -1)glColor4ub(fp->color[0],fp->color[1],fp->color[2],255);
         else       glColor4ub(iMat[m].mcolour1[0],iMat[m].mcolour1[1],iMat[m].mcolour1[2],255);
       }
       v0=(MainVp+fp->V[0]); v1=(MainVp+fp->V[1]); v2=(MainVp+fp->V[2]);
       if(inview(v0) || inview(v1) || inview(v2)){
         if(Normalize(v0->xyz,v1->xyz,v2->xyz,n)){
           for(j=0;j<3;j++){
             Vi=fp->V[j]; v=(MainVp+Vi);
             if(fp->gp == TRUE){  // use face mapping coordinates
               alpha[j] = (GLfloat)(fp->x[j]); 
               beta[j]  = (GLfloat)(fp->y[j]); 
             }
             else if(iMap[k].Map == MAP_BY_VERTEX){
               alpha[j]=(GLfloat)v->x;
               beta[j]=(GLfloat)v->y;
             }
             else if(iMap[k].Map == MAP_SPHERICAL)
                  GetMappingCoordS(k,mN,mX,mY,mP,v->xyz,&(alpha[j]),&(beta[j]));
             else if(iMap[k].Map == CYLINDER || iMap[k].Map == CYLINDER_MOZIAC)
                  GetMappingCoordC(k,mN,mX,mY,mP,v->xyz,&(alpha[j]),&(beta[j]));
             else GetMappingCoordP(k,mN,mX,mY,mP,v->xyz,&(alpha[j]),&(beta[j]));
           }
           if(!fp->gp && (iMap[k].Map == CYLINDER || iMap[k].Map == CYLINDER_MOZIAC || iMap[k].Map == MAP_SPHERICAL)){
             FixUpMapEdge(alpha);
           }
           for(j=0;j<3;j++){
             Vi=fp->V[j]; v=(MainVp+Vi);
             x=((GLfloat)(v->xyz[0]-TVpointX-TVsizeX/2))*scale;
             y=((GLfloat)(v->xyz[1]-TVpointY-TVsizeY/2))*scale;
             z=((GLfloat)(v->xyz[2]-TVpointZ-TVsizeZ/2))*scale;
             if(fp->bSmooth){ /* smoothed */
               dot=DOT(nv[Vi],n);
               if(fabs(dot) < 0.5)glNormal3f(n[0],n[2],-n[1]);
               else if(dot  < 0.0)glNormal3f(-nv[Vi][0],-nv[Vi][2], nv[Vi][1]);
               else               glNormal3f( nv[Vi][0], nv[Vi][2],-nv[Vi][1]);
             }
             else{/* not smoothed */
               glNormal3f( n[0], n[2],-n[1]);
             }
             if(!fp->gp && (iMap[k].Map == CYLINDER || iMap[k].Map == CYLINDER_MOZIAC))alpha[j] *= 360.0/(GLfloat)iMap[k].Angle;
             //glTexCoord2f(alpha[j],beta[j]);
             glMultiTexCoord2f(GL_TEXTURE0,alpha[j],beta[j]);  // for non reflective textures
             glMultiTexCoord2f(GL_TEXTURE2,alpha[j],beta[j]);
             glVertex3f(x,z,-y);
           }
         }
       }
     }
     glEnd();
     glDisable(GL_COLOR_MATERIAL);
     m++;
     if(nMats > 0 && m >= 0 && m < nMats)goto matloop;
     glActiveTexture(GL_TEXTURE2); 
     glBindTexture(GL_TEXTURE_2D,0);
     glActiveTexture(GL_TEXTURE1); 
     glBindTexture(GL_TEXTURE_2D,0);
     if(refmap){
       glDisable(GL_TEXTURE_GEN_S);
       glDisable(GL_TEXTURE_GEN_T);
     }
     glActiveTexture(GL_TEXTURE0); 
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
     glBindTexture(GL_TEXTURE_2D,0);
   } // valid map list
 }   // each map
}

void DrawGlNurbs(GLfloat drawtype){
 GLUnurbsObj *theNurb;
 GLfloat *sknots,*tknots,*ctlarray;
 nurbs *np;
 GLfloat w,xp,yp,zp,scale;
 long i,j,k;
 vector4 *p1;
 if(Nnurbs == 0 || MainNp == NULL)return;
// if(drawtype == GLU_FILL && bNurbsWireOnly)drawtype=GLU_OUTLINE_POLYGON;
 drawtype=GLU_OUTLINE_POLYGON;
 scale=vertex_scale/TVsizeX;
 np=MainNp; while(np != NULL){
   if(!(np->properties.hidden) && (theNurb = gluNewNurbsRenderer()) != 0){
     sknots=(GLfloat *)X__Malloc(sizeof(GLfloat)*(np->numU+np->orderU));
     tknots=(GLfloat *)X__Malloc(sizeof(GLfloat)*(np->numV+np->orderV));
     if(sknots != NULL)for(j=0;j<np->numU+np->orderU;j++){ //knotsU
       sknots[j]=(GLfloat)np->kvU[j];
     }
     if(tknots != NULL)for(i=0;i<np->numV+np->orderV;i++){ //knotsV
       tknots[i]=(GLfloat)np->kvV[i];
     }
     ctlarray=(GLfloat *)X__Malloc(sizeof(GLfloat)*(4*np->numV*np->numU));
     if(ctlarray != NULL){
       k=0;
       for(j=0;j<np->numU;j++)
       for(i=0;i<np->numV;i++){
         p1 = &(np->points[i][j]);
         w=(GLfloat)(1.0/p1->w);
         xp=(GLfloat)((p1->x)*w);
         yp=(GLfloat)((p1->y)*w);
         zp=(GLfloat)((p1->z)*w);
         xp = (xp-(GLfloat)(TVpointX+TVsizeX/2))*scale;
         yp = (yp-(GLfloat)(TVpointY+TVsizeY/2))*scale;
         zp = (zp-(GLfloat)(TVpointZ+TVsizeZ/2))*scale;
         w=(GLfloat)(p1->w);
         *(ctlarray+(k++)) =  xp*w;
         *(ctlarray+(k++)) =  zp*w;
         *(ctlarray+(k++)) = -yp*w;
         *(ctlarray+(k++)) =  w;
       }
       if(drawtype == GLU_FILL)glEnable(GL_AUTO_NORMAL);
       gluBeginSurface(theNurb);
       glColor3f((GLfloat)(np->properties.colour[0])/255.0,
                 (GLfloat)(np->properties.colour[1])/255.0,
                 (GLfloat)(np->properties.colour[2])/255.0);
       if(drawtype == GLU_OUTLINE_POLYGON){
         gluNurbsProperty(theNurb,GLU_SAMPLING_METHOD,GLU_DOMAIN_DISTANCE);
         gluNurbsProperty(theNurb,GLU_U_STEP,5);
         gluNurbsProperty(theNurb,GLU_V_STEP,5);
       }
       else{
         gluNurbsProperty(theNurb,GLU_SAMPLING_TOLERANCE,50.0);
         gluNurbsProperty(theNurb,GLU_SAMPLING_METHOD,GLU_PATH_LENGTH);
       }
//gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
//gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_OUTLINE_PATCH);
//gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
       gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, drawtype);
       gluNurbsSurface(theNurb,
            np->numU+np->orderU, sknots,
            np->numV+np->orderV, tknots,
            4 * np->numV,
            4,
            ctlarray,
            np->orderU, np->orderV,
            GL_MAP2_VERTEX_4);
       gluEndSurface(theNurb);
       if(drawtype == GLU_FILL)glDisable(GL_AUTO_NORMAL);
     }
     if(sknots != NULL)X__Free(sknots);
     if(tknots != NULL)X__Free(tknots);
     if(ctlarray != NULL)X__Free(ctlarray);
     gluDeleteNurbsRenderer(theNurb);
   }
   np=np->last;
 }
 return;
}


#define TOL 1000.0

BOOL normalise(GLfloat *v){
 GLfloat n,nn;
 n= (GLfloat)((v[0]*v[0]) + (v[1]*v[1]) + (v[2]*v[2]));
 if(n < 1.e-10)return FALSE;
 nn=sqrt(n);
 n = 1.0 / nn;
 VECSCALE(n,v,v)
 return TRUE;
}

BOOL Normalize(point x,point y,point z,GLfloat *n){
 GLfloat dz[3],dy[3];
 VECSUB((GLfloat)y,(GLfloat)x,dy)
 VECSUB((GLfloat)z,(GLfloat)x,dz)
 CROSS(dy,dz,n)
 if(normalise(n))return TRUE;
 return FALSE;
}

#define HIDDEN 2

BOOL inview(vertex  *vp){
 if(bSelectOnlyInView){
 if(vp->status == HIDDEN)return 0;
 if( ((vp->xyz[0] > TVpointX) && (vp->xyz[0] < TVpointX+TVsizeX))
  && ((vp->xyz[1] > TVpointY) && (vp->xyz[1] < TVpointY+TVsizeY))
  && ((vp->xyz[2] > TVpointZ) && (vp->xyz[2] < TVpointZ+TVsizeZ))
   )return TRUE;
 return FALSE;
 }
 else{
 if(vp->status == HIDDEN)return 0;
 // enlarge the size of view
 if( ((vp->xyz[0] > TVpointX-2*TVsizeX) && (vp->xyz[0] < TVpointX+3*TVsizeX))
  && ((vp->xyz[1] > TVpointY-2*TVsizeX) && (vp->xyz[1] < TVpointY+3*TVsizeY))
  && ((vp->xyz[2] > TVpointZ-2*TVsizeX) && (vp->xyz[2] < TVpointZ+3*TVsizeZ))
   )return TRUE;
  return FALSE;
  }
}

void GetMapNormal(int k, vector mP, vector mX, vector mY,
                         vector mN){
 GLfloat n[3];
 if(iMap[k].Map == CYLINDER || 
    iMap[k].Map == MAP_SPHERICAL || 
    iMap[k].Map == CYLINDER_MOZIAC){
   VECCOPY((double)iMap[k].P,mP)
   VECSUB((double)iMap[k].X,mP,mX)
   VECSUB((double)iMap[k].Y,mP,mY)
   CROSS(mY,mX,mN)
 }
 else{                                              /* arranged this way to */
   VECCOPY((double)iMap[k].Y,mP)                    /* have map with origin */
   VECSUB((double)iMap[k].X,(double)iMap[k].P,mX)   /* at bottom left       */
   VECSUB((double)iMap[k].P,mP,mY)
   CROSS(mX,mY,mN)
 }
 VECCOPY((GLfloat)mN,n)
 if(!normalise(n))MessageBeep(MB_OK);
 VECCOPY((double)n,mN)
 return;
}

 void GetMappingCoordP(int id, vector n, vector x, vector y, vector p0,
                             long *pv,
                             GLfloat *a, GLfloat *b){
 vector v1,p;
 GLfloat mu,det,ve1,ve2,ve3,vp1,vp2,vp3,p1,p2,p3;
 VECSUB(p0,(double)pv,v1)
 mu=DOT(n,v1);
 VECSCALE(mu,n,v1)
 VECSUM((double)pv,v1,p)
 ve1=x[0]; ve2=x[1]; ve3=x[2];
 vp1=y[0]; vp2=y[1]; vp3=y[2];
 p1=p[0]-p0[0];
 p2=p[1]-p0[1];
 p3=p[2]-p0[2];
 det=ve1*vp2-vp1*ve2;
 if(det > TOL || det < -TOL)  /* e-10 appears not to work */
   {  *a=( vp2*p1-vp1*p2)/det;
      *b=(-ve2*p1+ve1*p2)/det;
      goto HIT;
   }
 det=ve1*vp3-vp1*ve3;
 if(det > TOL || det < -TOL)
   {  *a=( vp3*p1-vp1*p3)/det;
      *b=(-ve3*p1+ve1*p3)/det;
      goto HIT;
   }
 det=ve2*vp3-vp2*ve3;
 if(det > TOL || det < -TOL)
   {  *a=( vp3*p2-vp2*p3)/det;
      *b=(-ve3*p2+ve2*p3)/det;
      goto HIT;
   }
 *a = *b = 0.0;
 HIT:
 return;
}

#define RTD 0.159154943

void GetMappingCoordC(int id, vector n, vector x, vector y, vector p0,
                long *pv,
                GLfloat *a, GLfloat *b){
 GLfloat theta,nn;
 GLfloat p1[3],p2[3],q[3];
 VECSUB((GLfloat)p0,(GLfloat)pv,p1)
 *b=DOT(p1,y)/DOT(y,y);
 VECSCALE(*b,y,p2)
 VECSUB(p1,p2,q)
 normalise(q);
 nn=DOT(q,(GLfloat)n);
 if     (nn >  1.0)nn =  1.0;
 else if(nn < -1.0)nn = -1.0;
 theta=acos(nn)*RTD;
 CROSS(q,n,p1)
 if(DOT(p1,y) <= 0.0){
   if(theta <= 0.25) *a = (0.25 - theta);
   else  *a = (1.25 - theta);
 }
 else    *a = (0.25 + theta);
// *a *= 360.0/(GLfloat)iMap[id].Angle; // needs to be applied after the edge fix up !!!!
 *b = *b + 1.0;
 return;
}


void GetMappingCoordS(int id, vector n, vector dx, vector dy, vector p0, long *pv,
                GLfloat *a, GLfloat * b){
  GLfloat x[3],z[3],r[3],p[3];
  VECCOPY((GLfloat)pv,p)
  VECCOPY((GLfloat)dx,x)
  normalise(x);
  VECSCALE(-1.0,(GLfloat)dy,z)
  normalise(z);
  VECSUB(p,p0,r)
  normalise(r);
  *b = -acos(DOT(r,z))*0.3183;              /*  theta/pi                    */
  *a = -atan2(DOT(r,n),DOT(r,x))*0.1592;    /*  phi/(2 pi)    0   < a < 0.5 */
  if(*a < 0.0) *a = 1.0 + *a;              /*                0.5 < a < 1.0 */
  *b = *b + 1.0; 
  return;
}

void FixUpMapEdge(GLfloat a[]){
 if(a[0] < MAPDELTA){if(a[1] >= 1.0-MAPDELTA)a[1] -= 1.0; if(a[2] >= 1.0-MAPDELTA)a[2] -= 1.0; return;}
 if(a[1] < MAPDELTA){if(a[2] >= 1.0-MAPDELTA)a[2] -= 1.0; if(a[0] >= 1.0-MAPDELTA)a[0] -= 1.0; return;}
 if(a[2] < MAPDELTA){if(a[0] >= 1.0-MAPDELTA)a[0] -= 1.0; if(a[1] >= 1.0-MAPDELTA)a[1] -= 1.0; return;}
}