archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

style cleanup: comments

Browse Source
This commit is contained in:
Campbell Barton
2012-06-30 22:49:33 +00:00
parent 273f56ace0
commit 8b865c01cd
66 changed files with 480 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
View File

@@ -781,10 +781,10 @@ static void do_allEdgeDetection(unsigned int t, unsigned int rw, unsigned int *l
if (!limask[a]) { // if the inner mask is empty
if (lomask[a]) { // if the outer mask is full
/*
Next we test all 4 directions around the current pixel: next/prev/up/down
The test ensures that the outer mask is empty and that the inner mask
is also empty. If both conditions are true for any one of the 4 adjacent pixels
then the current pixel is counted as being a true outer edge pixel.
* Next we test all 4 directions around the current pixel: next/prev/up/down
* The test ensures that the outer mask is empty and that the inner mask
* is also empty. If both conditions are true for any one of the 4 adjacent pixels
* then the current pixel is counted as being a true outer edge pixel.
*/
if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
(!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
@@ -843,10 +843,10 @@ static void do_adjacentEdgeDetection(unsigned int t, unsigned int rw, unsigned i
if (!limask[a]) { // if the inner mask is empty
if (lomask[a]) { // if the outer mask is full
/*
Next we test all 4 directions around the current pixel: next/prev/up/down
The test ensures that the outer mask is empty and that the inner mask
is also empty. If both conditions are true for any one of the 4 adjacent pixels
then the current pixel is counted as being a true outer edge pixel.
* Next we test all 4 directions around the current pixel: next/prev/up/down
* The test ensures that the outer mask is empty and that the inner mask
* is also empty. If both conditions are true for any one of the 4 adjacent pixels
* then the current pixel is counted as being a true outer edge pixel.
*/
if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
(!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
@@ -902,65 +902,65 @@ static void do_createEdgeLocationBuffer(unsigned int t, unsigned int rw, unsigne
unsigned int outerAccum = 0; // for looping outer edge pixel indexes, represents current position from offset
unsigned int gradientAccum = 0; // for looping gradient pixel indexes, represents current position from offset
/*
Here we compute the size of buffer needed to hold (row,col) coordinates
for each pixel previously determined to be either gradient, inner edge,
or outer edge.
Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even
though gbuf[] is declared as unsigned short* (2 bytes) because we don't
store the pixel indexes, we only store x,y location of pixel in buffer.
This does make the assumption that x and y can fit in 16 unsigned bits
so if Blender starts doing renders greater than 65536 in either direction
this will need to allocate gbuf[] as unsigned int *and allocate 8 bytes
per flagged pixel.
In general, the buffer on-screen:
Example: 9 by 9 pixel block
. = pixel non-white in both outer and inner mask
o = pixel white in outer, but not inner mask, adjacent to "." pixel
g = pixel white in outer, but not inner mask, not adjacent to "." pixel
i = pixel white in inner mask, adjacent to "g" or "." pixel
F = pixel white in inner mask, only adjacent to other pixels white in the inner mask
......... <----- pixel #80
..oooo...
.oggggo..
.oggiggo.
.ogiFigo.
.oggiggo.
.oggggo..
..oooo...
pixel #00 -----> .........
gsz = 18 (18 "g" pixels above)
isz = 4 (4 "i" pixels above)
osz = 18 (18 "o" pixels above)
The memory in gbuf[] after filling will look like this:
gradientFillOffset (0 pixels) innerEdgeOffset (18 pixels) outerEdgeOffset (22 pixels)
/ / /
/ / /
|X Y X Y X Y X Y > <X Y X Y > <X Y X Y X Y > <X Y X Y | <- (x,y)
+--------------------------------> <----------------> <------------------------> <----------------+
|0 2 4 6 8 10 12 14 > ... <68 70 72 74 > ... <80 82 84 86 88 90 > ... <152 154 156 158 | <- bytes
+--------------------------------> <----------------> <------------------------> <----------------+
|g0 g0 g1 g1 g2 g2 g3 g3 > <g17 g17 i0 i0 > <i2 i2 i3 i3 o0 o0 > <o16 o16 o17 o17 | <- pixel
/ / /
/ / /
/ / /
+---------- gradientAccum (18) ---------+ +--- innerAccum (22) ---+ +--- outerAccum (40) ---+
Ultimately we do need the pixel's memory buffer index to set the output
pixel color, but it's faster to reconstruct the memory buffer location
each iteration of the final gradient calculation than it is to deconstruct
a memory location into x,y pairs each round.
* Here we compute the size of buffer needed to hold (row,col) coordinates
* for each pixel previously determined to be either gradient, inner edge,
* or outer edge.
*
* Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even
* though gbuf[] is declared as unsigned short* (2 bytes) because we don't
* store the pixel indexes, we only store x,y location of pixel in buffer.
*
* This does make the assumption that x and y can fit in 16 unsigned bits
* so if Blender starts doing renders greater than 65536 in either direction
* this will need to allocate gbuf[] as unsigned int *and allocate 8 bytes
* per flagged pixel.
*
* In general, the buffer on-screen:
*
* Example: 9 by 9 pixel block
*
* . = pixel non-white in both outer and inner mask
* o = pixel white in outer, but not inner mask, adjacent to "." pixel
* g = pixel white in outer, but not inner mask, not adjacent to "." pixel
* i = pixel white in inner mask, adjacent to "g" or "." pixel
* F = pixel white in inner mask, only adjacent to other pixels white in the inner mask
*
*
* ......... <----- pixel #80
* ..oooo...
* .oggggo..
* .oggiggo.
* .ogiFigo.
* .oggiggo.
* .oggggo..
* ..oooo...
* pixel #00 -----> .........
*
* gsz = 18 (18 "g" pixels above)
* isz = 4 (4 "i" pixels above)
* osz = 18 (18 "o" pixels above)
*
*
* The memory in gbuf[] after filling will look like this:
*
* gradientFillOffset (0 pixels) innerEdgeOffset (18 pixels) outerEdgeOffset (22 pixels)
* / / /
* / / /
* |X Y X Y X Y X Y > <X Y X Y > <X Y X Y X Y > <X Y X Y | <- (x,y)
* +--------------------------------> <----------------> <------------------------> <----------------+
* |0 2 4 6 8 10 12 14 > ... <68 70 72 74 > ... <80 82 84 86 88 90 > ... <152 154 156 158 | <- bytes
* +--------------------------------> <----------------> <------------------------> <----------------+
* |g0 g0 g1 g1 g2 g2 g3 g3 > <g17 g17 i0 i0 > <i2 i2 i3 i3 o0 o0 > <o16 o16 o17 o17 | <- pixel
* / / /
* / / /
* / / /
* +---------- gradientAccum (18) ---------+ +--- innerAccum (22) ---+ +--- outerAccum (40) ---+
*
*
* Ultimately we do need the pixel's memory buffer index to set the output
* pixel color, but it's faster to reconstruct the memory buffer location
* each iteration of the final gradient calculation than it is to deconstruct
* a memory location into x,y pairs each round.
*/

4
source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp
View File

@@ -120,8 +120,8 @@ static void FHT(fREAL *data, unsigned int M, unsigned int inverse)
}
//------------------------------------------------------------------------------
/* 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)
{

4
source/blender/compositor/operations/COM_KeyingClipOperation.h
View File

@@ -27,8 +27,8 @@
#include "COM_NodeOperation.h"
/**
* Class with implementation of black/white clipping for keying node
*/
* Class with implementation of black/white clipping for keying node
*/
class KeyingClipOperation : public NodeOperation {
protected:
float m_clipBlack;

4
source/blender/compositor/operations/COM_KeyingDespillOperation.h
View File

@@ -27,8 +27,8 @@
#include "COM_NodeOperation.h"
/**
* Class with implementation of keying despill node
*/
* Class with implementation of keying despill node
*/
class KeyingDespillOperation : public NodeOperation {
protected:
SocketReader *m_pixelReader;

4
source/blender/compositor/operations/COM_KeyingOperation.h
View File

@@ -32,8 +32,8 @@
#include "BLI_listbase.h"
/**
* Class with implementation of keying node
*/
* Class with implementation of keying node
*/
class KeyingOperation : public NodeOperation {
protected:
SocketReader *m_pixelReader;