From c5c44939b90807b3435c23be7f20ff45e046c2e1 Mon Sep 17 00:00:00 2001
From: Lee Salzman <lsalzman@gmail.com>
Date: Sat, 7 Apr 2007 06:58:34 +0000
Subject: [PATCH] *** empty log message ***

git-svn-id: svn://svn.code.sf.net/p/actiongame/code/trunk/ac@941 e016b1c5-ed68-44aa-a2f7-31cac88cffde
---
 source/src/cube.h          |   2 +-
 source/src/protos.h        |   6 ++
 source/src/rendercubes.cpp | 202 +++++++++++++++++++++++++++++--------
 source/src/rendergl.cpp    |  28 ++++-
 source/src/vertmodel.h     |  21 ++--
 5 files changed, 202 insertions(+), 57 deletions(-)

diff --git a/source/src/cube.h b/source/src/cube.h
index 99c14909..351f21d0 100644
--- a/source/src/cube.h
+++ b/source/src/cube.h
@@ -87,7 +87,7 @@ extern bool demoplayback;
 extern bool intermission;
 extern bool arenajoin;
 extern int maxclients;
-extern bool hasoverbright;
+extern bool hasoverbright, hasmultitexture;
 
 extern int VIRTW;                       // virtual screen size for text & HUD
 #define VIRTH 1800
diff --git a/source/src/protos.h b/source/src/protos.h
index f87e5a49..bf2552f2 100644
--- a/source/src/protos.h
+++ b/source/src/protos.h
@@ -326,3 +326,9 @@ extern bool intersect(entity *e, vec &from, vec &to, vec *end=NULL);
 // rndmap
 extern void perlinarea(block &b, int scale, int seed, int psize);
 
+// GL_ARB_multitexture
+extern PFNGLACTIVETEXTUREARBPROC   glActiveTexture_;
+extern PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2f_;
+extern PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3f_;
+
+
diff --git a/source/src/rendercubes.cpp b/source/src/rendercubes.cpp
index 23491bba..6d013586 100644
--- a/source/src/rendercubes.cpp
+++ b/source/src/rendercubes.cpp
@@ -378,41 +378,141 @@ void setwatercolor(char *r, char *g, char *b, char *a)
 
 COMMANDN(watercolour, setwatercolor, ARG_4STR);
 
-inline void vertw(int v1, float v2, int v3, float t, int tex)
-{
-    float angle = v1*v3*0.1f + t;
-    float h = sinf(angle);
-    if(tex)
-    {
-        float v = cosf(angle);
-        if(tex>0)
-        {
-            glTexCoord3f(v1+v*0.3f, v2+h*0.3f, v3+v*0.3f);
-            if(tex>1) glColor4f(1, 1, 1, 0.15f + max(v, 0)*0.15f);
-        }
-        else glColor4ub(hdr.watercolor[0], hdr.watercolor[1], hdr.watercolor[2], (uchar)(hdr.watercolor[3] + (max(v, 0) - 0.5f)*51.0f));
-    }
-    glVertex3f((float)v1, v2 + h*0.3f, (float)v3);
-}
-
 // renders water for bounding rect area that contains water... simple but very inefficient
 
-void renderwaterstrips(float hf, int tex, float t)
-{
-    for(int x = wx1; x<wx2; x += watersubdiv)
-    {
-        glBegin(GL_TRIANGLE_STRIP);
-        vertw(x,             hf, wy1, t, tex);
-        vertw(x+watersubdiv, hf, wy1, t, tex);
-        for(int y = wy1; y<wy2; y += watersubdiv)
-        {
-            vertw(x,             hf, y+watersubdiv, t, tex);
-            vertw(x+watersubdiv, hf, y+watersubdiv, t, tex);
-        }
-        glEnd();
+#define VERTW(vertw, body) \
+    inline void vertw(int v1, float v2, int v3, float t) \
+    { \
+        float angle = v1*v3*0.1f + t; \
+        float h = 0.3f*sinf(angle); \
+        body; \
+        glVertex3f((float)v1, v2+h, (float)v3); \
     }
+#define VERTWT(vertwt, body) VERTW(vertwt, { float v = cosf(angle); float duv = 0.2f*v; body; })
+VERTW(vertw, {})
+VERTW(vertwc, {
+    float v = cosf(angle);
+    glColor4ub(hdr.watercolor[0], hdr.watercolor[1], hdr.watercolor[2], (uchar)(hdr.watercolor[3] + (max(v, 0) - 0.5f)*51.0f));
+})
+VERTWT(vertwt, {
+    glTexCoord3f(v1+duv, v2+h, v3+duv);
+})
+VERTWT(vertwtc, {
+    glColor4f(1, 1, 1, 0.15f + max(v, 0)*0.15f);
+    glTexCoord3f(v1+duv, v2+h, v3+duv);
+})
+VERTWT(vertwmtc, {
+    glColor4f(1, 1, 1, 0.15f + max(v, 0)*0.15f);
+    glMultiTexCoord3f_(GL_TEXTURE0_ARB, v1+duv, v2+h, v3+duv);
+    glMultiTexCoord3f_(GL_TEXTURE1_ARB, v1+duv, v2+h, v3+duv);
+})
+ 
+#define renderwaterstrips(vertw, hf, t) \
+    for(int x = wx1; x<wx2; x += watersubdiv) \
+    { \
+        glBegin(GL_TRIANGLE_STRIP); \
+        vertw(x,             hf, wy1, t); \
+        vertw(x+watersubdiv, hf, wy1, t); \
+        for(int y = wy1; y<wy2; y += watersubdiv) \
+        { \
+            vertw(x,             hf, y+watersubdiv, t); \
+            vertw(x+watersubdiv, hf, y+watersubdiv, t); \
+        } \
+        glEnd(); \
+    }
+
+void setprojtexmatrix()
+{
+    GLfloat pm[16], mm[16];
+    glGetFloatv(GL_PROJECTION_MATRIX, pm);
+    glGetFloatv(GL_MODELVIEW_MATRIX, mm);
+
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
+    glTranslatef(0.5f, 0.5f, 0.5f);
+    glScalef(0.5f, 0.5f, 0.5f);
+    glMultMatrixf(pm);
+    glMultMatrixf(mm);
 }
 
+void setupmultitexrefract(GLuint reflecttex, GLuint refracttex)
+{
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB,  GL_INTERPOLATE_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB,  GL_CONSTANT_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB,  GL_TEXTURE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB,  GL_CONSTANT_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA);
+    
+    float wc[4] = { hdr.watercolor[0]/255.0f, hdr.watercolor[1]/255.0f, hdr.watercolor[2]/255.0f, hdr.watercolor[3]/255.0f };
+    glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, wc);
+    glBindTexture(GL_TEXTURE_2D, refracttex);
+    setprojtexmatrix();
+
+    glActiveTexture_(GL_TEXTURE1_ARB);
+    glEnable(GL_TEXTURE_2D);
+
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB,  GL_INTERPOLATE_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB,  GL_PREVIOUS_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB,  GL_TEXTURE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB,  GL_PRIMARY_COLOR_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_ONE_MINUS_SRC_ALPHA);
+   
+    glBindTexture(GL_TEXTURE_2D, reflecttex);
+    setprojtexmatrix();
+
+    glActiveTexture_(GL_TEXTURE0_ARB);
+}
+
+void setupmultitexreflect(GLuint reflecttex)
+{
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB,  GL_INTERPOLATE_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB,  GL_TEXTURE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB,  GL_CONSTANT_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB,  GL_PRIMARY_COLOR_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA);
+
+    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB,  GL_MODULATE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB,  GL_CONSTANT_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB,  GL_PREVIOUS_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_ONE_MINUS_SRC_ALPHA);
+    
+    float a = hdr.watercolor[3]/255.0f;
+    float wc[4] = { hdr.watercolor[0]/255.0f*a, hdr.watercolor[1]/255.0f*a, hdr.watercolor[2]/255.0f*a, 1.0f-a };
+    glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, wc);
+    glBindTexture(GL_TEXTURE_2D, reflecttex);
+    setprojtexmatrix();
+}
+
+void cleanupmultitex(GLuint reflecttex, GLuint refracttex)
+{
+    if(!refracttex) 
+    {
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
+        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA);
+    }
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    glLoadIdentity();
+    
+    glActiveTexture_(GL_TEXTURE1_ARB);
+    glDisable(GL_TEXTURE_2D);
+    glLoadIdentity();
+    
+    glActiveTexture_(GL_TEXTURE0_ARB);
+    glMatrixMode(GL_MODELVIEW);
+}
+
+VAR(mtwater, 0, 1, 1);
+
 int renderwater(float hf, GLuint reflecttex, GLuint refracttex)
 {
     if(wx1<0) return nquads;
@@ -422,6 +522,28 @@ int renderwater(float hf, GLuint reflecttex, GLuint refracttex)
 
     float t = lastmillis/300.0f;
 
+    if(mtwater && hasmultitexture && hasoverbright && reflecttex)
+    {
+        if(refracttex)
+        {
+            setupmultitexrefract(reflecttex, refracttex);        
+            renderwaterstrips(vertwmtc, hf, t);
+        }
+        else
+        {
+            setupmultitexreflect(reflecttex);
+            glDepthMask(GL_FALSE);
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_ONE, GL_SRC_ALPHA);
+            renderwaterstrips(vertwtc, hf, t);
+            glDisable(GL_BLEND);
+            glDepthMask(GL_TRUE);
+        }
+        cleanupmultitex(reflecttex, refracttex);
+        
+        return nquads;
+    }
+
     if(!refracttex) 
     {
         glDisable(GL_TEXTURE_2D);
@@ -435,21 +557,12 @@ int renderwater(float hf, GLuint reflecttex, GLuint refracttex)
         if(!refracttex)
         {
             glColor4ubv(hdr.watercolor);
-            renderwaterstrips(hf, 0, t);
-
+            renderwaterstrips(vertw, hf, t);
+        
             glEnable(GL_TEXTURE_2D);
         }
 
-        GLfloat pm[16], mm[16];
-        glGetFloatv(GL_PROJECTION_MATRIX, pm);
-        glGetFloatv(GL_MODELVIEW_MATRIX, mm);
-
-        glMatrixMode(GL_TEXTURE);
-        glLoadIdentity();
-        glTranslatef(0.5f, 0.5f, 0.5f);
-        glScalef(0.5f, 0.5f, 0.5f);
-        glMultMatrixf(pm);
-        glMultMatrixf(mm);
+        setprojtexmatrix();
 
         glBindTexture(GL_TEXTURE_2D, refracttex ? refracttex : reflecttex);
     }
@@ -457,14 +570,15 @@ int renderwater(float hf, GLuint reflecttex, GLuint refracttex)
     if(refracttex) 
     {
         glColor3f(1, 1, 1);
-        renderwaterstrips(hf, 1, t);
+        renderwaterstrips(vertwt, hf, t);
         glEnable(GL_BLEND);
         glDepthMask(GL_FALSE);
 
         glDepthFunc(GL_LEQUAL);
         glBindTexture(GL_TEXTURE_2D, reflecttex);
     }
-    renderwaterstrips(hf, reflecttex ? 2 : -1, t);
+    if(reflecttex) { renderwaterstrips(vertwtc, hf, t); }
+    else { renderwaterstrips(vertwc, hf, t); }
 
     if(reflecttex)
     {
diff --git a/source/src/rendergl.cpp b/source/src/rendergl.cpp
index bf475e9b..70f0fbb9 100644
--- a/source/src/rendergl.cpp
+++ b/source/src/rendergl.cpp
@@ -3,7 +3,17 @@
 #include "cube.h"
 #include "bot/bot.h"
 
-bool hasoverbright = false;
+bool hasoverbright = false, hasmultitexture = false;
+
+// GL_ARB_multitexture
+PFNGLACTIVETEXTUREARBPROC   glActiveTexture_   = NULL;
+PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2f_ = NULL;
+PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3f_ = NULL;
+
+void *getprocaddress(const char *name)
+{
+    return SDL_GL_GetProcAddress(name);
+}
 
 VAR(maxtexsize, 0, 0, 4096);
 
@@ -37,7 +47,15 @@ void gl_init(int w, int h, int bpp, int depth, int fsaa)
     if(strstr(exts, "GL_EXT_texture_env_combine")) hasoverbright = true;
 	else if(strstr(exts, "GL_ARB_texture_env_combine")) hasoverbright = true;
     else conoutf("WARNING: cannot use overbright lighting, using old lighting model!");
-        
+
+    if(strstr(exts, "GL_ARB_multitexture"))
+    {
+        hasmultitexture = true;
+        glActiveTexture_       = (PFNGLACTIVETEXTUREARBPROC)  getprocaddress("glActiveTextureARB");
+        glMultiTexCoord2f_     = (PFNGLMULTITEXCOORD2FARBPROC)getprocaddress("glMultiTexCoord2fARB");
+        glMultiTexCoord3f_     = (PFNGLMULTITEXCOORD3FARBPROC)getprocaddress("glMultiTexCoord3fARB");
+    }
+
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize);
 
     if(fsaa) glEnable(GL_MULTISAMPLE);
@@ -259,7 +277,6 @@ int reflectlastsize = 0;
 
 VARP(reflectres, 6, 7, 10);
 VAR(reflectclip, 0, 3, 100);
-VAR(refractclip, 0, 3, 100);
 VARP(waterreflect, 0, 1, 1);
 VARP(waterrefract, 0, 0, 1);
 
@@ -312,7 +329,7 @@ void drawreflection(float hf, int w, int h, float changelod, bool refract)
     }
 
     GLfloat clipmat[16];
-    genclipmatrix(0, refract ? -1 : 1, 0, refract ? 0.1f*refractclip+hf : 0.1f*reflectclip-hf, clipmat);
+    genclipmatrix(0, refract ? -1 : 1, 0, refract ? 0.1f*reflectclip+hf : 0.1f*reflectclip-hf, clipmat);
     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadMatrixf(clipmat);
@@ -346,7 +363,8 @@ void drawreflection(float hf, int w, int h, float changelod, bool refract)
 
     if(refract) glLoadIdentity();
     glMatrixMode(GL_PROJECTION);
-    if(refract)
+    extern int mtwater;
+    if(refract && !mtwater)
     {
         glLoadIdentity();
         glOrtho(0, 1, 0, 1, -1, 1);
diff --git a/source/src/vertmodel.h b/source/src/vertmodel.h
index a7bd2c00..80694b32 100644
--- a/source/src/vertmodel.h
+++ b/source/src/vertmodel.h
@@ -30,6 +30,8 @@ struct vertmodel : model
                 fr2 = (as.frame+as.range-1)-(fr2-as.frame);
             }
         }
+
+        bool operator==(const anpos &a) const { return fr1==a.fr1 && fr2==a.fr2 && (fr1==fr2 || t==a.t); }
     };
 
     struct tcvert { float u, v; ushort index; };
@@ -48,11 +50,15 @@ struct vertmodel : model
 
         vec *dynbuf;
         ushort *dynidx;
-        int dynframe, dynlen;
+        int dynlen;
+        anpos dyncur, dynprev;
         GLuint statlist;
         int statlen;
 
-        mesh() : name(0), verts(0), tcverts(0), tris(0), skin(crosshair), tex(0), dynbuf(0), dynidx(0), dynframe(-1), statlist(0) {}
+        mesh() : name(0), verts(0), tcverts(0), tris(0), skin(crosshair), tex(0), dynbuf(0), dynidx(0), statlist(0) 
+        {
+            dyncur.fr1 = dynprev.fr1 = -1;
+        }
 
         ~mesh()
         {
@@ -84,16 +90,17 @@ struct vertmodel : model
                 *pvert1 = NULL, *pvert2 = NULL;
             if(prev)
             {
+                if(dynprev==*prev && dyncur==cur) return;
+                dynprev = *prev;
                 pvert1 = &verts[prev->fr1 * numverts];
                 pvert2 = &verts[prev->fr2 * numverts];
-                dynframe = -1;
             }
-            else if(cur.fr1==cur.fr2)
+            else
             {
-                if(cur.fr1==dynframe) return;
-                dynframe = cur.fr1;
+                if(dynprev.fr1<0 && dyncur==cur) return;
+                dynprev.fr1 = -1;
             }
-            else dynframe = -1;
+            dyncur = cur;
             loopi(numverts) // vertices
             {
                 vec &v = dynbuf[i];