rendergl1.c

Go to the documentation of this file.

// File rendergl1.c

#define MODULE_RENDERGL1

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

// These are still under investigation 
//#define  NEAR_CLIP_PLANE    1.0 // minimum possible - may not give good scale
#define  NEAR_CLIP_PLANE    1.0  // best working hypothesis so far
//#define  NEAR_CLIP_PLANE    75.0 // seems good on a distance scale but may be too far aways
#define  FAR_CLIP_PLANE   500.0  // Scale so that ALL objects inside this distance
//#define  GROUND_RECTS        40  
#define  GROUND_RECTS       120  

//#define  ANGL_FOV 46.0  // Original settings - too wide
#define  ANGL_FOV 35.3    // should give the same Ar as software renderr

extern double DepthScalingGL,FrontDepthGL,BackDepthGL;
extern char gszHomeDir[];
extern GLint DlistID;
extern int TEXTUREBUFFER_WIDTH;
extern int TEXTUREBUFFER_HEIGHT;
extern GLuint g_check_texture;
extern GLuint g_map_texture;
extern GLuint g_ref_texture;  
extern GLuint g_bump_texture;
extern GLuint g_tran_texture;
extern GLuint g_movie_texture;
extern GLuint g_env_texture;
extern GLuint g_envB_texture;
extern GLuint g_envN_texture;
extern GLuint g_noise_texture;
extern GLuint g_env3D_texture;
extern GLuint g_sky_texture;

double GlobalScale;

static void Draw3dScene(GLfloat);
static void Draw3dObjects(int pass, BOOL clip);
static void DrawPlain3dObjects(void);
static void DrawSky(GLfloat);
static void DrawGround(BOOL,GLfloat);
static void DrawGroundShadow(void);
static void DrawGroundReflection(GLfloat);
static void PositionLights(void);
static void CancelLights(void);
static BOOL IsaNoise(int i);
static void DrawMaterialPolys(BOOL, BOOL,long, matl *, long, face *, long, vertex *);
static void DrawMappedPolys(BOOL,BOOL,long, matl*, long, imap *, long, face *, long, vertex *);
static void TextureWithAlpha(long x, long y, unsigned char *R, unsigned char *G, unsigned char *B, 
                      unsigned char alpha, BOOL bDecal,
                      unsigned char r, unsigned char g, unsigned char b);
static void Texture(long x, long y, unsigned char *R, unsigned char *G, unsigned char *B);
static void InstallShadowMatrix(GLfloat [4], GLfloat [4]);
static void InstallReflectionMatrix(GLfloat p0[3], GLfloat n[3]);


typedef struct{
        GLfloat x, y;
} jitter_point;

static jitter_point jj2[] = {
{0.25, 0.75}, {0.75, 0.25}
}; 
static jitter_point jj3[] = {
{0.5033922635, 0.8317967229}, {0.7806016275, 0.2504380877},
{0.2261828938, 0.4131553612}
};
static jitter_point jj4[] = {
{0.375, 0.25}, {0.125, 0.75}, {0.875, 0.25}, {0.625, 0.75}
};
static jitter_point jj5[] = {
{0.5, 0.5}, {0.3, 0.1}, {0.7, 0.9}, {0.9, 0.3}, {0.1, 0.7}
};
static jitter_point jj6[] = {
{0.4646464646, 0.4646464646}, {0.1313131313, 0.7979797979},
{0.5353535353, 0.8686868686}, {0.8686868686, 0.5353535353},
{0.7979797979, 0.1313131313}, {0.2020202020, 0.2020202020}
};
static jitter_point jj8[] = {
{0.5625, 0.4375}, {0.0625, 0.9375}, {0.3125, 0.6875}, {0.6875, 0.8125},
{0.8125, 0.1875}, {0.9375, 0.5625}, {0.4375, 0.0625}, {0.1875, 0.3125}
};
static jitter_point jj9[] = {
{0.5, 0.5}, {0.1666666666, 0.9444444444}, {0.5, 0.1666666666},
{0.5, 0.8333333333}, {0.1666666666, 0.2777777777},
{0.8333333333, 0.3888888888}, {0.1666666666, 0.6111111111},
{0.8333333333, 0.7222222222}, {0.8333333333, 0.0555555555}
};
static jitter_point jj12[] = {
{0.4166666666, 0.625}, {0.9166666666, 0.875}, {0.25, 0.375},
{0.4166666666, 0.125}, {0.75, 0.125}, {0.0833333333, 0.125}, {0.75, 0.625},
{0.25, 0.875}, {0.5833333333, 0.375}, {0.9166666666, 0.375},
{0.0833333333, 0.625}, {0.583333333, 0.875}
};
static jitter_point jj16[] = {
{0.375, 0.4375}, {0.625, 0.0625}, {0.875, 0.1875}, {0.125, 0.0625},
{0.375, 0.6875}, {0.875, 0.4375}, {0.625, 0.5625}, {0.375, 0.9375},
{0.625, 0.3125}, {0.125, 0.5625}, {0.125, 0.8125}, {0.375, 0.1875},
{0.875, 0.9375}, {0.875, 0.6875}, {0.125, 0.3125}, {0.625, 0.8125}
};
static jitter_point *jjp[]={0,0,jj2,jj3,jj4,jj5,jj6,0,jj8,jj9,0,0,jj12,0,0,0,jj16};


void RenderCameraView(BOOL renderbuffer,BOOL bAntiAliased,int jitter, int aa, GLfloat asp){ // render into the current colour buffer
 double dx,dy,dz,maxd;                                                       // with AA if required and using a
 dx=(double)(ClipXmax-ClipXmin); // this scaling still needs work            //  Display List when AA 
 dy=(double)(ClipYmax-ClipYmin);
 dz=(double)(ClipZmax-ClipZmin);
 maxd=max(dy,dz);
 maxd=max(dx,maxd);
 GlobalScale=(FAR_CLIP_PLANE)/maxd;
 DepthScalingGL=GlobalScale;
 FrontDepthGL=NEAR_CLIP_PLANE;
 if(R_Nground == 0)BackDepthGL=FAR_CLIP_PLANE*2.0;
 else              BackDepthGL=FAR_CLIP_PLANE*5.0;
 //if(debug != NULL && jitter == 0)fprintf(debug,"GLrender: GlobalScale=%lf maxd=%lf FCP=%lf RCP=%lf\n",GlobalScale,maxd,FrontDepthGL,BackDepthGL);
 if(bAntiAliased && jitter == 0){ 
   //if(debug != NULL)fprintf(debug,"Building Display list TXBUFFER SIZE [%ld %ld]\n",TEXTUREBUFFER_WIDTH,TEXTUREBUFFER_HEIGHT);
   glNewList(1,GL_COMPILE);
   Draw3dScene(asp);
   glEndList();
   DlistID=1;
 } 
 glMatrixMode( GL_PROJECTION );
 glLoadIdentity();
 if(bAntiAliased){
   accPerspective(ANGL_FOV/CamSx,asp,FrontDepthGL,BackDepthGL,
                    jjp[aa][jitter].x-0.5,jjp[aa][jitter].y-0.5,0.0,0.0,1.0);
   //if(debug != NULL)fprintf(debug,"Rendering AA sample %ld of %ld at (%lf,%lf)\n",jitter,aa,jjp[aa][jitter].x-0.5,jjp[aa][jitter].y-0.5);
 }
 else{
   gluPerspective(ANGL_FOV/CamSx,asp,FrontDepthGL,BackDepthGL);
 }
 glViewport( 0, 0, TEXTUREBUFFER_WIDTH, TEXTUREBUFFER_HEIGHT );
 glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 glMatrixMode( GL_MODELVIEW );
 glLoadIdentity();
 if(DlistID > 0){
   //if(debug != NULL)fprintf(debug,"Running Display List\n");
   glCallList(DlistID);
 }
 else Draw3dScene(asp);
}

static void Draw3dScene(GLfloat asp){
 GLdouble GroundClip[4];
 GLfloat color[4]={0.0,0.0,0.0,0.5};
 //if(debug != NULL)fprintf(debug,"Drawing Scene\n");
 if(Nsky > 0)DrawSky(asp);
 if(R_Nground > 0){ // render the ground and its shadows and reflection
   glEnable(GL_STENCIL_TEST);
   glClear(GL_STENCIL_BUFFER_BIT);
   glStencilFunc(GL_ALWAYS,1,0xFFFFFFFF);
   glStencilOp(GL_REPLACE,GL_REPLACE,GL_REPLACE);
   glDepthMask(GL_FALSE);
   glColor4ub(0,0,0,0);
   DrawGround(FALSE,1.0);
   glDepthMask(GL_TRUE);
   //Ground.refl=0.50;  // 50 %
   if(Ground.refl > 0.01){  // Render the Ground reflection
     glStencilFunc(GL_NOTEQUAL,0,0xFFFFFFFF);
     glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
     DrawGroundReflection(asp);
     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
     glEnable(GL_BLEND);   // darken the reflection 
     glColor4ub(0,0,0,(unsigned char)((1.0-Ground.refl)*255.0)); 
     DrawGround(FALSE,1.0);
   }
   PositionLights();
   glDepthMask(GL_FALSE);
   glEnable(GL_LIGHTING);
   DrawGround(TRUE,1.0-Ground.refl);  // draw the ground in with the appropriate degree of blending if relective
   glFlush();
   glDisable(GL_LIGHTING);
   CancelLights();
   glDepthMask(GL_TRUE);
   if(Ground.refl > 0.01)glDisable(GL_BLEND);
   glStencilFunc(GL_EQUAL,1,0xFFFFFFFF);
   glStencilOp(GL_KEEP,GL_KEEP,GL_INCR);
   if(Nlights > 0 && Lights > 0)DrawGroundShadow();
   glDisable(GL_STENCIL_TEST);
   GroundClip[0]=-Ground.n[0]; GroundClip[1]=-Ground.n[2]; GroundClip[2]=Ground.n[1]; // clip everything below the ground
   GroundClip[3]=DOT(Ground.n,Ground.p)*GlobalScale; 
   // NOTE ATI/NVIDIA differences - this may requre us to build in our own clipping mechanism
   // GLSL in ATI automatically puts in the clipping planes nVidia does not. On nVidia gl_ClipVertex needs
   // to be set on VS but on ATI this causes a problem with the colour of ftagments. To allow our shaders to run on
   // both hardware we use our own clipping mechanism in the fragment shaders. Thus if the ground plane is in use
   // we clip using access to the clipping planes. so the enable below is redundant, but we cannot include it as it
   // seems to upset the reflection with it is clipped (ODD).
   //glEnable(GL_CLIP_PLANE0);  // done in ftag shader
   glClipPlane(GL_CLIP_PLANE0,GroundClip);
 }
 PositionLights();
 glEnable(GL_LIGHTING);
 Draw3dObjects(1,(R_Nground > 0 ? TRUE: FALSE));
 glDisable(GL_LIGHTING);
 CancelLights();
 if(Nparticles > 0)RenderParticlesGL((R_Nground > 0 ? TRUE: FALSE)); // particles will be AA
 //if(R_Nground > 0)glDisable(GL_CLIP_PLANE0); // done in frag shader
 glFlush();
}

static void DrawGround(BOOL bDrawAll, GLfloat NonRefFract){
 int i,j,progID=6;
 GLfloat x,y,z,tangent[3];
 if(bDrawAll){
   glNormal3f(-Ground.n[0],-Ground.n[2],Ground.n[1]);
   UseShaderProgram(progID); 
   if(Ground.shiny)SetUniformVariable(1,"SpecularContribution",1.0);  
   else            SetUniformVariable(1,"SpecularContribution",0.0);
   SetUniformVariable(progID,"GroundHeight",Ground.height);  // effect scaling value default 1.0 but could be more or less
   VECCOPY(GlobalScale*Ground.dx,tangent)
   SetUniformVector(progID,"Tangent",tangent[0],-tangent[2],tangent[1]);
   SetUniformVariable(progID,"NonRefFract",NonRefFract);
   if(Ground.mapped && Ground.map.bLoadedS && Ground.map.p24R != NULL){
     if(Ground.maptype == TILE)SetUniformInteger(4,"bTiled",1);
     else                      SetUniformInteger(4,"bTiled",0);
     SetUniformInteger(progID,"bShaded",1);
     //SetUniformInteger(progID,"bDecal",0); // NOT on Ground
     glActiveTexture(GL_TEXTURE0);  // Surface Map
     glBindTexture(GL_TEXTURE_2D,g_map_texture);
     Texture(Ground.map.xmax,Ground.map.ymax,Ground.map.p24R,Ground.map.p24G,Ground.map.p24B);
     if(Ground.map.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(progID,"SurfaceMap",0);
     SetUniformInteger(progID,"bS",100);
   }
   else if(Ground.type == TEXTU){ // textured 
     SetUniformVector(progID,"MaterialC",(GLfloat)Ground.acolor[0]/255.0,
                                         (GLfloat)Ground.acolor[1]/255.0,
                                         (GLfloat)Ground.acolor[2]/255.0);
     SetUniformInteger(progID,"bS",(int)Ground.texture);
     if(Ground.texture < 4 || Ground.texture == 10){ // need bump map
       glActiveTexture(GL_TEXTURE0); 
       glBindTexture(GL_TEXTURE_2D,g_envB_texture);
       SetUniformInteger(progID,"NormalMap",0);
     }
   }
   else SetUniformInteger(progID,"bS",0);

   glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);
   glColor4ub(Ground.color[0],Ground.color[1],Ground.color[2],255);
 }
 glBegin(GL_QUADS);
 for(i=-GROUND_RECTS/2;i<GROUND_RECTS/2+1;i++)
 for(j=-GROUND_RECTS/2;j<GROUND_RECTS/2+1;j++){
   x=(GLfloat)(Ground.p[0] + i*Ground.dx[0] + j*Ground.dy[0])*GlobalScale;
   y=(GLfloat)(Ground.p[1] + i*Ground.dx[1] + j*Ground.dy[1])*GlobalScale;
   z=(GLfloat)(Ground.p[2] + i*Ground.dx[2] + j*Ground.dy[2])*GlobalScale;
   glTexCoord2f((GLfloat)i,(GLfloat)j);
   glVertex3f(x,z,-y);
   x=x+(GLfloat)Ground.dx[0]*GlobalScale;
   y=y+(GLfloat)Ground.dx[1]*GlobalScale;
   z=z+(GLfloat)Ground.dx[2]*GlobalScale;
   glTexCoord2f((GLfloat)i+1.0,(GLfloat)j);
   glVertex3f(x,z,-y);
   x=x+(GLfloat)Ground.dy[0]*GlobalScale;
   y=y+(GLfloat)Ground.dy[1]*GlobalScale;
   z=z+(GLfloat)Ground.dy[2]*GlobalScale;
   glTexCoord2f((GLfloat)i+1.0,(GLfloat)j+1.0);
   glVertex3f(x,z,-y);
   x=x-(GLfloat)Ground.dx[0]*GlobalScale;
   y=y-(GLfloat)Ground.dx[1]*GlobalScale;
   z=z-(GLfloat)Ground.dx[2]*GlobalScale;
   glTexCoord2f((GLfloat)i,(GLfloat)j+1.0);
   glVertex3f(x,z,-y);
 }
 glEnd();
 if(bDrawAll){
   if(Ground.mapped && Ground.map.bLoadedS && Ground.map.p24R != NULL){
     glBindTexture(GL_TEXTURE_2D,0);  
   }
   else if(Ground.type == TEXTU){ 
     if(Ground.texture < 4 || Ground.texture == 10){ 
       glBindTexture(GL_TEXTURE_2D,0);  
     }
   }
   glDisable(GL_COLOR_MATERIAL); 
   UseShaderProgram(0); 
 }
}

static void DrawGroundReflection(GLfloat asp){
 GLdouble GroundClip[4];
 GLfloat n[3],p[3];
 n[0] = -Ground.n[0]; n[1] = -Ground.n[2]; n[2] = Ground.n[1];
 p[0] = Ground.p[0]*GlobalScale; p[1] = Ground.p[2]*GlobalScale; p[2] = -Ground.p[1]*GlobalScale; 
 GroundClip[0]=-n[0]; GroundClip[1]=-n[1]; GroundClip[2]=-n[2]; // clip away everything above ground
 GroundClip[3]=-DOT(Ground.n,Ground.p)*GlobalScale; 
// glEnable(GL_CLIP_PLANE0); // Done in Shader
 glClipPlane(GL_CLIP_PLANE0,GroundClip);
 glPushMatrix();
 InstallReflectionMatrix(p,n);
 if(Nsky > 0)DrawSky(asp);  
 PositionLights();
 glEnable(GL_LIGHTING);
 Draw3dObjects(1,TRUE); 
 glDisable(GL_LIGHTING);
 glPopMatrix();
// glDisable(GL_CLIP_PLANE0); // Done in Frag Shader
}

static void DrawGroundShadow(void){  // Only the first light
 int i;
 GLfloat n[4]; // plane equation
 GLfloat p[4]; // position of light
 p[0] =  Lights[0].p[0]*GlobalScale; 
 p[1] =  Lights[0].p[2]*GlobalScale; 
 p[2] = -Lights[0].p[1]*GlobalScale; 
// glLightfv(GL_LIGHT0,GL_POSITION,p);
 p[3] = 1.0; // position of light //  p[3]=0.0; // for directional light source
 n[0] = -Ground.n[0]; n[1] = -Ground.n[2]; n[2] = Ground.n[1];  // so that it points UP from ground
 n[3]=  DOT(Ground.n,Ground.p)*GlobalScale; // +ve sign because ground normal has been reversed
 glDisable(GL_DEPTH_TEST);
 glDepthMask(GL_FALSE); 
 glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 glEnable(GL_BLEND);
 glPushMatrix();
 InstallShadowMatrix(n,p);
 glColor4ub(0,0,0,64);  // fraction of shadow
 DrawPlain3dObjects();
 glPopMatrix();
 glDisable(GL_BLEND);
 glDepthMask(GL_TRUE);  
 glEnable(GL_DEPTH_TEST); 
}

static void PositionLights(void){  // Only 1 light at present
 int i,j;
 GLfloat d[]={1.0,1.0,1.0,1.0};
 GLfloat a[]={0.1,0.1,0.1,1.0};
 GLfloat s[]={1.0,1.0,1.0,1.0};
 GLenum lightID[8]={GL_LIGHT0,GL_LIGHT1,GL_LIGHT2,GL_LIGHT3,GL_LIGHT4,GL_LIGHT5,GL_LIGHT6,GL_LIGHT7};
 GLfloat p[4]; p[3] = 1.0; // position of light
 if(Nlights > 0 && Lights != NULL){
   for(i=0;i<min(Nlights,8);i++){
     glEnable(lightID[i]);
     for(j=0;j<3;j++)d[j]=((GLfloat)Lights[i].color[j])/255.0;
     glLightfv(lightID[i],GL_DIFFUSE,d);
     glLightfv(lightID[i],GL_AMBIENT,a);
     glLightfv(lightID[i],GL_SPECULAR,s);
     // set up any attenuation
     //glLightf(GL_LIGHT0,GL_LINEAR_ATTENUATION,0.15);
     //glLightf(GL_LIGHT0,GL_QUADRATIC_ATTENUATION,0.05);
     p[0] =  Lights[i].p[0]*GlobalScale; 
     p[1] =  Lights[i].p[2]*GlobalScale; 
     p[2] = -Lights[i].p[1]*GlobalScale; 
     glLightfv(lightID[i],GL_POSITION,p);
     if(Lights[i].type == SPOTLIGHT){
        GLfloat dirl[3];
        dirl[0] = -Lights[i].d[0], // our light structure, i.e. Light's "d" points in opposite direction.
        dirl[1] = -Lights[i].d[2], 
        dirl[2] =  Lights[i].d[1];
        glLightfv(lightID[i],GL_SPOT_DIRECTION,dirl);
        glLightf(lightID[i],GL_SPOT_CUTOFF,Lights[i].cone2*180.0/PI);
        glLightf(lightID[i],GL_SPOT_EXPONENT,1.0);
     }
   }
 }
 else{
   glEnable(GL_LIGHT0);
   glLightfv(GL_LIGHT0,GL_DIFFUSE,d);
   glLightfv(GL_LIGHT0,GL_AMBIENT,a);
   glLightfv(GL_LIGHT0,GL_SPECULAR,s);
 }
}

static void CancelLights(void){
 int i;
 GLenum lightID[8]={GL_LIGHT0,GL_LIGHT1,GL_LIGHT2,GL_LIGHT3,GL_LIGHT4,GL_LIGHT5,GL_LIGHT6,GL_LIGHT7};
 if(Nlights > 0 && Lights != NULL){
   for(i=0;i<min(Nlights,8);i++)glDisable(lightID[i]);
 }
 else glDisable(GL_LIGHT0);
}

static void DrawSky(GLfloat asp){
 int x,y,i,j;
 unsigned char *Image,*px,*r,*g,*b;
 Image=NULL;
 glDepthMask(GL_FALSE);
 glPushMatrix();
 glMatrixMode(GL_PROJECTION);
 glPushMatrix();
 glLoadIdentity();
 if(Sky.type == SKYMAPPED ||Sky.type == SKYCUBE)
       gluPerspective(ANGL_FOV/CamSx,asp,0.1,5);
 else  glOrtho(-1.0,1.0,-1.0,1.0,0.0,2.0);
 glMatrixMode( GL_MODELVIEW );
 glLoadIdentity();
 glRasterPos2i(-1.0,-1.0);
 if(Sky.type == SKYMAPPED || Sky.type == BACKDROP ||Sky.type == SKYCUBE){
   if(Sky.mapped && Sky.map.bLoadedS){
     x =Sky.map.xmax; y=Sky.map.ymax;
     if((Image=(unsigned char *)X__Malloc(x*y*3+3)) != NULL){
       for(j=0;j<y;j++){ 
         px=(Image+(y-j-1)*x*3);
         r=(Sky.map.p24R + j*x); g=(Sky.map.p24G + j*x); b=(Sky.map.p24B + j*x);
         for(i=0;i<x;i++){
           *px++ = *r++; *px++ = *g++; *px++ = *b++;
         } 
       }
     }
   }
 }
 if(Sky.type == SKYCOLOUR){
   glClearColor((GLfloat)Sky.Zenith[0]/255.0,(GLfloat)Sky.Zenith[1]/255.0,(GLfloat)Sky.Zenith[2]/255.0,1.0);
   glClear(GL_COLOR_BUFFER_BIT);
 }
 else if(Sky.type == SKYGRADED){
   GLfloat horizon[3],zenith[3];
   for(i=0;i<3;i++){zenith[i]=(GLfloat)Sky.Zenith[i]/255.0; horizon[i]=(GLfloat)Sky.Horizon[i]/255.0;}
   glBegin(GL_QUADS);
   glColor3fv(zenith);  glVertex3f(-1.0,-1.0,-1.0);
   glColor3fv(zenith);  glVertex3f( 1.0,-1.0,-1.0);
   glColor3fv(horizon); glVertex3f( 1.0, 0.0,-1.0);
   glColor3fv(horizon); glVertex3f(-1.0, 0.0,-1.0);
   glColor3fv(horizon); glVertex3f(-1.0, 0.0,-1.0);
   glColor3fv(horizon); glVertex3f( 1.0, 0.0,-1.0);
   glColor3fv(zenith);  glVertex3f( 1.0, 1.0,-1.0);
   glColor3fv(zenith);  glVertex3f(-1.0, 1.0,-1.0);
   glEnd();
 }
 else if(Sky.type == SKYMAPPED){
   if(Image != NULL){
     glActiveTexture(GL_TEXTURE0); 
     glBindTexture(GL_TEXTURE_2D,g_sky_texture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_MIRRORED_REPEAT);
     glTexImage2D(GL_TEXTURE_2D,0,3,x,y,0,GL_RGB,GL_UNSIGNED_BYTE,(GLvoid *)Image);
     glColor4ub(255,255,255,255);
     UseShaderProgram(7); 
     SetUniformInteger(7,"SkyMap",0); // tex unit 0
     {
     GLUquadricObj *Q;
     glRotatef(-CamTheta*180.0/PI,0.0,0.0,1.0); // Bank on axis
     glRotatef(-CamAlpha*180.0/PI,1.0,0.0,0.0); // 
     glRotatef(-CamPhi*180.0/PI,0.0,1.0,0.0);   // vertical axis - heading
     glRotatef(-90.0,1.0,0.0,0.0);
     Q=gluNewQuadric();
     gluQuadricTexture(Q,GL_TRUE);
     gluSphere(Q,5.0,20,20);
     gluDeleteQuadric(Q);
     }
     UseShaderProgram(0); 
     glBindTexture(GL_TEXTURE_2D,0);
   }
 }
 else if(Sky.type == BACKDROP){
   if(Image != NULL){
     glPixelZoom((GLfloat)TEXTUREBUFFER_WIDTH/(GLfloat)x,
                 (GLfloat)TEXTUREBUFFER_HEIGHT/(GLfloat)y);
     glDrawPixels((GLsizei)x,(GLsizei)y,GL_RGB,GL_UNSIGNED_BYTE,(GLvoid *)Image);
   }
 }
 else if(Sky.type == SKYCUBE){
   if(Image != NULL){
     GLfloat six=1.0/6.0,xss,xff;
     glActiveTexture(GL_TEXTURE0); 
     glBindTexture(GL_TEXTURE_2D,g_sky_texture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_MIRRORED_REPEAT);
     glTexImage2D(GL_TEXTURE_2D,0,3,x,y,0,GL_RGB,GL_UNSIGNED_BYTE,(GLvoid *)Image);
     glColor4ub(255,255,255,255);
     glRotatef(-CamTheta*180.0/PI,0.0,0.0,1.0); // Bank on axis
     glRotatef(-CamAlpha*180.0/PI,1.0,0.0,0.0); // 
     glRotatef(-CamPhi*180.0/PI,0.0,1.0,0.0);   // vertical axis - heading
     glBegin(GL_QUADS);
     xss=0.0; xff=xss+six;
     glTexCoord2f(xss,0.0); glVertex3f(-1.0,-1.0,-1.0);  // front 
     glTexCoord2f(xff,0.0); glVertex3f( 1.0,-1.0,-1.0);
     glTexCoord2f(xff,1.0); glVertex3f( 1.0, 1.0,-1.0);
     glTexCoord2f(xss,1.0); glVertex3f(-1.0, 1.0,-1.0);
     xss=xss+six, xff=xff+six;
     glTexCoord2f(xss,0.0); glVertex3f( 1.0,-1.0,-1.0); // right
     glTexCoord2f(xff,0.0); glVertex3f( 1.0,-1.0, 1.0);
     glTexCoord2f(xff,1.0); glVertex3f( 1.0, 1.0, 1.0);
     glTexCoord2f(xss,1.0); glVertex3f( 1.0, 1.0,-1.0);
     xss=xss+six, xff=xff+six;
     glTexCoord2f(xss,0.0); glVertex3f( 1.0,-1.0, 1.0);  // back
     glTexCoord2f(xff,0.0); glVertex3f(-1.0,-1.0, 1.0);
     glTexCoord2f(xff,1.0); glVertex3f(-1.0, 1.0, 1.0);
     glTexCoord2f(xss,1.0); glVertex3f( 1.0, 1.0, 1.0);
     xss=xss+six, xff=xff+six;
     glTexCoord2f(xss,0.0); glVertex3f(-1.0,-1.0, 1.0);  //left
     glTexCoord2f(xff,0.0); glVertex3f(-1.0,-1.0,-1.0);
     glTexCoord2f(xff,1.0); glVertex3f(-1.0, 1.0,-1.0);
     glTexCoord2f(xss,1.0); glVertex3f(-1.0, 1.0, 1.0);
     xss=xss+six, xff=xff+six;
     glTexCoord2f(xss,0.0); glVertex3f(-1.0, 1.0,-1.0);  // top
     glTexCoord2f(xff,0.0); glVertex3f( 1.0, 1.0,-1.0);
     glTexCoord2f(xff,1.0); glVertex3f( 1.0, 1.0, 1.0);
     glTexCoord2f(xss,1.0); glVertex3f(-1.0, 1.0, 1.0);
     xss=xss+six, xff=xff+six;
     glTexCoord2f(xss,0.0); glVertex3f(-1.0,-1.0, 1.0);  // bottom
     glTexCoord2f(xff,0.0); glVertex3f( 1.0,-1.0, 1.0);
     glTexCoord2f(xff,1.0); glVertex3f( 1.0,-1.0,-1.0);
     glTexCoord2f(xss,1.0); glVertex3f(-1.0,-1.0,-1.0);
     glEnd();
     glBindTexture(GL_TEXTURE_2D,0);
   }
 }
 glMatrixMode(GL_PROJECTION);
 glPopMatrix();
 glMatrixMode( GL_MODELVIEW);
 glPopMatrix();
 glDepthMask(GL_TRUE);
 if(Image != NULL)X__Free(Image);
}

static void DrawPlain3dObjects(void){  // used for rendering shadows
 GLfloat x,y,z;
 long i,j,k;
 long Nvert,Nface,nImaps,nMats;
 vertex *vp,*MainVp; 
 face   *fp,*MainFp;
 for(k=0;k<ObjectCount;k++){
   if(!Object[k].in_use)continue;
   MainVp=Object[k].Vbase;
   MainFp=Object[k].Fbase;
   Nvert=Object[k].NoVertices;
   Nface=Object[k].NoFaces;
   if(Nface > 0){
     glBegin(GL_TRIANGLES);
     for(fp=MainFp,i=0;i<Nface;i++,fp++){
       for(j=0;j<3;j++){
         vp=(MainVp+(fp->V[j]));
         x=((GLfloat)(vp->p[0]))*GlobalScale;
         y=((GLfloat)(vp->p[1]))*GlobalScale;
         z=((GLfloat)(vp->p[2]))*GlobalScale;
         glVertex3f(x,z,-y);
       }
     }
     glEnd();
   }
 }
 return;
}

static void Draw3dObjects(int pass, BOOL clip){
 GLfloat x,y,z,
         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;
 long i,j,k;
 long Nvert,Nface,nImaps,nMats;
 vertex *vp,*MainVp; 
 face   *fp,*MainFp;
 imap   *iMap;
 matl   *iMat;
 for(k=0;k<ObjectCount;k++){ // possibly draw all transp in a later pass not yet implemented TODO
   if(!Object[k].in_use)continue;
   MainVp=Object[k].Vbase;
   MainFp=Object[k].Fbase;
   iMap=Object[k].Mbase;
   iMat=Object[k].Tbase;
   Nvert=Object[k].NoVertices;
   Nface=Object[k].NoFaces;
   nMats=Object[k].NoMats;
   nImaps= Object[k].NoMaps;
   if(Nface > 0){
     // First Draw Polygons that have basic attributes only
     UseShaderProgram(1); 
     SetUniformInteger(1,"Clip1",(int)clip);
     SetUniformVariable(1,"SpecularContribution",0.5);   // only mix in a little
     glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,shiny);
     glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,glos_color);
     glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
     glEnable(GL_COLOR_MATERIAL);  // set color material properties
     glBegin(GL_TRIANGLES);
     for(fp=MainFp,i=0;i<Nface;i++,fp++){
       if(fp->ffmap >= 0)continue; // don't draw the mapped polygons or
       if(fp->ffmat >= 0)continue; // materials in this pass
       glColor4ub(fp->color[0],fp->color[1],fp->color[2],255);
       for(j=0;j<3;j++){
         vp=(MainVp+(fp->V[j]));
         x=((GLfloat)(vp->p[0]))*GlobalScale;
         y=((GLfloat)(vp->p[1]))*GlobalScale;
         z=((GLfloat)(vp->p[2]))*GlobalScale;
         if(fp->bSmooth){
           //if(fp->pn[j][1] > 0.0)glNormal3f(-fp->pn[j][0],-fp->pn[j][2],fp->pn[j][1]);
           //else                  
           glNormal3f(fp->pn[j][0],fp->pn[j][2],-fp->pn[j][1]);
         }
         else {
           //if(fp->n[1] > 0.0)glNormal3f(-fp->n[0],-fp->n[2],fp->n[1]);
           //else              
           glNormal3f(fp->n[0],fp->n[2],-fp->n[1]);
         }
         glVertex3f(x,z,-y);
       }
     }
     glEnd();
     UseShaderProgram(0); 
     glDisable(GL_COLOR_MATERIAL);
     if(nMats > 0 && Nface > 0)DrawMaterialPolys(FALSE,clip,nMats,iMat,Nface,MainFp,Nvert,MainVp);
     //if(nImaps > 0 && Nface > 0)DrawMappedPolys(FALSE,clip,nMats,iMat,nImaps,iMap,Nface,MainFp,Nvert,MainVp);
     if(nImaps > 0 && Nface > 0)DrawMappedPolys(TRUE,clip,nMats,iMat,nImaps,iMap,Nface,MainFp,Nvert,MainVp);
     if(nMats > 0 && Nface > 0)DrawMaterialPolys(TRUE,clip,nMats,iMat,Nface,MainFp,Nvert,MainVp);
     if(nMats > 0 && Nface > 0)DrawExternalMaterialPolys(FALSE,clip,nMats,iMat,Nface,MainFp,Nvert,MainVp);
   }
 }
 // Go back and draw transparent polys - TO DO - still on object basis
 return;
}

static void DrawMaterialPolys(BOOL bDrawTransparent, BOOL bClip, 
            long nMats, matl *iMat, 
            long Nface, face *MainFp, long Nvert, vertex *MainVp){
 int i,j,k,pass,matID=0;
 vector mN,mX,mY,mP,mp;
 GLfloat uu,vv,ww,spower,color[3];
 GLuint progID;
 GLint  attrloc;
 GLfloat x,y,z,
         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;
 vertex *vp;
 face   *fp;
 //
 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
   if(bDrawTransparent && pass != 2)continue;
   if(!bDrawTransparent && pass == 2)continue;
   for(k=0;k<nMats;k++){
     if(iMat[k].bInternalShader)matID=iMat[k].internalShaderID;
     else if(iMat[k].shaderID[0] >= 0 || iMat[k].shaderID[1] >= 0 || // skip any external shaders
             iMat[k].shaderID[2] >= 0 || iMat[k].shaderID[3] >= 0)continue;
     if(pass == 0)progID=3; else progID=2;
     // 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;
     for(i=0;i<3;i++)color[i]=(GLfloat)iMat[k].color[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,"Clip1",(int)bClip);
     SetUniformVariable(progID,"MixRatio",(GLfloat)iMat[k].refl/255.0);
     SetUniformVariable(progID,"ShaderParameter",(GLfloat)iMat[k].params[0]/255.0); // shader parameter
     // Set up the reflection transformation for the reflected direction - this will UNDO the camera
     // orientation so that the reflection vector still points in a direction that is relative to world coordinates
     SetUniformVector(progID,"AntiNormal1",AntiCameraGL[0][0],AntiCameraGL[1][0],AntiCameraGL[2][0]);
     SetUniformVector(progID,"AntiNormal2",AntiCameraGL[0][1],AntiCameraGL[1][1],AntiCameraGL[2][1]);
     SetUniformVector(progID,"AntiNormal3",AntiCameraGL[0][2],AntiCameraGL[1][2],AntiCameraGL[2][2]);
     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){ // Bumpy - use normal map 
       glActiveTexture(GL_TEXTURE1);
       glBindTexture(GL_TEXTURE_2D,g_envB_texture);
       SetUniformInteger(progID,"NormalMap",1);
       SetUniformVector(progID,"Uvector",(GLfloat)(iMat[k].ax.bu_norm[0]),
                                         (GLfloat)(iMat[k].ax.bu_norm[2]),
                                        -(GLfloat)(iMat[k].ax.bu_norm[1]));
       SetUniformVector(progID,"Vvector",(GLfloat)(iMat[k].ax.bv_norm[0]),
                                         (GLfloat)(iMat[k].ax.bv_norm[2]),
                                        -(GLfloat)(iMat[k].ax.bv_norm[1]));
       SetUniformVector(progID,"Wvector",(GLfloat)(iMat[k].ax.bn[0]),
                                         (GLfloat)(iMat[k].ax.bn[2]),
                                        -(GLfloat)(iMat[k].ax.bn[1]));
    }
     if(pass == 0){  // A noise texture 
//       glDisable(GL_TEXTURE_2D); 
//       glEnable(GL_TEXTURE_3D);
//       glActiveTexture(GL_TEXTURE1);
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_3D,g_noise_texture);
//       SetUniformInteger(progID,"NoiseMap",1); 
       SetUniformInteger(progID,"NoiseMap",0); 
       if(iMat[k].refl > 0){
//         glActiveTexture(GL_TEXTURE0);
         glActiveTexture(GL_TEXTURE1);
//         glBindTexture(GL_TEXTURE_2D,g_env_texture);
         glBindTexture(GL_TEXTURE_3D,g_env3D_texture);
//         SetUniformInteger(progID,"RefMap",0); // texture unit 0
         SetUniformInteger(progID,"RefMap",1); // texture unit 0
       }
     }
     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].texco[0]/255.0,
                                         (GLfloat)iMat[k].texco[1]/255.0,
                                         (GLfloat)iMat[k].texco[2]/255.0);
     SetUniformInteger(progID,"ShaderID",matID);
     attrloc=GetAttibuteLocation(progID,"ShaderPosition");
     glBegin(GL_TRIANGLES);
     fp=MainFp; for(i=0;i<Nface;i++,fp++){ // daw the mapped polys
       if(fp->ffmat != k || fp->ffmap >= 0  || fp->ffmat < 0)continue; //skip
       for(j=0;j<3;j++){
         vp=(MainVp+(fp->V[j]));
         x=((GLfloat)(vp->p[0]))*GlobalScale;
         y=((GLfloat)(vp->p[1]))*GlobalScale;
         z=((GLfloat)(vp->p[2]))*GlobalScale;
         if(fp->bSmooth){
           //if(fp->pn[j][1] > 0.0)glNormal3f(-fp->pn[j][0],-fp->pn[j][2],fp->pn[j][1]);
           //else
           glNormal3f(fp->pn[j][0],fp->pn[j][2],-fp->pn[j][1]);
         }
         else {
           //if(fp->n[1] > 0.0)glNormal3f(-fp->n[0],-fp->n[2],fp->n[1]);
           //else
           glNormal3f(fp->n[0],fp->n[2],-fp->n[1]);
         }
         uu=fp->uu[j]; vv=fp->vv[j]; ww=fp->ww[j];
         //fprintf(debug,"Face %ld Vertex %ld - uu=%f vv=%f ww=%f\n",i,j,uu,vv,ww);
         //SetAttributeVector(3,"ShaderPosition",uu,vv,ww);   // DO NOT USE THIS !!! Get the location first
         SetAttributeVectorID(progID,attrloc,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){
       if(pass == 0){
         glActiveTexture(GL_TEXTURE1);
         glBindTexture(GL_TEXTURE_3D,0);
       }
       else{
         glActiveTexture(GL_TEXTURE0);
         glBindTexture(GL_TEXTURE_2D,0);
       }
     }
     if(pass == 0){
       glActiveTexture(GL_TEXTURE0);  
//       glActiveTexture(GL_TEXTURE1);  ///// unbind the noise
       glBindTexture(GL_TEXTURE_3D,0);
//       glDisable(GL_TEXTURE_3D);
//       glEnable(GL_TEXTURE_2D);
     }
   }
 }
 glDisable(GL_COLOR_MATERIAL);
}

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

static void DrawMappedPolys(BOOL bDrawTransparent,BOOL bClip,
            long nMats, matl *iMat,  
            long nImaps, imap *iMap, 
            long Nface, face *MainFp, long Nvert, vertex *MainVp){
 GLfloat mixColour[4]={0.0,0.0,0.0,0.0};
 GLfloat x,y,z,n[3],
         dot;
 GLint   TanLoc,BinLoc;
 face *fp;
 vertex *v;
 int i,j,k,m;
 BOOL refmap;
 int brushID;
 vector mN,mX,mY,mP;
 GLfloat alpha,beta,tangent[3],binormal[3]; //tangent/binormal not used yet
 GLfloat colour3,bc[4]={0.0,0.0,0.0,0.0};
 for(k=0;k<nImaps;k++){       // loop over all maps
   UseShaderProgram(4);   
   SetUniformInteger(4,"bTransPass",(int)bDrawTransparent);  // transparency ?
   SetUniformInteger(4,"Clip1",(int)bClip); // to clip or not to clip ?
   // Assign anti-reflection matrix
   SetUniformVector(4,"AntiNormal1",AntiCameraGL[0][0],AntiCameraGL[1][0],AntiCameraGL[2][0]); // OGL needs
   SetUniformVector(4,"AntiNormal2",AntiCameraGL[0][1],AntiCameraGL[1][1],AntiCameraGL[2][1]); // this order
   SetUniformVector(4,"AntiNormal3",AntiCameraGL[0][2],AntiCameraGL[1][2],AntiCameraGL[2][2]);
   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);  // Surface Map
   glBindTexture(GL_TEXTURE_2D,0);  
   if(iMap[k].bLoadedS){     
     SetUniformInteger(4,"bS",1);
//     if(iMap[k].bAnimS)glBindTexture(GL_TEXTURE_2D,g_movie_texture); 
//     else 
     if(iMap[k].p24R != NULL){
       glBindTexture(GL_TEXTURE_2D,g_map_texture);
       TextureWithAlpha(iMap[k].xmax,iMap[k].ymax,iMap[k].p24R,iMap[k].p24G,iMap[k].p24B,255,
       iMap[k].bDecal,iMap[k].kc[0],iMap[k].kc[1],iMap[k].kc[2]);
     }
     else glBindTexture(GL_TEXTURE_2D,g_check_texture);
     if(iMap[k].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].pp*0.01);
     SetUniformInteger(4,"SurfaceMap",0); // texture unit 0
   }
   else SetUniformInteger(4,"bS",0);
   glActiveTexture(GL_TEXTURE1);  // Reflection Map
   glBindTexture(GL_TEXTURE_2D,0);
   if(iMap[k].bLoadedR){
     SetUniformInteger(4,"bR",1);
//     if(iMap[k].bAnimR)glBindTexture(GL_TEXTURE_2D,g_movie_texture);
//     else 
     if(iMap[k].p24Rrefl != NULL){
       glBindTexture(GL_TEXTURE_2D,g_ref_texture);
       Texture(iMap[k].xmaxrefl,iMap[k].ymaxrefl,iMap[k].p24Rrefl,iMap[k].p24Grefl,iMap[k].p24Brefl);
     }
     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].bLoadedB){   
     SetUniformInteger(4,"bB",1);
//     if(iMap[k].bAnimB)glBindTexture(GL_TEXTURE_2D,g_movie_texture);
//     else 
     if(iMap[k].p24Rbump != NULL){
       glBindTexture(GL_TEXTURE_2D,g_bump_texture);
       Texture(iMap[k].xmaxbump,iMap[k].ymaxbump,iMap[k].p24Rbump,iMap[k].p24Gbump,iMap[k].p24Bbump);
     }
     else glBindTexture(GL_TEXTURE_2D,g_check_texture);
     if(iMap[k].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].bLoadedT){ // Transparency map  // discard any Transparent pixels
     SetUniformInteger(4,"bT",1);
//     if(iMap[k].bAnimT)glBindTexture(GL_TEXTURE_2D,g_movie_texture);
//     else 
     if(iMap[k].p24Rtran != NULL){
       glBindTexture(GL_TEXTURE_2D,g_tran_texture);
       Texture(iMap[k].xmaxtran,iMap[k].ymaxtran,iMap[k].p24Rtran,iMap[k].p24Gtran,iMap[k].p24Btran);
     }
     else glBindTexture(GL_TEXTURE_2D,g_check_texture);
     if(iMap[k].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);

   glActiveTexture(GL_TEXTURE0);   // Render the mapped surface - loop over the materials
   m = -1; 
   matloop:
   glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);
   colour3=1.0;
   if(bDrawTransparent && iMap[k].bLoadedT){
     glEnable(GL_BLEND);
     glDepthMask(GL_FALSE);
     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
     colour3=1.0;
   }
   else if(m >= 0){
     if(iMat[m].bShiny)SetUniformVariable(4,"SpecularContribution",1.0);
     else              SetUniformVariable(4,"SpecularContribution",0.0);
     if(iMat[m].transp > 0){ // Set transparent blending
       glEnable(GL_BLEND);
       glDepthMask(GL_FALSE);
       glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
       colour3=(1.0 - (GLfloat)iMat[m].transp / 255.0);
     }
   }
   else SetUniformVariable(4,"SpecularContribution",0.5);
   // There should really be set on a per vertex basis but 
   // calculating them here is OK because we don't user true BINORMAL
   // may be hardware dependent - thes need to be set per map
   VECCOPY(iMap[k].x,tangent)  normalize(tangent);
   VECCOPY(iMap[k].y,binormal) normalize(binormal);
   TanLoc=GetAttibuteLocation(4,"Tangent"); // Needs to be called before glBegin !!!!
   BinLoc=GetAttibuteLocation(4,"Binormal");
   //SetAttributeVector(4,"Tangent",tangent[0],tangent[2],-tangent[1]); //  
   //SetAttributeVector(4,"Binormal",binormal[0],binormal[2],-binormal[1]); 
   //
   glBegin(GL_TRIANGLES);
   fp=MainFp; if(Nface > 0)for(i=0;i<Nface;i++,fp++){
     if(fp->ffmap < 0)continue; /* if not mapped */
     if(m >= 0 && fp->ffmat != m)continue; // not this material
     if(m == -1 && fp->ffmat >= 0)continue; // or this basic one
     brushID=fp->ffmap;
     if(brushID != k)continue;         /* skip if not this map */
     if(m == -1)glColor4ub(fp->color[0],fp->color[1],fp->color[2],(unsigned char)(colour3*255));
     else       glColor4ub(iMat[m].color[0],iMat[m].color[1],iMat[m].color[2],(unsigned char)(colour3*255));
     for(j=0;j<3;j++){
       v=(MainVp+(fp->V[j]));
       x=((GLfloat)(v->p[0]))*GlobalScale;
       y=((GLfloat)(v->p[1]))*GlobalScale;
       z=((GLfloat)(v->p[2]))*GlobalScale;
       if(fp->bSmooth){ /* smoothed */
         if(fp->pn[j][1] > 0.0)glNormal3f(-fp->pn[j][0],-fp->pn[j][2],fp->pn[j][1]);
         else                  glNormal3f(fp->pn[j][0],fp->pn[j][2],-fp->pn[j][1]);
       }
       else {
         if(fp->n[1] > 0.0)glNormal3f(-fp->n[0],-fp->n[2],fp->n[1]);
         else              glNormal3f(fp->n[0],fp->n[2],-fp->n[1]);
       }
       //SetAttributeVector(4,"Tangent",tangent[0],tangent[2],-tangent[1]); // DO NOT USE
       //SetAttributeVector(4,"Binormal",binormal[0],binormal[2],-binormal[1]); // DO NOT USE
       SetAttributeVectorID(4,TanLoc,tangent[0],tangent[2],-tangent[1]);   // 
       SetAttributeVectorID(4,BinLoc,binormal[0],binormal[2],-binormal[1]); 
       alpha=fp->uu[j]; beta=fp->vv[j];
       glMultiTexCoord2f(GL_TEXTURE0,alpha,beta);  // for non reflective textures
       glVertex3f(x,z,-y);
     }
   }
   glEnd();
   if((bDrawTransparent && iMap[k].bLoadedT) || (m >= 0 && iMat[m].transp > 0)){
     glDepthMask(GL_TRUE);
     glDisable(GL_BLEND);
   }

   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);
   UseShaderProgram(0); 
 }   // each map
}

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

static void Texture(long x, long y, unsigned char *R, unsigned char *G, unsigned char *B){
  unsigned char *pout,*p;
  long i,j;
  pout=X__Malloc(x*y*3); p=pout;
  for(i=0;i<y;i++)for(j=0;j<x;j++){
    *p++ = *R++;
    *p++ = *G++;
    *p++ = *B++;
  }
  glTexImage2D(GL_TEXTURE_2D,0,3,x,y,0,GL_RGB,GL_UNSIGNED_BYTE,(GLvoid *)pout);
  X__Free(pout);
}

static void InstallShadowMatrix(GLfloat ground[4], GLfloat light[4]){
GLfloat dot;
GLfloat shadowMat[4][4];
dot = ground[0] * light[0] +
      ground[1] * light[1] +
      ground[2] * light[2] +
      ground[3] * light[3];
shadowMat[0][0] = dot - light[0] * ground[0];
shadowMat[1][0] = 0.0 - light[0] * ground[1];
shadowMat[2][0] = 0.0 - light[0] * ground[2];
shadowMat[3][0] = 0.0 - light[0] * ground[3];
shadowMat[0][1] = 0.0 - light[1] * ground[0];
shadowMat[1][1] = dot - light[1] * ground[1];
shadowMat[2][1] = 0.0 - light[1] * ground[2];
shadowMat[3][1] = 0.0 - light[1] * ground[3];
shadowMat[0][2] = 0.0 - light[2] * ground[0];
shadowMat[1][2] = 0.0 - light[2] * ground[1];
shadowMat[2][2] = dot - light[2] * ground[2];
shadowMat[3][2] = 0.0 - light[2] * ground[3];
shadowMat[0][3] = 0.0 - light[3] * ground[0];
shadowMat[1][3] = 0.0 - light[3] * ground[1];
shadowMat[2][3] = 0.0 - light[3] * ground[2];
shadowMat[3][3] = dot - light[3] * ground[3];
glMultMatrixf((const GLfloat*)shadowMat);
}

static void InstallReflectionMatrix(GLfloat p0[3], GLfloat n[3]){
GLfloat d;
GLfloat refMat[4][4];
GLfloat n0s,n1s,n2s;
d = DOT(p0,n);
n0s=n[0]*n[0]; n1s=n[1]*n[1]; n2s=n[2]*n[2];
refMat[0][0] = 1-2.0*n0s;
refMat[0][1] = -2.0*n[0]*n[1];
refMat[0][2] = -2.0*n[0]*n[2];
refMat[0][3] = 0.0;
refMat[1][0] = -2.0*n[1]*n[0];
refMat[1][1] = 1-2.0*n1s;
refMat[1][2] = -2.0*n[1]*n[2];
refMat[1][3] = 0.0;
refMat[2][0] = -2.0*n[2]*n[0];
refMat[2][1] = -2.0*n[2]*n[1];
refMat[2][2] = 1-2.0*n2s;
refMat[2][3] = 0.0;
refMat[3][0] = 2.0*d*n[0];
refMat[3][1] = 2.0*d*n[1];
refMat[3][2] = 2.0*d*n[2];
refMat[3][3] = 1.0;
glMultMatrixf((const GLfloat*)refMat);
}