Reworked v_isometric code significantly, it now defaults to a proper isometric view...

[xonotic/darkplaces.git] / polygon.c

diff --git a/polygon.c b/polygon.c
index a02c032c1370da4fd85ed960d47e74a624069789..99ceb0b9d7680abecec324bd44d4d66429aaa013 100644 (file)
--- a/polygon.c
+++ b/polygon.c
@@ -3,8 +3,6 @@
 Polygon clipping routines written by Forest Hale and placed into public domain.
 */
 
-#include "quakedef.h"
-
 #include <math.h>
 #include "polygon.h"
 
@@ -98,21 +96,23 @@ void PolygonD_QuadForPlane(double *outpoints, double planenormalx, double planen
        outpoints[11] = planedist * planenormalz - quadsize * quadright[2] - quadsize * quadup[2];
 }
 
-void PolygonF_Divide(int innumpoints, const float *inpoints, float planenormalx, float planenormaly, float planenormalz, float planedist, float epsilon, int outfrontmaxpoints, float *outfrontpoints, int *neededfrontpoints, int outbackmaxpoints, float *outbackpoints, int *neededbackpoints, int *oncountpointer)
+int PolygonF_Clip(int innumpoints, const float *inpoints, float planenormalx, float planenormaly, float planenormalz, float planedist, float epsilon, int outfrontmaxpoints, float *outfrontpoints)
 {
-       int i, frontcount = 0, backcount = 0, oncount = 0;
+       int i, frontcount = 0;
        const float *n, *p;
-       double frac, pdist, ndist;
-       for (i = 0;i < innumpoints;i++)
+       float frac, pdist, ndist;
+       if (innumpoints < 1)
+               return 0;
+       n = inpoints;
+       ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+       for(i = 0;i < innumpoints;i++)
        {
-               p = inpoints + i * 3;
+               p = n;
+               pdist = ndist;
                n = inpoints + ((i + 1) < innumpoints ? (i + 1) : 0) * 3;
-               pdist = p[0] * planenormalx + p[1] * planenormaly + p[2] * planenormalz - planedist;
                ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
                if (pdist >= -epsilon)
                {
-                       if (pdist <= epsilon)
-                               oncount++;
                        if (frontcount < outfrontmaxpoints)
                        {
                                *outfrontpoints++ = p[0];
@@ -121,59 +121,38 @@ void PolygonF_Divide(int innumpoints, const float *inpoints, float planenormalx,
                        }
                        frontcount++;
                }
-               if (pdist <= epsilon)
-               {
-                       if (backcount < outbackmaxpoints)
-                       {
-                               *outbackpoints++ = p[0];
-                               *outbackpoints++ = p[1];
-                               *outbackpoints++ = p[2];
-                       }
-                       backcount++;
-               }
                if ((pdist > epsilon && ndist < -epsilon) || (pdist < -epsilon && ndist > epsilon))
                {
-                       oncount++;
                        frac = pdist / (pdist - ndist);
                        if (frontcount < outfrontmaxpoints)
                        {
-                               *outfrontpoints++ = (float)(p[0] + frac * (n[0] - p[0]));
-                               *outfrontpoints++ = (float)(p[1] + frac * (n[1] - p[1]));
-                               *outfrontpoints++ = (float)(p[2] + frac * (n[2] - p[2]));
+                               *outfrontpoints++ = p[0] + frac * (n[0] - p[0]);
+                               *outfrontpoints++ = p[1] + frac * (n[1] - p[1]);
+                               *outfrontpoints++ = p[2] + frac * (n[2] - p[2]);
                        }
                        frontcount++;
-                       if (backcount < outbackmaxpoints)
-                       {
-                               *outbackpoints++ = (float)(p[0] + frac * (n[0] - p[0]));
-                               *outbackpoints++ = (float)(p[1] + frac * (n[1] - p[1]));
-                               *outbackpoints++ = (float)(p[2] + frac * (n[2] - p[2]));
-                       }
-                       backcount++;
                }
        }
-       if (neededfrontpoints)
-               *neededfrontpoints = frontcount;
-       if (neededbackpoints)
-               *neededbackpoints = backcount;
-       if (oncountpointer)
-               *oncountpointer = oncount;
+       return frontcount;
 }
 
-void PolygonD_Divide(int innumpoints, const double *inpoints, double planenormalx, double planenormaly, double planenormalz, double planedist, double epsilon, int outfrontmaxpoints, double *outfrontpoints, int *neededfrontpoints, int outbackmaxpoints, double *outbackpoints, int *neededbackpoints, int *oncountpointer)
+int PolygonD_Clip(int innumpoints, const double *inpoints, double planenormalx, double planenormaly, double planenormalz, double planedist, double epsilon, int outfrontmaxpoints, double *outfrontpoints)
 {
-       int i, frontcount = 0, backcount = 0, oncount = 0;
+       int i, frontcount = 0;
        const double *n, *p;
        double frac, pdist, ndist;
-       for (i = 0;i < innumpoints;i++)
+       if (innumpoints < 1)
+               return 0;
+       n = inpoints;
+       ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+       for(i = 0;i < innumpoints;i++)
        {
-               p = inpoints + i * 3;
+               p = n;
+               pdist = ndist;
                n = inpoints + ((i + 1) < innumpoints ? (i + 1) : 0) * 3;
-               pdist = p[0] * planenormalx + p[1] * planenormaly + p[2] * planenormalz - planedist;
                ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
                if (pdist >= -epsilon)
                {
-                       if (pdist <= epsilon)
-                               oncount++;
                        if (frontcount < outfrontmaxpoints)
                        {
                                *outfrontpoints++ = p[0];
@@ -182,19 +161,8 @@ void PolygonD_Divide(int innumpoints, const double *inpoints, double planenormal
                        }
                        frontcount++;
                }
-               if (pdist <= epsilon)
-               {
-                       if (backcount < outbackmaxpoints)
-                       {
-                               *outbackpoints++ = p[0];
-                               *outbackpoints++ = p[1];
-                               *outbackpoints++ = p[2];
-                       }
-                       backcount++;
-               }
                if ((pdist > epsilon && ndist < -epsilon) || (pdist < -epsilon && ndist > epsilon))
                {
-                       oncount++;
                        frac = pdist / (pdist - ndist);
                        if (frontcount < outfrontmaxpoints)
                        {
@@ -203,13 +171,133 @@ void PolygonD_Divide(int innumpoints, const double *inpoints, double planenormal
                                *outfrontpoints++ = p[2] + frac * (n[2] - p[2]);
                        }
                        frontcount++;
-                       if (backcount < outbackmaxpoints)
+               }
+       }
+       return frontcount;
+}
+
+void PolygonF_Divide(int innumpoints, const float *inpoints, float planenormalx, float planenormaly, float planenormalz, float planedist, float epsilon, int outfrontmaxpoints, float *outfrontpoints, int *neededfrontpoints, int outbackmaxpoints, float *outbackpoints, int *neededbackpoints, int *oncountpointer)
+{
+       int i, frontcount = 0, backcount = 0, oncount = 0;
+       const float *n, *p;
+       float frac, pdist, ndist;
+       if (innumpoints)
+       {
+               n = inpoints;
+               ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+               for(i = 0;i < innumpoints;i++)
+               {
+                       p = n;
+                       pdist = ndist;
+                       n = inpoints + ((i + 1) < innumpoints ? (i + 1) : 0) * 3;
+                       ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+                       if (pdist >= -epsilon)
+                       {
+                               if (pdist <= epsilon)
+                                       oncount++;
+                               if (frontcount < outfrontmaxpoints)
+                               {
+                                       *outfrontpoints++ = p[0];
+                                       *outfrontpoints++ = p[1];
+                                       *outfrontpoints++ = p[2];
+                               }
+                               frontcount++;
+                       }
+                       if (pdist <= epsilon)
+                       {
+                               if (backcount < outbackmaxpoints)
+                               {
+                                       *outbackpoints++ = p[0];
+                                       *outbackpoints++ = p[1];
+                                       *outbackpoints++ = p[2];
+                               }
+                               backcount++;
+                       }
+                       if ((pdist > epsilon && ndist < -epsilon) || (pdist < -epsilon && ndist > epsilon))
                        {
-                               *outbackpoints++ = p[0] + frac * (n[0] - p[0]);
-                               *outbackpoints++ = p[1] + frac * (n[1] - p[1]);
-                               *outbackpoints++ = p[2] + frac * (n[2] - p[2]);
+                               oncount++;
+                               frac = pdist / (pdist - ndist);
+                               if (frontcount < outfrontmaxpoints)
+                               {
+                                       *outfrontpoints++ = p[0] + frac * (n[0] - p[0]);
+                                       *outfrontpoints++ = p[1] + frac * (n[1] - p[1]);
+                                       *outfrontpoints++ = p[2] + frac * (n[2] - p[2]);
+                               }
+                               frontcount++;
+                               if (backcount < outbackmaxpoints)
+                               {
+                                       *outbackpoints++ = p[0] + frac * (n[0] - p[0]);
+                                       *outbackpoints++ = p[1] + frac * (n[1] - p[1]);
+                                       *outbackpoints++ = p[2] + frac * (n[2] - p[2]);
+                               }
+                               backcount++;
+                       }
+               }
+       }
+       if (neededfrontpoints)
+               *neededfrontpoints = frontcount;
+       if (neededbackpoints)
+               *neededbackpoints = backcount;
+       if (oncountpointer)
+               *oncountpointer = oncount;
+}
+
+void PolygonD_Divide(int innumpoints, const double *inpoints, double planenormalx, double planenormaly, double planenormalz, double planedist, double epsilon, int outfrontmaxpoints, double *outfrontpoints, int *neededfrontpoints, int outbackmaxpoints, double *outbackpoints, int *neededbackpoints, int *oncountpointer)
+{
+       int i = 0, frontcount = 0, backcount = 0, oncount = 0;
+       const double *n, *p;
+       double frac, pdist, ndist;
+       if (innumpoints)
+       {
+               n = inpoints;
+               ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+               for(i = 0;i < innumpoints;i++)
+               {
+                       p = n;
+                       pdist = ndist;
+                       n = inpoints + ((i + 1) < innumpoints ? (i + 1) : 0) * 3;
+                       ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+                       if (pdist >= -epsilon)
+                       {
+                               if (pdist <= epsilon)
+                                       oncount++;
+                               if (frontcount < outfrontmaxpoints)
+                               {
+                                       *outfrontpoints++ = p[0];
+                                       *outfrontpoints++ = p[1];
+                                       *outfrontpoints++ = p[2];
+                               }
+                               frontcount++;
+                       }
+                       if (pdist <= epsilon)
+                       {
+                               if (backcount < outbackmaxpoints)
+                               {
+                                       *outbackpoints++ = p[0];
+                                       *outbackpoints++ = p[1];
+                                       *outbackpoints++ = p[2];
+                               }
+                               backcount++;
+                       }
+                       if ((pdist > epsilon && ndist < -epsilon) || (pdist < -epsilon && ndist > epsilon))
+                       {
+                               oncount++;
+                               frac = pdist / (pdist - ndist);
+                               if (frontcount < outfrontmaxpoints)
+                               {
+                                       *outfrontpoints++ = p[0] + frac * (n[0] - p[0]);
+                                       *outfrontpoints++ = p[1] + frac * (n[1] - p[1]);
+                                       *outfrontpoints++ = p[2] + frac * (n[2] - p[2]);
+                               }
+                               frontcount++;
+                               if (backcount < outbackmaxpoints)
+                               {
+                                       *outbackpoints++ = p[0] + frac * (n[0] - p[0]);
+                                       *outbackpoints++ = p[1] + frac * (n[1] - p[1]);
+                                       *outbackpoints++ = p[2] + frac * (n[2] - p[2]);
+                               }
+                               backcount++;
                        }
-                       backcount++;
                }
        }
        if (neededfrontpoints)