some code refactors in raskter.c to sync it with build where mask tiling is being developed. Also adds a bit more mask tiling code.

3 files changed, 478 insertions, 468 deletions

diff --git a/intern/raskter/raskter.c b/intern/raskter/raskter.c
index a5fb0c4b118..9511b931e8f 100644
--- a/intern/raskter/raskter.c
+++ b/intern/raskter/raskter.c
@@ -814,14 +814,14 @@ int get_range_expanded_pixel_coord(float normalized_value, int max_value) {
     return (int)((normalized_value * (float)(max_value)) + 0.5f);
 }
 
-float get_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y) {
+inline float get_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y) {
     if(pos_x < 0 || pos_x >= buf_x || pos_y < 0 || pos_y >= buf_y) {
         return 0.0f;
     }
     return buf[(pos_y * buf_x) + pos_x];
 }
 
-float get_pixel_intensity_bilinear(float *buf, int buf_x, int buf_y, float u, float v) {
+inline float get_pixel_intensity_bilinear(float *buf, int buf_x, int buf_y, float u, float v) {
     int a;
     int b;
     int a_plus_1;
@@ -847,7 +847,7 @@ float get_pixel_intensity_bilinear(float *buf, int buf_x, int buf_y, float u, fl
 
 }
 
-void set_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y, float intensity) {
+inline void set_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y, float intensity) {
     if(pos_x < 0 || pos_x >= buf_x || pos_y < 0 || pos_y >= buf_y) {
         return;
     }
@@ -869,114 +869,114 @@ int PLX_antialias_buffer(float *buf, int buf_x, int buf_y) {
     (void)buf;
     return 1;
 #else
-    const float p0 = 1.0f;
-    const float p1 = 1.0f;
-    const float p2 = 1.0f;
-    const float p3 = 1.0f;
-    const float p4 = 1.0f;
-    const float p5 = 1.5f;
-    const float p6 = 2.0f;
-    const float p7 = 2.0f;
-    const float p8 = 2.0f;
-    const float p9 = 2.0f;
-    const float p10 = 4.0f;
-    const float p11 = 8.0f;
+    const float jump01 = 1.0f;
+    const float jump02 = 1.0f;
+    const float jump03 = 1.0f;
+    const float jump04 = 1.0f;
+    const float jump05 = 1.0f;
+    const float jump06 = 1.5f;
+    const float jump07 = 2.0f;
+    const float jump08 = 2.0f;
+    const float jump09 = 2.0f;
+    const float jump10 = 2.0f;
+    const float jump11 = 4.0f;
+    const float jump12 = 8.0f;
 
     const float edge_threshold = 0.063f;
     const float edge_threshold_min = 0.0312f;
     const float quality_subpix = 1.0f;
 
-    float posM_x,posM_y;
-    float posB_x,posB_y;
-    float posN_x,posN_y;
-    float posP_x,posP_y;
-    float offNP_x,offNP_y;
-    float lumaM;
-    float lumaS;
-    float lumaE;
-    float lumaN;
-    float lumaW;
-    float lumaNW;
-    float lumaSE;
-    float lumaNE;
-    float lumaSW;
-    float lumaNS;
-    float lumaWE;
-    float lumaNESE;
-    float lumaNWNE;
-    float lumaNWSW;
-    float lumaSWSE;
-    float lumaNN;
-    float lumaSS;
-    float lumaEndN;
-    float lumaEndP;
-    float lumaMM;
-    float lumaMLTZero;
-    float subpixNWSWNESE;
-    float subpixRcpRange;
-    float subpixNSWE;
-    float maxSM;
-    float minSM;
-    float maxESM;
-    float minESM;
-    float maxWN;
-    float minWN;
-    float rangeMax;
-    float rangeMin;
-    float rangeMaxScaled;
-    float range;
-    float rangeMaxClamped;
-    float edgeHorz;
-    float edgeVert;
-    float edgeHorz1;
-    float edgeVert1;
-    float edgeHorz2;
-    float edgeVert2;
-    float edgeHorz3;
-    float edgeVert3;
-    float edgeHorz4;
-    float edgeVert4;
-    float lengthSign;
-    float subpixA;
-    float subpixB;
-    float subpixC;
-    float subpixD;
-    float subpixE;
-    float subpixF;
-    float subpixG;
-    float subpixH;
-    float gradientN;
-    float gradientS;
-    float gradient;
-    float gradientScaled;
-    float dstN;
-    float dstP;
+    float fpcx,fpcy;
+    float fpsqx,fpsqy;
+    float fprevx,fprevy;
+    float fpfowx,fpfowy;
+    float offset_dgx,offset_dgy;
+    float pci;
+    float pdi;
+    float pri;
+    float pui;
+    float pli;
+    float uli;
+    float dri;
+    float uri;
+    float dli;
+    float udi;
+    float lri;
+    float fsi;
+    float ti;
+    float cdi;
+    float bi;
+    float uui;
+    float ddi;
+    float eri;
+    float efi;
+    float cci;
+    float ltz;
+    float spX;
+    float inv_r;
+    float spP;
+    float gdc;
+    float sdc;
+    float gedc;
+    float sedc;
+    float glu;
+    float slu;
+    float gr;
+    float sr;
+    float grexp;
+    float r;
+    float grc;
+    float lre;
+    float ude;
+    float lre0;
+    float ude0;
+    float lre1;
+    float ude1;
+    float lre2;
+    float ude2;
+    float lre3;
+    float ude3;
+    float sdst;
+    float tg0;
+    float tg1;
+    float tg2;
+    float tg3;
+    float tg4;
+    float tg5;
+    float tg6;
+    float tg7;
+    float ugrad;
+    float dgrad;
+    float grad;
+    float gradexp;
+    float revdst;
+    float fowdst;
     float dst;
-    float spanLength;
-    float spanLengthRcp;
-    float pixelOffset;
-    float pixelOffsetGood;
-    float pixelOffsetSubpix;
+    float dsts;
+    float inv_dsts;
+    float pxOff;
+    float gpxOff;
+    float tgpxOff;
     float opx;
     float opy;
-    int directionN;
-    int goodSpan;
-    int goodSpanN;
-    int goodSpanP;
-    int horzSpan;
-    int earlyExit;
-    int pairN;
-    int doneN;
-    int doneP;
-    int doneNP;
+    int uls;
+    int sph;
+    int revsph;
+    int fowsph;
+    int lrsp;
+    int done;
+    int revpp;
+    int revdone;
+    int fowdone;
+    int tug_of_war;
     int curr_x=0;
     int curr_y=0;
     opx = (1.0f / (float)(buf_x));
     opy = (1.0f / (float)(buf_y));
     for(curr_y=0; curr_y < buf_y; curr_y++) {
         for(curr_x=0; curr_x < buf_x; curr_x++) {
-            posM_x = ((float)(curr_x) + 0.5f) * opx;
-            posM_y = ((float)(curr_y) + 0.5f) * opy;
+            fpcx = ((float)(curr_x) + 0.5f) * opx;
+            fpcy = ((float)(curr_y) + 0.5f) * opy;
 //#define __PLX_BILINEAR_INITIAL_SAMPLES__ 1
 #ifdef __PLX_BILINEAR_INITIAL_SAMPLES__
             lumaM = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x, posM_y);
@@ -985,359 +985,359 @@ int PLX_antialias_buffer(float *buf, int buf_x, int buf_y) {
             lumaN = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x, posM_y - opy);
             lumaW = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x - opx, posM_y);
 #else
-    lumaM = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y);
-    lumaS = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y + 1);
-    lumaE = get_pixel_intensity(buf, buf_x, buf_y, curr_x + 1, curr_y);
-    lumaN = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y - 1);
-    lumaW = get_pixel_intensity(buf, buf_x, buf_y, curr_x - 1, curr_y);
+    pci = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y);
+    pdi = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y + 1);
+    pri = get_pixel_intensity(buf, buf_x, buf_y, curr_x + 1, curr_y);
+    pui = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y - 1);
+    pli = get_pixel_intensity(buf, buf_x, buf_y, curr_x - 1, curr_y);
 #endif
-            maxSM = MAX2(lumaS, lumaM);
-            minSM = MIN2(lumaS, lumaM);
-            maxESM = MAX2(lumaE, maxSM);
-            minESM = MIN2(lumaE, minSM);
-            maxWN = MAX2(lumaN, lumaW);
-            minWN = MIN2(lumaN, lumaW);
-            rangeMax = MAX2(maxWN, maxESM);
-            rangeMin = MIN2(minWN, minESM);
-            rangeMaxScaled = rangeMax * edge_threshold;
-            range = rangeMax - rangeMin;
-            rangeMaxClamped = MAX2(edge_threshold_min, rangeMaxScaled);
-
-            earlyExit = range < rangeMaxClamped ? 1:0;
-            if(earlyExit) {
-                set_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y, lumaM);
+            gdc = MAX2(pdi, pci);
+            sdc = MIN2(pdi, pci);
+            gedc = MAX2(pri, gdc);
+            sedc = MIN2(pri, sdc);
+            glu = MAX2(pui, pli);
+            slu = MIN2(pui, pli);
+            gr = MAX2(glu, gedc);
+            sr = MIN2(slu, sedc);
+            grexp = gr * edge_threshold;
+            r = gr - sr;
+            grc = MAX2(edge_threshold_min, grexp);
+
+            done = r < grc ? 1:0;
+            if(done) {
+                set_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y, pci);
             } else {
 
-                lumaNW = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x - opx, posM_y - opy);
-                lumaSE = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x + opx, posM_y + opy);
-                lumaNE = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x + opx, posM_y - opy);
-                lumaSW = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x - opx, posM_y + opy);
-
-                lumaNS = lumaN + lumaS;
-                lumaWE = lumaW + lumaE;
-                subpixRcpRange = 1.0f/range;
-                subpixNSWE = lumaNS + lumaWE;
-                edgeHorz1 = (-2.0f * lumaM) + lumaNS;
-                edgeVert1 = (-2.0f * lumaM) + lumaWE;
-
-                lumaNESE = lumaNE + lumaSE;
-                lumaNWNE = lumaNW + lumaNE;
-                edgeHorz2 = (-2.0f * lumaE) + lumaNESE;
-                edgeVert2 = (-2.0f * lumaN) + lumaNWNE;
-
-                lumaNWSW = lumaNW + lumaSW;
-                lumaSWSE = lumaSW + lumaSE;
-                edgeHorz4 = (ABS(edgeHorz1) * 2.0f) + ABS(edgeHorz2);
-                edgeVert4 = (ABS(edgeVert1) * 2.0f) + ABS(edgeVert2);
-                edgeHorz3 = (-2.0f * lumaW) + lumaNWSW;
-                edgeVert3 = (-2.0f * lumaS) + lumaSWSE;
-                edgeHorz = ABS(edgeHorz3) + edgeHorz4;
-                edgeVert = ABS(edgeVert3) + edgeVert4;
-
-                subpixNWSWNESE = lumaNWSW + lumaNESE;
-                lengthSign = 1.0f / (float)(buf_x);
-                horzSpan = edgeHorz >= edgeVert ? 1:0;
-                subpixA = subpixNSWE * 2.0f + subpixNWSWNESE;
-
-                if(!horzSpan) {
-                    lumaN = lumaW;
-                    lumaS = lumaE;
+                uli = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx - opx, fpcy - opy);
+                dri = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx + opx, fpcy + opy);
+                uri = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx + opx, fpcy - opy);
+                dli = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx - opx, fpcy + opy);
+
+                udi = pui + pdi;
+                lri = pli + pri;
+                inv_r = 1.0f/r;
+                spP = udi + lri;
+                lre0 = (-2.0f * pci) + udi;
+                ude0 = (-2.0f * pci) + lri;
+
+                fsi = uri + dri;
+                ti = uli + uri;
+                lre1 = (-2.0f * pri) + fsi;
+                ude1 = (-2.0f * pui) + ti;
+
+                cdi = uli + dli;
+                bi = dli + dri;
+                lre3 = (ABS(lre0) * 2.0f) + ABS(lre1);
+                ude3 = (ABS(ude0) * 2.0f) + ABS(ude1);
+                lre2 = (-2.0f * pli) + cdi;
+                ude2 = (-2.0f * pdi) + bi;
+                lre = ABS(lre2) + lre3;
+                ude = ABS(ude2) + ude3;
+
+                spX = cdi + fsi;
+                sdst = 1.0f / (float)(buf_x);
+                lrsp = lre >= ude ? 1:0;
+                tg0 = spP * 2.0f + spX;
+
+                if(!lrsp) {
+                    pui = pli;
+                    pdi = pri;
                 } else {
-                    lengthSign = 1.0f / (float)(buf_y);
+                    sdst = 1.0f / (float)(buf_y);
                 }
-                subpixB = (subpixA * (1.0f/12.0f)) - lumaM;
-
-                gradientN = lumaN - lumaM;
-                gradientS = lumaS - lumaM;
-                lumaNN = lumaN + lumaM;
-                lumaSS = lumaS + lumaM;
-                pairN = (ABS(gradientN)) >= (ABS(gradientS)) ? 1:0;
-                gradient = MAX2(ABS(gradientN), ABS(gradientS));
-                if(pairN) {
-                    lengthSign = -lengthSign;
+                tg1 = (tg0 * (1.0f/12.0f)) - pci;
+
+                ugrad = pui - pci;
+                dgrad = pdi - pci;
+                uui = pui + pci;
+                ddi = pdi + pci;
+                revpp = (ABS(ugrad)) >= (ABS(dgrad)) ? 1:0;
+                grad = MAX2(ABS(ugrad), ABS(dgrad));
+                if(revpp) {
+                    sdst = -sdst;
                 }
-                subpixC = MAX2(MIN2(ABS(subpixB) * subpixRcpRange,1.0f),0.0f);
-
-                posB_x = posM_x;
-                posB_y = posM_y;
-                offNP_x = (!horzSpan) ? 0.0f:(1.0f / (float)(buf_x));
-                offNP_y = (horzSpan) ? 0.0f:(1.0f / (float)(buf_y));
-                if(!horzSpan) {
-                    posB_x += lengthSign * 0.5f;
+                tg2 = MAX2(MIN2(ABS(tg1) * inv_r,1.0f),0.0f);
+
+                fpsqx = fpcx;
+                fpsqy = fpcy;
+                offset_dgx = (!lrsp) ? 0.0f:(1.0f / (float)(buf_x));
+                offset_dgy = (lrsp) ? 0.0f:(1.0f / (float)(buf_y));
+                if(!lrsp) {
+                    fpsqx += sdst * 0.5f;
                 } else {
-                    posB_y += lengthSign * 0.5f;
+                    fpsqy += sdst * 0.5f;
                 }
 
-                posN_x = posB_x - offNP_x * p0;
-                posN_y = posB_y - offNP_y * p0;
-                posP_x = posB_x + offNP_x * p0;
-                posP_y = posB_y + offNP_y * p0;
-                subpixD = ((-2.0f)*subpixC) + 3.0f;
-                lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
-                subpixE = subpixC * subpixC;
-                lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
-
-                if(!pairN) {
-                    lumaNN = lumaSS;
+                fprevx = fpsqx - offset_dgx * jump01;
+                fprevy = fpsqy - offset_dgy * jump01;
+                fpfowx = fpsqx + offset_dgx * jump01;
+                fpfowy = fpsqy + offset_dgy * jump01;
+                tg3 = ((-2.0f)*tg2) + 3.0f;
+                eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
+                tg4 = tg2 * tg2;
+                efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
+
+                if(!revpp) {
+                    uui = ddi;
                 }
-                gradientScaled = gradient * 1.0f/4.0f;
-                lumaMM =lumaM - lumaNN * 0.5f;
-                subpixF = subpixD * subpixE;
-                lumaMLTZero = lumaMM < 0.0f ? 1:0;
-
-                lumaEndN -= lumaNN * 0.5f;
-                lumaEndP -= lumaNN * 0.5f;
-                doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                if(!doneN) {
-                    posN_x -= offNP_x * p1;
-                    posN_y -= offNP_y * p1;
+                gradexp = grad * 1.0f/4.0f;
+                cci =pci - uui * 0.5f;
+                tg5 = tg3 * tg4;
+                ltz = cci < 0.0f ? 1:0;
+
+                eri -= uui * 0.5f;
+                efi -= uui * 0.5f;
+                revdone = (ABS(eri)) >= gradexp ? 1:0;
+                fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                if(!revdone) {
+                    fprevx -= offset_dgx * jump02;
+                    fprevy -= offset_dgy * jump02;
                 }
-                doneNP = (!doneN) || (!doneP) ? 1:0;
-                if(!doneP) {
-                    posP_x += offNP_x * p1;
-                    posP_y += offNP_y * p1;
+                tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                if(!fowdone) {
+                    fpfowx += offset_dgx * jump02;
+                    fpfowy += offset_dgy * jump02;
                 }
 
-                if(doneNP) {
-                    if(!doneN) {
-                        lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posN_x,posN_y);
+                if(tug_of_war) {
+                    if(!revdone) {
+                        eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fprevx,fprevy);
                     }
-                    if(!doneP) {
-                        lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x, posP_y);
+                    if(!fowdone) {
+                        efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx, fpfowy);
                     }
-                    if(!doneN) {
-                        lumaEndN = lumaEndN - lumaNN * 0.5;
+                    if(!revdone) {
+                        eri = eri - uui * 0.5;
                     }
-                    if(!doneP) {
-                        lumaEndP = lumaEndP - lumaNN * 0.5;
+                    if(!fowdone) {
+                        efi = efi - uui * 0.5;
                     }
-                    doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                    doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                    if(!doneN) {
-                        posN_x -= offNP_x * p2;
-                        posN_y -= offNP_y * p2;
+                    revdone = (ABS(eri)) >= gradexp ? 1:0;
+                    fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                    if(!revdone) {
+                        fprevx -= offset_dgx * jump03;
+                        fprevy -= offset_dgy * jump03;
                     }
-                    doneNP = (!doneN) || (!doneP) ? 1:0;
-                    if(!doneP) {
-                        posP_x += offNP_x * p2;
-                        posP_y += offNP_y * p2;
+                    tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                    if(!fowdone) {
+                        fpfowx += offset_dgx * jump03;
+                        fpfowy += offset_dgy * jump03;
                     }
-                    if(doneNP) {
-                        if(!doneN) {
-                            lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                    if(tug_of_war) {
+                        if(!revdone) {
+                            eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                         }
-                        if(!doneP) {
-                            lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                        if(!fowdone) {
+                            efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                         }
-                        if(!doneN) {
-                            lumaEndN = lumaEndN - lumaNN * 0.5;
+                        if(!revdone) {
+                            eri = eri - uui * 0.5;
                         }
-                        if(!doneP) {
-                            lumaEndP = lumaEndP - lumaNN * 0.5;
+                        if(!fowdone) {
+                            efi = efi - uui * 0.5;
                         }
-                        doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                        doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                        if(!doneN) {
-                            posN_x -= offNP_x * p3;
-                            posN_y -= offNP_y * p3;
+                        revdone = (ABS(eri)) >= gradexp ? 1:0;
+                        fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                        if(!revdone) {
+                            fprevx -= offset_dgx * jump04;
+                            fprevy -= offset_dgy * jump04;
                         }
-                        doneNP = (!doneN) || (!doneP) ? 1:0;
-                        if(!doneP) {
-                            posP_x += offNP_x * p3;
-                            posP_y += offNP_y * p3;
+                        tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                        if(!fowdone) {
+                            fpfowx += offset_dgx * jump04;
+                            fpfowy += offset_dgy * jump04;
                         }
-                        if(doneNP) {
-                            if(!doneN) {
-                                lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                        if(tug_of_war) {
+                            if(!revdone) {
+                                eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                             }
-                            if(!doneP) {
-                                lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                            if(!fowdone) {
+                                efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                             }
-                            if(!doneN) {
-                                lumaEndN = lumaEndN - lumaNN * 0.5;
+                            if(!revdone) {
+                                eri = eri - uui * 0.5;
                             }
-                            if(!doneP) {
-                                lumaEndP = lumaEndP - lumaNN * 0.5;
+                            if(!fowdone) {
+                                efi = efi - uui * 0.5;
                             }
-                            doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                            doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                            if(!doneN) {
-                                posN_x -= offNP_x * p4;
-                                posN_y -= offNP_y * p4;
+                            revdone = (ABS(eri)) >= gradexp ? 1:0;
+                            fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                            if(!revdone) {
+                                fprevx -= offset_dgx * jump05;
+                                fprevy -= offset_dgy * jump05;
                             }
-                            doneNP = (!doneN) || (!doneP) ? 1:0;
-                            if(!doneP) {
-                                posP_x += offNP_x * p4;
-                                posP_y += offNP_y * p4;
+                            tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                            if(!fowdone) {
+                                fpfowx += offset_dgx * jump05;
+                                fpfowy += offset_dgy * jump05;
                             }
-                            if(doneNP) {
-                                if(!doneN) {
-                                    lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                            if(tug_of_war) {
+                                if(!revdone) {
+                                    eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                                 }
-                                if(!doneP) {
-                                    lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                                if(!fowdone) {
+                                    efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                                 }
-                                if(!doneN) {
-                                    lumaEndN = lumaEndN - lumaNN * 0.5;
+                                if(!revdone) {
+                                    eri = eri - uui * 0.5;
                                 }
-                                if(!doneP) {
-                                    lumaEndP = lumaEndP - lumaNN * 0.5;
+                                if(!fowdone) {
+                                    efi = efi - uui * 0.5;
                                 }
-                                doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                                doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                                if(!doneN) {
-                                    posN_x -= offNP_x * p5;
-                                    posN_y -= offNP_y * p5;
+                                revdone = (ABS(eri)) >= gradexp ? 1:0;
+                                fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                                if(!revdone) {
+                                    fprevx -= offset_dgx * jump06;
+                                    fprevy -= offset_dgy * jump06;
                                 }
-                                doneNP = (!doneN) || (!doneP) ? 1:0;
-                                if(!doneP) {
-                                    posP_x += offNP_x * p5;
-                                    posP_y += offNP_y * p5;
+                                tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                                if(!fowdone) {
+                                    fpfowx += offset_dgx * jump06;
+                                    fpfowy += offset_dgy * jump06;
                                 }
-                                if(doneNP) {
-                                    if(!doneN) {
-                                        lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                                if(tug_of_war) {
+                                    if(!revdone) {
+                                        eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                                     }
-                                    if(!doneP) {
-                                        lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                                    if(!fowdone) {
+                                        efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                                     }
-                                    if(!doneN) {
-                                        lumaEndN = lumaEndN - lumaNN * 0.5;
+                                    if(!revdone) {
+                                        eri = eri - uui * 0.5;
                                     }
-                                    if(!doneP) {
-                                        lumaEndP = lumaEndP - lumaNN * 0.5;
+                                    if(!fowdone) {
+                                        efi = efi - uui * 0.5;
                                     }
-                                    doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                                    doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                                    if(!doneN) {
-                                        posN_x -= offNP_x * p6;
-                                        posN_y -= offNP_y * p6;
+                                    revdone = (ABS(eri)) >= gradexp ? 1:0;
+                                    fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                                    if(!revdone) {
+                                        fprevx -= offset_dgx * jump07;
+                                        fprevy -= offset_dgy * jump07;
                                     }
-                                    doneNP = (!doneN) || (!doneP) ? 1:0;
-                                    if(!doneP) {
-                                        posP_x += offNP_x * p6;
-                                        posP_y += offNP_y * p6;
+                                    tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                                    if(!fowdone) {
+                                        fpfowx += offset_dgx * jump07;
+                                        fpfowy += offset_dgy * jump07;
                                     }
-                                    if(doneNP) {
-                                        if(!doneN) {
-                                            lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                                    if(tug_of_war) {
+                                        if(!revdone) {
+                                            eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                                         }
-                                        if(!doneP) {
-                                            lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                                        if(!fowdone) {
+                                            efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                                         }
-                                        if(!doneN) {
-                                            lumaEndN = lumaEndN - lumaNN * 0.5;
+                                        if(!revdone) {
+                                            eri = eri - uui * 0.5;
                                         }
-                                        if(!doneP) {
-                                            lumaEndP = lumaEndP - lumaNN * 0.5;
+                                        if(!fowdone) {
+                                            efi = efi - uui * 0.5;
                                         }
-                                        doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                                        doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                                        if(!doneN) {
-                                            posN_x -= offNP_x * p7;
-                                            posN_y -= offNP_y * p7;
+                                        revdone = (ABS(eri)) >= gradexp ? 1:0;
+                                        fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                                        if(!revdone) {
+                                            fprevx -= offset_dgx * jump08;
+                                            fprevy -= offset_dgy * jump08;
                                         }
-                                        doneNP = (!doneN) || (!doneP) ? 1:0;
-                                        if(!doneP) {
-                                            posP_x += offNP_x * p7;
-                                            posP_y += offNP_y * p7;
+                                        tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                                        if(!fowdone) {
+                                            fpfowx += offset_dgx * jump08;
+                                            fpfowy += offset_dgy * jump08;
                                         }
-                                        if(doneNP) {
-                                            if(!doneN) {
-                                                lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                                        if(tug_of_war) {
+                                            if(!revdone) {
+                                                eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                                             }
-                                            if(!doneP) {
-                                                lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                                            if(!fowdone) {
+                                                efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                                             }
-                                            if(!doneN) {
-                                                lumaEndN = lumaEndN - lumaNN * 0.5;
+                                            if(!revdone) {
+                                                eri = eri - uui * 0.5;
                                             }
-                                            if(!doneP) {
-                                                lumaEndP = lumaEndP - lumaNN * 0.5;
+                                            if(!fowdone) {
+                                                efi = efi - uui * 0.5;
                                             }
-                                            doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                                            doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                                            if(!doneN) {
-                                                posN_x -= offNP_x * p8;
-                                                posN_y -= offNP_y * p8;
+                                            revdone = (ABS(eri)) >= gradexp ? 1:0;
+                                            fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                                            if(!revdone) {
+                                                fprevx -= offset_dgx * jump09;
+                                                fprevy -= offset_dgy * jump09;
                                             }
-                                            doneNP = (!doneN) || (!doneP) ? 1:0;
-                                            if(!doneP) {
-                                                posP_x += offNP_x * p8;
-                                                posP_y += offNP_y * p8;
+                                            tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                                            if(!fowdone) {
+                                                fpfowx += offset_dgx * jump09;
+                                                fpfowy += offset_dgy * jump09;
                                             }
-                                            if(doneNP) {
-                                                if(!doneN) {
-                                                    lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                                            if(tug_of_war) {
+                                                if(!revdone) {
+                                                    eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                                                 }
-                                                if(!doneP) {
-                                                    lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                                                if(!fowdone) {
+                                                    efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                                                 }
-                                                if(!doneN) {
-                                                    lumaEndN = lumaEndN - lumaNN * 0.5;
+                                                if(!revdone) {
+                                                    eri = eri - uui * 0.5;
                                                 }
-                                                if(!doneP) {
-                                                    lumaEndP = lumaEndP - lumaNN * 0.5;
+                                                if(!fowdone) {
+                                                    efi = efi - uui * 0.5;
                                                 }
-                                                doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                                                doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                                                if(!doneN) {
-                                                    posN_x -= offNP_x * p9;
-                                                    posN_y -= offNP_y * p9;
+                                                revdone = (ABS(eri)) >= gradexp ? 1:0;
+                                                fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                                                if(!revdone) {
+                                                    fprevx -= offset_dgx * jump10;
+                                                    fprevy -= offset_dgy * jump10;
                                                 }
-                                                doneNP = (!doneN) || (!doneP) ? 1:0;
-                                                if(!doneP) {
-                                                    posP_x += offNP_x * p9;
-                                                    posP_y += offNP_y * p9;
+                                                tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                                                if(!fowdone) {
+                                                    fpfowx += offset_dgx * jump10;
+                                                    fpfowy += offset_dgy * jump10;
                                                 }
-                                                if(doneNP) {
-                                                    if(!doneN) {
-                                                        lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                                                if(tug_of_war) {
+                                                    if(!revdone) {
+                                                        eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                                                     }
-                                                    if(!doneP) {
-                                                        lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                                                    if(!fowdone) {
+                                                        efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                                                     }
-                                                    if(!doneN) {
-                                                        lumaEndN = lumaEndN - lumaNN * 0.5;
+                                                    if(!revdone) {
+                                                        eri = eri - uui * 0.5;
                                                     }
-                                                    if(!doneP) {
-                                                        lumaEndP = lumaEndP - lumaNN * 0.5;
+                                                    if(!fowdone) {
+                                                        efi = efi - uui * 0.5;
                                                     }
-                                                    doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                                                    doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                                                    if(!doneN) {
-                                                        posN_x -= offNP_x * p10;
-                                                        posN_y -= offNP_y * p10;
+                                                    revdone = (ABS(eri)) >= gradexp ? 1:0;
+                                                    fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                                                    if(!revdone) {
+                                                        fprevx -= offset_dgx * jump11;
+                                                        fprevy -= offset_dgy * jump11;
                                                     }
-                                                    doneNP = (!doneN) || (!doneP) ? 1:0;
-                                                    if(!doneP) {
-                                                        posP_x += offNP_x * p10;
-                                                        posP_y += offNP_y * p10;
+                                                    tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                                                    if(!fowdone) {
+                                                        fpfowx += offset_dgx * jump11;
+                                                        fpfowy += offset_dgy * jump11;
                                                     }
-                                                    if(doneNP) {
-                                                        if(!doneN) {
-                                                            lumaEndN = get_pixel_intensity_bilinear(buf, buf_x, buf_y,posN_x,posN_y);
+                                                    if(tug_of_war) {
+                                                        if(!revdone) {
+                                                            eri = get_pixel_intensity_bilinear(buf, buf_x, buf_y,fprevx,fprevy);
                                                         }
-                                                        if(!doneP) {
-                                                            lumaEndP = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posP_x,posP_y);
+                                                        if(!fowdone) {
+                                                            efi = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpfowx,fpfowy);
                                                         }
-                                                        if(!doneN) {
-                                                            lumaEndN = lumaEndN - lumaNN * 0.5;
+                                                        if(!revdone) {
+                                                            eri = eri - uui * 0.5;
                                                         }
-                                                        if(!doneP) {
-                                                            lumaEndP = lumaEndP - lumaNN * 0.5;
+                                                        if(!fowdone) {
+                                                            efi = efi - uui * 0.5;
                                                         }
-                                                        doneN = (ABS(lumaEndN)) >= gradientScaled ? 1:0;
-                                                        doneP = (ABS(lumaEndP)) >= gradientScaled ? 1:0;
-                                                        if(!doneN) {
-                                                            posN_x -= offNP_x * p11;
-                                                            posN_y -= offNP_y * p11;
+                                                        revdone = (ABS(eri)) >= gradexp ? 1:0;
+                                                        fowdone = (ABS(efi)) >= gradexp ? 1:0;
+                                                        if(!revdone) {
+                                                            fprevx -= offset_dgx * jump12;
+                                                            fprevy -= offset_dgy * jump12;
                                                         }
-                                                        doneNP = (!doneN) || (!doneP) ? 1:0;
-                                                        if(!doneP) {
-                                                            posP_x += offNP_x * p11;
-                                                            posP_y += offNP_y * p11;
+                                                        tug_of_war = (!revdone) || (!fowdone) ? 1:0;
+                                                        if(!fowdone) {
+                                                            fpfowx += offset_dgx * jump12;
+                                                            fpfowy += offset_dgy * jump12;
                                                         }
                                                     }
                                                 }
@@ -1349,34 +1349,33 @@ int PLX_antialias_buffer(float *buf, int buf_x, int buf_y) {
                         }
                     }
                 }
-                dstN = posM_x - posN_x;
-                dstP = posP_x - posM_x;
-                if(!horzSpan) {
-                    dstN = posM_y - posN_y;
-                    dstP = posP_y - posM_y;
+                revdst = fpcx - fprevx;
+                fowdst = fpfowx - fpcx;
+                if(!lrsp) {
+                    revdst = fpcy - fprevy;
+                    fowdst = fpfowy - fpcy;
                 }
 
-                goodSpanN = ((lumaEndN < 0.0f) ? 1:0) != lumaMLTZero ? 1:0;
-                spanLength = (dstP + dstN);
-                goodSpanP = ((lumaEndP < 0.0f) ? 1:0) != lumaMLTZero ? 1:0;
-                spanLengthRcp = 1.0f/spanLength;
-
-                directionN = dstN < dstP ? 1:0;
-                dst = MIN2(dstN, dstP);
-                goodSpan = (directionN==1) ? goodSpanN:goodSpanP;
-                subpixG = subpixF * subpixF;
-                pixelOffset = (dst * (-spanLengthRcp)) + 0.5f;
-                subpixH = subpixG * quality_subpix;
-
-                pixelOffsetGood = (goodSpan==1) ? pixelOffset : 0.0f;
-                pixelOffsetSubpix = MAX2(pixelOffsetGood, subpixH);
-                if(!horzSpan) {
-                    posM_x += pixelOffsetSubpix * lengthSign;
+                revsph = ((eri < 0.0f) ? 1:0) != ltz ? 1:0;
+                dsts = (fowdst + revdst);
+                fowsph = ((efi < 0.0f) ? 1:0) != ltz ? 1:0;
+                inv_dsts = 1.0f/dsts;
+
+                uls = revdst < fowdst ? 1:0;
+                dst = MIN2(revdst, fowdst);
+                sph = (uls==1) ? revsph:fowsph;
+                tg6 = tg5 * tg5;
+                pxOff = (dst * (-inv_dsts)) + 0.5f;
+                tg7 = tg6 * quality_subpix;
+
+                gpxOff = (sph==1) ? pxOff : 0.0f;
+                tgpxOff = MAX2(gpxOff, tg7);
+                if(!lrsp) {
+                    fpcx += tgpxOff * sdst;
                 } else {
-                    posM_y += pixelOffsetSubpix * lengthSign;
+                    fpcy += tgpxOff * sdst;
                 }
-                //may need bilinear filtered get_pixel_intensity() here...
-                set_pixel_intensity(buf,buf_x,buf_y,curr_x,curr_y,get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x,posM_y));
+                set_pixel_intensity(buf,buf_x,buf_y,curr_x,curr_y,get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx,fpcy));
             }
         }
     }
@@ -1385,82 +1384,82 @@ int PLX_antialias_buffer(float *buf, int buf_x, int buf_y) {
 #endif
 }
 
-#define SWAP_POLYVERT(a,b)	ptemp[0]=(a)[0]; ptemp[1]=(a)[1]; (a)[0]=(b)[0]; (a)[1]=(b)[1]; (b)[0]=ptemp[0]; (b)[1]=ptemp[1];
+#define SWAP_POLYVERT(a,b)	point_temp[0]=(a)[0]; point_temp[1]=(a)[1]; (a)[0]=(b)[0]; (a)[1]=(b)[1]; (b)[0]=point_temp[0]; (b)[1]=point_temp[1];
 #define __PLX_SMALL_COUNT__ 13
 void plx_floatsort(float(*f)[2], unsigned int n, int sortby) {
-    unsigned int i;
-    unsigned int ir;
-    unsigned int j;
-    unsigned int k;
-    unsigned int l=1;
-    unsigned int istack[50];
-    int jstack=0;
-    float a[2];
-    float ptemp[2];
-
-    ir=n;
+    unsigned int a;
+    unsigned int b;
+    unsigned int c;
+    unsigned int d=1;
+    unsigned int hold;
+    unsigned int index_list[50];
+    int index_offset=0;
+    float t[2];
+    float point_temp[2];
+
+    hold=n;
     for(;;) {
-        if(ir-l < __PLX_SMALL_COUNT__) {
-            for(j=l+1; j<=ir; j++) {
-                a[1]=f[j][1];
-                a[0]=f[j][0];
-                for(i=j-1; i>=l; i--) {
-                    if(f[i][sortby] <= a[sortby]) {
+        if(hold-d < __PLX_SMALL_COUNT__) {
+            for(b=d+1; b<=hold; b++) {
+                t[1]=f[b][1];
+                t[0]=f[b][0];
+                for(a=b-1; a>=d; a--) {
+                    if(f[a][sortby] <= t[sortby]) {
                         break;
                     }
-                    f[i+1][1]=f[i][1];
-                    f[i+1][0]=f[i][0];
+                    f[a+1][1]=f[a][1];
+                    f[a+1][0]=f[a][0];
                 }
-                f[i+1][1]=a[1];
-                f[i+1][0]=a[0];
+                f[a+1][1]=t[1];
+                f[a+1][0]=t[0];
             }
-            if(jstack < 0) {
+            if(index_offset < 0) {
                 break;
             }
-            ir=istack[jstack--];
-            l=istack[jstack--];
+            hold=index_list[index_offset--];
+            d=index_list[index_offset--];
         } else {
-            k=(l+ir) >> 1;
-            SWAP_POLYVERT(f[k],f[l+1])
-            if(f[l][sortby] > f[ir][sortby]) {
-                SWAP_POLYVERT(f[l],f[ir])
+            c=(d+hold) >> 1;
+            SWAP_POLYVERT(f[c],f[d+1])
+            if(f[d][sortby] > f[hold][sortby]) {
+                SWAP_POLYVERT(f[d],f[hold])
             }
-            if(f[l+1][sortby] > f[ir][sortby]) {
-                SWAP_POLYVERT(f[l+1],f[ir])
+            if(f[d+1][sortby] > f[hold][sortby]) {
+                SWAP_POLYVERT(f[d+1],f[hold])
             }
-            if(f[l][sortby] > f[l+1][sortby]) {
-                SWAP_POLYVERT(f[l],f[l+1])
+            if(f[d][sortby] > f[d+1][sortby]) {
+                SWAP_POLYVERT(f[d],f[d+1])
             }
-            i=l+1;
-            j=ir;
-            a[0]=f[l+1][0];
-            a[1]=f[l+1][1];
+            a=d+1;
+            b=hold;
+            t[0]=f[d+1][0];
+            t[1]=f[d+1][1];
             for(;;) {
-                do i++;
-                while(f[i][sortby] < a[sortby]);
-                do j--;
-                while(f[j][sortby] > a[sortby]);
-                if(j < i) {
+                do a++;
+                while(f[a][sortby] < t[sortby]);
+                do b--;
+                while(f[b][sortby] > t[sortby]);
+                if(b < a) {
                     break;
                 }
-                SWAP_POLYVERT(f[i],f[j])
+                SWAP_POLYVERT(f[a],f[b])
             }
-            f[l+1][0]=f[j][0];
-            f[l+1][1]=f[j][1];
-            f[j][0]=a[0];
-            f[j][1]=a[1];
-            jstack+=2;
-            if(jstack > __PLX_SMALL_COUNT__) {
+            f[d+1][0]=f[b][0];
+            f[d+1][1]=f[b][1];
+            f[b][0]=t[0];
+            f[b][1]=t[1];
+            index_offset+=2;
+            if(index_offset > __PLX_SMALL_COUNT__) {
                 return;
             }
-            if(ir-i+1 >= j-l) {
-                istack[jstack]=ir;
-                istack[jstack-1]=i;
-                ir=j-1;
+            if(hold-a+1 >= b-d) {
+                index_list[index_offset]=hold;
+                index_list[index_offset-1]=a;
+                hold=b-1;
             } else {
-                istack[jstack]=j-1;
-                istack[jstack-1]=l;
-                l=i;
+                index_list[index_offset]=b-1;
+                index_list[index_offset-1]=d;
+                d=a;
             }
         }
     }
@@ -1521,3 +1520,4 @@ int plx_find_upper_bound(float v, float(*a)[2], int num_feather_verts) {
         return num_feather_verts;
     }
 }
+
diff --git a/intern/raskter/raskter.h b/intern/raskter/raskter.h
index 004085d23c7..cf679dd37c0 100644
--- a/intern/raskter/raskter.h
+++ b/intern/raskter/raskter.h
@@ -80,11 +80,21 @@ struct r_fill_context {
     int bounds_length;
 };
 
+struct layer_init_data {
+	struct poly_vert *imask;
+	struct poly_vert *omask;
+	struct scan_line *bounds;
+	int *bound_indexes;
+	int bounds_length;
+};
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 void preprocess_all_edges(struct r_fill_context *ctx, struct poly_vert *verts, int num_verts, struct e_status *open_edge);
+int PLX_init_base_data(struct layer_init_data *mlayer_data, float(*base_verts)[2], int num_base_verts, 
+							float *buf, int buf_x, int buf_y);
 int PLX_raskterize(float (*base_verts)[2], int num_base_verts,
                    float *buf, int buf_x, int buf_y, int do_mask_AA);
 int PLX_raskterize_feather(float (*base_verts)[2], int num_base_verts,
diff --git a/intern/raskter/raskter_mt.c b/intern/raskter/raskter_mt.c
index c323a2eaa12..feda624d668 100644
--- a/intern/raskter/raskter_mt.c
+++ b/intern/raskter/raskter_mt.c
@@ -30,7 +30,7 @@
 #include <stdlib.h>
 
 #include "raskter.h"
-static int rast_scan_init(struct r_fill_context *ctx, struct poly_vert *verts, int num_verts) {
+static int rast_scan_init(struct layer_init_data *mlayer_data, struct r_fill_context *ctx, struct poly_vert *verts, int num_verts) {
     int x_curr;                 /* current pixel position in X */
     int y_curr;                 /* current scan line being drawn */
     int yp;                     /* y-pixel's position in frame buffer */
@@ -54,7 +54,7 @@ static int rast_scan_init(struct r_fill_context *ctx, struct poly_vert *verts, i
     }
 
     /* set initial bounds length to 0 */
-    ctx->bounds_length=0;
+    mlayer_data->bounds_length=0;
 
     /* round 1, count up all the possible spans in the base buffer */
     preprocess_all_edges(ctx, verts, num_verts, edgbuf);
@@ -96,7 +96,7 @@ static int rast_scan_init(struct r_fill_context *ctx, struct poly_vert *verts, i
             mpxl = spxl + MIN2(e_curr->x, ctx->rb.sizex) - 1;
 
             if((y_curr >= 0) && (y_curr < ctx->rb.sizey)) {
-                ctx->bounds_length++;
+                mlayer_data->bounds_length++;
             }
         }
 
@@ -152,16 +152,16 @@ static int rast_scan_init(struct r_fill_context *ctx, struct poly_vert *verts, i
 
 /*initialize index buffer and bounds buffers*/
     //gets the +1 for dummy at the end
-    if((ctx->bound_indexes = (int *)(malloc(sizeof(int) * ctx->rb.sizey+1)))==NULL) {
+    if((mlayer_data->bound_indexes = (int *)(malloc(sizeof(int) * ctx->rb.sizey+1)))==NULL) {
         return(0);
     }
     //gets the +1 for dummy at the start
-    if((ctx->bounds = (struct scan_line *)(malloc(sizeof(struct scan_line) * ctx->bounds_length+1)))==NULL){
+    if((mlayer_data->bounds = (struct scan_line *)(malloc(sizeof(struct scan_line) * mlayer_data->bounds_length+1)))==NULL){
         return(0);
     }
     //init all the indexes to zero (are they already zeroed from malloc???)
     for(i=0;i<ctx->rb.sizey+1;i++){
-        ctx->bound_indexes[i]=0;
+        mlayer_data->bound_indexes[i]=0;
     }
     /* round 2, fill in the full list of bounds, and create indexes to the list... */
     preprocess_all_edges(ctx, verts, num_verts, edgbuf);
@@ -207,8 +207,8 @@ static int rast_scan_init(struct r_fill_context *ctx, struct poly_vert *verts, i
             mpxl = spxl + MIN2(e_curr->x, ctx->rb.sizex) - 1;
 
             if((y_curr >= 0) && (y_curr < ctx->rb.sizey)) {
-                ctx->bounds[i].xstart=cpxl-spxl;
-                ctx->bounds[i].xend=mpxl-spxl;
+                mlayer_data->bounds[i].xstart=cpxl-spxl;
+                mlayer_data->bounds[i].xend=mpxl-spxl;
                 i++;
             }
         }
@@ -266,7 +266,7 @@ static int rast_scan_init(struct r_fill_context *ctx, struct poly_vert *verts, i
     return 1;
 }
 
-/* static */ int init_base_data(float(*base_verts)[2], int num_base_verts,
+/* static */ int PLX_init_base_data(struct layer_init_data *mlayer_data, float(*base_verts)[2], int num_base_verts,
                    float *buf, int buf_x, int buf_y) {
     int i;                                   /* i: Loop counter. */
     struct poly_vert *ply;                   /* ply: Pointer to a list of integer buffer-space vertex coordinates. */
@@ -283,7 +283,7 @@ static int rast_scan_init(struct r_fill_context *ctx, struct poly_vert *verts, i
         ply[i].x = (int)((base_verts[i][0] * buf_x_f) + 0.5f);       /* Range expand normalized X to integer buffer-space X. */
         ply[i].y = (int)((base_verts[i][1] * buf_y_f) + 0.5f); /* Range expand normalized Y to integer buffer-space Y. */
     }
-    i = rast_scan_init(&ctx, ply, num_base_verts);  /* Call our rasterizer, passing in the integer coords for each vert. */
+    i = rast_scan_init(mlayer_data, &ctx, ply, num_base_verts);  /* Call our rasterizer, passing in the integer coords for each vert. */
     free(ply);                                      /* Free the memory allocated for the integer coordinate table. */
     return(i);                                      /* Return the value returned by the rasterizer. */
 }