Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers into modules, and delete rossubsys.

win32ss/gdi/ntgdi/bezier.c

@@ -0,0 +1,215 @@
+/*
+ * COPYRIGHT: GNU LGPL
+ * PURPOSE:   Bezier functions
+ */
+
+#include <win32k.h>
+
+#define NDEBUG
+#include <debug.h>
+
+/* Based on Wine Staging 1.7.37 - dlls/gdi32/painting.c */
+
+/******************************************************************
+ *
+ *   *Very* simple bezier drawing code,
+ *
+ *   It uses a recursive algorithm to divide the curve in a series
+ *   of straight line segments. Not ideal but sufficient for me.
+ *   If you are in need for something better look for some incremental
+ *   algorithm.
+ *
+ *   7 July 1998 Rein Klazes
+ */
+
+ /*
+  * some macro definitions for bezier drawing
+  *
+  * to avoid truncation errors the coordinates are
+  * shifted upwards. When used in drawing they are
+  * shifted down again, including correct rounding
+  * and avoiding floating point arithmetic
+  * 4 bits should allow 27 bits coordinates which I saw
+  * somewhere in the win32 doc's
+  *
+  */
+
+#define BEZIERSHIFTBITS 4
+#define BEZIERSHIFTUP(x)    ((x)<<BEZIERSHIFTBITS)
+#define BEZIERPIXEL        BEZIERSHIFTUP(1)
+#define BEZIERSHIFTDOWN(x)  (((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS)
+/* maximum depth of recursion */
+#define BEZIERMAXDEPTH  8
+
+/* size of array to store points on */
+/* enough for one curve */
+#define BEZIER_INITBUFSIZE    (150)
+
+/* calculate Bezier average, in this case the middle
+ * correctly rounded...
+ * */
+
+#define BEZIERMIDDLE(Mid, P1, P2) \
+    (Mid).x=((P1).x+(P2).x + 1)/2;\
+    (Mid).y=((P1).y+(P2).y + 1)/2;
+
+/**********************************************************
+* BezierCheck helper function to check
+* that recursion can be terminated
+*       Points[0] and Points[3] are begin and endpoint
+*       Points[1] and Points[2] are control points
+*       level is the recursion depth
+*       returns true if the recursion can be terminated
+*/
+static BOOL BezierCheck( int level, POINT *Points)
+{
+    INT dx, dy;
+    dx=Points[3].x-Points[0].x;
+    dy=Points[3].y-Points[0].y;
+    if(abs(dy)<=abs(dx)){/* shallow line */
+        /* check that control points are between begin and end */
+        if(Points[1].x < Points[0].x){
+            if(Points[1].x < Points[3].x)
+                return FALSE;
+        }else
+            if(Points[1].x > Points[3].x)
+                return FALSE;
+        if(Points[2].x < Points[0].x){
+            if(Points[2].x < Points[3].x)
+                return FALSE;
+        }else
+            if(Points[2].x > Points[3].x)
+                return FALSE;
+        dx=BEZIERSHIFTDOWN(dx);
+        if(!dx) return TRUE;
+        if(abs(Points[1].y-Points[0].y-(dy/dx)*
+                BEZIERSHIFTDOWN(Points[1].x-Points[0].x)) > BEZIERPIXEL ||
+           abs(Points[2].y-Points[0].y-(dy/dx)*
+                   BEZIERSHIFTDOWN(Points[2].x-Points[0].x)) > BEZIERPIXEL )
+            return FALSE;
+        else
+            return TRUE;
+    }else{ /* steep line */
+        /* check that control points are between begin and end */
+        if(Points[1].y < Points[0].y){
+            if(Points[1].y < Points[3].y)
+                return FALSE;
+        }else
+            if(Points[1].y > Points[3].y)
+                return FALSE;
+        if(Points[2].y < Points[0].y){
+            if(Points[2].y < Points[3].y)
+                return FALSE;
+        }else
+            if(Points[2].y > Points[3].y)
+                return FALSE;
+        dy=BEZIERSHIFTDOWN(dy);
+        if(!dy) return TRUE;
+        if(abs(Points[1].x-Points[0].x-(dx/dy)*
+                BEZIERSHIFTDOWN(Points[1].y-Points[0].y)) > BEZIERPIXEL ||
+           abs(Points[2].x-Points[0].x-(dx/dy)*
+                   BEZIERSHIFTDOWN(Points[2].y-Points[0].y)) > BEZIERPIXEL )
+            return FALSE;
+        else
+            return TRUE;
+    }
+}
+
+/* Helper for GDI_Bezier.
+ * Just handles one Bezier, so Points should point to four POINTs
+ */
+static void GDI_InternalBezier( POINT *Points, POINT **PtsOut, INT *dwOut,
+				INT *nPtsOut, INT level )
+{
+    if(*nPtsOut == *dwOut) {
+        *dwOut *= 2;
+        *PtsOut = ExAllocatePoolWithTag(PagedPool, *dwOut * sizeof(POINT), TAG_BEZIER);
+        if (*PtsOut == NULL)
+        {
+            /// \todo FIXME!
+            NT_ASSERT(FALSE);
+            return;
+        }
+    }
+
+    if(!level || BezierCheck(level, Points)) {
+        if(*nPtsOut == 0) {
+            (*PtsOut)[0].x = BEZIERSHIFTDOWN(Points[0].x);
+            (*PtsOut)[0].y = BEZIERSHIFTDOWN(Points[0].y);
+            *nPtsOut = 1;
+        }
+	(*PtsOut)[*nPtsOut].x = BEZIERSHIFTDOWN(Points[3].x);
+        (*PtsOut)[*nPtsOut].y = BEZIERSHIFTDOWN(Points[3].y);
+        (*nPtsOut) ++;
+    } else {
+        POINT Points2[4]; /* for the second recursive call */
+        Points2[3]=Points[3];
+        BEZIERMIDDLE(Points2[2], Points[2], Points[3]);
+        BEZIERMIDDLE(Points2[0], Points[1], Points[2]);
+        BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);
+
+        BEZIERMIDDLE(Points[1], Points[0],  Points[1]);
+        BEZIERMIDDLE(Points[2], Points[1], Points2[0]);
+        BEZIERMIDDLE(Points[3], Points[2], Points2[1]);
+
+        Points2[0]=Points[3];
+
+        /* do the two halves */
+        GDI_InternalBezier(Points, PtsOut, dwOut, nPtsOut, level-1);
+        GDI_InternalBezier(Points2, PtsOut, dwOut, nPtsOut, level-1);
+    }
+}
+
+
+
+/***********************************************************************
+ *           GDI_Bezier   [INTERNAL]
+ *   Calculate line segments that approximate -what microsoft calls- a bezier
+ *   curve.
+ *   The routine recursively divides the curve in two parts until a straight
+ *   line can be drawn
+ *
+ *  PARAMS
+ *
+ *  Points  [I] Ptr to count POINTs which are the end and control points
+ *              of the set of Bezier curves to flatten.
+ *  count   [I] Number of Points.  Must be 3n+1.
+ *  nPtsOut [O] Will contain no of points that have been produced (i.e. no. of
+ *              lines+1).
+ *
+ *  RETURNS
+ *
+ *  Ptr to an array of POINTs that contain the lines that approximate the
+ *  Beziers.  The array is allocated on the process heap and it is the caller's
+ *  responsibility to HeapFree it. [this is not a particularly nice interface
+ *  but since we can't know in advance how many points we will generate, the
+ *  alternative would be to call the function twice, once to determine the size
+ *  and a second time to do the work - I decided this was too much of a pain].
+ */
+POINT *GDI_Bezier( const POINT *Points, INT count, INT *nPtsOut )
+{
+    POINT *out;
+    INT Bezier, dwOut = BEZIER_INITBUFSIZE, i;
+
+    if (count == 1 || (count - 1) % 3 != 0) {
+        DPRINT1("Invalid no. of points %d\n", count);
+	return NULL;
+    }
+    *nPtsOut = 0;
+
+    out = ExAllocatePoolWithTag(PagedPool, dwOut * sizeof(POINT), TAG_BEZIER);
+    if (!out) return NULL;
+
+    for(Bezier = 0; Bezier < (count-1)/3; Bezier++) {
+	POINT ptBuf[4];
+	memcpy(ptBuf, Points + Bezier * 3, sizeof(POINT) * 4);
+	for(i = 0; i < 4; i++) {
+	    ptBuf[i].x = BEZIERSHIFTUP(ptBuf[i].x);
+	    ptBuf[i].y = BEZIERSHIFTUP(ptBuf[i].y);
+	}
+        GDI_InternalBezier( ptBuf, &out, &dwOut, nPtsOut, BEZIERMAXDEPTH );
+    }
+    DPRINT("Produced %d points\n", *nPtsOut);
+    return out;
+}
+/* EOF */