doubled entity limit in animcache, we should never hit this

[xonotic/darkplaces.git] / vid_shared.c

diff --git a/vid_shared.c b/vid_shared.c
index f66cc9a6f41711010f615b5dd9531d8eacf795e1..ce164b4d48b511a32b5ee82cf387624f32f6e7c9 100644 (file)
--- a/vid_shared.c
+++ b/vid_shared.c
@@ -404,7 +404,12 @@ int GL_CheckExtension(const char *minglver_or_ext, const dllfunction_t *funcs, c
        struct { int major, minor; } min_version, curr_version;
        int ext;
 
-       ext = !(sscanf(minglver_or_ext, "%d.%d", &min_version.major, &min_version.minor) == 2);
+       if(sscanf(minglver_or_ext, "%d.%d", &min_version.major, &min_version.minor) == 2)
+               ext = 0; // opengl version
+       else if(minglver_or_ext[0] != toupper(minglver_or_ext[0]))
+               ext = -1; // pseudo name
+       else
+               ext = 1; // extension name
 
        if (ext)
                Con_DPrintf("checking for %s...  ", minglver_or_ext);
@@ -420,7 +425,7 @@ int GL_CheckExtension(const char *minglver_or_ext, const dllfunction_t *funcs, c
                return false;
        }
 
-       if (ext)
+       if (ext == 1) // opengl extension
        {
                if (!strstr(gl_extensions ? gl_extensions : "", minglver_or_ext) && !strstr(gl_platformextensions ? gl_platformextensions : "", minglver_or_ext))
                {
@@ -428,7 +433,8 @@ int GL_CheckExtension(const char *minglver_or_ext, const dllfunction_t *funcs, c
                        return false;
                }
        }
-       else
+
+       if(ext == 0) // opengl version
        {
                sscanf(gl_version, "%d.%d", &curr_version.major, &curr_version.minor);
 
@@ -966,7 +972,7 @@ void VID_UpdateGamma(qboolean force, int rampsize)
        BOUNDCVAR(v_gamma, 0.1, 5);
        BOUNDCVAR(v_contrast, 1, 5);
        BOUNDCVAR(v_brightness, 0, 0.8);
-       BOUNDCVAR(v_contrastboost, 0.0625, 16);
+       //BOUNDCVAR(v_contrastboost, 0.0625, 16);
        BOUNDCVAR(v_color_black_r, 0, 0.8);
        BOUNDCVAR(v_color_black_g, 0, 0.8);
        BOUNDCVAR(v_color_black_b, 0, 0.8);
@@ -1261,3 +1267,65 @@ void VID_Start(void)
        VID_OpenSystems();
 }
 
+int VID_SortModes_Compare(const void *a_, const void *b_)
+{
+       vid_mode_t *a = (vid_mode_t *) a_;
+       vid_mode_t *b = (vid_mode_t *) b_;
+       if(a->width > b->width)
+               return +1;
+       if(a->width < b->width)
+               return -1;
+       if(a->height > b->height)
+               return +1;
+       if(a->height < b->height)
+               return -1;
+       if(a->refreshrate > b->refreshrate)
+               return +1;
+       if(a->refreshrate < b->refreshrate)
+               return -1;
+       if(a->bpp > b->bpp)
+               return +1;
+       if(a->bpp < b->bpp)
+               return -1;
+       if(a->pixelheight_num * b->pixelheight_denom > a->pixelheight_denom * b->pixelheight_num)
+               return +1;
+       if(a->pixelheight_num * b->pixelheight_denom < a->pixelheight_denom * b->pixelheight_num)
+               return -1;
+       return 0;
+}
+size_t VID_SortModes(vid_mode_t *modes, size_t count, qboolean usebpp, qboolean userefreshrate, qboolean useaspect)
+{
+       size_t i;
+       if(count == 0)
+               return 0;
+       // 1. sort them
+       qsort(modes, count, sizeof(*modes), VID_SortModes_Compare);
+       // 2. remove duplicates
+       for(i = 0; i < count; ++i)
+       {
+               if(modes[i].width && modes[i].height)
+               {
+                       if(i == 0)
+                               continue;
+                       if(modes[i].width != modes[i-1].width)
+                               continue;
+                       if(modes[i].height != modes[i-1].height)
+                               continue;
+                       if(userefreshrate)
+                               if(modes[i].refreshrate != modes[i-1].refreshrate)
+                                       continue;
+                       if(usebpp)
+                               if(modes[i].bpp != modes[i-1].bpp)
+                                       continue;
+                       if(useaspect)
+                               if(modes[i].pixelheight_num * modes[i-1].pixelheight_denom != modes[i].pixelheight_denom * modes[i-1].pixelheight_num)
+                                       continue;
+               }
+               // a dupe, or a bogus mode!
+               if(i < count-1)
+                       memmove(&modes[i], &modes[i+1], sizeof(*modes) * (count-1 - i));
+               --i; // check this index again, as mode i+1 is now here
+               --count;
+       }
+       return count;
+}