gldesign2_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 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,scale_view;
extern GLfloat gbRed,gbGreen,gbBlue;
extern GLfloat gwRed,gwGreen,gwBlue;
extern GLfloat near_plane,far_plane;
extern GLint listID,mode,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 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);


void Make3dDisplayListProg(void){
 GLfloat x,y,z,dxn,dyn,dzn,scale,n[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;
 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]])
         }
         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]);

 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=4.0/TVsizeX;
 glEnable(GL_LIGHTING);
 
 // first draw the polygon with basic attributes only
 glEnable(GL_COLOR_MATERIAL);
 UseShaderProgram(1); 
 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; // 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(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(nMats > 0 && Nface > 0){ // render the materials
   int pass,matID=0;
   vector mN,mX,mY,mP,mp;
   GLfloat uu,vv,ww,spower;  
   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;
     matID=0;
     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(2);   
     SetUniformVariable(2,"MixRatio",(GLfloat)iMat[k].refl/255.0);
     if(iMat[k].refl > 0){
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_2D,g_env_texture);
       SetUniformInteger(2,"RefMap",0); // texture unit 0
     }
     if(matID == 2){
       //glDisable(GL_TEXTURE_2D);
       //glEnable(GL_TEXTURE_3D);
       //glBindTexture(GL_TEXTURE_3D,g_noise_texture);
       //SetUniformInteger(2,"Noise",0); // texture unit 0  (was 1)
       glActiveTexture(GL_TEXTURE1);
       glBindTexture(GL_TEXTURE_2D,g_envB_texture);
       SetUniformInteger(2,"NormalMap",1);
     }
     spower=(20.0 + (80.0 - 10.0)*(GLfloat)(iMat[k].gloss)/255.0);
     SetUniformVariable(2,"SpecularPower",spower);
     if(iMat[k].bShiny)SetUniformVariable(2,"SpecularContribution",1.0);
     else              SetUniformVariable(2,"SpecularContribution",0.0);
     SetUniformVector(2,"MaterialC",(GLfloat)iMat[k].mcolour2[0]/255.0,
                                    (GLfloat)iMat[k].mcolour2[1]/255.0,
                                    (GLfloat)iMat[k].mcolour2[2]/255.0);
     SetUniformInteger(2,"ShaderID",matID);
     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;  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(j == 0){
               v=(MainVp+(fp->V[1]));
               dxn=((GLfloat)(v->xyz[0]-TVpointX-TVsizeX/2))*scale - x; 
               dyn=((GLfloat)(v->xyz[1]-TVpointY-TVsizeY/2))*scale - y;
               dzn=((GLfloat)(v->xyz[2]-TVpointZ-TVsizeZ/2))*scale - z;
             }   
             if(iMat[k].bSmooth){ /* smoothed */
               dot=DOT(nv[Vi],n);
               if(fabs(dot) < 0.5){
                 glNormal3f(n[0],n[2],-n[1]);
                 SetAttributeVector(2,"Tangent",dxn,dzn,-dyn); 
               }
               else if(dot  < 0.0){
                 glNormal3f(-nv[Vi][0],-nv[Vi][2], nv[Vi][1]);
                 SetAttributeVector(2,"Tangent",dxn,-dzn,dyn); 
               }
               else{
                 glNormal3f( nv[Vi][0], nv[Vi][2],-nv[Vi][1]);
                 SetAttributeVector(2,"Tangent",dxn,dzn,-dyn); 
               }
             }
             else{/* not smoothed */
               glNormal3f( n[0], n[2],-n[1]);
               SetAttributeVector(2,"Tangent",dxn,dzn,-dyn); 
             }
             GetRelativeCoord(mN,mX,mY,mP,mp, &uu, &vv, &ww);
             SetAttributeVector(2,"ShaderPosition",uu,ww,-vv);
             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 == 2){
       glActiveTexture(GL_TEXTURE1);
       glBindTexture(GL_TEXTURE_3D,0);
       glActiveTexture(GL_TEXTURE0);
//glDisable(GL_TEXTURE_3D);
//glEnable(GL_TEXTURE_2D);
     }
     if(iMat[k].refl > 0){
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_2D,0);
     }
   }
   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)DrawMappedPolysProg(scale,nv);
 glDisable(GL_BLEND);

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

 glEndList();
 listID=1;

 X__Free(nv);
 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];
 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;
         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
}



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

#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]);




#endif