fix some warnings about useless code (unsigned < 0, x = x)

[xonotic/darkplaces.git] / gl_backend.c

diff --git a/gl_backend.c b/gl_backend.c
index d2dae3841c4a6bd25a8f960103933847daa3fc32..0c3e73915e2192045b8645231d7ff6746680b274 100644 (file)
--- a/gl_backend.c
+++ b/gl_backend.c
@@ -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((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);
@@ -2120,77 +2113,66 @@ void GL_CullFace(int state)
        }
 }
 
-void GL_MultiSampling(qboolean state)
+void GL_AlphaTest(int state)
 {
-       switch(vid.renderpath)
+       if (gl_state.alphatest != state)
        {
+               gl_state.alphatest = state;
+               switch(vid.renderpath)
+               {
                case RENDERPATH_GL11:
                case RENDERPATH_GL13:
                case RENDERPATH_GLES1:
-               case RENDERPATH_GL20:
-               case RENDERPATH_GLES2:
-                       if (vid.support.arb_multisample)
+                       // only fixed function uses alpha test, other paths use pixel kill capability in shaders
+                       CHECKGLERROR
+                       if (gl_state.alphatest)
                        {
-                               if (state)
-                                       qglEnable(GL_MULTISAMPLE_ARB);
-                               else
-                                       qglDisable(GL_MULTISAMPLE_ARB);
-                               CHECKGLERROR
+                               qglEnable(GL_ALPHA_TEST);CHECKGLERROR
+                       }
+                       else
+                       {
+                               qglDisable(GL_ALPHA_TEST);CHECKGLERROR
                        }
                        break;
                case RENDERPATH_D3D9:
-                       break;
                case RENDERPATH_D3D10:
-                       break;
                case RENDERPATH_D3D11:
-                       break;
                case RENDERPATH_SOFT:
+               case RENDERPATH_GL20:
+               case RENDERPATH_GLES2:
                        break;
+               }
        }
 }
 
-void GL_AlphaTest(int state)
+void GL_AlphaToCoverage(qboolean state)
 {
-       if (gl_state.alphatest != state)
+       if (gl_state.alphatocoverage != state)
        {
-               gl_state.alphatest = state;
+               gl_state.alphatocoverage = state;
                switch(vid.renderpath)
                {
                case RENDERPATH_GL11:
                case RENDERPATH_GL13:
                case RENDERPATH_GLES1:
-                       // only fixed function uses alpha test, other paths use pixel kill capability in shaders
-                       CHECKGLERROR
-                       if (gl_state.alphatest)
-                       {
-                               qglEnable((r_transparent_alphatocoverage.integer) ? GL_SAMPLE_ALPHA_TO_COVERAGE_ARB : GL_ALPHA_TEST);CHECKGLERROR
-                       }
-                       else
-                       {
-                               qglDisable((r_transparent_alphatocoverage.integer) ? GL_SAMPLE_ALPHA_TO_COVERAGE_ARB : GL_ALPHA_TEST);CHECKGLERROR
-                       }
-                       break;
+               case RENDERPATH_GLES2:
                case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-//                     IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHATESTENABLE, gl_state.alphatest);
-#endif
-                       break;
                case RENDERPATH_D3D10:
-                       break;
                case RENDERPATH_D3D11:
-                       break;
                case RENDERPATH_SOFT:
-                       DPSOFTRAST_AlphaTest(gl_state.alphatest);
                        break;
                case RENDERPATH_GL20:
-               case RENDERPATH_GLES2:
-                       if (vid_multisampling.integer)
+                       // 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)
                        {
-                               if (gl_state.alphatest && r_transparent_alphatocoverage.integer)
-                                       qglEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
-                               else
-                                       qglDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
-                               CHECKGLERROR
+                               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;
                }
@@ -4414,3 +4396,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;
+               }
+       }
+}