[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [47875] trunk/blender/source/blender/ compositor/operations/COM_GlareFogGlowOperation.cpp: style cleanup
Campbell Barton
ideasman42 at gmail.com
Thu Jun 14 11:40:39 CEST 2012
Revision: 47875
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=47875
Author: campbellbarton
Date: 2012-06-14 09:40:36 +0000 (Thu, 14 Jun 2012)
Log Message:
-----------
style cleanup
Modified Paths:
--------------
trunk/blender/source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp
Modified: trunk/blender/source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp
===================================================================
--- trunk/blender/source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp 2012-06-14 09:39:54 UTC (rev 47874)
+++ trunk/blender/source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp 2012-06-14 09:40:36 UTC (rev 47875)
@@ -30,13 +30,13 @@
typedef float fREAL;
// returns next highest power of 2 of x, as well it's log2 in L2
-static unsigned int nextPow2(unsigned int x, unsigned int* L2)
+static unsigned int nextPow2(unsigned int x, unsigned int *L2)
{
- unsigned int pw, x_notpow2 = x & (x-1);
+ unsigned int pw, x_notpow2 = x & (x - 1);
*L2 = 0;
- while (x>>=1) ++(*L2);
+ while (x >>= 1) ++(*L2);
pw = 1 << (*L2);
- if (x_notpow2) { (*L2)++; pw<<=1; }
+ if (x_notpow2) { (*L2)++; pw <<= 1; }
return pw;
}
@@ -46,11 +46,11 @@
// use: r = revbin_upd(r, h) where h = N>>1
static unsigned int revbin_upd(unsigned int r, unsigned int h)
{
- while (!((r^=h)&h)) h >>= 1;
+ while (!((r ^= h) & h)) h >>= 1;
return r;
}
//------------------------------------------------------------------------------
-static void FHT(fREAL* data, unsigned int M, unsigned int inverse)
+static void FHT(fREAL *data, unsigned int M, unsigned int inverse)
{
double tt, fc, dc, fs, ds, a = M_PI;
fREAL t1, t2;
@@ -58,9 +58,9 @@
int i, j = 0;
unsigned int Nh = len >> 1;
- for (i=1;i<(len-1);++i) {
+ for (i = 1; i < (len - 1); ++i) {
j = revbin_upd(j, Nh);
- if (j>i) {
+ if (j > i) {
t1 = data[i];
data[i] = data[j];
data[j] = t1;
@@ -68,40 +68,40 @@
}
do {
- fREAL* data_n = &data[n];
+ fREAL *data_n = &data[n];
istep = n << 1;
- for (k=0; k<len; k+=istep) {
+ for (k = 0; k < len; k += istep) {
t1 = data_n[k];
data_n[k] = data[k] - t1;
data[k] += t1;
}
n2 = n >> 1;
- if (n>2) {
+ if (n > 2) {
fc = dc = cos(a);
- fs = ds = sqrt(1.0 - fc*fc); //sin(a);
- bd = n-2;
- for (bl=1; bl<n2; bl++) {
- fREAL* data_nbd = &data_n[bd];
- fREAL* data_bd = &data[bd];
- for (k=bl; k<len; k+=istep) {
- t1 = fc*data_n[k] + fs*data_nbd[k];
- t2 = fs*data_n[k] - fc*data_nbd[k];
+ fs = ds = sqrt(1.0 - fc * fc); //sin(a);
+ bd = n - 2;
+ for (bl = 1; bl < n2; bl++) {
+ fREAL *data_nbd = &data_n[bd];
+ fREAL *data_bd = &data[bd];
+ for (k = bl; k < len; k += istep) {
+ t1 = fc * data_n[k] + fs * data_nbd[k];
+ t2 = fs * data_n[k] - fc * data_nbd[k];
data_n[k] = data[k] - t1;
data_nbd[k] = data_bd[k] - t2;
data[k] += t1;
data_bd[k] += t2;
}
- tt = fc*dc - fs*ds;
- fs = fs*dc + fc*ds;
+ tt = fc * dc - fs * ds;
+ fs = fs * dc + fc * ds;
fc = tt;
bd -= 2;
}
}
- if (n>1) {
- for (k=n2; k<len; k+=istep) {
+ if (n > 1) {
+ for (k = n2; k < len; k += istep) {
t1 = data_n[k];
data_n[k] = data[k] - t1;
data[k] += t1;
@@ -110,20 +110,20 @@
n = istep;
a *= 0.5;
- } while (n<len);
+ } while (n < len);
if (inverse) {
fREAL sc = (fREAL)1 / (fREAL)len;
- for (k=0; k<len; ++k)
+ for (k = 0; k < len; ++k)
data[k] *= sc;
}
}
//------------------------------------------------------------------------------
/* 2D Fast Hartley Transform, Mx/My -> log2 of width/height,
- nzp -> the row where zero pad data starts,
- inverse -> see above */
+ nzp -> the row where zero pad data starts,
+ inverse -> see above */
static void FHT2D(fREAL *data, unsigned int Mx, unsigned int My,
- unsigned int nzp, unsigned int inverse)
+ unsigned int nzp, unsigned int inverse)
{
unsigned int i, j, Nx, Ny, maxy;
fREAL t;
@@ -133,25 +133,25 @@
// rows (forward transform skips 0 pad data)
maxy = inverse ? Ny : nzp;
- for (j=0; j<maxy; ++j)
- FHT(&data[Nx*j], Mx, inverse);
+ for (j = 0; j < maxy; ++j)
+ FHT(&data[Nx * j], Mx, inverse);
// transpose data
- if (Nx==Ny) { // square
- for (j=0; j<Ny; ++j)
- for (i=j+1; i<Nx; ++i) {
+ if (Nx == Ny) { // square
+ for (j = 0; j < Ny; ++j)
+ for (i = j + 1; i < Nx; ++i) {
unsigned int op = i + (j << Mx), np = j + (i << My);
- t=data[op], data[op]=data[np], data[np]=t;
+ t = data[op], data[op] = data[np], data[np] = t;
}
}
else { // rectangular
- unsigned int k, Nym = Ny-1, stm = 1 << (Mx + My);
- for (i=0; stm>0; i++) {
+ unsigned int k, Nym = Ny - 1, stm = 1 << (Mx + My);
+ for (i = 0; stm > 0; i++) {
#define PRED(k) (((k & Nym) << Mx) + (k >> My))
- for (j=PRED(i); j>i; j=PRED(j));
+ for (j = PRED(i); j > i; j = PRED(j)) ;
if (j < i) continue;
- for (k=i, j=PRED(i); j!=i; k=j, j=PRED(j), stm--) {
- t=data[j], data[j]=data[k], data[k]=t;
+ for (k = i, j = PRED(i); j != i; k = j, j = PRED(j), stm--) {
+ t = data[j], data[j] = data[k], data[k] = t;
}
#undef PRED
stm--;
@@ -162,21 +162,21 @@
i = Mx, Mx = My, My = i;
// now columns == transposed rows
- for (j=0; j<Ny; ++j)
- FHT(&data[Nx*j], Mx, inverse);
+ for (j = 0; j < Ny; ++j)
+ FHT(&data[Nx * j], Mx, inverse);
// finalize
- for (j=0; j<=(Ny >> 1); j++) {
- unsigned int jm = (Ny - j) & (Ny-1);
+ for (j = 0; j <= (Ny >> 1); j++) {
+ unsigned int jm = (Ny - j) & (Ny - 1);
unsigned int ji = j << Mx;
unsigned int jmi = jm << Mx;
- for (i=0; i<=(Nx >> 1); i++) {
- unsigned int im = (Nx - i) & (Nx-1);
+ for (i = 0; i <= (Nx >> 1); i++) {
+ unsigned int im = (Nx - i) & (Nx - 1);
fREAL A = data[ji + i];
fREAL B = data[jmi + i];
fREAL C = data[ji + im];
fREAL D = data[jmi + im];
- fREAL E = (fREAL)0.5*((A + D) - (B + C));
+ fREAL E = (fREAL)0.5 * ((A + D) - (B + C));
data[ji + i] = A - E;
data[jmi + i] = B + E;
data[ji + im] = C + E;
@@ -189,62 +189,62 @@
//------------------------------------------------------------------------------
/* 2D convolution calc, d1 *= d2, M/N - > log2 of width/height */
-static void fht_convolve(fREAL* d1, fREAL* d2, unsigned int M, unsigned int N)
+static void fht_convolve(fREAL *d1, fREAL *d2, unsigned int M, unsigned int N)
{
fREAL a, b;
unsigned int i, j, k, L, mj, mL;
unsigned int m = 1 << M, n = 1 << N;
- unsigned int m2 = 1 << (M-1), n2 = 1 << (N-1);
- unsigned int mn2 = m << (N-1);
+ unsigned int m2 = 1 << (M - 1), n2 = 1 << (N - 1);
+ unsigned int mn2 = m << (N - 1);
d1[0] *= d2[0];
d1[mn2] *= d2[mn2];
d1[m2] *= d2[m2];
d1[m2 + mn2] *= d2[m2 + mn2];
- for (i=1; i<m2; i++) {
+ for (i = 1; i < m2; i++) {
k = m - i;
- a = d1[i]*d2[i] - d1[k]*d2[k];
- b = d1[k]*d2[i] + d1[i]*d2[k];
- d1[i] = (b + a)*(fREAL)0.5;
- d1[k] = (b - a)*(fREAL)0.5;
- a = d1[i + mn2]*d2[i + mn2] - d1[k + mn2]*d2[k + mn2];
- b = d1[k + mn2]*d2[i + mn2] + d1[i + mn2]*d2[k + mn2];
- d1[i + mn2] = (b + a)*(fREAL)0.5;
- d1[k + mn2] = (b - a)*(fREAL)0.5;
+ a = d1[i] * d2[i] - d1[k] * d2[k];
+ b = d1[k] * d2[i] + d1[i] * d2[k];
+ d1[i] = (b + a) * (fREAL)0.5;
+ d1[k] = (b - a) * (fREAL)0.5;
+ a = d1[i + mn2] * d2[i + mn2] - d1[k + mn2] * d2[k + mn2];
+ b = d1[k + mn2] * d2[i + mn2] + d1[i + mn2] * d2[k + mn2];
+ d1[i + mn2] = (b + a) * (fREAL)0.5;
+ d1[k + mn2] = (b - a) * (fREAL)0.5;
}
- for (j=1; j<n2; j++) {
+ for (j = 1; j < n2; j++) {
L = n - j;
mj = j << M;
mL = L << M;
- a = d1[mj]*d2[mj] - d1[mL]*d2[mL];
- b = d1[mL]*d2[mj] + d1[mj]*d2[mL];
- d1[mj] = (b + a)*(fREAL)0.5;
- d1[mL] = (b - a)*(fREAL)0.5;
- a = d1[m2 + mj]*d2[m2 + mj] - d1[m2 + mL]*d2[m2 + mL];
- b = d1[m2 + mL]*d2[m2 + mj] + d1[m2 + mj]*d2[m2 + mL];
- d1[m2 + mj] = (b + a)*(fREAL)0.5;
- d1[m2 + mL] = (b - a)*(fREAL)0.5;
+ a = d1[mj] * d2[mj] - d1[mL] * d2[mL];
+ b = d1[mL] * d2[mj] + d1[mj] * d2[mL];
+ d1[mj] = (b + a) * (fREAL)0.5;
+ d1[mL] = (b - a) * (fREAL)0.5;
+ a = d1[m2 + mj] * d2[m2 + mj] - d1[m2 + mL] * d2[m2 + mL];
+ b = d1[m2 + mL] * d2[m2 + mj] + d1[m2 + mj] * d2[m2 + mL];
+ d1[m2 + mj] = (b + a) * (fREAL)0.5;
+ d1[m2 + mL] = (b - a) * (fREAL)0.5;
}
- for (i=1; i<m2; i++) {
+ for (i = 1; i < m2; i++) {
k = m - i;
- for (j=1; j<n2; j++) {
+ for (j = 1; j < n2; j++) {
L = n - j;
mj = j << M;
mL = L << M;
- a = d1[i + mj]*d2[i + mj] - d1[k + mL]*d2[k + mL];
- b = d1[k + mL]*d2[i + mj] + d1[i + mj]*d2[k + mL];
- d1[i + mj] = (b + a)*(fREAL)0.5;
- d1[k + mL] = (b - a)*(fREAL)0.5;
- a = d1[i + mL]*d2[i + mL] - d1[k + mj]*d2[k + mj];
- b = d1[k + mj]*d2[i + mL] + d1[i + mL]*d2[k + mj];
- d1[i + mL] = (b + a)*(fREAL)0.5;
- d1[k + mj] = (b - a)*(fREAL)0.5;
+ a = d1[i + mj] * d2[i + mj] - d1[k + mL] * d2[k + mL];
+ b = d1[k + mL] * d2[i + mj] + d1[i + mj] * d2[k + mL];
+ d1[i + mj] = (b + a) * (fREAL)0.5;
+ d1[k + mL] = (b - a) * (fREAL)0.5;
+ a = d1[i + mL] * d2[i + mL] - d1[k + mj] * d2[k + mj];
+ b = d1[k + mj] * d2[i + mL] + d1[i + mL] * d2[k + mj];
+ d1[i + mL] = (b + a) * (fREAL)0.5;
+ d1[k + mj] = (b - a) * (fREAL)0.5;
}
}
}
//------------------------------------------------------------------------------
-void convolve(float* dst, MemoryBuffer* in1, MemoryBuffer* in2)
+void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2)
{
fREAL *data1, *data2, *fp;
unsigned int w2, h2, hw, hh, log2_w, log2_h;
@@ -256,35 +256,35 @@
const unsigned int kernelHeight = in2->getHeight();
const unsigned int imageWidth = in1->getWidth();
const unsigned int imageHeight = in1->getHeight();
- float * kernelBuffer = in2->getBuffer();
- float * imageBuffer = in1->getBuffer();
+ float *kernelBuffer = in2->getBuffer();
+ float *imageBuffer = in1->getBuffer();
- MemoryBuffer* rdst = new MemoryBuffer(NULL, in1->getRect());
+ MemoryBuffer *rdst = new MemoryBuffer(NULL, in1->getRect());
// convolution result width & height
- w2 = 2*kernelWidth - 1;
- h2 = 2*kernelHeight - 1;
+ w2 = 2 * kernelWidth - 1;
+ h2 = 2 * kernelHeight - 1;
// FFT pow2 required size & log2
w2 = nextPow2(w2, &log2_w);
h2 = nextPow2(h2, &log2_h);
// alloc space
- data1 = (fREAL*)MEM_callocN(3*w2*h2*sizeof(fREAL), "convolve_fast FHT data1");
- data2 = (fREAL*)MEM_callocN(w2*h2*sizeof(fREAL), "convolve_fast FHT data2");
+ data1 = (fREAL *)MEM_callocN(3 * w2 * h2 * sizeof(fREAL), "convolve_fast FHT data1");
+ data2 = (fREAL *)MEM_callocN(w2 * h2 * sizeof(fREAL), "convolve_fast FHT data2");
// normalize convolutor
wt[0] = wt[1] = wt[2] = 0.f;
- for (y=0; y<kernelHeight; y++) {
- colp = (fRGB*)&kernelBuffer[y*kernelWidth*COM_NUMBER_OF_CHANNELS];
- for (x=0; x<kernelWidth; x++)
+ for (y = 0; y < kernelHeight; y++) {
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list