rendergl2.c

Go to the documentation of this file.

// File rendergl2.c

#define MODULE_RENDERGL2

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

extern int RENDERBUFFER_WIDTH;
extern int RENDERBUFFER_HEIGHT;
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;

extern double DepthScalingGL,FrontDepthGL,BackDepthGL;

extern char gszHomeDir[];
extern double GlobalScale;

static void DrawExternalTexturePolygons(long k, int pass, // material ID
                                        GLuint progID, GLint attrloc, 
                                        long Nface, face *MainFp, long Nvert, vertex *MainVp);


#include "..\common\postprocess\ximage.h"

long PostProcessRenderGL(long frame){ // NB: In the renderer "double" is always cast to "float"
 int i,j,k;
 char fname[256],tparam[256];
 long AnimatorIdList[256];
 HMODULE hLib;
 FARPROC fpFun;
 XIMAGE Ximage,*lpXimage;
 long l,result=0;
 long (*fpFun1)(char *, XIMAGE *);
 if(nImageProcesses == 0 || ImageProcesses == NULL)return 0;
 // Most of the fields in this structure are not necessary
 lpXimage=&Ximage;
 memset(lpXimage,0,sizeof(XIMAGE));
 Ximage.HWrender=1;
 Ximage.version=3;
 Ximage.Frame=frame;
 Ximage.Xscale=scalex;
 Ximage.Yscale=scaley;
 Ximage.Xmax=TEXTUREBUFFER_WIDTH;
 Ximage.Ymax=TEXTUREBUFFER_HEIGHT;
 Ximage.depthscalingGL=DepthScalingGL; 
 Ximage.frontbufferGL=FrontDepthGL;
 Ximage.backbufferGL=BackDepthGL;
 Ximage.Nlights=Nlights;
 Ximage.Lights=Lights;
 Ximage.ViewPoint = (double *)ViewPoint; 
 Ximage.CamPhi=CamPhi;
 Ximage.CamTheta=CamTheta;
 Ximage.CamAlpha=CamAlpha;
 Ximage.CamSx=CamSx;
 Ximage.CamSy=CamSy;
 Ximage.CamSz=CamSz;
 Ximage.fp_Terminate=R_terminator;
 Ximage.fp_Yield=RenderYield;
 for(i=0;i<4;i++)for(j=0;j<4;j++)Ximage.ViewTransform[i][j]=ViewTransform[i][j];
 for(k=0;k<nImageProcesses;k++){
   lpXimage->Morph=ImageProcesses[k].imo;
   lpXimage->MorphRatio=ImageProcesses[k].fmr;
   lpXimage->first_frame=ImageProcesses[k].first_frame;
   lpXimage->this_frame=ImageProcesses[k].this_frame;
   lpXimage->last_frame=ImageProcesses[k].last_frame;
   lpXimage->aParameters=ImageProcesses[k].parameters;
   lpXimage->mParameters=ImageProcesses[k].mparameters;
   sscanf(ImageProcesses[k].parameters,"%s",tparam);
   RestoreWhiteSpaces(tparam);
   sscanf(tparam,"%[^\0]",fname);
   //if(debug != NULL)fprintf(debug,"Loading OpenGL image process [%s]\n",fname);
   hLib=AddLoadedLibrary(fname);
   lpXimage->ModuleName=fname;
   if(hLib == NULL){ /* try the default ximage directory */
     char *sfname,tfname[256];
     sfname=short_form(fname);
     strcpy(tfname,gszHomeDir);  strcat(tfname,"postprocess\\");
     strcat(tfname,sfname);
     hLib=AddLoadedLibrary(tfname);
     lpXimage->ModuleName=tfname;
   }
   if(hLib != NULL){
     if((fpFun=GetProcAddress(hLib,"_RenderGLexternal")) != NULL){
       fpFun1 = (void *)fpFun;
       result=(*fpFun1)(ImageProcesses[k].parameters,lpXimage);
     }
     else MessageBox(GetFocus(), (LPCTSTR) "Failed Function", NULL, MB_OK | MB_SYSTEMMODAL );
   }
   else MessageBox(GetFocus(),(LPCTSTR) "Failed Load", NULL, MB_OK | MB_SYSTEMMODAL );
   if(!result)return FAIL;
 }
 return 0;
}

#include "..\textures\rstruct.h"

extern X__SHADER EviShader;

static void RenderExternalTextureGL(long tid, long k, // shader ID  material ID 
                                    int pass,    // two passes - first is for transparent polys then the non transparent
                                    GLuint progID, GLint attrloc, 
                                    long Nface, face *MainFp, long Nvert, vertex *MainVp,
                                    double bump_scale,
                                    unsigned char sc[3],
                                    unsigned char ac[3]){
 long (*fpTexFunGL)(
                   double,
                   unsigned char [3],
                   unsigned char [3],
                   X__SHADER *);
 long result;
 /*  x and y are same as alpha beta */
 if(tid < 0 || tid >= Nshader)return;
 fpTexFunGL=(void *)(Shader[tid].functionGL);
 EviShader.GLshaderID=Shader[tid].shaderID;
 EviShader.fp_DrawShaderPolygons=DrawExternalTexturePolygons;
 EviShader.fp_matpass=k;
 EviShader.fp_pass=pass;
 EviShader.fp_progID=progID;
 EviShader.fp_attrloc=attrloc;
 EviShader.fp_Nface=Nface;
 EviShader.fp_Nvert=Nvert;
 EviShader.fp_MainFp=(void *)MainFp;
 EviShader.fp_MainVp=(void *)MainVp;
 result=(*fpTexFunGL)(bump_scale,sc,ac,&EviShader);
}

void DrawExternalMaterialPolys(BOOL bDrawTransparent, BOOL bClip, 
            long nMats, matl *iMat, 
            long Nface, face *MainFp, long Nvert, vertex *MainVp){
 BOOL bFirstTex;
 int i,//j,
     k,n,pass,sID;
 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(k=0;k<nMats;k++){
   if(iMat[k].bInternalShader)continue;        // Only renderer external shaders
   bFirstTex=TRUE;
   for(n=0;n<4;n++){                             // render each shader
     if((sID=iMat[k].shaderID[n]) < 0)continue;  // only render active shaders
     for(pass=0;pass<2;pass++){ // render transparency last
       if(pass == 0 && iMat[k].transp > 0)continue;
       if(pass == 1 && iMat[k].transp == 0)continue;
       // set gl properites for this face
       for(i=0;i<3;i++)color[i]=(GLfloat)iMat[k].color[i]/255.0;
       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);
       progID=Shader[sID].shaderID;
       //if(debug != NULL)fprintf(debug,"Material %ld has plugin shader using ID %ld\n",k,progID);
       UseSingleShaderProgram(progID);
       // Set up the uniforms that must be part of the shader  
       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
       SetUniformInteger(progID,"ShaderID",0);
       // make noise sampler available & 3D reflection
//       glDisable(GL_TEXTURE_2D); 
//       glEnable(GL_TEXTURE_3D);
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_3D,g_noise_texture);
       SetUniformInteger(progID,"NoiseMap",0); 
       glActiveTexture(GL_TEXTURE1);
       glBindTexture(GL_TEXTURE_3D,g_env3D_texture);
       SetUniformInteger(progID,"RefMap3D",1); 

       // 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]);
       // make reflection available
       glActiveTexture(GL_TEXTURE2);
       glBindTexture(GL_TEXTURE_2D,g_env_texture);
       SetUniformInteger(progID,"RefMap",2); 
       // make bumpy texture available 
       glActiveTexture(GL_TEXTURE3);
       glBindTexture(GL_TEXTURE_2D,g_envB_texture);
       SetUniformInteger(progID,"NormalMap",3);
       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]));

       // make noise lookup table available
       glActiveTexture(GL_TEXTURE4);
       glBindTexture(GL_TEXTURE_2D,g_envN_texture);
       SetUniformInteger(progID,"NoiseData",4);

       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);
       attrloc=GetAttibuteLocation(progID,"ShaderPosition");
       // Set up any shader specific Uniforms in the Shader DLL - this also calls back to draw the polygons
       RenderExternalTextureGL(sID,k,pass,progID,attrloc,
            Nface,MainFp,Nvert,MainVp,  
            (GLfloat)iMat[k].params[0]/255.0,iMat[k].color,iMat[k].texco);
       UseShaderProgram(0); 
       // any material attributes that need to be undone ?
       if(iMat[k].transp > 0){ // Set transparent blending
         glDepthMask(GL_TRUE);
         glDisable(GL_BLEND);
       }
       glActiveTexture(GL_TEXTURE4);
       glBindTexture(GL_TEXTURE_2D,0);
       glActiveTexture(GL_TEXTURE3);
       glBindTexture(GL_TEXTURE_2D,0);
       glActiveTexture(GL_TEXTURE2);
       glBindTexture(GL_TEXTURE_2D,0);
       glActiveTexture(GL_TEXTURE1);  
       glBindTexture(GL_TEXTURE_3D,0);
       glActiveTexture(GL_TEXTURE0);  
       glBindTexture(GL_TEXTURE_3D,0);
//       glDisable(GL_TEXTURE_3D);
//       glEnable(GL_TEXTURE_2D);
     } // pass
     bFirstTex=FALSE;
   } // ext shader
 }
 glDisable(GL_COLOR_MATERIAL);
}

static void DrawExternalTexturePolygons(long k, int pass, // material ID
                                        GLuint progID, GLint attrloc, 
                                        long Nface, face *MainFp, long Nvert, vertex *MainVp){
 face *fp;  // This function is called back from the shader - possibly several times (blending - depth etc.)
 int i,j;
 vertex *vp;
 GLfloat x,y,z,uu,vv,ww;
 glBegin(GL_TRIANGLES);
 fp=MainFp; for(i=0;i<Nface;i++,fp++){ // draw the polys with external materials
   if(fp->ffmat != k || fp->ffmap >= 0  || fp->ffmat < 0)continue; //skip all except materials
   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];
     SetAttributeVectorID(progID,attrloc,uu,vv,ww);  
     glVertex3f(x,z,-y);
   }
 }
 glEnd();
}



#if 0
long RenderGL(long frame){  // Old way does not  -  blend in hardware and is slow - NOT used at prsent
 int  i,aa;
 unsigned char *p,*q;
 glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, g_frameBuffer );
// glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, 
//              GL_RENDERBUFFER_EXT, g_accumRenderBuffer );
 glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, 
                GL_RENDERBUFFER_EXT, g_colorRenderBuffer );
 glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, 
                GL_RENDERBUFFER_EXT, g_depthRenderBuffer );
// Stencil Buffers do not work when attached to FBOs
// glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, 
//    GL_RENDERBUFFER_EXT, g_stencilRenderBuffer );
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
 glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 for(aa=0;aa<nAAsamples;aa++){ 
   RenderCameraView(TRUE,bAntiAliased,aa,nAAsamples,(GLfloat)RENDERBUFFER_WIDTH/(GLfloat)RENDERBUFFER_HEIGHT);
   glFlush();
   glReadPixels(0,0,RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT,GL_RGBA,GL_UNSIGNED_BYTE,RenderBufferCopy);  // or this
   if(aa == 0)memcpy(RenderBufferAccu,RenderBufferCopy,RENDERBUFFER_WIDTH*RENDERBUFFER_HEIGHT*4);
   else{
     p=RenderBufferCopy; q=RenderBufferAccu; 
     for(i=0;i< RENDERBUFFER_WIDTH*RENDERBUFFER_HEIGHT*4;i++){
       *q = (unsigned char)((((float)*q)*((float)aa-1.0) + ((float)*p))/(float)aa  );
       p++; q++;
     }
   }
 }
 glFlush();
 glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );



#if 0   // this partially works works but is too slow on ATI hardware
 glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 glPixelZoom(1.0,1.0);
 //glBlendFunc(GL_ONE,GL_ZERO);
 //glBlendFunc(GL_ZERO,GL_ONE);
 //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 //glEnable(GL_BLEND);
 UseShaderProgram(5); // This is impossibly slow on ATI hardware
 glCopyPixels(0,0,RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT,GL_COLOR);
 UseShaderProgram(0); 
 //glDisable(GL_BLEND);
 glReadBuffer(GL_COLOR_ATTACHMENT1_EXT);
#endif

#if 0
 { // this also works - but is too slow on ATI hardware
 int i,j;
 p=RenderBufferCopy;
 glReadPixels(0,0,RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT,GL_RGBA,GL_UNSIGNED_BYTE,RenderBufferCopy);
 glFlush(); 
 //for(i=0;i< RENDERBUFFER_WIDTH*RENDERBUFFER_HEIGHT*4;i++){*p = *p/4; p++; }
 glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);
 glMatrixMode( GL_MODELVIEW );
 glPixelZoom(1.0,1.0);
 glRasterPos2i(0,0);
 UseShaderProgram(5); 
 glDrawPixels(RENDERBUFFER_WIDTH,RENDERBUFFER_HEIGHT,GL_RGBA,GL_UNSIGNED_BYTE,RenderBufferCopy);
 UseShaderProgram(0); 
 glFlush();
 glReadBuffer(GL_COLOR_ATTACHMENT1_EXT);
}
#endif

 return 1;
}
#endif