]> git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - gl_backend.c
Add/update cvars and such... Almost done now basically. Just a bit of testing left.
[xonotic/darkplaces.git] / gl_backend.c
index 6fc886ba0052b212304e5857536ddbcc4928ec79..74938dc509636456b57232e62e22db1376b99bb6 100644 (file)
@@ -137,6 +137,7 @@ typedef struct gl_state_s
        int alphatest;
        int alphafunc;
        float alphafuncvalue;
+       qboolean alphatocoverage;
        int scissortest;
        unsigned int unit;
        unsigned int clientunit;
@@ -1391,6 +1392,7 @@ static void GL_Backend_ResetState(void)
        gl_state.alphatest = false;
        gl_state.alphafunc = GL_GEQUAL;
        gl_state.alphafuncvalue = 0.5f;
+       gl_state.alphatocoverage = false;
        gl_state.blendfunc1 = GL_ONE;
        gl_state.blendfunc2 = GL_ZERO;
        gl_state.blend = false;
@@ -1412,9 +1414,6 @@ static void GL_Backend_ResetState(void)
 #ifdef SUPPORTD3D
                {
                        IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_COLORWRITEENABLE, gl_state.colormask);
-                       IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHATESTENABLE, gl_state.alphatest);
-                       IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHAFUNC, d3dcmpforglfunc(gl_state.alphafunc));
-                       IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHAREF, (int)bound(0, gl_state.alphafuncvalue * 256.0f, 255));
                        IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_NONE);
                        IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZFUNC, d3dcmpforglfunc(gl_state.depthfunc));
                        IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZENABLE, gl_state.depthtest);
@@ -1437,7 +1436,7 @@ static void GL_Backend_ResetState(void)
 
                qglColorMask(1, 1, 1, 1);CHECKGLERROR
                qglAlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);CHECKGLERROR
-               qglDisable((vid_multisampling.integer && r_transparent_alphatocoverage.integer) ? GL_SAMPLE_ALPHA_TO_COVERAGE_ARB : GL_ALPHA_TEST);CHECKGLERROR
+               qglDisable(GL_ALPHA_TEST);CHECKGLERROR
                qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
                qglDisable(GL_BLEND);CHECKGLERROR
                qglCullFace(gl_state.cullface);CHECKGLERROR
@@ -1499,7 +1498,6 @@ static void GL_Backend_ResetState(void)
                break;
        case RENDERPATH_SOFT:
                DPSOFTRAST_ColorMask(1,1,1,1);
-               DPSOFTRAST_AlphaTest(gl_state.alphatest);
                DPSOFTRAST_BlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);
                DPSOFTRAST_CullFace(gl_state.cullface);
                DPSOFTRAST_DepthFunc(gl_state.depthfunc);
@@ -1520,11 +1518,6 @@ static void GL_Backend_ResetState(void)
                qglEnable(GL_DEPTH_TEST);CHECKGLERROR
                qglDepthMask(gl_state.depthmask);CHECKGLERROR
                qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
-       //      if (vid.renderpath == RENDERPATH_GL20)
-       //      {
-       //              qglAlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);CHECKGLERROR
-       //              qglDisable(GL_ALPHA_TEST);CHECKGLERROR
-       //      }
                if (vid.support.arb_vertex_buffer_object)
                {
                        qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
@@ -2134,27 +2127,53 @@ void GL_AlphaTest(int state)
                        CHECKGLERROR
                        if (gl_state.alphatest)
                        {
-                               qglEnable((vid_multisampling.integer && r_transparent_alphatocoverage.integer) ? GL_SAMPLE_ALPHA_TO_COVERAGE_ARB : GL_ALPHA_TEST);CHECKGLERROR
+                               qglEnable(GL_ALPHA_TEST);CHECKGLERROR
                        }
                        else
                        {
-                               qglDisable((vid_multisampling.integer && r_transparent_alphatocoverage.integer) ? GL_SAMPLE_ALPHA_TO_COVERAGE_ARB : GL_ALPHA_TEST);CHECKGLERROR
+                               qglDisable(GL_ALPHA_TEST);CHECKGLERROR
                        }
                        break;
                case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-//                     IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHATESTENABLE, gl_state.alphatest);
-#endif
-                       break;
                case RENDERPATH_D3D10:
-                       break;
                case RENDERPATH_D3D11:
+               case RENDERPATH_SOFT:
+               case RENDERPATH_GL20:
+               case RENDERPATH_GLES2:
                        break;
+               }
+       }
+}
+
+void GL_AlphaToCoverage(qboolean state)
+{
+       if (gl_state.alphatocoverage != state)
+       {
+               gl_state.alphatocoverage = state;
+               switch(vid.renderpath)
+               {
+               case RENDERPATH_GL11:
+               case RENDERPATH_GL13:
+               case RENDERPATH_GLES1:
+               case RENDERPATH_GLES2:
+               case RENDERPATH_D3D9:
+               case RENDERPATH_D3D10:
+               case RENDERPATH_D3D11:
                case RENDERPATH_SOFT:
-//                     DPSOFTRAST_AlphaTest(gl_state.alphatest);
                        break;
                case RENDERPATH_GL20:
-               case RENDERPATH_GLES2:
+                       // alpha to coverage turns the alpha value of the pixel into 0%, 25%, 50%, 75% or 100% by masking the multisample fragments accordingly
+                       CHECKGLERROR
+                       if (gl_state.alphatocoverage)
+                       {
+                               qglEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR
+//                             qglEnable(GL_MULTISAMPLE_ARB);CHECKGLERROR
+                       }
+                       else
+                       {
+                               qglDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR
+//                             qglDisable(GL_MULTISAMPLE_ARB);CHECKGLERROR
+                       }
                        break;
                }
        }
@@ -2698,121 +2717,201 @@ void R_Mesh_Draw(int firstvertex, int numvertices, int firsttriangle, int numtri
                                unsigned int i, j, element;
                                const GLfloat *p;
                                qglBegin(GL_TRIANGLES);
-                               for (i = 0;i < (unsigned int) numtriangles * 3;i++)
+                               if(vid.renderpath == RENDERPATH_GL20)
                                {
-                                       if (element3i)
-                                               element = element3i[i];
-                                       else if (element3s)
-                                               element = element3s[i];
-                                       else
-                                               element = firstvertex + i;
-                                       for (j = 0;j < vid.texarrayunits;j++)
+                                       for (i = 0;i < (unsigned int) numtriangles * 3;i++)
                                        {
-                                               if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
+                                               if (element3i)
+                                                       element = element3i[i];
+                                               else if (element3s)
+                                                       element = element3s[i];
+                                               else
+                                                       element = firstvertex + i;
+                                               for (j = 0;j < vid.texarrayunits;j++)
                                                {
-                                                       if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
+                                                       if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
                                                        {
-                                                               p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
-                                                               if (vid.texarrayunits > 1)
-                                                               {
-                                                                       if (gl_state.units[j].pointer_texcoord_components == 4)
-                                                                               qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2], p[3]);
-                                                                       else if (gl_state.units[j].pointer_texcoord_components == 3)
-                                                                               qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2]);
-                                                                       else if (gl_state.units[j].pointer_texcoord_components == 2)
-                                                                               qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, p[0], p[1]);
-                                                                       else
-                                                                               qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, p[0]);
-                                                               }
-                                                               else
+                                                               if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
                                                                {
+                                                                       p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
                                                                        if (gl_state.units[j].pointer_texcoord_components == 4)
-                                                                               qglTexCoord4f(p[0], p[1], p[2], p[3]);
+                                                                               qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1], p[2], p[3]);
                                                                        else if (gl_state.units[j].pointer_texcoord_components == 3)
-                                                                               qglTexCoord3f(p[0], p[1], p[2]);
+                                                                               qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1], p[2]);
                                                                        else if (gl_state.units[j].pointer_texcoord_components == 2)
-                                                                               qglTexCoord2f(p[0], p[1]);
+                                                                               qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1]);
                                                                        else
-                                                                               qglTexCoord1f(p[0]);
+                                                                               qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, p[0]);
                                                                }
-                                                       }
-                                                       else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
-                                                       {
-                                                               const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
-                                                               if (vid.texarrayunits > 1)
+                                                               else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
                                                                {
+                                                                       const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
                                                                        if (gl_state.units[j].pointer_texcoord_components == 4)
-                                                                               qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, s[0], s[1], s[2], s[3]);
+                                                                               qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1], s[2], s[3]);
                                                                        else if (gl_state.units[j].pointer_texcoord_components == 3)
-                                                                               qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, s[0], s[1], s[2]);
+                                                                               qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1], s[2]);
                                                                        else if (gl_state.units[j].pointer_texcoord_components == 2)
-                                                                               qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, s[0], s[1]);
+                                                                               qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1]);
                                                                        else if (gl_state.units[j].pointer_texcoord_components == 1)
-                                                                               qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, s[0]);
+                                                                               qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, s[0]);
                                                                }
-                                                               else
+                                                               else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
                                                                {
+                                                                       const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
                                                                        if (gl_state.units[j].pointer_texcoord_components == 4)
-                                                                               qglTexCoord4f(s[0], s[1], s[2], s[3]);
+                                                                               qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1], sb[2], sb[3]);
                                                                        else if (gl_state.units[j].pointer_texcoord_components == 3)
-                                                                               qglTexCoord3f(s[0], s[1], s[2]);
+                                                                               qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1], sb[2]);
                                                                        else if (gl_state.units[j].pointer_texcoord_components == 2)
-                                                                               qglTexCoord2f(s[0], s[1]);
+                                                                               qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1]);
                                                                        else if (gl_state.units[j].pointer_texcoord_components == 1)
-                                                                               qglTexCoord1f(s[0]);
+                                                                               qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, sb[0]);
                                                                }
                                                        }
-                                                       else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
+                                               }
+                                               if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
+                                               {
+                                                       if (gl_state.pointer_color_gltype == GL_FLOAT)
+                                                       {
+                                                               p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
+                                                               qglVertexAttrib4f(GLSLATTRIB_COLOR, p[0], p[1], p[2], p[3]);
+                                                       }
+                                                       else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
+                                                       {
+                                                               const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
+                                                               qglVertexAttrib4Nub(GLSLATTRIB_COLOR, ub[0], ub[1], ub[2], ub[3]);
+                                                       }
+                                               }
+                                               if (gl_state.pointer_vertex_gltype == GL_FLOAT)
+                                               {
+                                                       p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
+                                                       if (gl_state.pointer_vertex_components == 4)
+                                                               qglVertexAttrib4f(GLSLATTRIB_POSITION, p[0], p[1], p[2], p[3]);
+                                                       else if (gl_state.pointer_vertex_components == 3)
+                                                               qglVertexAttrib3f(GLSLATTRIB_POSITION, p[0], p[1], p[2]);
+                                                       else
+                                                               qglVertexAttrib2f(GLSLATTRIB_POSITION, p[0], p[1]);
+                                               }
+                                       }
+                               }
+                               else
+                               {
+                                       for (i = 0;i < (unsigned int) numtriangles * 3;i++)
+                                       {
+                                               if (element3i)
+                                                       element = element3i[i];
+                                               else if (element3s)
+                                                       element = element3s[i];
+                                               else
+                                                       element = firstvertex + i;
+                                               for (j = 0;j < vid.texarrayunits;j++)
+                                               {
+                                                       if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
                                                        {
-                                                               const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
-                                                               if (vid.texarrayunits > 1)
+                                                               if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
                                                                {
-                                                                       if (gl_state.units[j].pointer_texcoord_components == 4)
-                                                                               qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, sb[0], sb[1], sb[2], sb[3]);
-                                                                       else if (gl_state.units[j].pointer_texcoord_components == 3)
-                                                                               qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, sb[0], sb[1], sb[2]);
-                                                                       else if (gl_state.units[j].pointer_texcoord_components == 2)
-                                                                               qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, sb[0], sb[1]);
-                                                                       else if (gl_state.units[j].pointer_texcoord_components == 1)
-                                                                               qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, sb[0]);
+                                                                       p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
+                                                                       if (vid.texarrayunits > 1)
+                                                                       {
+                                                                               if (gl_state.units[j].pointer_texcoord_components == 4)
+                                                                                       qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2], p[3]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 3)
+                                                                                       qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 2)
+                                                                                       qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, p[0], p[1]);
+                                                                               else
+                                                                                       qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, p[0]);
+                                                                       }
+                                                                       else
+                                                                       {
+                                                                               if (gl_state.units[j].pointer_texcoord_components == 4)
+                                                                                       qglTexCoord4f(p[0], p[1], p[2], p[3]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 3)
+                                                                                       qglTexCoord3f(p[0], p[1], p[2]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 2)
+                                                                                       qglTexCoord2f(p[0], p[1]);
+                                                                               else
+                                                                                       qglTexCoord1f(p[0]);
+                                                                       }
                                                                }
-                                                               else
+                                                               else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
                                                                {
-                                                                       if (gl_state.units[j].pointer_texcoord_components == 4)
-                                                                               qglTexCoord4f(sb[0], sb[1], sb[2], sb[3]);
-                                                                       else if (gl_state.units[j].pointer_texcoord_components == 3)
-                                                                               qglTexCoord3f(sb[0], sb[1], sb[2]);
-                                                                       else if (gl_state.units[j].pointer_texcoord_components == 2)
-                                                                               qglTexCoord2f(sb[0], sb[1]);
-                                                                       else if (gl_state.units[j].pointer_texcoord_components == 1)
-                                                                               qglTexCoord1f(sb[0]);
+                                                                       const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
+                                                                       if (vid.texarrayunits > 1)
+                                                                       {
+                                                                               if (gl_state.units[j].pointer_texcoord_components == 4)
+                                                                                       qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, s[0], s[1], s[2], s[3]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 3)
+                                                                                       qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, s[0], s[1], s[2]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 2)
+                                                                                       qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, s[0], s[1]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 1)
+                                                                                       qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, s[0]);
+                                                                       }
+                                                                       else
+                                                                       {
+                                                                               if (gl_state.units[j].pointer_texcoord_components == 4)
+                                                                                       qglTexCoord4f(s[0], s[1], s[2], s[3]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 3)
+                                                                                       qglTexCoord3f(s[0], s[1], s[2]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 2)
+                                                                                       qglTexCoord2f(s[0], s[1]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 1)
+                                                                                       qglTexCoord1f(s[0]);
+                                                                       }
+                                                               }
+                                                               else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
+                                                               {
+                                                                       const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
+                                                                       if (vid.texarrayunits > 1)
+                                                                       {
+                                                                               if (gl_state.units[j].pointer_texcoord_components == 4)
+                                                                                       qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, sb[0], sb[1], sb[2], sb[3]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 3)
+                                                                                       qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, sb[0], sb[1], sb[2]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 2)
+                                                                                       qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, sb[0], sb[1]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 1)
+                                                                                       qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, sb[0]);
+                                                                       }
+                                                                       else
+                                                                       {
+                                                                               if (gl_state.units[j].pointer_texcoord_components == 4)
+                                                                                       qglTexCoord4f(sb[0], sb[1], sb[2], sb[3]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 3)
+                                                                                       qglTexCoord3f(sb[0], sb[1], sb[2]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 2)
+                                                                                       qglTexCoord2f(sb[0], sb[1]);
+                                                                               else if (gl_state.units[j].pointer_texcoord_components == 1)
+                                                                                       qglTexCoord1f(sb[0]);
+                                                                       }
                                                                }
                                                        }
                                                }
-                                       }
-                                       if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
-                                       {
-                                               if (gl_state.pointer_color_gltype == GL_FLOAT)
+                                               if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
                                                {
-                                                       p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
-                                                       qglColor4f(p[0], p[1], p[2], p[3]);
+                                                       if (gl_state.pointer_color_gltype == GL_FLOAT)
+                                                       {
+                                                               p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
+                                                               qglColor4f(p[0], p[1], p[2], p[3]);
+                                                       }
+                                                       else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
+                                                       {
+                                                               const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
+                                                               qglColor4ub(ub[0], ub[1], ub[2], ub[3]);
+                                                       }
                                                }
-                                               else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
+                                               if (gl_state.pointer_vertex_gltype == GL_FLOAT)
                                                {
-                                                       const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
-                                                       qglColor4ub(ub[0], ub[1], ub[2], ub[3]);
+                                                       p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
+                                                       if (gl_state.pointer_vertex_components == 4)
+                                                               qglVertex4f(p[0], p[1], p[2], p[3]);
+                                                       else if (gl_state.pointer_vertex_components == 3)
+                                                               qglVertex3f(p[0], p[1], p[2]);
+                                                       else
+                                                               qglVertex2f(p[0], p[1]);
                                                }
                                        }
-                                       if (gl_state.pointer_vertex_gltype == GL_FLOAT)
-                                       {
-                                               p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
-                                               if (gl_state.pointer_vertex_components == 4)
-                                                       qglVertex4f(p[0], p[1], p[2], p[3]);
-                                               else if (gl_state.pointer_vertex_components == 3)
-                                                       qglVertex3f(p[0], p[1], p[2]);
-                                               else
-                                                       qglVertex2f(p[0], p[1]);
-                                       }
                                }
                                qglEnd();
                                CHECKGLERROR
@@ -4377,3 +4476,61 @@ void R_Mesh_PrepareVertices_Mesh(int numvertices, const r_vertexmesh_t *vertex,
                break;
        }
 }
+
+void GL_BlendEquationSubtract(qboolean negated)
+{
+       if(negated)
+       {
+               switch(vid.renderpath)
+               {
+               case RENDERPATH_GL11:
+               case RENDERPATH_GL13:
+               case RENDERPATH_GL20:
+               case RENDERPATH_GLES1:
+               case RENDERPATH_GLES2:
+                       qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
+                       break;
+               case RENDERPATH_D3D9:
+#ifdef SUPPORTD3D
+                       IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
+#endif
+                       break;
+               case RENDERPATH_D3D10:
+                       Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+                       break;
+               case RENDERPATH_D3D11:
+                       Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+                       break;
+               case RENDERPATH_SOFT:
+                       DPSOFTRAST_BlendSubtract(true);
+                       break;
+               }
+       }
+       else
+       {
+               switch(vid.renderpath)
+               {
+               case RENDERPATH_GL11:
+               case RENDERPATH_GL13:
+               case RENDERPATH_GL20:
+               case RENDERPATH_GLES1:
+               case RENDERPATH_GLES2:
+                       qglBlendEquationEXT(GL_FUNC_ADD_EXT);
+                       break;
+               case RENDERPATH_D3D9:
+#ifdef SUPPORTD3D
+                       IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
+#endif
+                       break;
+               case RENDERPATH_D3D10:
+                       Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+                       break;
+               case RENDERPATH_D3D11:
+                       Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+                       break;
+               case RENDERPATH_SOFT:
+                       DPSOFTRAST_BlendSubtract(false);
+                       break;
+               }
+       }
+}