From 3a10f8e1b135205f67f7168737ad46ec280f9ad0 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Sat, 14 Apr 2018 22:26:12 +0200 Subject: Cleanup: style --- .../operations/COM_VectorBlurOperation.cpp | 608 ++++++++++----------- 1 file changed, 304 insertions(+), 304 deletions(-) (limited to 'source/blender/compositor') diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.cpp b/source/blender/compositor/operations/COM_VectorBlurOperation.cpp index bccfe025089..9c04e74a7da 100644 --- a/source/blender/compositor/operations/COM_VectorBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_VectorBlurOperation.cpp @@ -24,20 +24,20 @@ #include "MEM_guardedalloc.h" #include "BLI_math.h" extern "C" { - #include "BLI_jitter_2d.h" +#include "BLI_jitter_2d.h" } #include "COM_VectorBlurOperation.h" /* Defined */ -#define PASS_VECTOR_MAX 10000.0f +#define PASS_VECTOR_MAX 10000.0f /* Forward declarations */ struct ZSpan; struct DrawBufPixel; void zbuf_accumulate_vecblur( - NodeBlurData *nbd, int xsize, int ysize, float *newrect, - const float *imgrect, float *vecbufrect, const float *zbufrect); + NodeBlurData *nbd, int xsize, int ysize, float *newrect, + const float *imgrect, float *vecbufrect, const float *zbufrect); void zbuf_alloc_span(ZSpan *zspan, int rectx, int recty, float clipcrop); void zbuf_free_span(ZSpan *zspan); void antialias_tagbuf(int xsize, int ysize, char *rectmove); @@ -70,7 +70,7 @@ void VectorBlurOperation::initExecution() void VectorBlurOperation::executePixel(float output[4], int x, int y, void *data) { - float *buffer = (float *) data; + float *buffer = (float *)data; int index = (y * this->getWidth() + x) * COM_NUM_CHANNELS_COLOR; copy_v4_v4(output, &buffer[index]); } @@ -148,7 +148,7 @@ typedef struct ZSpan { float zmulx, zmuly, zofsx, zofsy; int *rectz; - DrawBufPixel* rectdraw; + DrawBufPixel *rectdraw; float clipcrop; } ZSpan; @@ -158,13 +158,13 @@ void zbuf_alloc_span(ZSpan *zspan, int rectx, int recty, float clipcrop) { memset(zspan, 0, sizeof(ZSpan)); - zspan->rectx= rectx; - zspan->recty= recty; + zspan->rectx = rectx; + zspan->recty = recty; - zspan->span1= (float*)MEM_mallocN(recty*sizeof(float), "zspan"); - zspan->span2= (float*)MEM_mallocN(recty*sizeof(float), "zspan"); + zspan->span1 = (float *)MEM_mallocN(recty * sizeof(float), "zspan"); + zspan->span2 = (float *)MEM_mallocN(recty * sizeof(float), "zspan"); - zspan->clipcrop= clipcrop; + zspan->clipcrop = clipcrop; } void zbuf_free_span(ZSpan *zspan) @@ -172,16 +172,16 @@ void zbuf_free_span(ZSpan *zspan) if (zspan) { if (zspan->span1) MEM_freeN(zspan->span1); if (zspan->span2) MEM_freeN(zspan->span2); - zspan->span1= zspan->span2= NULL; + zspan->span1 = zspan->span2 = NULL; } } /* reset range for clipping */ static void zbuf_init_span(ZSpan *zspan) { - zspan->miny1= zspan->miny2= zspan->recty+1; - zspan->maxy1= zspan->maxy2= -1; - zspan->minp1= zspan->maxp1= zspan->minp2= zspan->maxp2= NULL; + zspan->miny1 = zspan->miny2 = zspan->recty + 1; + zspan->maxy1 = zspan->maxy2 = -1; + zspan->minp1 = zspan->maxp1 = zspan->minp2 = zspan->maxp2 = NULL; } static void zbuf_add_to_span(ZSpan *zspan, const float v1[2], const float v2[2]) @@ -191,30 +191,30 @@ static void zbuf_add_to_span(ZSpan *zspan, const float v1[2], const float v2[2]) float xx1, dx0, xs0; int y, my0, my2; - if (v1[1]= zspan->recty) return; + if (my2 < 0 || my0 >= zspan->recty) return; /* clip top */ - if (my2>=zspan->recty) my2= zspan->recty-1; + if (my2 >= zspan->recty) my2 = zspan->recty - 1; /* clip bottom */ - if (my0<0) my0= 0; + if (my0 < 0) my0 = 0; - if (my0>my2) return; + if (my0 > my2) return; /* if (my0>my2) should still fill in, that way we get spans that skip nicely */ - xx1= maxv[1]-minv[1]; - if (xx1>FLT_EPSILON) { - dx0= (minv[0]-maxv[0])/xx1; - xs0= dx0*(minv[1]-my2) + minv[0]; + xx1 = maxv[1] - minv[1]; + if (xx1 > FLT_EPSILON) { + dx0 = (minv[0] - maxv[0]) / xx1; + xs0 = dx0 * (minv[1] - my2) + minv[0]; } else { dx0 = 0.0f; @@ -223,43 +223,43 @@ static void zbuf_add_to_span(ZSpan *zspan, const float v1[2], const float v2[2]) /* empty span */ if (zspan->maxp1 == NULL) { - span= zspan->span1; + span = zspan->span1; } - else { /* does it complete left span? */ - if ( maxv == zspan->minp1 || minv==zspan->maxp1) { - span= zspan->span1; + else { /* does it complete left span? */ + if (maxv == zspan->minp1 || minv == zspan->maxp1) { + span = zspan->span1; } else { - span= zspan->span2; + span = zspan->span2; } } - if (span==zspan->span1) { + if (span == zspan->span1) { // printf("left span my0 %d my2 %d\n", my0, my2); - if (zspan->minp1==NULL || zspan->minp1[1] > minv[1] ) { - zspan->minp1= minv; + if (zspan->minp1 == NULL || zspan->minp1[1] > minv[1]) { + zspan->minp1 = minv; } - if (zspan->maxp1==NULL || zspan->maxp1[1] < maxv[1] ) { - zspan->maxp1= maxv; + if (zspan->maxp1 == NULL || zspan->maxp1[1] < maxv[1]) { + zspan->maxp1 = maxv; } - if (my0miny1) zspan->miny1= my0; - if (my2>zspan->maxy1) zspan->maxy1= my2; + if (my0 < zspan->miny1) zspan->miny1 = my0; + if (my2 > zspan->maxy1) zspan->maxy1 = my2; } else { // printf("right span my0 %d my2 %d\n", my0, my2); - if (zspan->minp2==NULL || zspan->minp2[1] > minv[1] ) { - zspan->minp2= minv; + if (zspan->minp2 == NULL || zspan->minp2[1] > minv[1]) { + zspan->minp2 = minv; } - if (zspan->maxp2==NULL || zspan->maxp2[1] < maxv[1] ) { - zspan->maxp2= maxv; + if (zspan->maxp2 == NULL || zspan->maxp2[1] < maxv[1]) { + zspan->maxp2 = maxv; } - if (my0miny2) zspan->miny2= my0; - if (my2>zspan->maxy2) zspan->maxy2= my2; + if (my0 < zspan->miny2) zspan->miny2 = my0; + if (my2 > zspan->maxy2) zspan->maxy2 = my2; } - for (y=my2; y>=my0; y--, xs0+= dx0) { + for (y = my2; y >= my0; y--, xs0 += dx0) { /* xs0 is the xcoord! */ - span[y]= xs0; + span[y] = xs0; } } @@ -292,79 +292,79 @@ static void zbuf_fill_in_rgba(ZSpan *zspan, DrawBufPixel *col, float *v1, float zbuf_add_to_span(zspan, v4, v1); /* clipped */ - if (zspan->minp2==NULL || zspan->maxp2==NULL) return; + if (zspan->minp2 == NULL || zspan->maxp2 == NULL) return; my0 = max_ii(zspan->miny1, zspan->miny2); my2 = min_ii(zspan->maxy1, zspan->maxy2); // printf("my %d %d\n", my0, my2); - if (my2rectx; - rectzofs= (float *)(zspan->rectz + rectx*my2); - rectpofs= ((DrawBufPixel *)zspan->rectdraw) + rectx*my2; + rectx = zspan->rectx; + rectzofs = (float *)(zspan->rectz + rectx * my2); + rectpofs = ((DrawBufPixel *)zspan->rectdraw) + rectx * my2; /* correct span */ - sn1= (my0 + my2)/2; + sn1 = (my0 + my2) / 2; if (zspan->span1[sn1] < zspan->span2[sn1]) { - span1= zspan->span1+my2; - span2= zspan->span2+my2; + span1 = zspan->span1 + my2; + span2 = zspan->span2 + my2; } else { - span1= zspan->span2+my2; - span2= zspan->span1+my2; + span1 = zspan->span2 + my2; + span2 = zspan->span1 + my2; } - for (y=my2; y>=my0; y--, span1--, span2--) { + for (y = my2; y >= my0; y--, span1--, span2--) { - sn1= floor(*span1); - sn2= floor(*span2); + sn1 = floor(*span1); + sn2 = floor(*span2); sn1++; - if (sn2>=rectx) sn2= rectx-1; - if (sn1<0) sn1= 0; + if (sn2 >= rectx) sn2 = rectx - 1; + if (sn1 < 0) sn1 = 0; - if (sn2>=sn1) { - zverg= (double)sn1*zxd + zy0; - rz= rectzofs+sn1; - rp= rectpofs+sn1; - x= sn2-sn1; + if (sn2 >= sn1) { + zverg = (double)sn1 * zxd + zy0; + rz = rectzofs + sn1; + rp = rectpofs + sn1; + x = sn2 - sn1; - while (x>=0) { + while (x >= 0) { if (zverg < (double)*rz) { - *rz= zverg; - *rp= *col; + *rz = zverg; + *rp = *col; } - zverg+= zxd; + zverg += zxd; rz++; rp++; x--; } } - zy0-=zyd; - rectzofs-= rectx; - rectpofs-= rectx; + zy0 -= zyd; + rectzofs -= rectx; + rectpofs -= rectx; } } @@ -377,43 +377,43 @@ void antialias_tagbuf(int xsize, int ysize, char *rectmove) int a, x, y, step; /* 1: tag pixels to be candidate for AA */ - for (y=2; y>8; + row1[a] = (prev * mfac + next * fac) >> 8; } } } @@ -422,28 +422,28 @@ void antialias_tagbuf(int xsize, int ysize, char *rectmove) /* 3: evaluate vertical scanlines and calculate alphas */ /* use for reading a copy of the original tagged buffer */ - for (x=0; x>8; + row1[a * xsize] = (prev * mfac + next * fac) >> 8; } } } @@ -451,15 +451,15 @@ void antialias_tagbuf(int xsize, int ysize, char *rectmove) } /* last: pixels with 0 we fill in zbuffer, with 1 we skip for mask */ - for (y=2; y1 || row2[2]>1 || row1[1]>1 || row3[1]>1) - row2[1]= 1; + row1 = rectmove + (y - 2) * xsize; + row2 = row1 + xsize; + row3 = row2 + xsize; + for (x = 2; x < xsize; x++, row1++, row2++, row3++) { + if (row2[1] == 0) { + if (row2[0] > 1 || row2[2] > 1 || row1[1] > 1 || row3[1] > 1) + row2[1] = 1; } } } @@ -473,32 +473,32 @@ static void quad_bezier_2d(float *result, float *v1, float *v2, float *ipodata) { float p1[2], p2[2], p3[2]; - p3[0]= -v2[0]; - p3[1]= -v2[1]; + p3[0] = -v2[0]; + p3[1] = -v2[1]; - p1[0]= v1[0]; - p1[1]= v1[1]; + p1[0] = v1[0]; + p1[1] = v1[1]; /* official formula 2*p2 - 0.5*p1 - 0.5*p3 */ - p2[0]= -0.5f*p1[0] - 0.5f*p3[0]; - p2[1]= -0.5f*p1[1] - 0.5f*p3[1]; + p2[0] = -0.5f * p1[0] - 0.5f * p3[0]; + p2[1] = -0.5f * p1[1] - 0.5f * p3[1]; - result[0]= ipodata[0]*p1[0] + ipodata[1]*p2[0] + ipodata[2]*p3[0]; - result[1]= ipodata[0]*p1[1] + ipodata[1]*p2[1] + ipodata[2]*p3[1]; + result[0] = ipodata[0] * p1[0] + ipodata[1] * p2[0] + ipodata[2] * p3[0]; + result[1] = ipodata[0] * p1[1] + ipodata[1] * p2[1] + ipodata[2] * p3[1]; } static void set_quad_bezier_ipo(float fac, float *data) { - float mfac= (1.0f-fac); + float mfac = (1.0f - fac); - data[0]= mfac*mfac; - data[1]= 2.0f*mfac*fac; - data[2]= fac*fac; + data[0] = mfac * mfac; + data[1] = 2.0f * mfac * fac; + data[2] = fac * fac; } void zbuf_accumulate_vecblur( - NodeBlurData *nbd, int xsize, int ysize, float *newrect, - const float *imgrect, float *vecbufrect, const float *zbufrect) + NodeBlurData *nbd, int xsize, int ysize, float *newrect, + const float *imgrect, float *vecbufrect, const float *zbufrect) { ZSpan zspan; DrawBufPixel *rectdraw, *dr; @@ -506,64 +506,64 @@ void zbuf_accumulate_vecblur( float v1[3], v2[3], v3[3], v4[3], fx, fy; const float *dimg, *dz, *ro; float *rectvz, *dvz, *dvec1, *dvec2, *dz1, *dz2, *rectz; - float *minvecbufrect= NULL, *rectweight, *rw, *rectmax, *rm; - float maxspeedsq= (float)nbd->maxspeed*nbd->maxspeed; - int y, x, step, maxspeed=nbd->maxspeed, samples= nbd->samples; - int tsktsk= 0; - static int firsttime= 1; + float *minvecbufrect = NULL, *rectweight, *rw, *rectmax, *rm; + float maxspeedsq = (float)nbd->maxspeed * nbd->maxspeed; + int y, x, step, maxspeed = nbd->maxspeed, samples = nbd->samples; + int tsktsk = 0; + static int firsttime = 1; char *rectmove, *dm; zbuf_alloc_span(&zspan, xsize, ysize, 1.0f); - zspan.zmulx= ((float)xsize)/2.0f; - zspan.zmuly= ((float)ysize)/2.0f; - zspan.zofsx= 0.0f; - zspan.zofsy= 0.0f; + zspan.zmulx = ((float)xsize) / 2.0f; + zspan.zmuly = ((float)ysize) / 2.0f; + zspan.zofsx = 0.0f; + zspan.zofsy = 0.0f; /* the buffers */ - rectz= (float*)MEM_mapallocN(sizeof(float)*xsize*ysize, "zbuf accum"); - zspan.rectz= (int *)rectz; + rectz = (float *)MEM_mapallocN(sizeof(float) * xsize * ysize, "zbuf accum"); + zspan.rectz = (int *)rectz; - rectmove= (char*)MEM_mapallocN(xsize*ysize, "rectmove"); - rectdraw= (DrawBufPixel*)MEM_mapallocN(sizeof(DrawBufPixel)*xsize*ysize, "rect draw"); - zspan.rectdraw= rectdraw; + rectmove = (char *)MEM_mapallocN(xsize * ysize, "rectmove"); + rectdraw = (DrawBufPixel *)MEM_mapallocN(sizeof(DrawBufPixel) * xsize * ysize, "rect draw"); + zspan.rectdraw = rectdraw; - rectweight= (float*)MEM_mapallocN(sizeof(float)*xsize*ysize, "rect weight"); - rectmax= (float*)MEM_mapallocN(sizeof(float)*xsize*ysize, "rect max"); + rectweight = (float *)MEM_mapallocN(sizeof(float) * xsize * ysize, "rect weight"); + rectmax = (float *)MEM_mapallocN(sizeof(float) * xsize * ysize, "rect max"); /* debug... check if PASS_VECTOR_MAX still is in buffers */ - dvec1= vecbufrect; - for (x= 4*xsize*ysize; x>0; x--, dvec1++) { - if (dvec1[0]==PASS_VECTOR_MAX) { - dvec1[0]= 0.0f; - tsktsk= 1; + dvec1 = vecbufrect; + for (x = 4 * xsize * ysize; x > 0; x--, dvec1++) { + if (dvec1[0] == PASS_VECTOR_MAX) { + dvec1[0] = 0.0f; + tsktsk = 1; } } if (tsktsk) printf("Found uninitialized speed in vector buffer... fixed.\n"); /* min speed? then copy speedbuffer to recalculate speed vectors */ if (nbd->minspeed) { - float minspeed= (float)nbd->minspeed; - float minspeedsq= minspeed*minspeed; + float minspeed = (float)nbd->minspeed; + float minspeedsq = minspeed * minspeed; - minvecbufrect= (float*)MEM_mapallocN(4*sizeof(float)*xsize*ysize, "minspeed buf"); + minvecbufrect = (float *)MEM_mapallocN(4 * sizeof(float) * xsize * ysize, "minspeed buf"); - dvec1= vecbufrect; - dvec2= minvecbufrect; - for (x= 2*xsize*ysize; x>0; x--, dvec1+=2, dvec2+=2) { - if (dvec1[0]==0.0f && dvec1[1]==0.0f) { - dvec2[0]= dvec1[0]; - dvec2[1]= dvec1[1]; + dvec1 = vecbufrect; + dvec2 = minvecbufrect; + for (x = 2 * xsize * ysize; x > 0; x--, dvec1 += 2, dvec2 += 2) { + if (dvec1[0] == 0.0f && dvec1[1] == 0.0f) { + dvec2[0] = dvec1[0]; + dvec2[1] = dvec1[1]; } else { - float speedsq= dvec1[0]*dvec1[0] + dvec1[1]*dvec1[1]; + float speedsq = dvec1[0] * dvec1[0] + dvec1[1] * dvec1[1]; if (speedsq <= minspeedsq) { - dvec2[0]= 0.0f; - dvec2[1]= 0.0f; + dvec2[0] = 0.0f; + dvec2[1] = 0.0f; } else { speedsq = 1.0f - minspeed / sqrtf(speedsq); - dvec2[0]= speedsq*dvec1[0]; - dvec2[1]= speedsq*dvec1[1]; + dvec2[0] = speedsq * dvec1[0]; + dvec2[1] = speedsq * dvec1[1]; } } } @@ -571,75 +571,75 @@ void zbuf_accumulate_vecblur( } /* make vertex buffer with averaged speed and zvalues */ - rectvz= (float*)MEM_mapallocN(4*sizeof(float)*(xsize+1)*(ysize+1), "vertices"); - dvz= rectvz; - for (y=0; y<=ysize; y++) { + rectvz = (float *)MEM_mapallocN(4 * sizeof(float) * (xsize + 1) * (ysize + 1), "vertices"); + dvz = rectvz; + for (y = 0; y <= ysize; y++) { - if (y==0) - dvec1= vecbufrect + 4*y*xsize; + if (y == 0) + dvec1 = vecbufrect + 4 * y * xsize; else - dvec1= vecbufrect + 4*(y-1)*xsize; + dvec1 = vecbufrect + 4 * (y - 1) * xsize; - if (y==ysize) - dvec2= vecbufrect + 4*(y-1)*xsize; + if (y == ysize) + dvec2 = vecbufrect + 4 * (y - 1) * xsize; else - dvec2= vecbufrect + 4*y*xsize; + dvec2 = vecbufrect + 4 * y * xsize; - for (x=0; x<=xsize; x++) { + for (x = 0; x <= xsize; x++) { /* two vectors, so a step loop */ - for (step=0; step<2; step++, dvec1+=2, dvec2+=2, dvz+=2) { + for (step = 0; step < 2; step++, dvec1 += 2, dvec2 += 2, dvz += 2) { /* average on minimal speed */ - int div= 0; + int div = 0; - if (x!=0) { - if (dvec1[-4]!=0.0f || dvec1[-3]!=0.0f) { - dvz[0]= dvec1[-4]; - dvz[1]= dvec1[-3]; + if (x != 0) { + if (dvec1[-4] != 0.0f || dvec1[-3] != 0.0f) { + dvz[0] = dvec1[-4]; + dvz[1] = dvec1[-3]; div++; } - if (dvec2[-4]!=0.0f || dvec2[-3]!=0.0f) { - if (div==0) { - dvz[0]= dvec2[-4]; - dvz[1]= dvec2[-3]; + if (dvec2[-4] != 0.0f || dvec2[-3] != 0.0f) { + if (div == 0) { + dvz[0] = dvec2[-4]; + dvz[1] = dvec2[-3]; div++; } - else if ( (ABS(dvec2[-4]) + ABS(dvec2[-3]))< (ABS(dvz[0]) + ABS(dvz[1])) ) { - dvz[0]= dvec2[-4]; - dvz[1]= dvec2[-3]; + else if ( (ABS(dvec2[-4]) + ABS(dvec2[-3])) < (ABS(dvz[0]) + ABS(dvz[1])) ) { + dvz[0] = dvec2[-4]; + dvz[1] = dvec2[-3]; } } } - if (x!=xsize) { - if (dvec1[0]!=0.0f || dvec1[1]!=0.0f) { - if (div==0) { - dvz[0]= dvec1[0]; - dvz[1]= dvec1[1]; + if (x != xsize) { + if (dvec1[0] != 0.0f || dvec1[1] != 0.0f) { + if (div == 0) { + dvz[0] = dvec1[0]; + dvz[1] = dvec1[1]; div++; } - else if ( (ABS(dvec1[0]) + ABS(dvec1[1]))< (ABS(dvz[0]) + ABS(dvz[1])) ) { - dvz[0]= dvec1[0]; - dvz[1]= dvec1[1]; + else if ( (ABS(dvec1[0]) + ABS(dvec1[1])) < (ABS(dvz[0]) + ABS(dvz[1])) ) { + dvz[0] = dvec1[0]; + dvz[1] = dvec1[1]; } } - if (dvec2[0]!=0.0f || dvec2[1]!=0.0f) { - if (div==0) { - dvz[0]= dvec2[0]; - dvz[1]= dvec2[1]; + if (dvec2[0] != 0.0f || dvec2[1] != 0.0f) { + if (div == 0) { + dvz[0] = dvec2[0]; + dvz[1] = dvec2[1]; } - else if ( (ABS(dvec2[0]) + ABS(dvec2[1]))< (ABS(dvz[0]) + ABS(dvz[1])) ) { - dvz[0]= dvec2[0]; - dvz[1]= dvec2[1]; + else if ( (ABS(dvec2[0]) + ABS(dvec2[1])) < (ABS(dvz[0]) + ABS(dvz[1])) ) { + dvz[0] = dvec2[0]; + dvz[1] = dvec2[1]; } } } if (maxspeed) { - float speedsq= dvz[0]*dvz[0] + dvz[1]*dvz[1]; + float speedsq = dvz[0] * dvz[0] + dvz[1] * dvz[1]; if (speedsq > maxspeedsq) { speedsq = (float)maxspeed / sqrtf(speedsq); - dvz[0]*= speedsq; - dvz[1]*= speedsq; + dvz[0] *= speedsq; + dvz[1] *= speedsq; } } } @@ -647,117 +647,117 @@ void zbuf_accumulate_vecblur( } /* set border speeds to keep border speeds on border */ - dz1= rectvz; - dz2= rectvz+4*(ysize)*(xsize+1); - for (x=0; x<=xsize; x++, dz1+=4, dz2+=4) { - dz1[1]= 0.0f; - dz2[1]= 0.0f; - dz1[3]= 0.0f; - dz2[3]= 0.0f; + dz1 = rectvz; + dz2 = rectvz + 4 * (ysize) * (xsize + 1); + for (x = 0; x <= xsize; x++, dz1 += 4, dz2 += 4) { + dz1[1] = 0.0f; + dz2[1] = 0.0f; + dz1[3] = 0.0f; + dz2[3] = 0.0f; } - dz1= rectvz; - dz2= rectvz+4*(xsize); - for (y=0; y<=ysize; y++, dz1+=4*(xsize+1), dz2+=4*(xsize+1)) { - dz1[0]= 0.0f; - dz2[0]= 0.0f; - dz1[2]= 0.0f; - dz2[2]= 0.0f; + dz1 = rectvz; + dz2 = rectvz + 4 * (xsize); + for (y = 0; y <= ysize; y++, dz1 += 4 * (xsize + 1), dz2 += 4 * (xsize + 1)) { + dz1[0] = 0.0f; + dz2[0] = 0.0f; + dz1[2] = 0.0f; + dz2[2] = 0.0f; } /* tag moving pixels, only these faces we draw */ - dm= rectmove; - dvec1= vecbufrect; - for (x=xsize*ysize; x>0; x--, dm++, dvec1+=4) { - if ((dvec1[0]!=0.0f || dvec1[1]!=0.0f || dvec1[2]!=0.0f || dvec1[3]!=0.0f)) - *dm= 255; + dm = rectmove; + dvec1 = vecbufrect; + for (x = xsize * ysize; x > 0; x--, dm++, dvec1 += 4) { + if ((dvec1[0] != 0.0f || dvec1[1] != 0.0f || dvec1[2] != 0.0f || dvec1[3] != 0.0f)) + *dm = 255; } antialias_tagbuf(xsize, ysize, rectmove); /* has to become static, the init-jit calls a random-seed, screwing up texture noise node */ if (firsttime) { - firsttime= 0; + firsttime = 0; BLI_jitter_init(jit, 256); } - memset(newrect, 0, sizeof(float)*xsize*ysize*4); + memset(newrect, 0, sizeof(float) * xsize * ysize * 4); /* accumulate */ - samples/= 2; - for (step= 1; step<=samples; step++) { - float speedfac= 0.5f*nbd->fac*(float)step/(float)(samples+1); + samples /= 2; + for (step = 1; step <= samples; step++) { + float speedfac = 0.5f * nbd->fac * (float)step / (float)(samples + 1); int side; - for (side=0; side<2; side++) { + for (side = 0; side < 2; side++) { float blendfac, ipodata[4]; /* clear zbuf, if we draw future we fill in not moving pixels */ if (0) - for (x= xsize*ysize-1; x>=0; x--) rectz[x]= 10e16; + for (x = xsize * ysize - 1; x >= 0; x--) rectz[x] = 10e16; else - for (x= xsize*ysize-1; x>=0; x--) { - if (rectmove[x]==0) - rectz[x]= zbufrect[x]; + for (x = xsize * ysize - 1; x >= 0; x--) { + if (rectmove[x] == 0) + rectz[x] = zbufrect[x]; else - rectz[x]= 10e16; + rectz[x] = 10e16; } /* clear drawing buffer */ - for (x= xsize*ysize-1; x>=0; x--) rectdraw[x].colpoin= NULL; + for (x = xsize * ysize - 1; x >= 0; x--) rectdraw[x].colpoin = NULL; - dimg= imgrect; - dm= rectmove; - dz= zbufrect; - dz1= rectvz; - dz2= rectvz + 4*(xsize + 1); + dimg = imgrect; + dm = rectmove; + dz = zbufrect; + dz1 = rectvz; + dz2 = rectvz + 4 * (xsize + 1); if (side) { - if (nbd->curved==0) { - dz1+= 2; - dz2+= 2; + if (nbd->curved == 0) { + dz1 += 2; + dz2 += 2; } - speedfac= -speedfac; + speedfac = -speedfac; } - set_quad_bezier_ipo(0.5f + 0.5f*speedfac, ipodata); + set_quad_bezier_ipo(0.5f + 0.5f * speedfac, ipodata); - for (fy= -0.5f+jit[step & 255][0], y=0; y1) { + for (fy = -0.5f + jit[step & 255][0], y = 0; y < ysize; y++, fy += 1.0f) { + for (fx = -0.5f + jit[step & 255][1], x = 0; x < xsize; x++, fx += 1.0f, dimg += 4, dz1 += 4, dz2 += 4, dm++, dz++) { + if (*dm > 1) { float jfx = fx + 0.5f; float jfy = fy + 0.5f; DrawBufPixel col; /* make vertices */ - if (nbd->curved) { /* curved */ - quad_bezier_2d(v1, dz1, dz1+2, ipodata); - v1[0]+= jfx; v1[1]+= jfy; v1[2]= *dz; + if (nbd->curved) { /* curved */ + quad_bezier_2d(v1, dz1, dz1 + 2, ipodata); + v1[0] += jfx; v1[1] += jfy; v1[2] = *dz; - quad_bezier_2d(v2, dz1+4, dz1+4+2, ipodata); - v2[0]+= jfx+1.0f; v2[1]+= jfy; v2[2]= *dz; + quad_bezier_2d(v2, dz1 + 4, dz1 + 4 + 2, ipodata); + v2[0] += jfx + 1.0f; v2[1] += jfy; v2[2] = *dz; - quad_bezier_2d(v3, dz2+4, dz2+4+2, ipodata); - v3[0]+= jfx+1.0f; v3[1]+= jfy+1.0f; v3[2]= *dz; + quad_bezier_2d(v3, dz2 + 4, dz2 + 4 + 2, ipodata); + v3[0] += jfx + 1.0f; v3[1] += jfy + 1.0f; v3[2] = *dz; - quad_bezier_2d(v4, dz2, dz2+2, ipodata); - v4[0]+= jfx; v4[1]+= jfy+1.0f; v4[2]= *dz; + quad_bezier_2d(v4, dz2, dz2 + 2, ipodata); + v4[0] += jfx; v4[1] += jfy + 1.0f; v4[2] = *dz; } else { - v1[0]= speedfac*dz1[0]+jfx; v1[1]= speedfac*dz1[1]+jfy; v1[2]= *dz; - v2[0]= speedfac*dz1[4]+jfx+1.0f; v2[1]= speedfac*dz1[5]+jfy; v2[2]= *dz; - v3[0]= speedfac*dz2[4]+jfx+1.0f; v3[1]= speedfac*dz2[5]+jfy+1.0f; v3[2]= *dz; - v4[0]= speedfac*dz2[0]+jfx; v4[1]= speedfac*dz2[1]+jfy+1.0f; v4[2]= *dz; + ARRAY_SET_ITEMS(v1, speedfac * dz1[0] + jfx, speedfac * dz1[1] + jfy, *dz); + ARRAY_SET_ITEMS(v2, speedfac * dz1[4] + jfx + 1.0f, speedfac * dz1[5] + jfy, *dz); + ARRAY_SET_ITEMS(v3, speedfac * dz2[4] + jfx + 1.0f, speedfac * dz2[5] + jfy + 1.0f, *dz); + ARRAY_SET_ITEMS(v4, speedfac * dz2[0] + jfx, speedfac * dz2[1] + jfy + 1.0f, *dz); } - if (*dm==255) col.alpha= 1.0f; - else if (*dm<2) col.alpha= 0.0f; - else col.alpha= ((float)*dm)/255.0f; - col.colpoin= dimg; + if (*dm == 255) col.alpha = 1.0f; + else if (*dm < 2) col.alpha = 0.0f; + else col.alpha = ((float)*dm) / 255.0f; + col.colpoin = dimg; zbuf_fill_in_rgba(&zspan, &col, v1, v2, v3, v4); } } - dz1+=4; - dz2+=4; + dz1 += 4; + dz2 += 4; } /* blend with a falloff. this fixes the ugly effect you get with @@ -767,43 +767,43 @@ void zbuf_accumulate_vecblur( * we don't know what is behind it so we don't do that. this hack * overestimates the contribution of foreground pixels but looks a * bit better without a sudden cutoff. */ - blendfac= ((samples - step)/(float)samples); + blendfac = ((samples - step) / (float)samples); /* smoothstep to make it look a bit nicer as well */ - blendfac= 3.0f*pow(blendfac, 2.0f) - 2.0f*pow(blendfac, 3.0f); + blendfac = 3.0f * pow(blendfac, 2.0f) - 2.0f * pow(blendfac, 3.0f); /* accum */ - rw= rectweight; - rm= rectmax; - for (dr= rectdraw, dz2=newrect, x= xsize*ysize-1; x>=0; x--, dr++, dz2+=4, rw++, rm++) { + rw = rectweight; + rm = rectmax; + for (dr = rectdraw, dz2 = newrect, x = xsize * ysize - 1; x >= 0; x--, dr++, dz2 += 4, rw++, rm++) { if (dr->colpoin) { - float bfac= dr->alpha*blendfac; + float bfac = dr->alpha * blendfac; - dz2[0] += bfac*dr->colpoin[0]; - dz2[1] += bfac*dr->colpoin[1]; - dz2[2] += bfac*dr->colpoin[2]; - dz2[3] += bfac*dr->colpoin[3]; + dz2[0] += bfac * dr->colpoin[0]; + dz2[1] += bfac * dr->colpoin[1]; + dz2[2] += bfac * dr->colpoin[2]; + dz2[3] += bfac * dr->colpoin[3]; *rw += bfac; - *rm= MAX2(*rm, bfac); + *rm = MAX2(*rm, bfac); } } } } /* blend between original images and accumulated image */ - rw= rectweight; - rm= rectmax; - ro= imgrect; - dm= rectmove; - for (dz2=newrect, x= xsize*ysize-1; x>=0; x--, dz2+=4, ro+=4, rw++, rm++, dm++) { + rw = rectweight; + rm = rectmax; + ro = imgrect; + dm = rectmove; + for (dz2 = newrect, x = xsize * ysize - 1; x >= 0; x--, dz2 += 4, ro += 4, rw++, rm++, dm++) { float mfac = *rm; - float fac = (*rw == 0.0f)? 0.0f: mfac/(*rw); + float fac = (*rw == 0.0f) ? 0.0f : mfac / (*rw); float nfac = 1.0f - mfac; - dz2[0]= fac*dz2[0] + nfac*ro[0]; - dz2[1]= fac*dz2[1] + nfac*ro[1]; - dz2[2]= fac*dz2[2] + nfac*ro[2]; - dz2[3]= fac*dz2[3] + nfac*ro[3]; + dz2[0] = fac * dz2[0] + nfac * ro[0]; + dz2[1] = fac * dz2[1] + nfac * ro[1]; + dz2[2] = fac * dz2[2] + nfac * ro[2]; + dz2[3] = fac * dz2[3] + nfac * ro[3]; } MEM_freeN(rectz); -- cgit v1.2.3