gldesign1_old.c

Go to the documentation of this file.

/* --
OpenFX version 2,0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 OpenFX Development Team
-- */

/* 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 ShadersInit(char *);
extern void UseShaderProgram(long id);


#define MAPDELTA 0.3333333

extern GLfloat up_angle,round_angle,scale_view;
extern GLfloat gbRed,gbGreen,gbBlue;
extern GLfloat gwRed,gwGreen,gwBlue;
extern GLfloat near_plane,far_plane;
extern GLint listID,mode,flat,bounding_box,current_map;
extern BOOL  Mapped,Update,Fastest,Clamped,
      Cmaterial,AttenuateLight,TwoSided,
      ScrollBars,bDrawMapping,bOverlayWire,
      bThickWire,bNurbsWireOnly,
      bStereo,bStereoDraw;
extern char gszBMPfile[],gszBMPdir[],gszRootDir[];
extern GLMAP    *glMapList;
extern long     NglMapList;

extern GLuint g_check_texture;
extern GLuint g_map_texture;
extern GLuint g_movie_texture;
extern GLuint g_bump_texture;
extern GLubyte checkImage[checkImageWidth][checkImageHeight][3];

void PrepareStereo(double, double, double, double, 
                   double, double, double, double, 
                   double, double, double);
void Make3dDisplayList(void);
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);
static BOOL normalise(GLfloat *v);
static BOOL Normalize(point x,point y,point z,GLfloat *n);
static BOOL inview(vertex  *vp);
static BOOL same_color(unsigned char *color);
static void  FixUpMapEdge(GLfloat alpha[]);

static 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);
 }
 if(Fastest)glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_FASTEST);
 else       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];
 long movie_image_x,movie_image_y;
 ShadersInit(gszRootDir);
 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 / oldrect.bottom;;
 near_plane = 1.5; far_plane = 9.5;
 gluPerspective( 45.0, aspect, near_plane, far_plane);
 glMatrixMode( GL_MODELVIEW );
 glLoadIdentity();
 glClearDepth(1.0);
 glEnable(GL_DEPTH_TEST);
 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, 3, checkImageWidth,
              checkImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
              &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
 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);
 }
 glBindTexture(GL_TEXTURE_2D,0);
}

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 ();
    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 ();
     glFinish();
     hDC = wglGetCurrentDC();
    SwapBuffers(hDC);
 }
 else{
   glDrawBuffer(GL_BACK);
   // glDrawBuffer(GL_FRONT);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   if(flat)glShadeModel(GL_FLAT);
   else    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();
   glFinish();
   hDC = wglGetCurrentDC();
   SwapBuffers(hDC);
 }
 return;
}

GLvoid resize(HWND hWnd){
 RECT    rect;
 GLfloat aspect;
 GetClientRect(hWnd, &rect);
 glViewport(0, 0, rect.right, rect.bottom);
 /* don't paint here */
 oldrect.right = rect.right;
 oldrect.bottom = rect.bottom;
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 aspect = (GLfloat) oldrect.right / oldrect.bottom;
 gluPerspective( 45.0, aspect, near_plane, far_plane);
 glMatrixMode( GL_MODELVIEW );
 glLoadIdentity();
}

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=4.0/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=4.0/TVsizeX;
 ep=MainEp; if(Nedge > 0)for(i=0;i<Nedge;i++){
   v1=(MainVp+ep->V[0]);
   v2=(MainVp+ep->V[1]);
   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);
   ep++;
 }
 glEnd();
 glLineWidth(1.0);
 DrawGlNurbs(GLU_OUTLINE_PATCH);
 glPopMatrix();
}

#if 0
TextureWithAlpha(long x, long y, unsigned char *pin){  // 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++;
    *p++ = 0;
  }
  glTexImage2D(GL_TEXTURE_2D,0,3,x,y,0,GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid *)pout);
  X__Free(pout);
}
#elif 0
TextureWithAlpha(long x, long y, unsigned char *pin){   // border
  unsigned char *pout,*p;
  long i,j;
  pout=X__Malloc((x+2)*(y+2)*4); p=pout; memset(pout,255,(x+2)*(y+2)*4);
  p += (x+3)*4;
  for(i=0;i<y;i++){
    for(j=0;j<x;j++){
     *p++ = *pin++;
     *p++ = *pin++;
     *p++ = *pin++;
     *p++ = 0;
    }
    p += 2*4;
  }
  glTexImage2D(GL_TEXTURE_2D,0,3,x+2,y+2,1,GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid *)pout);
  X__Free(pout);
}
#endif

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 surface 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(fabs(dot) < 1.e-10){
           VECCOPY(n,nv[V[j]])
         }
         else if(dot >  0.5){
           VECSUM(nv[V[j]],n,nv[V[j]])
//           normalise(nv[V[j]]);
         }
         else if(dot < -0.5){
           VECSUB(nv[V[j]],n,nv[V[j]])
//           normalise(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);
 
 //UseShaderProgram(1);  ///

 color[3]=1.0; color[0]=1.0; color[1]=1.0; color[2]=1.0;
 scale=4.0/TVsizeX;
 glEnable(GL_LIGHTING);
 // first draw the polygon with basic attributes only
 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; // dont draw maps or
   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);
       //glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,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(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();
 glDisable(GL_COLOR_MATERIAL);

 //UseShaderProgram(0);  ///

 DrawGlNurbs(GLU_FILL);

 if(Mapped && Nface > 0){
   BOOL refmap;
   int brushID;
   vector mN,mX,mY,mP;
   GLfloat alpha[3],beta[3];
   GLfloat bc[4];
   //color[0]=1.0; color[1]=1.0; color[2]=1.0; color[3]=1.0;  // modulate colour - peank white
   color[0]=0.5; color[1]=0.5; color[2]=0.5; color[3]=1.0;  // modulate colour
   glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,color);
   spec_color=glos_color;
   glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,spec_color);
   glColor4f(color[0],color[1],color[2],color[3]);
   if(Nface > 0 && nImaps > 0)for(k=0;k<nImaps;k++){       // loop over all maps
     GetMapNormal(k,mP,mX,mY,mN);
     if(glMapList != NULL && k < NglMapList){

       if(glMapList[k].pixelsB != NULL){
glActiveTexture(GL_TEXTURE1); //RSFx
         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);
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);
#if 1
{static GLfloat mixColour[4]={0.0,0.0,0.0,0.0};
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]=0.5;
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);
}
#endif
glActiveTexture(GL_TEXTURE0);
       }

       refmap=FALSE;
       if(glMapList[k].bMovie)glBindTexture(GL_TEXTURE_2D,g_movie_texture);
       else if(glMapList[k].bMovieR){
         glBindTexture(GL_TEXTURE_2D,g_movie_texture);
         glEnable(GL_TEXTURE_GEN_S);
         glEnable(GL_TEXTURE_GEN_T);
         refmap=TRUE;
       }
       else if(glMapList[k].pixelsR != NULL){
         glBindTexture(GL_TEXTURE_2D,g_map_texture);
         glTexImage2D(GL_TEXTURE_2D,0,3,
                          glMapList[k].xR,glMapList[k].yR,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)glMapList[k].pixelsR);
         glEnable(GL_TEXTURE_GEN_S);
         glEnable(GL_TEXTURE_GEN_T);
         refmap=TRUE;
       }
       else if(glMapList[k].pixels != NULL){
         glBindTexture(GL_TEXTURE_2D,g_map_texture);
         glTexImage2D(GL_TEXTURE_2D,0,3,
                          glMapList[k].x,glMapList[k].y,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)glMapList[k].pixels);
       }
       else glBindTexture(GL_TEXTURE_2D,g_check_texture);
     }
     else glBindTexture(GL_TEXTURE_2D,g_check_texture);
     if(!refmap){
       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);
       } 
       if(iMap[k].bShaded) glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
       else                glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
     }
     // loop over all materials to get the border colour
     // any basic colour attributes will just appear as a grey border
     m = -1; 
     matloop:
     if(m >= 0){for(j=0;j<3;j++)bc[j]=(GLfloat)iMat[m].mcolour1[j]/255.0; bc[3]=1.0;}
     else      {bc[0]=bc[1]=bc[2]=0.5; bc[3]=1.0;}
     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR,bc);

     if(m == -1)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) || (m == -1 && fp->material >= 0))continue; /* not this material */
       brushID=fp->imagemap;
       if(brushID != k)continue;         /* skip if not this map */

       if(m == -1)glColor3ub(fp->color[0],fp->color[1],fp->color[2]);

       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(!refmap){
               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_TEXTURE1,alpha[j],beta[j]);

             }
             glVertex3f(x,z,-y);
           }
         }
       }
     }
     glEnd();

     if(m == -1)glDisable(GL_COLOR_MATERIAL);
     m++;
     if(nMats > 0 && m >= 0 && m < nMats)goto matloop;

     if(refmap){
       glDisable(GL_TEXTURE_GEN_S);
       glDisable(GL_TEXTURE_GEN_T);
     }
     else{
       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);

     if(glMapList[k].pixelsB != NULL){
glActiveTexture(GL_TEXTURE1); //RSFx
     glBindTexture(GL_TEXTURE_2D,0);
glActiveTexture(GL_TEXTURE0); //RSFx
     }


   }
 }

 if(nMats > 0 && Nface > 0){ // render the materials
   int pass;
   color[0]=1.0; color[1]=1.0; color[2]=1.0;
   for(pass=0;pass<2;pass++) // render transparency last
   for(k=0;k<nMats;k++){
     if(pass == 1 && 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);
       for(i=0;i<3;i++)color[i] *= 0.3;
       glEnable(GL_BLEND);
       glDepthMask(GL_FALSE);
       glBlendFunc(GL_SRC_ALPHA,GL_ONE);
     }
     glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,color);

//     UseShaderProgram(1);   ///////////////////////
     glBegin(GL_TRIANGLES);
     fp=MainFp; if(Nface > 0)for(i=0;i<Nface;i++,fp++){
       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();
//     UseShaderProgram(0);   ///////////////////////

     // any material attributes that need to be undone ?
     if(iMat[k].transp > 0){ // Set transparent blending
       glDepthMask(GL_TRUE);
       glDisable(GL_BLEND);
     }
   }
 }

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

 glEndList();
 listID=1;

 X__Free(nv);
 return;
}

static 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;
 scale=4.0/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

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

static 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

static BOOL inview(vertex  *vp){
 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;
}

static BOOL same_color(unsigned char *color){
 static unsigned char lastcolor[3]={0,0,0};
 if(labs((long)(color[0]) - (long)(lastcolor[0])) > 2 ||
    labs((long)(color[1]) - (long)(lastcolor[1])) > 2 ||
    labs((long)(color[2]) - (long)(lastcolor[2])) > 2){
   VECCOPY(color,lastcolor)
   return FALSE;
 }
 return TRUE;
}

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

static 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

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

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


//glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,mc);
//         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
//         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
//         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
//{
//static float CC[4]={0.0,1.0,0.0,0.4};
//glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
//glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,CC);
//glTexEnvf(GL_TEXTURE_ENV,GL_SRC2_RGB,GL_CONSTANT);
//glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND2_RGB,GL_SRC_ALPHA);
//}