gldesign2.c

Go to the documentation of this file.

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

/* file GLDESIGN2.C   */

#define _DSCRUCT_SUB 1

#include "gldesign1.h"

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

extern GLfloat up_angle,round_angle;
extern GLfloat gbRed,gbGreen,gbBlue;
extern GLfloat gwRed,gwGreen,gwBlue;
extern GLfloat near_plane,far_plane,vertex_scale;
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;
extern char gszBMPfile[],gszBMPdir[],gszRootDir[];
extern GLMAP    *glMapList;
extern long     NglMapList;
extern void TextureWithAlpha(long x, long y, unsigned char *pin, unsigned char alpha, BOOL, 
                      unsigned char,unsigned char, unsigned char);

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

extern void DrawGlNurbs(GLfloat);
extern void DrawProjectMapRectangle(void);
extern void makeCheckImageMap(int id);
extern void GetMappingCoordS(int id, vector n, vector dx, vector dy, vector p0, long *pv,
                 GLfloat * a, GLfloat * b);
extern void GetMappingCoordP(int id, vector n, vector x, vector y, vector p0,
                             long *pv,
                             GLfloat *a, GLfloat *b);
extern void GetMappingCoordC(int id, vector n, vector x, vector y, vector p0,
                long *pv,
                GLfloat *a, GLfloat *b);
extern void GetMapNormal(int k, vector mP, vector mX, vector mY,
                         vector mN);
extern BOOL normalise(GLfloat *v);
extern BOOL Normalize(point x,point y,point z,GLfloat *n);

extern BOOL inview(vertex  *vp);
extern void FixUpMapEdge(GLfloat alpha[]);

static void DrawMappedPolysProg(GLfloat scale, normal *nv);
static void GetRelativeCoord(vector n, vector x, vector y, vector pb, vector pf,
                GLfloat * a, GLfloat * b, GLfloat *c);
static void GetTextureNormal(int k, vector mP, vector mX, vector mY,
                         vector mN);
static void fix_tangents(normal t0, normal t1, normal t2, normal *tng);

static BOOL IsaNoise(int i){
//  if(i == 1 || i == 2 || i == 3 || i == 6 || i == 10 || i == 11 || i == 12)return TRUE;
  if(i == 1 || i == 2 || i == 3 || i == 6 || i == 7 || i == 10 || i == 11 || i == 12)return TRUE;
  return FALSE;
}

void Make3dDisplayListProg(void){
 GLfloat x,y,z,scale,n[3],tangent[3],color[4],vv[3],*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,*vnext;
 normal *nv; //,*nt,tng,ftng[3];
 int i,j,jn,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;
   }
//   if((nt=(normal *)X__Malloc(sizeof(normal)*Nvert)) == NULL){  // tangent vector
//     X__Free(nv);
//     return;
//   }
   for(i=0;i<Nvert;i++)for(j=0;j<3;j++)nv[i][j]=0.0; // nt[i][j]=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)){
     VECSUB((GLfloat)v1->xyz,(GLfloat)v0->xyz,tangent)
     //for(j=0;j<3;j++)VECCOPY(tangent,nt[V[j]])
     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]); 
 //  CROSS(nt[i],nv[i],tng)
 //  CROSS(nv[i],tng,nt[i])
 //  normalise(nt[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);
 
 // first draw the polygon with basic attributes only
 glEnable(GL_COLOR_MATERIAL);
 UseShaderProgram(1); 
 SetUniformInteger(1,"TwoSided",(int)TwoSided); 
 SetUniformVariable(1,"SpecularContribution",0.5);   // only mix in a little
 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; // don't draw the mapped polygons shader prog can handle this
   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(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); 
 glDisable(GL_COLOR_MATERIAL);

 DrawGlNurbs(GLU_FILL);

 if(Mapped && Nface > 0)DrawMappedPolysProg(scale,nv);

 if(nMats > 0 && Nface > 0){ // render the materials
   int pass,matID=0;
   vector mN,mX,mY,mP,mp;
   GLfloat uu,vv,ww,spower;
   GLuint progID;
   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<3;pass++) // render transparency last
   for(k=0;k<nMats;k++){
     if(pass == 0)progID=3; else progID=2;
     if(iMat[k].bInternalShader)matID=iMat[k].internalShaderID;
     // skip any 3D Textures - put them in next pass //
     if(pass == 0 && !IsaNoise(matID))continue;  // skip unless a noise texture
     if(pass != 0 &&  IsaNoise(matID))continue;  // SKIP if a noise textures
     if(pass == 1 && iMat[k].transp > 0)continue;
     if(pass == 2 && iMat[k].transp == 0)continue;
     GetTextureNormal(k,mP,mX,mY,mN);
     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);
     UseShaderProgram(progID);   
     SetUniformInteger(progID,"TwoSided",(int)TwoSided); 
     SetUniformVariable(progID,"MixRatio",(GLfloat)iMat[k].refl/255.0);
     SetUniformVariable(progID,"ShaderParameter",(GLfloat)iMat[k].params[0]/255.0); // shader parameter
     if(pass > 0 && iMat[k].refl > 0){
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_2D,g_env_texture);
       SetUniformInteger(progID,"RefMap",0); // texture unit 0
     }
     if(matID == 8 || matID == 9 ||matID == 13){ // wrinkled (not bumpy that is in Noise texture)
       glActiveTexture(GL_TEXTURE1);
       glBindTexture(GL_TEXTURE_2D,g_envB_texture);
       SetUniformInteger(progID,"NormalMap",1);
       SetUniformVector(progID,"Uvector",(GLfloat)mX[0],-(GLfloat)mX[2],(GLfloat)mX[1]);
       SetUniformVector(progID,"Vvector",(GLfloat)mY[0],-(GLfloat)mY[2],(GLfloat)mY[1]);
       SetUniformVector(progID,"Wvector",(GLfloat)mN[0],-(GLfloat)mN[2],(GLfloat)mN[1]);
     }
     if(pass == 0){ // noisy texture and bumpy
       glDisable(GL_TEXTURE_2D);  // A noise texture 
       glEnable(GL_TEXTURE_3D);
       glActiveTexture(GL_TEXTURE1);
       glBindTexture(GL_TEXTURE_3D,g_noise_texture);
       SetUniformInteger(progID,"NoiseMap",1); // texture unit (was 1)
       if(iMat[k].refl > 0){
         glActiveTexture(GL_TEXTURE0);
         glBindTexture(GL_TEXTURE_2D,g_env_texture);
         SetUniformInteger(progID,"RefMap",0); // texture unit 0
       }
     }
     SetUniformInteger(progID,"ShaderID",matID);
     spower=(20.0 + (80.0 - 10.0)*(GLfloat)(iMat[k].gloss)/255.0);
     SetUniformVariable(progID,"SpecularPower",spower);
     if(iMat[k].bShiny)SetUniformVariable(progID,"SpecularContribution",1.0);
     else              SetUniformVariable(progID,"SpecularContribution",0.0);
     SetUniformVector(progID,"MaterialC",(GLfloat)iMat[k].mcolour2[0]/255.0,
                                         (GLfloat)iMat[k].mcolour2[1]/255.0,
                                         (GLfloat)iMat[k].mcolour2[2]/255.0);
     SetUniformInteger(progID,"ShaderID",matID);
     glBegin(GL_TRIANGLES);
     fp=MainFp; if(Nface > 0)for(i=0;i<Nface;i++,fp++){ // daw the mapped polys
       // skip the mapped polys - shader progs can handle this because the mapped surfaces do not have to be blended in
       //if(fp->material != k /* || (Mapped && fp->imagemap >= 0) */ || fp->material < 0)continue; //skip
       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)){
           //fix_tangents(nt[fp->V[0]],nt[fp->V[1]],nt[fp->V[2]],ftng);
           for(j=0;j<3;j++){
             Vi=fp->V[j]; v=(MainVp+Vi);
             x=((GLfloat)(v->xyz[0]-TVpointX-TVsizeX/2))*scale;  mp[0]=(double)v->xyz[0];
             y=((GLfloat)(v->xyz[1]-TVpointY-TVsizeY/2))*scale;  mp[1]=(double)v->xyz[1];
             z=((GLfloat)(v->xyz[2]-TVpointZ-TVsizeZ/2))*scale;  mp[2]=(double)v->xyz[2];
             if(iMat[k].bSmooth){ /* smoothed */
               dot=DOT(nv[Vi],n);
               if(fabs(dot) < 0.5){
                 glNormal3f(n[0],n[2],-n[1]);
                 //SetAttributeVector(progID,"Tangent",ftng[j][0],ftng[j][2],-ftng[j][1]); 
               }
               else if(dot  < 0.0){
                 glNormal3f(-nv[Vi][0],-nv[Vi][2], nv[Vi][1]);
                 //SetAttributeVector(progID,"Tangent",ftng[j][0],-ftng[j][2],ftng[j][1]); 
               }
               else{
                 glNormal3f( nv[Vi][0], nv[Vi][2],-nv[Vi][1]);
                 //SetAttributeVector(progID,"Tangent",ftng[j][0],ftng[j][2],-ftng[j][1]); 
               }
             }
             else{/* not smoothed */
               glNormal3f( n[0], n[2],-n[1]);
               //SetAttributeVector(progID,"Tangent",ftng[j][0],ftng[j][2],-ftng[j][1]); 
             }
             GetRelativeCoord(mN,mX,mY,mP,mp, &uu, &vv, &ww);
             //SetAttributeVector(progID,"ShaderPosition",uu,ww,-vv);
             SetAttributeVector(progID,"ShaderPosition",uu,vv,ww);
             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);
     }
     if(matID == 8 ||matID == 9 ||matID == 13){
       glActiveTexture(GL_TEXTURE1);
       glBindTexture(GL_TEXTURE_2D,0);
       glActiveTexture(GL_TEXTURE0);
     }
     if(iMat[k].refl > 0){
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_2D,0);
     }
     if(pass == 0){
       glActiveTexture(GL_TEXTURE1);  
       glBindTexture(GL_TEXTURE_3D,0);
       glDisable(GL_TEXTURE_3D);
       glEnable(GL_TEXTURE_2D);
     }
   }
   glEnable(GL_COLOR_MATERIAL);
 }

 // The mapping - Shader Progs don't need it to be blended so do it at the start
 // glEnable(GL_BLEND);
 // glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 // if(Mapped && Nface > 0)DrawMappedPolysProg(scale,nv);
 // glDisable(GL_BLEND);

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

 glEndList();
 listID=1;

 X__Free(nv); // X__Free(nt);  // tangents are not used in the designer preview - give bad results
 return;
}

static void DrawMappedPolysProg(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],tangent[3],binormal[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
   UseShaderProgram(4);   
   SetUniformInteger(4,"TwoSided",(int)TwoSided); 
   GetMapNormal(k,mP,mX,mY,mN);
   VECCOPY(mX,(GLfloat)tangent)
   VECCOPY(mY,(GLfloat)binormal)
   if(glMapList != NULL && k < NglMapList){
     refmap=FALSE;
     if(iMap[k].bTiled)SetUniformInteger(4,"bTiled",1);
     else              SetUniformInteger(4,"bTiled",0);
     if(iMap[k].bShaded)SetUniformInteger(4,"bShaded",1);
     else               SetUniformInteger(4,"bShaded",0);
     if(iMap[k].bDecal)SetUniformInteger(4,"bDecal",1);
     else              SetUniformInteger(4,"bDecal",0);
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D,0);
     if(iMap[k].s == 1){    // .sp  
       SetUniformInteger(4,"bS",1);
       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].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);
       }
       SetUniformVariable(4,"MixSurface",(GLfloat)iMap[k].sp*0.01);
       SetUniformInteger(4,"SurfaceMap",0); // texture unit 0
     }
     else SetUniformInteger(4,"bS",0);

     glActiveTexture(GL_TEXTURE1);
     glBindTexture(GL_TEXTURE_2D,0);
     if(iMap[k].r == 1){
       SetUniformInteger(4,"bR",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;
       SetUniformVariable(4,"MixRef",(GLfloat)iMap[k].rp*0.01);
       SetUniformInteger(4,"RefMap",1); // texture unit 1
     }
     else SetUniformInteger(4,"bR",0);

     glActiveTexture(GL_TEXTURE2);
     glBindTexture(GL_TEXTURE_2D,0);
     if(iMap[k].b == 1){   
       SetUniformInteger(4,"bB",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].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);
       }
       SetUniformVariable(4,"MixBump",(GLfloat)iMap[k].bp*0.01);
       SetUniformInteger(4,"BumpMap",2); // texture unit 2
     }
     else SetUniformInteger(4,"bB",0);

     glActiveTexture(GL_TEXTURE3);
     glBindTexture(GL_TEXTURE_2D,0);
     if(iMap[k].t == 1){ // Transparency map  // discard any Transparent pixels
       SetUniformInteger(4,"bT",1);
       if(glMapList[k].bMovie)glBindTexture(GL_TEXTURE_2D,g_movie_texture);
       else if(glMapList[k].pixelsT != NULL){
         glBindTexture(GL_TEXTURE_2D,g_tran_texture);
         glTexImage2D(GL_TEXTURE_2D,0,3,
                          glMapList[k].xT,glMapList[k].yT,
                          0,GL_RGB,GL_UNSIGNED_BYTE,
                          (GLvoid *)glMapList[k].pixelsT);
       }
       else glBindTexture(GL_TEXTURE_2D,g_check_texture);
       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);
       }
       SetUniformInteger(4,"TransMap",3); // texture unit 3
     }
     else SetUniformInteger(4,"bT",0);

     // 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);
     if(m >= 0){
       if(iMat[k].bShiny)SetUniformVariable(4,"SpecularContribution",1.0);
       else              SetUniformVariable(4,"SpecularContribution",0.0);
     }
     else SetUniformVariable(4,"SpecularContribution",0.5);
     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(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]);
                 SetAttributeVector(4,"Tangent",tangent[0],tangent[2],-tangent[1]); 
                 SetAttributeVector(4,"Binormal",binormal[0],binormal[2],-binormal[1]); 
               }  
               else if(dot  < 0.0){
                 glNormal3f(-nv[Vi][0],-nv[Vi][2], nv[Vi][1]);
                 SetAttributeVector(4,"Tangent",tangent[0],-tangent[2],tangent[1]); 
                 SetAttributeVector(4,"Binormal",binormal[0],-binormal[2],binormal[1]); 
               }
               else{
                 glNormal3f( nv[Vi][0], nv[Vi][2],-nv[Vi][1]);
                 SetAttributeVector(4,"Tangent",tangent[0],tangent[2],-tangent[1]); 
                 SetAttributeVector(4,"Binormal",binormal[0],binormal[2],-binormal[1]); 
               }
             }
             else{/* not smoothed */
               glNormal3f( n[0], n[2],-n[1]);
               SetAttributeVector(4,"Tangent",tangent[0],tangent[2],-tangent[1]); 
               SetAttributeVector(4,"Binormal",binormal[0],binormal[2],-binormal[1]); 
             }
             if(!fp->gp && (iMap[k].Map == CYLINDER || iMap[k].Map == CYLINDER_MOZIAC))alpha[j] *= 360.0/(GLfloat)iMap[k].Angle;
             glMultiTexCoord2f(GL_TEXTURE0,alpha[j],beta[j]);  // for non reflective textures
             glVertex3f(x,z,-y);
           }
         }
       }
     }
     glEnd();
     glDisable(GL_COLOR_MATERIAL);
     m++;
     if(nMats > 0 && m >= 0 && m < nMats)goto matloop;
     glActiveTexture(GL_TEXTURE3); 
     glBindTexture(GL_TEXTURE_2D,0);
     glActiveTexture(GL_TEXTURE2); 
     glBindTexture(GL_TEXTURE_2D,0);
     glActiveTexture(GL_TEXTURE1); 
     glBindTexture(GL_TEXTURE_2D,0);
     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
   UseShaderProgram(0);   
 }   // each map
}



#define TOL 1.e-4;

static void GetRelativeCoord(vector n, vector x, vector y, vector pb, vector pf,
                GLfloat * a, GLfloat * b, GLfloat *c){
 /* n        is normal to plane of axis
    x & y    are vectors along the edges of the map  x= left y = down
    pb       is position vector to base point on map
    fp       is position vector to vertex to be mapped
    a & b    are output of mapping coordinates [0 - 1]
 */
 int k;
 vector v1,p;
 GLfloat lg;
 GLfloat mu,dm,detmax,det1,det2,det3,ve1,ve2,ve3,vp1,vp2,vp3,p1,p2,p3;
 VECSUB(pb,pf,v1)
 mu=DOT(n,v1);
 VECSCALE(mu,n,v1)
 VECSUM(pf,v1,p)
 ve1=x[0]; ve2=x[1]; ve3=x[2];
 vp1=y[0]; vp2=y[1]; vp3=y[2];
 p1=p[0]-pb[0];
 p2=p[1]-pb[1];
 p3=p[2]-pb[2];
 det1=ve1*vp2-vp1*ve2;
 det2=ve1*vp3-vp1*ve3;
 det3=ve2*vp3-vp2*ve3;
 k=0; detmax=TOL;
 if((dm=fabs(det1)) > detmax){k=1; detmax=dm;}
 if((dm=fabs(det2)) > detmax){k=2; detmax=dm;}
 if((dm=fabs(det3)) > detmax){k=3; detmax=dm;}
 if(k == 1){
   *a=( vp2*p1-vp1*p2)/det1;
   *b=(-ve2*p1+ve1*p2)/det1;
 }
 else if(k == 2){
   *a=( vp3*p1-vp1*p3)/det2;
   *b=(-ve3*p1+ve1*p3)/det2;
 }
 else if(k == 3){
   *a=( vp3*p2-vp2*p3)/det3;
   *b=(-ve3*p2+ve2*p3)/det3;
 }
 else {
   *a = *b = 0.0;
 }
 lg = max(1.0,sqrt(x[0]*x[0]+x[1]*x[1]+x[2]*x[2]));
 *c = -mu / lg;
}

static void GetTextureNormal(int k, vector mP, vector mX, vector mY,
                         vector mN){
 GLfloat n[3];
 VECCOPY((double)iMat[k].ax.P,mP)
 VECSUB((double)iMat[k].ax.X,mP,mX)
 VECSUB((double)iMat[k].ax.Y,mP,mY)
 CROSS(mX,mY,mN)
 VECCOPY((GLfloat)mN,n)
 if(!normalise(n))MessageBeep(MB_OK);
 VECCOPY((double)n,mN)
 return;
}

static void fix_tangents(normal t0, normal t1, normal t2, normal *tng){
 VECCOPY(t0,tng[0])
 if(DOT(t0,t1) > 0) VECCOPY(t1,tng[1]) else VECSCALE(-1,t1,tng[1]);
 if(DOT(t0,t2) < 0) VECCOPY(t2,tng[2]) else VECSCALE(-1,t2,tng[2]);
}

#if 0
//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);
//}
TextureWithAlphaAndBorder(long x, long y, unsigned char *pin){   // border only for testing
  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++ = 255;
    }
    p += 2*4;
  }
  glTexImage2D(GL_TEXTURE_2D,0,4,x+2,y+2,1,GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid *)pout);
  X__Free(pout);
}

static void DrawMappedPolyAlphaSurface(GLfloat scale, normal *nv){ // for debugging only
 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];

 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;
     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_COMBINE_RGB,GL_REPLACE);
     }
     glEnable(GL_COLOR_MATERIAL);
     glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
     glColor4f(1.0,1.0,1.0,1.0);
     m = -1; 
     matloop:
     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 */
       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]);
             glVertex3f(x,z,-y);
           }
         }
       }
     }
     glEnd();
     m++;
     if(nMats > 0 && m >= 0 && m < nMats)goto matloop;
     glEnable(GL_COLOR_MATERIAL);
     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
}

           tangent[0] =  mX[0];
           tangent[1] =  mX[2];
           tangent[2] = -mX[1];
           // pass the tangent vector to the shader as a vertex attribute.
           glVertexAttrib3f(1,tangent[0],tangent[1],tangent[2]);


 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]])
         }
         else if(dot < -0.5){
           VECSUB(nv[V[j]],n,nv[V[j]])
         }
       }
     }
   }
   fp++;
 }
 if(Nvert > 0)for(i=0;i<Nvert;i++)normalise(nv[i]);



#endif