bartvdbraak/blender
1
0
Fork 4
Code Issues 4 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity

Cleanup: style

Browse Source
This commit is contained in:
Campbell Barton 2018-04-14 22:26:12 +02:00
parent 5ab77ab4ee
commit 3a10f8e1b1
1 changed files with 304 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

608
source/blender/compositor/operations/COM_VectorBlurOperation.cpp
View File

@ -24,20 +24,20 @@
#include "MEM_guardedalloc.h" #include "MEM_guardedalloc.h"
#include "BLI_math.h" #include "BLI_math.h"
extern "C" { extern "C" {
#include "BLI_jitter_2d.h" #include "BLI_jitter_2d.h"
} }
#include "COM_VectorBlurOperation.h" #include "COM_VectorBlurOperation.h"
/* Defined */ /* Defined */
#define PASS_VECTOR_MAX 10000.0f #define PASS_VECTOR_MAX 10000.0f
/* Forward declarations */ /* Forward declarations */
struct ZSpan; struct ZSpan;
struct DrawBufPixel; struct DrawBufPixel;
void zbuf_accumulate_vecblur( void zbuf_accumulate_vecblur(
NodeBlurData *nbd, int xsize, int ysize, float *newrect, NodeBlurData *nbd, int xsize, int ysize, float *newrect,
const float *imgrect, float *vecbufrect, const float *zbufrect); const float *imgrect, float *vecbufrect, const float *zbufrect);
void zbuf_alloc_span(ZSpan *zspan, int rectx, int recty, float clipcrop); void zbuf_alloc_span(ZSpan *zspan, int rectx, int recty, float clipcrop);
void zbuf_free_span(ZSpan *zspan); void zbuf_free_span(ZSpan *zspan);
void antialias_tagbuf(int xsize, int ysize, char *rectmove); 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) 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; int index = (y * this->getWidth() + x) * COM_NUM_CHANNELS_COLOR;
copy_v4_v4(output, &buffer[index]); copy_v4_v4(output, &buffer[index]);
} }
@ -148,7 +148,7 @@ typedef struct ZSpan {
float zmulx, zmuly, zofsx, zofsy; float zmulx, zmuly, zofsx, zofsy;
int *rectz; int *rectz;
DrawBufPixel* rectdraw; DrawBufPixel *rectdraw;
float clipcrop; float clipcrop;
} ZSpan; } ZSpan;
@ -158,13 +158,13 @@ void zbuf_alloc_span(ZSpan *zspan, int rectx, int recty, float clipcrop)
{ {
memset(zspan, 0, sizeof(ZSpan)); memset(zspan, 0, sizeof(ZSpan));
zspan->rectx= rectx; zspan->rectx = rectx;
zspan->recty= recty; zspan->recty = recty;
zspan->span1= (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->span2 = (float *)MEM_mallocN(recty * sizeof(float), "zspan");
zspan->clipcrop= clipcrop; zspan->clipcrop = clipcrop;
} }
void zbuf_free_span(ZSpan *zspan) void zbuf_free_span(ZSpan *zspan)
@ -172,16 +172,16 @@ void zbuf_free_span(ZSpan *zspan)
if (zspan) { if (zspan) {
if (zspan->span1) MEM_freeN(zspan->span1); if (zspan->span1) MEM_freeN(zspan->span1);
if (zspan->span2) MEM_freeN(zspan->span2); if (zspan->span2) MEM_freeN(zspan->span2);
zspan->span1= zspan->span2= NULL; zspan->span1 = zspan->span2 = NULL;
} }
} }
/* reset range for clipping */ /* reset range for clipping */
static void zbuf_init_span(ZSpan *zspan) static void zbuf_init_span(ZSpan *zspan)
{ {
zspan->miny1= zspan->miny2= zspan->recty+1; zspan->miny1 = zspan->miny2 = zspan->recty + 1;
zspan->maxy1= zspan->maxy2= -1; zspan->maxy1 = zspan->maxy2 = -1;
zspan->minp1= zspan->maxp1= zspan->minp2= zspan->maxp2= NULL; 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]) 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; float xx1, dx0, xs0;
int y, my0, my2; int y, my0, my2;
if (v1[1]<v2[1]) { if (v1[1] < v2[1]) {
minv= v1; maxv= v2; minv = v1; maxv = v2;
} }
else { else {
minv= v2; maxv= v1; minv = v2; maxv = v1;
} }
my0= ceil(minv[1]); my0 = ceil(minv[1]);
my2= floor(maxv[1]); my2 = floor(maxv[1]);
if (my2<0 || my0>= zspan->recty) return; if (my2 < 0 || my0 >= zspan->recty) return;
/* clip top */ /* clip top */
if (my2>=zspan->recty) my2= zspan->recty-1; if (my2 >= zspan->recty) my2 = zspan->recty - 1;
/* clip bottom */ /* 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 */ /* if (my0>my2) should still fill in, that way we get spans that skip nicely */
xx1= maxv[1]-minv[1]; xx1 = maxv[1] - minv[1];
if (xx1>FLT_EPSILON) { if (xx1 > FLT_EPSILON) {
dx0= (minv[0]-maxv[0])/xx1; dx0 = (minv[0] - maxv[0]) / xx1;
xs0= dx0*(minv[1]-my2) + minv[0]; xs0 = dx0 * (minv[1] - my2) + minv[0];
} }
else { else {
dx0 = 0.0f; 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 */ /* empty span */
if (zspan->maxp1 == NULL) { if (zspan->maxp1 == NULL) {
span= zspan->span1; span = zspan->span1;
} }
else { /* does it complete left span? */ else { /* does it complete left span? */
if ( maxv == zspan->minp1 || minv==zspan->maxp1) { if (maxv == zspan->minp1 || minv == zspan->maxp1) {
span= zspan->span1; span = zspan->span1;
} }
else { 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); // printf("left span my0 %d my2 %d\n", my0, my2);
if (zspan->minp1==NULL || zspan->minp1[1] > minv[1] ) { if (zspan->minp1 == NULL || zspan->minp1[1] > minv[1]) {
zspan->minp1= minv; zspan->minp1 = minv;
} }
if (zspan->maxp1==NULL || zspan->maxp1[1] < maxv[1] ) { if (zspan->maxp1 == NULL || zspan->maxp1[1] < maxv[1]) {
zspan->maxp1= maxv; zspan->maxp1 = maxv;
} }
if (my0<zspan->miny1) zspan->miny1= my0; if (my0 < zspan->miny1) zspan->miny1 = my0;
if (my2>zspan->maxy1) zspan->maxy1= my2; if (my2 > zspan->maxy1) zspan->maxy1 = my2;
} }
else { else {
// printf("right span my0 %d my2 %d\n", my0, my2); // printf("right span my0 %d my2 %d\n", my0, my2);
if (zspan->minp2==NULL || zspan->minp2[1] > minv[1] ) { if (zspan->minp2 == NULL || zspan->minp2[1] > minv[1]) {
zspan->minp2= minv; zspan->minp2 = minv;
} }
if (zspan->maxp2==NULL || zspan->maxp2[1] < maxv[1] ) { if (zspan->maxp2 == NULL || zspan->maxp2[1] < maxv[1]) {
zspan->maxp2= maxv; zspan->maxp2 = maxv;
} }
if (my0<zspan->miny2) zspan->miny2= my0; if (my0 < zspan->miny2) zspan->miny2 = my0;
if (my2>zspan->maxy2) zspan->maxy2= my2; 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! */ /* 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); zbuf_add_to_span(zspan, v4, v1);
/* clipped */ /* clipped */
if (zspan->minp2==NULL || zspan->maxp2==NULL) return; if (zspan->minp2 == NULL || zspan->maxp2 == NULL) return;
my0 = max_ii(zspan->miny1, zspan->miny2); my0 = max_ii(zspan->miny1, zspan->miny2);
my2 = min_ii(zspan->maxy1, zspan->maxy2); my2 = min_ii(zspan->maxy1, zspan->maxy2);
// printf("my %d %d\n", my0, my2); // printf("my %d %d\n", my0, my2);
if (my2<my0) return; if (my2 < my0) return;
/* ZBUF DX DY, in floats still */ /* ZBUF DX DY, in floats still */
x1= v1[0]- v2[0]; x1 = v1[0] - v2[0];
x2= v2[0]- v3[0]; x2 = v2[0] - v3[0];
y1= v1[1]- v2[1]; y1 = v1[1] - v2[1];
y2= v2[1]- v3[1]; y2 = v2[1] - v3[1];
z1= v1[2]- v2[2]; z1 = v1[2] - v2[2];
z2= v2[2]- v3[2]; z2 = v2[2] - v3[2];
x0= y1*z2-z1*y2; x0 = y1 * z2 - z1 * y2;
y0= z1*x2-x1*z2; y0 = z1 * x2 - x1 * z2;
z0= x1*y2-y1*x2; z0 = x1 * y2 - y1 * x2;
if (z0==0.0f) return; if (z0 == 0.0f) return;
xx1= (x0*v1[0] + y0*v1[1])/z0 + v1[2]; xx1 = (x0 * v1[0] + y0 * v1[1]) / z0 + v1[2];
zxd= -(double)x0/(double)z0; zxd = -(double)x0 / (double)z0;
zyd= -(double)y0/(double)z0; zyd = -(double)y0 / (double)z0;
zy0= ((double)my2)*zyd + (double)xx1; zy0 = ((double)my2) * zyd + (double)xx1;
/* start-offset in rect */ /* start-offset in rect */
rectx= zspan->rectx; rectx = zspan->rectx;
rectzofs= (float *)(zspan->rectz + rectx*my2); rectzofs = (float *)(zspan->rectz + rectx * my2);
rectpofs= ((DrawBufPixel *)zspan->rectdraw) + rectx*my2; rectpofs = ((DrawBufPixel *)zspan->rectdraw) + rectx * my2;
/* correct span */ /* correct span */
sn1= (my0 + my2)/2; sn1 = (my0 + my2) / 2;
if (zspan->span1[sn1] < zspan->span2[sn1]) { if (zspan->span1[sn1] < zspan->span2[sn1]) {
span1= zspan->span1+my2; span1 = zspan->span1 + my2;
span2= zspan->span2+my2; span2 = zspan->span2 + my2;
} }
else { else {
span1= zspan->span2+my2; span1 = zspan->span2 + my2;
span2= zspan->span1+my2; span2 = zspan->span1 + my2;
} }
for (y=my2; y>=my0; y--, span1--, span2--) { for (y = my2; y >= my0; y--, span1--, span2--) {
sn1= floor(*span1); sn1 = floor(*span1);
sn2= floor(*span2); sn2 = floor(*span2);
sn1++; sn1++;
if (sn2>=rectx) sn2= rectx-1; if (sn2 >= rectx) sn2 = rectx - 1;
if (sn1<0) sn1= 0; if (sn1 < 0) sn1 = 0;
if (sn2>=sn1) { if (sn2 >= sn1) {
zverg= (double)sn1*zxd + zy0; zverg = (double)sn1 * zxd + zy0;
rz= rectzofs+sn1; rz = rectzofs + sn1;
rp= rectpofs+sn1; rp = rectpofs + sn1;
x= sn2-sn1; x = sn2 - sn1;
while (x>=0) { while (x >= 0) {
if (zverg < (double)*rz) { if (zverg < (double)*rz) {
*rz= zverg; *rz = zverg;
*rp= *col; *rp = *col;
} }
zverg+= zxd; zverg += zxd;
rz++; rz++;
rp++; rp++;
x--; x--;
} }
} }
zy0-=zyd; zy0 -= zyd;
rectzofs-= rectx; rectzofs -= rectx;
rectpofs-= rectx; rectpofs -= rectx;
} }
} }
@ -377,43 +377,43 @@ void antialias_tagbuf(int xsize, int ysize, char *rectmove)
int a, x, y, step; int a, x, y, step;
/* 1: tag pixels to be candidate for AA */ /* 1: tag pixels to be candidate for AA */
for (y=2; y<ysize; y++) { for (y = 2; y < ysize; y++) {
/* setup rows */ /* setup rows */
row1= rectmove + (y-2)*xsize; row1 = rectmove + (y - 2) * xsize;
row2= row1 + xsize; row2 = row1 + xsize;
row3= row2 + xsize; row3 = row2 + xsize;
for (x=2; x<xsize; x++, row1++, row2++, row3++) { for (x = 2; x < xsize; x++, row1++, row2++, row3++) {
if (row2[1]) { if (row2[1]) {
if (row2[0]==0 || row2[2]==0 || row1[1]==0 || row3[1]==0) if (row2[0] == 0 || row2[2] == 0 || row1[1] == 0 || row3[1] == 0)
row2[1]= 128; row2[1] = 128;
} }
} }
} }
/* 2: evaluate horizontal scanlines and calculate alphas */ /* 2: evaluate horizontal scanlines and calculate alphas */
row1= rectmove; row1 = rectmove;
for (y=0; y<ysize; y++) { for (y = 0; y < ysize; y++) {
row1++; row1++;
for (x=1; x<xsize; x++, row1++) { for (x = 1; x < xsize; x++, row1++) {
if (row1[0]==128 && row1[1]==128) { if (row1[0] == 128 && row1[1] == 128) {
/* find previous color and next color and amount of steps to blend */ /* find previous color and next color and amount of steps to blend */
prev= row1[-1]; prev = row1[-1];
step= 1; step = 1;
while (x+step<xsize && row1[step]==128) while (x + step < xsize && row1[step] == 128)
step++; step++;
if (x+step!=xsize) { if (x + step != xsize) {
/* now we can blend values */ /* now we can blend values */
next= row1[step]; next = row1[step];
/* note, prev value can be next value, but we do this loop to clear 128 then */ /* note, prev value can be next value, but we do this loop to clear 128 then */
for (a=0; a<step; a++) { for (a = 0; a < step; a++) {
int fac, mfac; int fac, mfac;
fac= ((a+1)<<8)/(step+1); fac = ((a + 1) << 8) / (step + 1);
mfac= 255-fac; mfac = 255 - fac;
row1[a]= (prev*mfac + next*fac)>>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 */ /* 3: evaluate vertical scanlines and calculate alphas */
/* use for reading a copy of the original tagged buffer */ /* use for reading a copy of the original tagged buffer */
for (x=0; x<xsize; x++) { for (x = 0; x < xsize; x++) {
row1= rectmove + x+xsize; row1 = rectmove + x + xsize;
for (y=1; y<ysize; y++, row1+=xsize) { for (y = 1; y < ysize; y++, row1 += xsize) {
if (row1[0]==128 && row1[xsize]==128) { if (row1[0] == 128 && row1[xsize] == 128) {
/* find previous color and next color and amount of steps to blend */ /* find previous color and next color and amount of steps to blend */
prev= row1[-xsize]; prev = row1[-xsize];
step= 1; step = 1;
while (y+step<ysize && row1[step*xsize]==128) while (y + step < ysize && row1[step * xsize] == 128)
step++; step++;
if (y+step!=ysize) { if (y + step != ysize) {
/* now we can blend values */ /* now we can blend values */
next= row1[step*xsize]; next = row1[step * xsize];
/* note, prev value can be next value, but we do this loop to clear 128 then */ /* note, prev value can be next value, but we do this loop to clear 128 then */
for (a=0; a<step; a++) { for (a = 0; a < step; a++) {
int fac, mfac; int fac, mfac;
fac= ((a+1)<<8)/(step+1); fac = ((a + 1) << 8) / (step + 1);
mfac= 255-fac; mfac = 255 - fac;
row1[a*xsize]= (prev*mfac + next*fac)>>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 */ /* last: pixels with 0 we fill in zbuffer, with 1 we skip for mask */
for (y=2; y<ysize; y++) { for (y = 2; y < ysize; y++) {
/* setup rows */ /* setup rows */
row1= rectmove + (y-2)*xsize; row1 = rectmove + (y - 2) * xsize;
row2= row1 + xsize; row2 = row1 + xsize;
row3= row2 + xsize; row3 = row2 + xsize;
for (x=2; x<xsize; x++, row1++, row2++, row3++) { for (x = 2; x < xsize; x++, row1++, row2++, row3++) {
if (row2[1]==0) { if (row2[1] == 0) {
if (row2[0]>1 || row2[2]>1 || row1[1]>1 || row3[1]>1) if (row2[0] > 1 || row2[2] > 1 || row1[1] > 1 || row3[1] > 1)
row2[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]; float p1[2], p2[2], p3[2];
p3[0]= -v2[0]; p3[0] = -v2[0];
p3[1]= -v2[1]; p3[1] = -v2[1];
p1[0]= v1[0]; p1[0] = v1[0];
p1[1]= v1[1]; p1[1] = v1[1];
/* official formula 2*p2 - 0.5*p1 - 0.5*p3 */ /* official formula 2*p2 - 0.5*p1 - 0.5*p3 */
p2[0]= -0.5f*p1[0] - 0.5f*p3[0]; p2[0] = -0.5f * p1[0] - 0.5f * p3[0];
p2[1]= -0.5f*p1[1] - 0.5f*p3[1]; 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[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[1] = ipodata[0] * p1[1] + ipodata[1] * p2[1] + ipodata[2] * p3[1];
} }
static void set_quad_bezier_ipo(float fac, float *data) 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[0] = mfac * mfac;
data[1]= 2.0f*mfac*fac; data[1] = 2.0f * mfac * fac;
data[2]= fac*fac; data[2] = fac * fac;
} }
void zbuf_accumulate_vecblur( void zbuf_accumulate_vecblur(
NodeBlurData *nbd, int xsize, int ysize, float *newrect, NodeBlurData *nbd, int xsize, int ysize, float *newrect,
const float *imgrect, float *vecbufrect, const float *zbufrect) const float *imgrect, float *vecbufrect, const float *zbufrect)
{ {
ZSpan zspan; ZSpan zspan;
DrawBufPixel *rectdraw, *dr; DrawBufPixel *rectdraw, *dr;
@ -506,64 +506,64 @@ void zbuf_accumulate_vecblur(
float v1[3], v2[3], v3[3], v4[3], fx, fy; float v1[3], v2[3], v3[3], v4[3], fx, fy;
const float *dimg, *dz, *ro; const float *dimg, *dz, *ro;
float *rectvz, *dvz, *dvec1, *dvec2, *dz1, *dz2, *rectz; float *rectvz, *dvz, *dvec1, *dvec2, *dz1, *dz2, *rectz;
float *minvecbufrect= NULL, *rectweight, *rw, *rectmax, *rm; float *minvecbufrect = NULL, *rectweight, *rw, *rectmax, *rm;
float maxspeedsq= (float)nbd->maxspeed*nbd->maxspeed; float maxspeedsq = (float)nbd->maxspeed * nbd->maxspeed;
int y, x, step, maxspeed=nbd->maxspeed, samples= nbd->samples; int y, x, step, maxspeed = nbd->maxspeed, samples = nbd->samples;
int tsktsk= 0; int tsktsk = 0;
static int firsttime= 1; static int firsttime = 1;
char *rectmove, *dm; char *rectmove, *dm;
zbuf_alloc_span(&zspan, xsize, ysize, 1.0f); zbuf_alloc_span(&zspan, xsize, ysize, 1.0f);
zspan.zmulx= ((float)xsize)/2.0f; zspan.zmulx = ((float)xsize) / 2.0f;
zspan.zmuly= ((float)ysize)/2.0f; zspan.zmuly = ((float)ysize) / 2.0f;
zspan.zofsx= 0.0f; zspan.zofsx = 0.0f;
zspan.zofsy= 0.0f; zspan.zofsy = 0.0f;
/* the buffers */ /* the buffers */
rectz= (float*)MEM_mapallocN(sizeof(float)*xsize*ysize, "zbuf accum"); rectz = (float *)MEM_mapallocN(sizeof(float) * xsize * ysize, "zbuf accum");
zspan.rectz= (int *)rectz; zspan.rectz = (int *)rectz;
rectmove= (char*)MEM_mapallocN(xsize*ysize, "rectmove"); rectmove = (char *)MEM_mapallocN(xsize * ysize, "rectmove");
rectdraw= (DrawBufPixel*)MEM_mapallocN(sizeof(DrawBufPixel)*xsize*ysize, "rect draw"); rectdraw = (DrawBufPixel *)MEM_mapallocN(sizeof(DrawBufPixel) * xsize * ysize, "rect draw");
zspan.rectdraw= rectdraw; zspan.rectdraw = rectdraw;
rectweight= (float*)MEM_mapallocN(sizeof(float)*xsize*ysize, "rect weight"); rectweight = (float *)MEM_mapallocN(sizeof(float) * xsize * ysize, "rect weight");
rectmax= (float*)MEM_mapallocN(sizeof(float)*xsize*ysize, "rect max"); rectmax = (float *)MEM_mapallocN(sizeof(float) * xsize * ysize, "rect max");
/* debug... check if PASS_VECTOR_MAX still is in buffers */ /* debug... check if PASS_VECTOR_MAX still is in buffers */
dvec1= vecbufrect; dvec1 = vecbufrect;
for (x= 4*xsize*ysize; x>0; x--, dvec1++) { for (x = 4 * xsize * ysize; x > 0; x--, dvec1++) {
if (dvec1[0]==PASS_VECTOR_MAX) { if (dvec1[0] == PASS_VECTOR_MAX) {
dvec1[0]= 0.0f; dvec1[0] = 0.0f;
tsktsk= 1; tsktsk = 1;
} }
} }
if (tsktsk) printf("Found uninitialized speed in vector buffer... fixed.\n"); if (tsktsk) printf("Found uninitialized speed in vector buffer... fixed.\n");
/* min speed? then copy speedbuffer to recalculate speed vectors */ /* min speed? then copy speedbuffer to recalculate speed vectors */
if (nbd->minspeed) { if (nbd->minspeed) {
float minspeed= (float)nbd->minspeed; float minspeed = (float)nbd->minspeed;
float minspeedsq= minspeed*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; dvec1 = vecbufrect;
dvec2= minvecbufrect; dvec2 = minvecbufrect;
for (x= 2*xsize*ysize; x>0; x--, dvec1+=2, dvec2+=2) { for (x = 2 * xsize * ysize; x > 0; x--, dvec1 += 2, dvec2 += 2) {
if (dvec1[0]==0.0f && dvec1[1]==0.0f) { if (dvec1[0] == 0.0f && dvec1[1] == 0.0f) {
dvec2[0]= dvec1[0]; dvec2[0] = dvec1[0];
dvec2[1]= dvec1[1]; dvec2[1] = dvec1[1];
} }
else { else {
float speedsq= dvec1[0]*dvec1[0] + dvec1[1]*dvec1[1]; float speedsq = dvec1[0] * dvec1[0] + dvec1[1] * dvec1[1];
if (speedsq <= minspeedsq) { if (speedsq <= minspeedsq) {
dvec2[0]= 0.0f; dvec2[0] = 0.0f;
dvec2[1]= 0.0f; dvec2[1] = 0.0f;
} }
else { else {
speedsq = 1.0f - minspeed / sqrtf(speedsq); speedsq = 1.0f - minspeed / sqrtf(speedsq);
dvec2[0]= speedsq*dvec1[0]; dvec2[0] = speedsq * dvec1[0];
dvec2[1]= speedsq*dvec1[1]; dvec2[1] = speedsq * dvec1[1];
} }
} }
} }
@ -571,75 +571,75 @@ void zbuf_accumulate_vecblur(
} }
/* make vertex buffer with averaged speed and zvalues */ /* make vertex buffer with averaged speed and zvalues */
rectvz= (float*)MEM_mapallocN(4*sizeof(float)*(xsize+1)*(ysize+1), "vertices"); rectvz = (float *)MEM_mapallocN(4 * sizeof(float) * (xsize + 1) * (ysize + 1), "vertices");
dvz= rectvz; dvz = rectvz;
for (y=0; y<=ysize; y++) { for (y = 0; y <= ysize; y++) {
if (y==0) if (y == 0)
dvec1= vecbufrect + 4*y*xsize; dvec1 = vecbufrect + 4 * y * xsize;
else else
dvec1= vecbufrect + 4*(y-1)*xsize; dvec1 = vecbufrect + 4 * (y - 1) * xsize;
if (y==ysize) if (y == ysize)
dvec2= vecbufrect + 4*(y-1)*xsize; dvec2 = vecbufrect + 4 * (y - 1) * xsize;
else 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 */ /* 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 */ /* average on minimal speed */
int div= 0; int div = 0;
if (x!=0) { if (x != 0) {
if (dvec1[-4]!=0.0f || dvec1[-3]!=0.0f) { if (dvec1[-4] != 0.0f || dvec1[-3] != 0.0f) {
dvz[0]= dvec1[-4]; dvz[0] = dvec1[-4];
dvz[1]= dvec1[-3]; dvz[1] = dvec1[-3];
div++; div++;
} }
if (dvec2[-4]!=0.0f || dvec2[-3]!=0.0f) { if (dvec2[-4] != 0.0f || dvec2[-3] != 0.0f) {
if (div==0) { if (div == 0) {
dvz[0]= dvec2[-4]; dvz[0] = dvec2[-4];
dvz[1]= dvec2[-3]; dvz[1] = dvec2[-3];
div++; div++;
} }
else if ( (ABS(dvec2[-4]) + ABS(dvec2[-3]))< (ABS(dvz[0]) + ABS(dvz[1])) ) { else if ( (ABS(dvec2[-4]) + ABS(dvec2[-3])) < (ABS(dvz[0]) + ABS(dvz[1])) ) {
dvz[0]= dvec2[-4]; dvz[0] = dvec2[-4];
dvz[1]= dvec2[-3]; dvz[1] = dvec2[-3];
} }
} }
} }
if (x!=xsize) { if (x != xsize) {
if (dvec1[0]!=0.0f || dvec1[1]!=0.0f) { if (dvec1[0] != 0.0f || dvec1[1] != 0.0f) {
if (div==0) { if (div == 0) {
dvz[0]= dvec1[0]; dvz[0] = dvec1[0];
dvz[1]= dvec1[1]; dvz[1] = dvec1[1];
div++; div++;
} }
else if ( (ABS(dvec1[0]) + ABS(dvec1[1]))< (ABS(dvz[0]) + ABS(dvz[1])) ) { else if ( (ABS(dvec1[0]) + ABS(dvec1[1])) < (ABS(dvz[0]) + ABS(dvz[1])) ) {
dvz[0]= dvec1[0]; dvz[0] = dvec1[0];
dvz[1]= dvec1[1]; dvz[1] = dvec1[1];
} }
} }
if (dvec2[0]!=0.0f || dvec2[1]!=0.0f) { if (dvec2[0] != 0.0f || dvec2[1] != 0.0f) {
if (div==0) { if (div == 0) {
dvz[0]= dvec2[0]; dvz[0] = dvec2[0];
dvz[1]= dvec2[1]; dvz[1] = dvec2[1];
} }
else if ( (ABS(dvec2[0]) + ABS(dvec2[1]))< (ABS(dvz[0]) + ABS(dvz[1])) ) { else if ( (ABS(dvec2[0]) + ABS(dvec2[1])) < (ABS(dvz[0]) + ABS(dvz[1])) ) {
dvz[0]= dvec2[0]; dvz[0] = dvec2[0];
dvz[1]= dvec2[1]; dvz[1] = dvec2[1];
} }
} }
} }
if (maxspeed) { 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) { if (speedsq > maxspeedsq) {
speedsq = (float)maxspeed / sqrtf(speedsq); speedsq = (float)maxspeed / sqrtf(speedsq);
dvz[0]*= speedsq; dvz[0] *= speedsq;
dvz[1]*= speedsq; dvz[1] *= speedsq;
} }
} }
} }
@ -647,117 +647,117 @@ void zbuf_accumulate_vecblur(
} }
/* set border speeds to keep border speeds on border */ /* set border speeds to keep border speeds on border */
dz1= rectvz; dz1 = rectvz;
dz2= rectvz+4*(ysize)*(xsize+1); dz2 = rectvz + 4 * (ysize) * (xsize + 1);
for (x=0; x<=xsize; x++, dz1+=4, dz2+=4) { for (x = 0; x <= xsize; x++, dz1 += 4, dz2 += 4) {
dz1[1]= 0.0f; dz1[1] = 0.0f;
dz2[1]= 0.0f; dz2[1] = 0.0f;
dz1[3]= 0.0f; dz1[3] = 0.0f;
dz2[3]= 0.0f; dz2[3] = 0.0f;
} }
dz1= rectvz; dz1 = rectvz;
dz2= rectvz+4*(xsize); dz2 = rectvz + 4 * (xsize);
for (y=0; y<=ysize; y++, dz1+=4*(xsize+1), dz2+=4*(xsize+1)) { for (y = 0; y <= ysize; y++, dz1 += 4 * (xsize + 1), dz2 += 4 * (xsize + 1)) {
dz1[0]= 0.0f; dz1[0] = 0.0f;
dz2[0]= 0.0f; dz2[0] = 0.0f;
dz1[2]= 0.0f; dz1[2] = 0.0f;
dz2[2]= 0.0f; dz2[2] = 0.0f;
} }
/* tag moving pixels, only these faces we draw */ /* tag moving pixels, only these faces we draw */
dm= rectmove; dm = rectmove;
dvec1= vecbufrect; dvec1 = vecbufrect;
for (x=xsize*ysize; x>0; x--, dm++, dvec1+=4) { 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)) if ((dvec1[0] != 0.0f || dvec1[1] != 0.0f || dvec1[2] != 0.0f || dvec1[3] != 0.0f))
*dm= 255; *dm = 255;
} }
antialias_tagbuf(xsize, ysize, rectmove); antialias_tagbuf(xsize, ysize, rectmove);
/* has to become static, the init-jit calls a random-seed, screwing up texture noise node */ /* has to become static, the init-jit calls a random-seed, screwing up texture noise node */
if (firsttime) { if (firsttime) {
firsttime= 0; firsttime = 0;
BLI_jitter_init(jit, 256); BLI_jitter_init(jit, 256);
} }
memset(newrect, 0, sizeof(float)*xsize*ysize*4); memset(newrect, 0, sizeof(float) * xsize * ysize * 4);
/* accumulate */ /* accumulate */
samples/= 2; samples /= 2;
for (step= 1; step<=samples; step++) { for (step = 1; step <= samples; step++) {
float speedfac= 0.5f*nbd->fac*(float)step/(float)(samples+1); float speedfac = 0.5f * nbd->fac * (float)step / (float)(samples + 1);
int side; int side;
for (side=0; side<2; side++) { for (side = 0; side < 2; side++) {
float blendfac, ipodata[4]; float blendfac, ipodata[4];
/* clear zbuf, if we draw future we fill in not moving pixels */ /* clear zbuf, if we draw future we fill in not moving pixels */
if (0) 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 else
for (x= xsize*ysize-1; x>=0; x--) { for (x = xsize * ysize - 1; x >= 0; x--) {
if (rectmove[x]==0) if (rectmove[x] == 0)
rectz[x]= zbufrect[x]; rectz[x] = zbufrect[x];
else else
rectz[x]= 10e16; rectz[x] = 10e16;
} }
/* clear drawing buffer */ /* 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; dimg = imgrect;
dm= rectmove; dm = rectmove;
dz= zbufrect; dz = zbufrect;
dz1= rectvz; dz1 = rectvz;
dz2= rectvz + 4*(xsize + 1); dz2 = rectvz + 4 * (xsize + 1);
if (side) { if (side) {
if (nbd->curved==0) { if (nbd->curved == 0) {
dz1+= 2; dz1 += 2;
dz2+= 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; y<ysize; y++, fy+=1.0f) { 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++) { 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) { if (*dm > 1) {
float jfx = fx + 0.5f; float jfx = fx + 0.5f;
float jfy = fy + 0.5f; float jfy = fy + 0.5f;
DrawBufPixel col; DrawBufPixel col;
/* make vertices */ /* make vertices */
if (nbd->curved) { /* curved */ if (nbd->curved) { /* curved */
quad_bezier_2d(v1, dz1, dz1+2, ipodata); quad_bezier_2d(v1, dz1, dz1 + 2, ipodata);
v1[0]+= jfx; v1[1]+= jfy; v1[2]= *dz; v1[0] += jfx; v1[1] += jfy; v1[2] = *dz;
quad_bezier_2d(v2, dz1+4, dz1+4+2, ipodata); quad_bezier_2d(v2, dz1 + 4, dz1 + 4 + 2, ipodata);
v2[0]+= jfx+1.0f; v2[1]+= jfy; v2[2]= *dz; v2[0] += jfx + 1.0f; v2[1] += jfy; v2[2] = *dz;
quad_bezier_2d(v3, dz2+4, dz2+4+2, ipodata); quad_bezier_2d(v3, dz2 + 4, dz2 + 4 + 2, ipodata);
v3[0]+= jfx+1.0f; v3[1]+= jfy+1.0f; v3[2]= *dz; v3[0] += jfx + 1.0f; v3[1] += jfy + 1.0f; v3[2] = *dz;
quad_bezier_2d(v4, dz2, dz2+2, ipodata); quad_bezier_2d(v4, dz2, dz2 + 2, ipodata);
v4[0]+= jfx; v4[1]+= jfy+1.0f; v4[2]= *dz; v4[0] += jfx; v4[1] += jfy + 1.0f; v4[2] = *dz;
} }
else { else {
v1[0]= speedfac*dz1[0]+jfx; v1[1]= speedfac*dz1[1]+jfy; v1[2]= *dz; ARRAY_SET_ITEMS(v1, speedfac * dz1[0] + jfx, speedfac * dz1[1] + jfy, *dz);
v2[0]= speedfac*dz1[4]+jfx+1.0f; v2[1]= speedfac*dz1[5]+jfy; v2[2]= *dz; ARRAY_SET_ITEMS(v2, speedfac * dz1[4] + jfx + 1.0f, speedfac * dz1[5] + jfy, *dz);
v3[0]= speedfac*dz2[4]+jfx+1.0f; v3[1]= speedfac*dz2[5]+jfy+1.0f; v3[2]= *dz; ARRAY_SET_ITEMS(v3, speedfac * dz2[4] + jfx + 1.0f, speedfac * dz2[5] + jfy + 1.0f, *dz);
v4[0]= speedfac*dz2[0]+jfx; v4[1]= speedfac*dz2[1]+jfy+1.0f; v4[2]= *dz; ARRAY_SET_ITEMS(v4, speedfac * dz2[0] + jfx, speedfac * dz2[1] + jfy + 1.0f, *dz);
} }
if (*dm==255) col.alpha= 1.0f; if (*dm == 255) col.alpha = 1.0f;
else if (*dm<2) col.alpha= 0.0f; else if (*dm < 2) col.alpha = 0.0f;
else col.alpha= ((float)*dm)/255.0f; else col.alpha = ((float)*dm) / 255.0f;
col.colpoin= dimg; col.colpoin = dimg;
zbuf_fill_in_rgba(&zspan, &col, v1, v2, v3, v4); zbuf_fill_in_rgba(&zspan, &col, v1, v2, v3, v4);
} }
} }
dz1+=4; dz1 += 4;
dz2+=4; dz2 += 4;
} }
/* blend with a falloff. this fixes the ugly effect you get with /* 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 * 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 * overestimates the contribution of foreground pixels but looks a
* bit better without a sudden cutoff. */ * 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 */ /* 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 */ /* accum */
rw= rectweight; rw = rectweight;
rm= rectmax; rm = rectmax;
for (dr= rectdraw, dz2=newrect, x= xsize*ysize-1; x>=0; x--, dr++, dz2+=4, rw++, rm++) { for (dr = rectdraw, dz2 = newrect, x = xsize * ysize - 1; x >= 0; x--, dr++, dz2 += 4, rw++, rm++) {
if (dr->colpoin) { if (dr->colpoin) {
float bfac= dr->alpha*blendfac; float bfac = dr->alpha * blendfac;
dz2[0] += bfac*dr->colpoin[0]; dz2[0] += bfac * dr->colpoin[0];
dz2[1] += bfac*dr->colpoin[1]; dz2[1] += bfac * dr->colpoin[1];
dz2[2] += bfac*dr->colpoin[2]; dz2[2] += bfac * dr->colpoin[2];
dz2[3] += bfac*dr->colpoin[3]; dz2[3] += bfac * dr->colpoin[3];
*rw += bfac; *rw += bfac;
*rm= MAX2(*rm, bfac); *rm = MAX2(*rm, bfac);
} }
} }
} }
} }
/* blend between original images and accumulated image */ /* blend between original images and accumulated image */
rw= rectweight; rw = rectweight;
rm= rectmax; rm = rectmax;
ro= imgrect; ro = imgrect;
dm= rectmove; dm = rectmove;
for (dz2=newrect, x= xsize*ysize-1; x>=0; x--, dz2+=4, ro+=4, rw++, rm++, dm++) { for (dz2 = newrect, x = xsize * ysize - 1; x >= 0; x--, dz2 += 4, ro += 4, rw++, rm++, dm++) {
float mfac = *rm; 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; float nfac = 1.0f - mfac;
dz2[0]= fac*dz2[0] + nfac*ro[0]; dz2[0] = fac * dz2[0] + nfac * ro[0];
dz2[1]= fac*dz2[1] + nfac*ro[1]; dz2[1] = fac * dz2[1] + nfac * ro[1];
dz2[2]= fac*dz2[2] + nfac*ro[2]; dz2[2] = fac * dz2[2] + nfac * ro[2];
dz2[3]= fac*dz2[3] + nfac*ro[3]; dz2[3] = fac * dz2[3] + nfac * ro[3];
} }
MEM_freeN(rectz); MEM_freeN(rectz);