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

rename remaining class members with m_ prefix.

Browse Source
This commit is contained in:
Campbell Barton
2012-06-26 07:09:49 +00:00
parent 6a1d82490e
commit 69ab13a7db
84 changed files with 582 additions and 585 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/blender/compositor/intern/COM_ChannelInfo.cpp
View File

@@ -29,7 +29,7 @@
*/
ChannelInfo::ChannelInfo()
{
this->number = 0;
this->premultiplied = true;
this->type = COM_CT_UNUSED;
this->m_number = 0;
this->m_premultiplied = true;
this->m_type = COM_CT_UNUSED;
}

24
source/blender/compositor/intern/COM_ChannelInfo.h
View File

@@ -61,23 +61,23 @@ private:
/**
* @brief the channel number, in the connection. [0-3]
*/
int number;
int m_number;
/**
* @brief type of channel
*/
ChannelType type;
ChannelType m_type;
/**
* @brieg Is this value in this channel premultiplied with its alpha
* @note only valid if type = ColorComponent;
*/
bool premultiplied;
bool m_premultiplied;
// /**
// * Color space of this value.
// * only valid when type = ColorComponent;
// */
// * Color space of this value.
// * only valid when type = ColorComponent;
// */
// string colorspacename;
public:
@@ -89,32 +89,32 @@ public:
/**
* @brief set the index of this channel in the SocketConnection
*/
void setNumber(const int number) { this->number = number; }
void setNumber(const int number) { this->m_number = number; }
/**
* @brief get the index of this channel in the SocketConnection
*/
const int getNumber() const { return this->number; }
const int getNumber() const { return this->m_number; }
/**
* @brief set the type of channel
*/
void setType(const ChannelType type) { this->type = type; }
void setType(const ChannelType type) { this->m_type = type; }
/**
* @brief get the type of channel
*/
const ChannelType getType() const { return this->type; }
const ChannelType getType() const { return this->m_type; }
/**
* @brief set the premultiplicatioin of this channel
*/
void setPremultiplied(const bool premultiplied) { this->premultiplied = premultiplied; }
void setPremultiplied(const bool premultiplied) { this->m_premultiplied = premultiplied; }
/**
* @brief is this channel premultiplied
*/
const bool isPremultiplied() const { return this->premultiplied; }
const bool isPremultiplied() const { return this->m_premultiplied; }
};

14
source/blender/compositor/intern/COM_ChunkOrder.cpp
View File

@@ -25,10 +25,10 @@
ChunkOrder::ChunkOrder()
{
this->distance = 0.0;
this->number = 0;
this->x = 0;
this->y = 0;
this->m_distance = 0.0;
this->m_number = 0;
this->m_x = 0;
this->m_y = 0;
}
void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots)
@@ -37,15 +37,15 @@ void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int nu
double distance = MAXFLOAT;
for (index = 0; index < numberOfHotspots; index++) {
ChunkOrderHotspot *hotspot = hotspots[index];
double ndistance = hotspot->determineDistance(this->x, this->y);
double ndistance = hotspot->determineDistance(this->m_x, this->m_y);
if (ndistance < distance) {
distance = ndistance;
}
}
this->distance = distance;
this->m_distance = distance;
}
bool operator<(const ChunkOrder& a, const ChunkOrder& b)
{
return a.distance < b.distance;
return a.m_distance < b.m_distance;
}

18
source/blender/compositor/intern/COM_ChunkOrder.h
View File

@@ -26,20 +26,20 @@
#include "COM_ChunkOrderHotspot.h"
class ChunkOrder {
private:
unsigned int number;
int x;
int y;
double distance;
unsigned int m_number;
int m_x;
int m_y;
double m_distance;
public:
ChunkOrder();
void determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots);
friend bool operator<(const ChunkOrder& a, const ChunkOrder& b);
void setChunkNumber(unsigned int chunknumber) { this->number = chunknumber; }
void setX(int x) { this->x = x; }
void setY(int y) { this->y = y; }
unsigned int getChunkNumber() { return this->number; }
double getDistance() { return this->distance; }
void setChunkNumber(unsigned int chunknumber) { this->m_number = chunknumber; }
void setX(int x) { this->m_x = x; }
void setY(int y) { this->m_y = y; }
unsigned int getChunkNumber() { return this->m_number; }
double getDistance() { return this->m_distance; }
};
#endif

12
source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp
View File

@@ -25,16 +25,16 @@
ChunkOrderHotspot::ChunkOrderHotspot(int x, int y, float addition)
{
this->x = x;
this->y = y;
this->addition = addition;
this->m_x = x;
this->m_y = y;
this->m_addition = addition;
}
double ChunkOrderHotspot::determineDistance(int x, int y)
{
int dx = x - this->x;
int dy = y - this->y;
int dx = x - this->m_x;
int dy = y - this->m_y;
double result = sqrt((double)(dx * dx + dy * dy));
result += (double)this->addition;
result += (double)this->m_addition;
return result;
}

6
source/blender/compositor/intern/COM_ChunkOrderHotspot.h
View File

@@ -29,9 +29,9 @@
class ChunkOrderHotspot {
private:
int x;
int y;
float addition;
int m_x;
int m_y;
float m_addition;
public:
ChunkOrderHotspot(int x, int y, float addition);

16
source/blender/compositor/intern/COM_CompositorContext.cpp
View File

@@ -26,16 +26,16 @@
CompositorContext::CompositorContext()
{
this->rd = NULL;
this->quality = COM_QUALITY_HIGH;
this->hasActiveOpenCLDevices = false;
this->activegNode = NULL;
this->m_rd = NULL;
this->m_quality = COM_QUALITY_HIGH;
this->m_hasActiveOpenCLDevices = false;
this->m_activegNode = NULL;
}
const int CompositorContext::getFramenumber() const
{
if (this->rd) {
return this->rd->cfra;
if (this->m_rd) {
return this->m_rd->cfra;
}
else {
return -1; /* this should never happen */
@@ -44,8 +44,8 @@ const int CompositorContext::getFramenumber() const
const int CompositorContext::isColorManaged() const
{
if (this->rd) {
return this->rd->color_mgt_flag & R_COLOR_MANAGEMENT;
if (this->m_rd) {
return this->m_rd->color_mgt_flag & R_COLOR_MANAGEMENT;
}
else {
return 0; /* this should never happen */

44
source/blender/compositor/intern/COM_CompositorContext.h
View File

@@ -41,38 +41,38 @@ private:
* This field is initialized in ExecutionSystem and must only be read from that point on.
* @see ExecutionSystem
*/
bool rendering;
bool m_rendering;
/**
* @brief The quality of the composite.
* This field is initialized in ExecutionSystem and must only be read from that point on.
* @see ExecutionSystem
*/
CompositorQuality quality;
CompositorQuality m_quality;
/**
* @brief Reference to the render data that is being composited.
* This field is initialized in ExecutionSystem and must only be read from that point on.
* @see ExecutionSystem
*/
RenderData *rd;
RenderData *m_rd;
/**
* @brief reference to the bNodeTree
* This field is initialized in ExecutionSystem and must only be read from that point on.
* @see ExecutionSystem
*/
bNodeTree *bnodetree;
bNodeTree *m_bnodetree;
/**
* @brief activegNode the group node that is currently being edited.
*/
bNode *activegNode;
bNode *m_activegNode;
/**
* @brief does this system have active opencl devices?
*/
bool hasActiveOpenCLDevices;
bool m_hasActiveOpenCLDevices;
public:
/**
@@ -83,56 +83,52 @@ public:
/**
* @brief set the rendering field of the context
*/
void setRendering(bool rendering) { this->rendering = rendering; }
void setRendering(bool rendering) { this->m_rendering = rendering; }
/**
* @brief get the rendering field of the context
*/
bool isRendering() const { return this->rendering; }
bool isRendering() const { return this->m_rendering; }
/**
* @brief set the scene of the context
*/
void setRenderData(RenderData *rd) { this->rd = rd; }
void setRenderData(RenderData *rd) { this->m_rd = rd; }
/**
* @brief set the bnodetree of the context
*/
void setbNodeTree(bNodeTree *bnodetree) { this->bnodetree = bnodetree; }
void setbNodeTree(bNodeTree *bnodetree) { this->m_bnodetree = bnodetree; }
/**
* @brief get the bnodetree of the context
*/
const bNodeTree *getbNodeTree() const { return this->bnodetree; }
const bNodeTree *getbNodeTree() const { return this->m_bnodetree; }
/**
* @brief set the active groupnode of the context
*/
void setActivegNode(bNode *gnode) { this->activegNode = gnode; }
void setActivegNode(bNode *gnode) { this->m_activegNode = gnode; }
/**
* @brief get the active groupnode of the context
*/
const bNode *getActivegNode() const { return this->activegNode; }
const bNode *getActivegNode() const { return this->m_activegNode; }
/**
* @brief get the scene of the context
*/
const RenderData *getRenderData() const { return this->rd; }
const RenderData *getRenderData() const { return this->m_rd; }
/**
* @brief set the quality
*/
void setQuality(CompositorQuality quality) {
this->quality = quality;
}
void setQuality(CompositorQuality quality) { this->m_quality = quality; }
/**
* @brief get the quality
*/
const CompositorQuality getQuality() const {
return quality;
}
const CompositorQuality getQuality() const { return this->m_quality; }
/**
* @brief get the current framenumber of the scene in this context
@@ -142,16 +138,12 @@ public:
/**
* @brief has this system active openclDevices?
*/
const bool getHasActiveOpenCLDevices() const {
return this->hasActiveOpenCLDevices;
}
const bool getHasActiveOpenCLDevices() const { return this->m_hasActiveOpenCLDevices; }
/**
* @brief set has this system active openclDevices?
*/
void setHasActiveOpenCLDevices(bool hasAvtiveOpenCLDevices) {
this->hasActiveOpenCLDevices = hasAvtiveOpenCLDevices;
}
void setHasActiveOpenCLDevices(bool hasAvtiveOpenCLDevices) { this->m_hasActiveOpenCLDevices = hasAvtiveOpenCLDevices; }
int getChunksize() { return this->getbNodeTree()->chunksize; }

228
source/blender/compositor/intern/COM_ExecutionGroup.cpp
View File

@@ -43,20 +43,20 @@
ExecutionGroup::ExecutionGroup()
{
this->isOutput = false;
this->complex = false;
this->chunkExecutionStates = NULL;
this->bTree = NULL;
this->height = 0;
this->width = 0;
this->cachedMaxReadBufferOffset = 0;
this->numberOfXChunks = 0;
this->numberOfYChunks = 0;
this->numberOfChunks = 0;
this->initialized = false;
this->openCL = false;
this->singleThreaded = false;
this->chunksFinished = 0;
this->m_isOutput = false;
this->m_complex = false;
this->m_chunkExecutionStates = NULL;
this->m_bTree = NULL;
this->m_height = 0;
this->m_width = 0;
this->m_cachedMaxReadBufferOffset = 0;
this->m_numberOfXChunks = 0;
this->m_numberOfYChunks = 0;
this->m_numberOfChunks = 0;
this->m_initialized = false;
this->m_openCL = false;
this->m_singleThreaded = false;
this->m_chunksFinished = 0;
}
CompositorPriority ExecutionGroup::getRenderPriotrity()
@@ -66,7 +66,7 @@ CompositorPriority ExecutionGroup::getRenderPriotrity()
bool ExecutionGroup::containsOperation(NodeOperation *operation)
{
for (vector<NodeOperation *>::const_iterator iterator = this->operations.begin(); iterator != this->operations.end(); ++iterator) {
for (vector<NodeOperation *>::const_iterator iterator = this->m_operations.begin(); iterator != this->m_operations.end(); ++iterator) {
NodeOperation *inListOperation = *iterator;
if (inListOperation == operation) {
return true;
@@ -77,12 +77,12 @@ bool ExecutionGroup::containsOperation(NodeOperation *operation)
const bool ExecutionGroup::isComplex() const
{
return this->complex;
return this->m_complex;
}
bool ExecutionGroup::canContainOperation(NodeOperation *operation)
{
if (!this->initialized) { return true; }
if (!this->m_initialized) { return true; }
if (operation->isReadBufferOperation()) { return true; }
if (operation->isWriteBufferOperation()) { return false; }
if (operation->isSetOperation()) { return true; }
@@ -100,12 +100,12 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
if (containsOperation(operation)) return;
if (canContainOperation(operation)) {
if (!operation->isBufferOperation()) {
this->complex = operation->isComplex();
this->openCL = operation->isOpenCL();
this->singleThreaded = operation->isSingleThreaded();
this->initialized = true;
this->m_complex = operation->isComplex();
this->m_openCL = operation->isOpenCL();
this->m_singleThreaded = operation->isSingleThreaded();
this->m_initialized = true;
}
this->operations.push_back(operation);
this->m_operations.push_back(operation);
if (operation->isReadBufferOperation()) {
ReadBufferOperation *readOperation = (ReadBufferOperation *)operation;
WriteBufferOperation *writeOperation = readOperation->getMemoryProxy()->getWriteBufferOperation();
@@ -137,52 +137,52 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
NodeOperation *ExecutionGroup::getOutputNodeOperation() const
{
return this->operations[0]; // the first operation of the group is always the output operation.
return this->m_operations[0]; // the first operation of the group is always the output operation.
}
void ExecutionGroup::initExecution()
{
if (this->chunkExecutionStates != NULL) {
delete[] this->chunkExecutionStates;
if (this->m_chunkExecutionStates != NULL) {
delete[] this->m_chunkExecutionStates;
}
unsigned int index;
determineNumberOfChunks();
this->chunkExecutionStates = NULL;
if (this->numberOfChunks != 0) {
this->chunkExecutionStates = new ChunkExecutionState[numberOfChunks];
for (index = 0; index < numberOfChunks; index++) {
this->chunkExecutionStates[index] = COM_ES_NOT_SCHEDULED;
this->m_chunkExecutionStates = NULL;
if (this->m_numberOfChunks != 0) {
this->m_chunkExecutionStates = new ChunkExecutionState[this->m_numberOfChunks];
for (index = 0; index < this->m_numberOfChunks; index++) {
this->m_chunkExecutionStates[index] = COM_ES_NOT_SCHEDULED;
}
}
unsigned int maxNumber = 0;
for (index = 0; index < this->operations.size(); index++) {
NodeOperation *operation = this->operations[index];
for (index = 0; index < this->m_operations.size(); index++) {
NodeOperation *operation = this->m_operations[index];
if (operation->isReadBufferOperation()) {
ReadBufferOperation *readOperation = (ReadBufferOperation *)operation;
this->cachedReadOperations.push_back(readOperation);
this->m_cachedReadOperations.push_back(readOperation);
maxNumber = max(maxNumber, readOperation->getOffset());
}
}
maxNumber++;
this->cachedMaxReadBufferOffset = maxNumber;
this->m_cachedMaxReadBufferOffset = maxNumber;
}
void ExecutionGroup::deinitExecution()
{
if (this->chunkExecutionStates != NULL) {
delete[] this->chunkExecutionStates;
this->chunkExecutionStates = NULL;
if (this->m_chunkExecutionStates != NULL) {
delete[] this->m_chunkExecutionStates;
this->m_chunkExecutionStates = NULL;
}
this->numberOfChunks = 0;
this->numberOfXChunks = 0;
this->numberOfYChunks = 0;
this->cachedReadOperations.clear();
this->bTree = NULL;
this->m_numberOfChunks = 0;
this->m_numberOfXChunks = 0;
this->m_numberOfYChunks = 0;
this->m_cachedReadOperations.clear();
this->m_bTree = NULL;
}
void ExecutionGroup::determineResolution(unsigned int resolution[])
{
@@ -194,16 +194,16 @@ void ExecutionGroup::determineResolution(unsigned int resolution[])
void ExecutionGroup::determineNumberOfChunks()
{
if (singleThreaded) {
this->numberOfXChunks = 1;
this->numberOfYChunks = 1;
this->numberOfChunks = 1;
if (this->m_singleThreaded) {
this->m_numberOfXChunks = 1;
this->m_numberOfYChunks = 1;
this->m_numberOfChunks = 1;
}
else {
const float chunkSizef = this->chunkSize;
this->numberOfXChunks = ceil(this->width / chunkSizef);
this->numberOfYChunks = ceil(this->height / chunkSizef);
this->numberOfChunks = this->numberOfXChunks * this->numberOfYChunks;
const float chunkSizef = this->m_chunkSize;
this->m_numberOfXChunks = ceil(this->m_width / chunkSizef);
this->m_numberOfYChunks = ceil(this->m_height / chunkSizef);
this->m_numberOfChunks = this->m_numberOfXChunks * this->m_numberOfYChunks;
}
}
@@ -214,17 +214,17 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
{
CompositorContext& context = graph->getContext();
const bNodeTree *bTree = context.getbNodeTree();
if (this->width == 0 || this->height == 0) {return; } /// @note: break out... no pixels to calculate.
if (this->m_width == 0 || this->m_height == 0) {return; } /// @note: break out... no pixels to calculate.
if (bTree->test_break && bTree->test_break(bTree->tbh)) {return; } /// @note: early break out for blur and preview nodes
if (this->numberOfChunks == 0) {return; } /// @note: early break out
if (this->m_numberOfChunks == 0) {return; } /// @note: early break out
unsigned int chunkNumber;
this->chunksFinished = 0;
this->bTree = bTree;
this->m_chunksFinished = 0;
this->m_bTree = bTree;
unsigned int index;
unsigned int *chunkOrder = new unsigned int[this->numberOfChunks];
unsigned int *chunkOrder = new unsigned int[this->m_numberOfChunks];
for (chunkNumber = 0; chunkNumber < this->numberOfChunks; chunkNumber++) {
for (chunkNumber = 0; chunkNumber < this->m_numberOfChunks; chunkNumber++) {
chunkOrder[chunkNumber] = chunkNumber;
}
NodeOperation *operation = this->getOutputNodeOperation();
@@ -241,9 +241,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
switch (chunkorder) {
case COM_TO_RANDOM:
for (index = 0; index < 2 * numberOfChunks; index++) {
int index1 = rand() % numberOfChunks;
int index2 = rand() % numberOfChunks;
for (index = 0; index < 2 * this->m_numberOfChunks; index++) {
int index1 = rand() % this->m_numberOfChunks;
int index2 = rand() % this->m_numberOfChunks;
int s = chunkOrder[index1];
chunkOrder[index1] = chunkOrder[index2];
chunkOrder[index2] = s;
@@ -252,10 +252,10 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
case COM_TO_CENTER_OUT:
{
ChunkOrderHotspot **hotspots = new ChunkOrderHotspot *[1];
hotspots[0] = new ChunkOrderHotspot(this->width * centerX, this->height * centerY, 0.0f);
hotspots[0] = new ChunkOrderHotspot(this->m_width * centerX, this->m_height * centerY, 0.0f);
rcti rect;
ChunkOrder *chunkOrders = new ChunkOrder[this->numberOfChunks];
for (index = 0; index < this->numberOfChunks; index++) {
ChunkOrder *chunkOrders = new ChunkOrder[this->m_numberOfChunks];
for (index = 0; index < this->m_numberOfChunks; index++) {
determineChunkRect(&rect, index);
chunkOrders[index].setChunkNumber(index);
chunkOrders[index].setX(rect.xmin);
@@ -263,8 +263,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
chunkOrders[index].determineDistance(hotspots, 1);
}
sort(&chunkOrders[0], &chunkOrders[numberOfChunks - 1]);
for (index = 0; index < numberOfChunks; index++) {
sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks - 1]);
for (index = 0; index < this->m_numberOfChunks; index++) {
chunkOrder[index] = chunkOrders[index].getChunkNumber();
}
@@ -276,14 +276,14 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
case COM_TO_RULE_OF_THIRDS:
{
ChunkOrderHotspot **hotspots = new ChunkOrderHotspot *[9];
unsigned int tx = this->width / 6;
unsigned int ty = this->height / 6;
unsigned int mx = this->width / 2;
unsigned int my = this->height / 2;
unsigned int tx = this->m_width / 6;
unsigned int ty = this->m_height / 6;
unsigned int mx = this->m_width / 2;
unsigned int my = this->m_height / 2;
unsigned int bx = mx + 2 * tx;
unsigned int by = my + 2 * ty;
float addition = numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER;
float addition = this->m_numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER;
hotspots[0] = new ChunkOrderHotspot(mx, my, addition * 0);
hotspots[1] = new ChunkOrderHotspot(tx, my, addition * 1);
hotspots[2] = new ChunkOrderHotspot(bx, my, addition * 2);
@@ -294,8 +294,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
hotspots[7] = new ChunkOrderHotspot(mx, ty, addition * 7);
hotspots[8] = new ChunkOrderHotspot(mx, by, addition * 8);
rcti rect;
ChunkOrder *chunkOrders = new ChunkOrder[this->numberOfChunks];
for (index = 0; index < this->numberOfChunks; index++) {
ChunkOrder *chunkOrders = new ChunkOrder[this->m_numberOfChunks];
for (index = 0; index < this->m_numberOfChunks; index++) {
determineChunkRect(&rect, index);
chunkOrders[index].setChunkNumber(index);
chunkOrders[index].setX(rect.xmin);
@@ -303,9 +303,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
chunkOrders[index].determineDistance(hotspots, 9);
}
sort(&chunkOrders[0], &chunkOrders[numberOfChunks]);
sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks]);
for (index = 0; index < numberOfChunks; index++) {
for (index = 0; index < this->m_numberOfChunks; index++) {
chunkOrder[index] = chunkOrders[index].getChunkNumber();
}
@@ -338,11 +338,11 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
finished = true;
int numberEvaluated = 0;
for (index = startIndex; index < numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) {
for (index = startIndex; index < this->m_numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) {
int chunkNumber = chunkOrder[index];
int yChunk = chunkNumber / this->numberOfXChunks;
int xChunk = chunkNumber - (yChunk * this->numberOfXChunks);
const ChunkExecutionState state = this->chunkExecutionStates[chunkNumber];
int yChunk = chunkNumber / this->m_numberOfXChunks;
int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
const ChunkExecutionState state = this->m_chunkExecutionStates[chunkNumber];
if (state == COM_ES_NOT_SCHEDULED) {
scheduleChunkWhenPossible(graph, xChunk, yChunk);
finished = false;
@@ -375,12 +375,12 @@ MemoryBuffer **ExecutionGroup::getInputBuffersCPU()
unsigned int index;
this->determineDependingMemoryProxies(&memoryproxies);
MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->cachedMaxReadBufferOffset];
for (index = 0; index < this->cachedMaxReadBufferOffset; index++) {
MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->m_cachedMaxReadBufferOffset];
for (index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
memoryBuffers[index] = NULL;
}
for (index = 0; index < this->cachedReadOperations.size(); index++) {
ReadBufferOperation *readOperation = (ReadBufferOperation *)this->cachedReadOperations[index];
for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
memoryBuffers[readOperation->getOffset()] = readOperation->getMemoryProxy()->getBuffer();
}
return memoryBuffers;
@@ -394,13 +394,13 @@ MemoryBuffer **ExecutionGroup::getInputBuffersOpenCL(int chunkNumber)
determineChunkRect(&rect, chunkNumber);
this->determineDependingMemoryProxies(&memoryproxies);
MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->cachedMaxReadBufferOffset];
for (index = 0; index < this->cachedMaxReadBufferOffset; index++) {
MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->m_cachedMaxReadBufferOffset];
for (index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
memoryBuffers[index] = NULL;
}
rcti output;
for (index = 0; index < this->cachedReadOperations.size(); index++) {
ReadBufferOperation *readOperation = (ReadBufferOperation *)this->cachedReadOperations[index];
for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
MemoryProxy *memoryProxy = readOperation->getMemoryProxy();
this->determineDependingAreaOfInterest(&rect, readOperation, &output);
MemoryBuffer *memoryBuffer = memoryProxy->getExecutor()->constructConsolidatedMemoryBuffer(memoryProxy, &output);
@@ -419,12 +419,12 @@ MemoryBuffer *ExecutionGroup::constructConsolidatedMemoryBuffer(MemoryProxy *mem
void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers)
{
if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED)
this->chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED;
if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED)
this->m_chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED;
this->chunksFinished++;
this->m_chunksFinished++;
if (memoryBuffers) {
for (unsigned int index = 0; index < this->cachedMaxReadBufferOffset; index++) {
for (unsigned int index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
MemoryBuffer *buffer = memoryBuffers[index];
if (buffer) {
if (buffer->isTemporarily()) {
@@ -435,30 +435,30 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
}
delete[] memoryBuffers;
}
if (bTree) {
if (this->m_bTree) {
// status report is only performed for top level Execution Groups.
float progress = chunksFinished;
progress /= numberOfChunks;
bTree->progress(bTree->prh, progress);
float progress = this->m_chunksFinished;
progress /= this->m_numberOfChunks;
this->m_bTree->progress(this->m_bTree->prh, progress);
}
}
inline void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk) const
{
if (singleThreaded) {
BLI_init_rcti(rect, 0, this->width, 0, this->height);
if (this->m_singleThreaded) {
BLI_init_rcti(rect, 0, this->m_width, 0, this->m_height);
}
else {
const unsigned int minx = xChunk * chunkSize;
const unsigned int miny = yChunk * chunkSize;
BLI_init_rcti(rect, minx, min(minx + this->chunkSize, this->width), miny, min(miny + this->chunkSize, this->height));
const unsigned int minx = xChunk * this->m_chunkSize;
const unsigned int miny = yChunk * this->m_chunkSize;
BLI_init_rcti(rect, minx, min(minx + this->m_chunkSize, this->m_width), miny, min(miny + this->m_chunkSize, this->m_height));
}
}
void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int chunkNumber) const
{
const unsigned int yChunk = chunkNumber / numberOfXChunks;
const unsigned int xChunk = chunkNumber - (yChunk * numberOfXChunks);
const unsigned int yChunk = chunkNumber / this->m_numberOfXChunks;
const unsigned int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
determineChunkRect(rect, xChunk, yChunk);
}
@@ -477,13 +477,13 @@ MemoryBuffer *ExecutionGroup::allocateOutputBuffer(int chunkNumber, rcti *rect)
bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area)
{
if (singleThreaded) {
if (this->m_singleThreaded) {
return scheduleChunkWhenPossible(graph, 0, 0);
}
// find all chunks inside the rect
// determine minxchunk, minychunk, maxxchunk, maxychunk where x and y are chunknumbers
float chunkSizef = this->chunkSize;
float chunkSizef = this->m_chunkSize;
int indexx, indexy;
const int minxchunk = floor(area->xmin / chunkSizef);
@@ -505,8 +505,8 @@ bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area
bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
{
if (this->chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) {
this->chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED;
if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) {
this->m_chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED;
WorkScheduler::schedule(this, chunkNumber);
return true;
}
@@ -515,20 +515,20 @@ bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk)
{
if (xChunk < 0 || xChunk >= (int)this->numberOfXChunks) {
if (xChunk < 0 || xChunk >= (int)this->m_numberOfXChunks) {
return true;
}
if (yChunk < 0 || yChunk >= (int)this->numberOfYChunks) {
if (yChunk < 0 || yChunk >= (int)this->m_numberOfYChunks) {
return true;
}
int chunkNumber = yChunk * this->numberOfXChunks + xChunk;
int chunkNumber = yChunk * this->m_numberOfXChunks + xChunk;
// chunk is already executed
if (this->chunkExecutionStates[chunkNumber] == COM_ES_EXECUTED) {
if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_EXECUTED) {
return true;
}
// chunk is scheduled, but not executed
if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) {
if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) {
return false;
}
@@ -542,8 +542,8 @@ bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChun
bool canBeExecuted = true;
rcti area;
for (index = 0; index < cachedReadOperations.size(); index++) {
ReadBufferOperation *readOperation = (ReadBufferOperation *)cachedReadOperations[index];
for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
BLI_init_rcti(&area, 0, 0, 0, 0);
MemoryProxy *memoryProxy = memoryProxies[index];
determineDependingAreaOfInterest(&rect, readOperation, &area);
@@ -574,13 +574,13 @@ void ExecutionGroup::determineDependingAreaOfInterest(rcti *input, ReadBufferOpe
void ExecutionGroup::determineDependingMemoryProxies(vector<MemoryProxy *> *memoryProxies)
{
unsigned int index;
for (index = 0; index < this->cachedReadOperations.size(); index++) {
ReadBufferOperation *readOperation = (ReadBufferOperation *) this->cachedReadOperations[index];
for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
ReadBufferOperation *readOperation = (ReadBufferOperation *) this->m_cachedReadOperations[index];
memoryProxies->push_back(readOperation->getMemoryProxy());
}
}
bool ExecutionGroup::isOpenCL()
{
return this->openCL;
return this->m_openCL;
}

46
source/blender/compositor/intern/COM_ExecutionGroup.h
View File

@@ -67,81 +67,81 @@ private:
/**
* @brief list of operations in this ExecutionGroup
*/
vector<NodeOperation *> operations;
vector<NodeOperation *> m_operations;
/**
* @brief is this ExecutionGroup an input ExecutionGroup
* an input execution group is a group that is at the end of the calculation (the output is important for the user)
*/
int isOutput;
int m_isOutput;
/**
* @brief Width of the output
*/
unsigned int width;
unsigned int m_width;
/**
* @brief Height of the output
*/
unsigned int height;
unsigned int m_height;
/**
* @brief size of a single chunk, being Width or of height
* a chunk is always a square, except at the edges of the MemoryBuffer
*/
unsigned int chunkSize;
unsigned int m_chunkSize;
/**
* @brief number of chunks in the x-axis
*/
unsigned int numberOfXChunks;
unsigned int m_numberOfXChunks;
/**
* @brief number of chunks in the y-axis
*/
unsigned int numberOfYChunks;
unsigned int m_numberOfYChunks;
/**
* @brief total number of chunks
*/
unsigned int numberOfChunks;
unsigned int m_numberOfChunks;
/**
* @brief contains this ExecutionGroup a complex NodeOperation.
*/
bool complex;
bool m_complex;
/**
* @brief can this ExecutionGroup be scheduled on an OpenCLDevice
*/
bool openCL;
bool m_openCL;
/**
* @brief Is this Execution group SingleThreaded
*/
bool singleThreaded;
bool m_singleThreaded;
/**
* @brief what is the maximum number field of all ReadBufferOperation in this ExecutionGroup.
* @note this is used to construct the MemoryBuffers that will be passed during execution.
*/
unsigned int cachedMaxReadBufferOffset;
unsigned int m_cachedMaxReadBufferOffset;
/**
* @brief a cached vector of all read operations in the execution group.
*/
vector<NodeOperation *> cachedReadOperations;
vector<NodeOperation *> m_cachedReadOperations;
/**
* @brief reference to the original bNodeTree, this field is only set for the 'top' execution group.
* @note can only be used to call the callbacks for progress, status and break
*/
const bNodeTree *bTree;
const bNodeTree *m_bTree;
/**
* @brief total number of chunks that have been calculated for this ExecutionGroup
*/
unsigned int chunksFinished;
unsigned int m_chunksFinished;
/**
* @brief the chunkExecutionStates holds per chunk the execution state. this state can be
@@ -149,7 +149,7 @@ private:
* - COM_ES_SCHEDULED: scheduled
* - COM_ES_EXECUTED: executed
*/
ChunkExecutionState *chunkExecutionStates;
ChunkExecutionState *m_chunkExecutionStates;
/**
* @brief indicator when this ExecutionGroup has valid NodeOperations in its vector for Execution
@@ -160,7 +160,7 @@ private:
* @see complex
* @see openCL
*/
bool initialized;
bool m_initialized;
// methods
/**
@@ -258,13 +258,13 @@ public:
* @note ViewerOperation, CompositeOperation, PreviewOperation.
* @see NodeOperation.isOutputOperation
*/
const int isOutputExecutionGroup() const { return this->isOutput; }
const int isOutputExecutionGroup() const { return this->m_isOutput; }
/**
* @brief set whether this ExecutionGroup is an output
* @param isOutput
*/
void setOutputExecutionGroup(int isOutput) { this->isOutput = isOutput; }
void setOutputExecutionGroup(int isOutput) { this->m_isOutput = isOutput; }
/**
* @brief determine the resolution of this ExecutionGroup
@@ -276,17 +276,17 @@ public:
* @brief set the resolution of this executiongroup
* @param resolution
*/
void setResolution(unsigned int resolution[]) { this->width = resolution[0]; this->height = resolution[1]; }
void setResolution(unsigned int resolution[]) { this->m_width = resolution[0]; this->m_height = resolution[1]; }
/**
* @brief get the width of this execution group
*/
const unsigned int getWidth() { return this->width; }
const unsigned int getWidth() { return this->m_width; }
/**
* @brief get the height of this execution group
*/
const unsigned int getHeight() { return this->height; }
const unsigned int getHeight() { return this->m_height; }
/**
* @brief does this ExecutionGroup contains a complex NodeOperation
@@ -387,7 +387,7 @@ public:
*/
bool isOpenCL();
void setChunksize(int chunksize) { this->chunkSize = chunksize; }
void setChunksize(int chunksize) { this->m_chunkSize = chunksize; }
/**
* @brief get the Render priority of this ExecutionGroup

110
source/blender/compositor/intern/COM_ExecutionSystem.cpp
View File

@@ -47,36 +47,36 @@
ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool rendering)
{
context.setbNodeTree(editingtree);
this->m_context.setbNodeTree(editingtree);
bNode *gnode;
for (gnode = (bNode *)editingtree->nodes.first; gnode; gnode = (bNode *)gnode->next) {
if (gnode->type == NODE_GROUP && gnode->typeinfo->group_edit_get(gnode)) {
context.setActivegNode(gnode);
this->m_context.setActivegNode(gnode);
break;
}
}
/* initialize the CompositorContext */
if (rendering) {
context.setQuality((CompositorQuality)editingtree->render_quality);
this->m_context.setQuality((CompositorQuality)editingtree->render_quality);
}
else {
context.setQuality((CompositorQuality)editingtree->edit_quality);
this->m_context.setQuality((CompositorQuality)editingtree->edit_quality);
}
context.setRendering(rendering);
context.setHasActiveOpenCLDevices(WorkScheduler::hasGPUDevices() && (editingtree->flag & NTREE_COM_OPENCL));
this->m_context.setRendering(rendering);
this->m_context.setHasActiveOpenCLDevices(WorkScheduler::hasGPUDevices() && (editingtree->flag & NTREE_COM_OPENCL));
ExecutionSystemHelper::addbNodeTree(*this, 0, editingtree, NULL);
context.setRenderData(rd);
this->m_context.setRenderData(rd);
this->convertToOperations();
this->groupOperations(); /* group operations in ExecutionGroups */
unsigned int index;
unsigned int resolution[2];
for (index = 0; index < this->groups.size(); index++) {
for (index = 0; index < this->m_groups.size(); index++) {
resolution[0] = 0;
resolution[1] = 0;
ExecutionGroup *executionGroup = groups[index];
ExecutionGroup *executionGroup = this->m_groups[index];
executionGroup->determineResolution(resolution);
}
@@ -88,32 +88,32 @@ ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool re
ExecutionSystem::~ExecutionSystem()
{
unsigned int index;
for (index = 0; index < this->connections.size(); index++) {
SocketConnection *connection = this->connections[index];
for (index = 0; index < this->m_connections.size(); index++) {
SocketConnection *connection = this->m_connections[index];
delete connection;
}
this->connections.clear();
for (index = 0; index < this->nodes.size(); index++) {
Node *node = this->nodes[index];
this->m_connections.clear();
for (index = 0; index < this->m_nodes.size(); index++) {
Node *node = this->m_nodes[index];
delete node;
}
this->nodes.clear();
for (index = 0; index < this->operations.size(); index++) {
NodeOperation *operation = this->operations[index];
this->m_nodes.clear();
for (index = 0; index < this->m_operations.size(); index++) {
NodeOperation *operation = this->m_operations[index];
delete operation;
}
this->operations.clear();
for (index = 0; index < this->groups.size(); index++) {
ExecutionGroup *group = this->groups[index];
this->m_operations.clear();
for (index = 0; index < this->m_groups.size(); index++) {
ExecutionGroup *group = this->m_groups[index];
delete group;
}
this->groups.clear();
this->m_groups.clear();
}
void ExecutionSystem::execute()
{
unsigned int order = 0;
for (vector<NodeOperation *>::iterator iter = this->operations.begin(); iter != operations.end(); ++iter) {
for (vector<NodeOperation *>::iterator iter = this->m_operations.begin(); iter != this->m_operations.end(); ++iter) {
NodeBase *node = *iter;
NodeOperation *operation = (NodeOperation *) node;
if (operation->isReadBufferOperation()) {
@@ -124,18 +124,18 @@ void ExecutionSystem::execute()
}
unsigned int index;
for (index = 0; index < this->operations.size(); index++) {
NodeOperation *operation = this->operations[index];
operation->setbNodeTree(this->context.getbNodeTree());
for (index = 0; index < this->m_operations.size(); index++) {
NodeOperation *operation = this->m_operations[index];
operation->setbNodeTree(this->m_context.getbNodeTree());
operation->initExecution();
}
for (index = 0; index < this->groups.size(); index++) {
ExecutionGroup *executionGroup = this->groups[index];
executionGroup->setChunksize(context.getChunksize());
for (index = 0; index < this->m_groups.size(); index++) {
ExecutionGroup *executionGroup = this->m_groups[index];
executionGroup->setChunksize(this->m_context.getChunksize());
executionGroup->initExecution();
}
WorkScheduler::start(this->context);
WorkScheduler::start(this->m_context);
executeGroups(COM_PRIORITY_HIGH);
executeGroups(COM_PRIORITY_MEDIUM);
@@ -144,12 +144,12 @@ void ExecutionSystem::execute()
WorkScheduler::finish();
WorkScheduler::stop();
for (index = 0; index < this->operations.size(); index++) {
NodeOperation *operation = this->operations[index];
for (index = 0; index < this->m_operations.size(); index++) {
NodeOperation *operation = this->m_operations[index];
operation->deinitExecution();
}
for (index = 0; index < this->groups.size(); index++) {
ExecutionGroup *executionGroup = this->groups[index];
for (index = 0; index < this->m_groups.size(); index++) {
ExecutionGroup *executionGroup = this->m_groups[index];
executionGroup->deinitExecution();
}
}
@@ -168,7 +168,7 @@ void ExecutionSystem::executeGroups(CompositorPriority priority)
void ExecutionSystem::addOperation(NodeOperation *operation)
{
ExecutionSystemHelper::addOperation(this->operations, operation);
ExecutionSystemHelper::addOperation(this->m_operations, operation);
// operation->setBTree
}
@@ -231,13 +231,13 @@ void ExecutionSystem::addReadWriteBufferOperations(NodeOperation *operation)
void ExecutionSystem::convertToOperations()
{
unsigned int index;
for (index = 0; index < this->nodes.size(); index++) {
Node *node = (Node *)this->nodes[index];
node->convertToOperations(this, &this->context);
for (index = 0; index < this->m_nodes.size(); index++) {
Node *node = (Node *)this->m_nodes[index];
node->convertToOperations(this, &this->m_context);
}
for (index = 0; index < this->connections.size(); index++) {
SocketConnection *connection = this->connections[index];
for (index = 0; index < this->m_connections.size(); index++) {
SocketConnection *connection = this->m_connections[index];
if (connection->isValid()) {
if (connection->getFromSocket()->getDataType() != connection->getToSocket()->getDataType()) {
Converter::convertDataType(connection, this);
@@ -246,18 +246,18 @@ void ExecutionSystem::convertToOperations()
}
// determine all resolutions of the operations (Width/Height)
for (index = 0; index < this->operations.size(); index++) {
NodeOperation *operation = this->operations[index];
if (operation->isOutputOperation(context.isRendering()) && !operation->isPreviewOperation()) {
for (index = 0; index < this->m_operations.size(); index++) {
NodeOperation *operation = this->m_operations[index];
if (operation->isOutputOperation(this->m_context.isRendering()) && !operation->isPreviewOperation()) {
unsigned int resolution[2] = {0, 0};
unsigned int preferredResolution[2] = {0, 0};
operation->determineResolution(resolution, preferredResolution);
operation->setResolution(resolution);
}
}
for (index = 0; index < this->operations.size(); index++) {
NodeOperation *operation = this->operations[index];
if (operation->isOutputOperation(context.isRendering()) && operation->isPreviewOperation()) {
for (index = 0; index < this->m_operations.size(); index++) {
NodeOperation *operation = this->m_operations[index];
if (operation->isOutputOperation(this->m_context.isRendering()) && operation->isPreviewOperation()) {
unsigned int resolution[2] = {0, 0};
unsigned int preferredResolution[2] = {0, 0};
operation->determineResolution(resolution, preferredResolution);
@@ -266,8 +266,8 @@ void ExecutionSystem::convertToOperations()
}
// add convert resolution operations when needed.
for (index = 0; index < this->connections.size(); index++) {
SocketConnection *connection = this->connections[index];
for (index = 0; index < this->m_connections.size(); index++) {
SocketConnection *connection = this->m_connections[index];
if (connection->isValid()) {
if (connection->needsResolutionConversion()) {
Converter::convertResolution(connection, this);
@@ -282,13 +282,13 @@ void ExecutionSystem::groupOperations()
NodeOperation *operation;
unsigned int index;
// surround complex operations with ReadBufferOperation and WriteBufferOperation
for (index = 0; index < this->operations.size(); index++) {
operation = this->operations[index];
for (index = 0; index < this->m_operations.size(); index++) {
operation = this->m_operations[index];
if (operation->isComplex()) {
this->addReadWriteBufferOperations(operation);
}
}
ExecutionSystemHelper::findOutputNodeOperations(&outputOperations, this->getOperations(), this->context.isRendering());
ExecutionSystemHelper::findOutputNodeOperations(&outputOperations, this->getOperations(), this->m_context.isRendering());
for (vector<NodeOperation *>::iterator iter = outputOperations.begin(); iter != outputOperations.end(); ++iter) {
operation = *iter;
ExecutionGroup *group = new ExecutionGroup();
@@ -300,15 +300,15 @@ void ExecutionSystem::groupOperations()
void ExecutionSystem::addSocketConnection(SocketConnection *connection)
{
this->connections.push_back(connection);
this->m_connections.push_back(connection);
}
void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result, CompositorPriority priority) const
{
unsigned int index;
for (index = 0; index < this->groups.size(); index++) {
ExecutionGroup *group = this->groups[index];
for (index = 0; index < this->m_groups.size(); index++) {
ExecutionGroup *group = this->m_groups[index];
if (group->isOutputExecutionGroup() && group->getRenderPriotrity() == priority) {
result->push_back(group);
}
@@ -318,8 +318,8 @@ void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result,
void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result) const
{
unsigned int index;
for (index = 0; index < this->groups.size(); index++) {
ExecutionGroup *group = this->groups[index];
for (index = 0; index < this->m_groups.size(); index++) {
ExecutionGroup *group = this->m_groups[index];
if (group->isOutputExecutionGroup()) {
result->push_back(group);
}

22
source/blender/compositor/intern/COM_ExecutionSystem.h
View File

@@ -108,27 +108,27 @@ private:
/**
* @brief the context used during execution
*/
CompositorContext context;
CompositorContext m_context;
/**
* @brief vector of nodes
*/
vector<Node *> nodes;
vector<Node *> m_nodes;
/**
* @brief vector of operations
*/
vector<NodeOperation *> operations;
vector<NodeOperation *> m_operations;
/**
* @brief vector of groups
*/
vector<ExecutionGroup *> groups
vector<ExecutionGroup *> m_groups;
/**
* @brief vector of connections
*/;
vector<SocketConnection *> connections;
*/
vector<SocketConnection *> m_connections;
private: //methods
/**
@@ -200,27 +200,27 @@ public:
/**
* @brief get the reference to the compositor context
*/
CompositorContext& getContext() { return this->context; }
CompositorContext& getContext() { return this->m_context; }
/**
* @brief get the reference to the compositor nodes
*/
vector<Node *>& getNodes() { return this->nodes; }
vector<Node *>& getNodes() { return this->m_nodes; }
/**
* @brief get the reference to the compositor connections
*/
vector<SocketConnection *>& getConnections() { return this->connections; }
vector<SocketConnection *>& getConnections() { return this->m_connections; }
/**
* @brief get the reference to the list of execution groups
*/
vector<ExecutionGroup *>& getExecutionGroups() { return this->groups; }
vector<ExecutionGroup *>& getExecutionGroups() { return this->m_groups; }
/**
* @brief get the reference to the list of operations
*/
vector<NodeOperation *>& getOperations() { return this->operations; }
vector<NodeOperation *>& getOperations() { return this->m_operations; }
private:

22
source/blender/compositor/intern/COM_InputSocket.cpp
View File

@@ -27,37 +27,37 @@
InputSocket::InputSocket(DataType datatype) : Socket(datatype)
{
this->connection = NULL;
this->resizeMode = COM_SC_CENTER;
this->m_connection = NULL;
this->m_resizeMode = COM_SC_CENTER;
}
InputSocket::InputSocket(DataType datatype, InputSocketResizeMode resizeMode) : Socket(datatype)
{
this->connection = NULL;
this->resizeMode = resizeMode;
this->m_connection = NULL;
this->m_resizeMode = resizeMode;
}
InputSocket::InputSocket(InputSocket *from) : Socket(from->getDataType())
{
this->connection = NULL;
this->resizeMode = from->getResizeMode();
this->m_connection = NULL;
this->m_resizeMode = from->getResizeMode();
}
int InputSocket::isInputSocket() const { return true; }
const int InputSocket::isConnected() const { return this->connection != NULL; }
const int InputSocket::isConnected() const { return this->m_connection != NULL; }
void InputSocket::setConnection(SocketConnection *connection)
{
this->connection = connection;
this->m_connection = connection;
}
SocketConnection *InputSocket::getConnection()
{
return this->connection;
return this->m_connection;
}
void InputSocket::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
{
if (this->isConnected()) {
this->connection->getFromSocket()->determineResolution(resolution, preferredResolution);
this->m_connection->getFromSocket()->determineResolution(resolution, preferredResolution);
}
else {
return;
@@ -140,7 +140,7 @@ SocketReader *InputSocket::getReader()
NodeOperation *InputSocket::getOperation() const
{
if (isConnected()) {
return (NodeOperation *)this->connection->getFromSocket()->getNode();
return (NodeOperation *)this->m_connection->getFromSocket()->getNode();
}
else {
return NULL;

8
source/blender/compositor/intern/COM_InputSocket.h
View File

@@ -65,12 +65,12 @@ private:
* @brief connection connected to this InputSocket.
* An input socket can only have a single connection
*/
SocketConnection *connection;
SocketConnection *m_connection;
/**
* @brief resize mode of this socket
*/
InputSocketResizeMode resizeMode;
InputSocketResizeMode m_resizeMode;
public:
@@ -126,7 +126,7 @@ public:
* @param resizeMode the new resize mode.
*/
void setResizeMode(InputSocketResizeMode resizeMode) {
this->resizeMode = resizeMode;
this->m_resizeMode = resizeMode;
}
/**
@@ -134,7 +134,7 @@ public:
* @return InputSocketResizeMode
*/
InputSocketResizeMode getResizeMode() const {
return this->resizeMode;
return this->m_resizeMode;
}
const ChannelInfo *getChannelInfo(const int channelnumber);

88
source/blender/compositor/intern/COM_MemoryBuffer.cpp
View File

@@ -32,43 +32,43 @@ unsigned int MemoryBuffer::determineBufferSize()
int MemoryBuffer::getWidth() const
{
return this->rect.xmax - this->rect.xmin;
return this->m_rect.xmax - this->m_rect.xmin;
}
int MemoryBuffer::getHeight() const
{
return this->rect.ymax - this->rect.ymin;
return this->m_rect.ymax - this->m_rect.ymin;
}
MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti *rect)
{
BLI_init_rcti(&this->rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
this->memoryProxy = memoryProxy;
this->chunkNumber = chunkNumber;
this->buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
this->state = COM_MB_ALLOCATED;
this->datatype = COM_DT_COLOR;
this->chunkWidth = this->rect.xmax - this->rect.xmin;
BLI_init_rcti(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
this->m_memoryProxy = memoryProxy;
this->m_chunkNumber = chunkNumber;
this->m_buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
this->m_state = COM_MB_ALLOCATED;
this->m_datatype = COM_DT_COLOR;
this->m_chunkWidth = this->m_rect.xmax - this->m_rect.xmin;
}
MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, rcti *rect)
{
BLI_init_rcti(&this->rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
this->memoryProxy = memoryProxy;
this->chunkNumber = -1;
this->buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
this->state = COM_MB_TEMPORARILY;
this->datatype = COM_DT_COLOR;
this->chunkWidth = this->rect.xmax - this->rect.xmin;
BLI_init_rcti(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
this->m_memoryProxy = memoryProxy;
this->m_chunkNumber = -1;
this->m_buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
this->m_state = COM_MB_TEMPORARILY;
this->m_datatype = COM_DT_COLOR;
this->m_chunkWidth = this->m_rect.xmax - this->m_rect.xmin;
}
MemoryBuffer *MemoryBuffer::duplicate()
{
MemoryBuffer *result = new MemoryBuffer(this->memoryProxy, &this->rect);
memcpy(result->buffer, this->buffer, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
MemoryBuffer *result = new MemoryBuffer(this->m_memoryProxy, &this->m_rect);
memcpy(result->m_buffer, this->m_buffer, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
return result;
}
void MemoryBuffer::clear()
{
memset(this->buffer, 0, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
memset(this->m_buffer, 0, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
}
float *MemoryBuffer::convertToValueBuffer()
@@ -78,7 +78,7 @@ float *MemoryBuffer::convertToValueBuffer()
float *result = new float[size];
const float *fp_src = this->buffer;
const float *fp_src = this->m_buffer;
float *fp_dst = result;
for (i = 0; i < size; i++, fp_dst++, fp_src += COM_NUMBER_OF_CHANNELS) {
@@ -90,9 +90,9 @@ float *MemoryBuffer::convertToValueBuffer()
MemoryBuffer::~MemoryBuffer()
{
if (this->buffer) {
MEM_freeN(this->buffer);
this->buffer = NULL;
if (this->m_buffer) {
MEM_freeN(this->m_buffer);
this->m_buffer = NULL;
}
}
@@ -102,30 +102,30 @@ void MemoryBuffer::copyContentFrom(MemoryBuffer *otherBuffer)
return;
}
unsigned int otherY;
unsigned int minX = max(this->rect.xmin, otherBuffer->rect.xmin);
unsigned int maxX = min(this->rect.xmax, otherBuffer->rect.xmax);
unsigned int minY = max(this->rect.ymin, otherBuffer->rect.ymin);
unsigned int maxY = min(this->rect.ymax, otherBuffer->rect.ymax);
unsigned int minX = max(this->m_rect.xmin, otherBuffer->m_rect.xmin);
unsigned int maxX = min(this->m_rect.xmax, otherBuffer->m_rect.xmax);
unsigned int minY = max(this->m_rect.ymin, otherBuffer->m_rect.ymin);
unsigned int maxY = min(this->m_rect.ymax, otherBuffer->m_rect.ymax);
int offset;
int otherOffset;
for (otherY = minY; otherY < maxY; otherY++) {
otherOffset = ((otherY - otherBuffer->rect.ymin) * otherBuffer->chunkWidth + minX - otherBuffer->rect.xmin) * COM_NUMBER_OF_CHANNELS;
offset = ((otherY - this->rect.ymin) * this->chunkWidth + minX - this->rect.xmin) * COM_NUMBER_OF_CHANNELS;
memcpy(&this->buffer[offset], &otherBuffer->buffer[otherOffset], (maxX - minX) * COM_NUMBER_OF_CHANNELS * sizeof(float));
otherOffset = ((otherY - otherBuffer->m_rect.ymin) * otherBuffer->m_chunkWidth + minX - otherBuffer->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
offset = ((otherY - this->m_rect.ymin) * this->m_chunkWidth + minX - this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
memcpy(&this->m_buffer[offset], &otherBuffer->m_buffer[otherOffset], (maxX - minX) * COM_NUMBER_OF_CHANNELS * sizeof(float));
}
}
void MemoryBuffer::read(float result[4], int x, int y)
{
if (x >= this->rect.xmin && x < this->rect.xmax &&
y >= this->rect.ymin && y < this->rect.ymax)
if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
y >= this->m_rect.ymin && y < this->m_rect.ymax)
{
const int dx = x - this->rect.xmin;
const int dy = y - this->rect.ymin;
const int offset = (this->chunkWidth * dy + dx) * COM_NUMBER_OF_CHANNELS;
copy_v4_v4(result, &this->buffer[offset]);
const int dx = x - this->m_rect.xmin;
const int dy = y - this->m_rect.ymin;
const int offset = (this->m_chunkWidth * dy + dx) * COM_NUMBER_OF_CHANNELS;
copy_v4_v4(result, &this->m_buffer[offset]);
}
else {
zero_v4(result);
@@ -133,21 +133,21 @@ void MemoryBuffer::read(float result[4], int x, int y)
}
void MemoryBuffer::writePixel(int x, int y, const float color[4])
{
if (x >= this->rect.xmin && x < this->rect.xmax &&
y >= this->rect.ymin && y < this->rect.ymax)
if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
y >= this->m_rect.ymin && y < this->m_rect.ymax)
{
const int offset = (this->chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
copy_v4_v4(&this->buffer[offset], color);
const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
copy_v4_v4(&this->m_buffer[offset], color);
}
}
void MemoryBuffer::addPixel(int x, int y, const float color[4])
{
if (x >= this->rect.xmin && x < this->rect.xmax &&
y >= this->rect.ymin && y < this->rect.ymax)
if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
y >= this->m_rect.ymin && y < this->m_rect.ymax)
{
const int offset = (this->chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
add_v4_v4(&this->buffer[offset], color);
const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
add_v4_v4(&this->m_buffer[offset], color);
}
}

24
source/blender/compositor/intern/COM_MemoryBuffer.h
View File

@@ -56,39 +56,39 @@ private:
/**
* @brief proxy of the memory (same for all chunks in the same buffer)
*/
MemoryProxy *memoryProxy;
MemoryProxy *m_memoryProxy;
/**
* @brief the type of buffer COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR
*/
DataType datatype;
DataType m_datatype;
/**
* @brief region of this buffer inside reative to the MemoryProxy
*/
rcti rect;
rcti m_rect;
/**
* brief refers to the chunknumber within the executiongroup where related to the MemoryProxy
* @see memoryProxy
*/
unsigned int chunkNumber;
unsigned int m_chunkNumber;
/**
* @brief width of the chunk
*/
unsigned int chunkWidth;
unsigned int m_chunkWidth;
/**
* @brief state of the buffer
*/
MemoryBufferState state;
MemoryBufferState m_state;
/**
* @brief the actual float buffer/data
*/
float *buffer;
float *m_buffer;
public:
/**
@@ -109,19 +109,19 @@ public:
/**
* @brief read the ChunkNumber of this MemoryBuffer
*/
unsigned int getChunkNumber() { return this->chunkNumber; }
unsigned int getChunkNumber() { return this->m_chunkNumber; }
/**
* @brief get the data of this MemoryBuffer
* @note buffer should already be available in memory
*/
float *getBuffer() { return this->buffer; }
float *getBuffer() { return this->m_buffer; }
/**
* @brief after execution the state will be set to available by calling this method
*/
void setCreatedState() {
this->state = COM_MB_AVAILABLE;
this->m_state = COM_MB_AVAILABLE;
}
void read(float result[4], int x, int y);
@@ -133,7 +133,7 @@ public:
/**
* @brief is this MemoryBuffer a temporarily buffer (based on an area, not on a chunk)
*/
inline const bool isTemporarily() const { return this->state == COM_MB_TEMPORARILY; }
inline const bool isTemporarily() const { return this->m_state == COM_MB_TEMPORARILY; }
/**
* @brief add the content from otherBuffer to this MemoryBuffer
@@ -144,7 +144,7 @@ public:
/**
* @brief get the rect of this MemoryBuffer
*/
rcti *getRect() { return &this->rect; }
rcti *getRect() { return &this->m_rect; }
/**
* @brief get the width of this MemoryBuffer

12
source/blender/compositor/intern/COM_MemoryProxy.cpp
View File

@@ -25,8 +25,8 @@
MemoryProxy::MemoryProxy()
{
this->writeBufferOperation = NULL;
this->executor = NULL;
this->m_writeBufferOperation = NULL;
this->m_executor = NULL;
}
void MemoryProxy::allocate(unsigned int width, unsigned int height)
@@ -37,14 +37,14 @@ void MemoryProxy::allocate(unsigned int width, unsigned int height)
result.ymin = 0;
result.ymax = height;
buffer = new MemoryBuffer(this, 1, &result);
this->m_buffer = new MemoryBuffer(this, 1, &result);
}
void MemoryProxy::free()
{
if (buffer) {
delete buffer;
buffer = NULL;
if (this->m_buffer) {
delete this->m_buffer;
this->m_buffer = NULL;
}
}

24
source/blender/compositor/intern/COM_MemoryProxy.h
View File

@@ -23,8 +23,8 @@
class MemoryProxy;
#ifndef _COM_MemoryProxy_h
#define _COM_MemoryProxy_h
#ifndef _COM_MemoryProxy_h_
#define _COM_MemoryProxy_h_
#include "COM_ExecutionGroup.h"
class ExecutionGroup;
@@ -40,27 +40,27 @@ private:
/**
* @brief reference to the ouput operation of the executiongroup
*/
WriteBufferOperation *writeBufferOperation;
WriteBufferOperation *m_writeBufferOperation;
/**
* @brief reference to the executor. the Execution group that can fill a chunk
*/
ExecutionGroup *executor;
ExecutionGroup *m_executor;
/**
* @brief datatype of this MemoryProxy
*/
DataType datatype;
DataType m_datatype;
/**
* @brief channel information of this buffer
*/
ChannelInfo channelInfo[COM_NUMBER_OF_CHANNELS];
ChannelInfo m_channelInfo[COM_NUMBER_OF_CHANNELS];
/**
* @brief the allocated memory
*/
MemoryBuffer *buffer;
MemoryBuffer *m_buffer;
public:
MemoryProxy();
@@ -69,24 +69,24 @@ public:
* @brief set the ExecutionGroup that can be scheduled to calculate a certain chunk.
* @param group the ExecutionGroup to set
*/
void setExecutor(ExecutionGroup *executor) { this->executor = executor; }
void setExecutor(ExecutionGroup *executor) { this->m_executor = executor; }
/**
* @brief get the ExecutionGroup that can be scheduled to calculate a certain chunk.
*/
ExecutionGroup *getExecutor() { return this->executor; }
ExecutionGroup *getExecutor() { return this->m_executor; }
/**
* @brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy
* @param operation
*/
void setWriteBufferOperation(WriteBufferOperation *operation) { this->writeBufferOperation = operation; }
void setWriteBufferOperation(WriteBufferOperation *operation) { this->m_writeBufferOperation = operation; }
/**
* @brief get the WriteBufferOperation that is responsible for writing to this MemoryProxy
* @return WriteBufferOperation
*/
WriteBufferOperation *getWriteBufferOperation() { return this->writeBufferOperation; }
WriteBufferOperation *getWriteBufferOperation() { return this->m_writeBufferOperation; }
/**
* @brief allocate memory of size widht x height
@@ -101,7 +101,7 @@ public:
/**
* @brief get the allocated memory
*/
inline MemoryBuffer *getBuffer() { return this->buffer; }
inline MemoryBuffer *getBuffer() { return this->m_buffer; }
#ifdef WITH_CXX_GUARDEDALLOC
MEM_CXX_CLASS_ALLOC_FUNCS("COM:MemoryProxy")

6
source/blender/compositor/intern/COM_Node.cpp
View File

@@ -41,7 +41,7 @@
Node::Node(bNode *editorNode, bool create_sockets)
{
this->editorNode = editorNode;
this->m_editorNode = editorNode;
if (create_sockets) {
bNodeSocket *input = (bNodeSocket *)editorNode->inputs.first;
@@ -66,12 +66,12 @@ Node::Node(bNode *editorNode, bool create_sockets)
}
Node::Node()
{
this->editorNode = NULL;
this->m_editorNode = NULL;
}
bNode *Node::getbNode()
{
return this->editorNode;
return this->m_editorNode;
}
void Node::addSetValueOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex)

8
source/blender/compositor/intern/COM_Node.h
View File

@@ -51,12 +51,12 @@ private:
/**
* @brief stores the reference to the SDNA bNode struct
*/
bNode *editorNode;
bNode *m_editorNode;
/**
* @brief Is this node part of the active group
*/
bool inActiveGroup;
bool m_inActiveGroup;
public:
Node(bNode *editorNode, bool create_sockets = true);
@@ -70,7 +70,7 @@ public:
* @brief Is this node in the active group (the group that is being edited)
* @param isInActiveGroup
*/
void setIsInActiveGroup(bool isInActiveGroup) { this->inActiveGroup = isInActiveGroup; }
void setIsInActiveGroup(bool isInActiveGroup) { this->m_inActiveGroup = isInActiveGroup; }
/**
* @brief Is this node part of the active group
@@ -78,7 +78,7 @@ public:
* the active group will be the main tree (all nodes that are not part of a group will be active)
* @return bool [false:true]
*/
inline bool isInActiveGroup() { return this->inActiveGroup; }
inline bool isInActiveGroup() { return this->m_inActiveGroup; }
/**
* @brief convert node to operation

26
source/blender/compositor/intern/COM_NodeBase.cpp
View File

@@ -39,13 +39,13 @@ NodeBase::NodeBase()
NodeBase::~NodeBase()
{
while (!this->outputsockets.empty()) {
delete (this->outputsockets.back());
this->outputsockets.pop_back();
while (!this->m_outputsockets.empty()) {
delete (this->m_outputsockets.back());
this->m_outputsockets.pop_back();
}
while (!this->inputsockets.empty()) {
delete (this->inputsockets.back());
this->inputsockets.pop_back();
while (!this->m_inputsockets.empty()) {
delete (this->m_inputsockets.back());
this->m_inputsockets.pop_back();
}
}
@@ -63,7 +63,7 @@ void NodeBase::addInputSocket(DataType datatype, InputSocketResizeMode resizeMod
InputSocket *socket = new InputSocket(datatype, resizeMode);
socket->setEditorSocket(bSocket);
socket->setNode(this);
this->inputsockets.push_back(socket);
this->m_inputsockets.push_back(socket);
}
void NodeBase::addOutputSocket(DataType datatype)
@@ -76,21 +76,21 @@ void NodeBase::addOutputSocket(DataType datatype, bNodeSocket *bSocket)
OutputSocket *socket = new OutputSocket(datatype);
socket->setEditorSocket(bSocket);
socket->setNode(this);
this->outputsockets.push_back(socket);
this->m_outputsockets.push_back(socket);
}
const bool NodeBase::isInputNode() const
{
return this->inputsockets.size() == 0;
return this->m_inputsockets.size() == 0;
}
OutputSocket *NodeBase::getOutputSocket(unsigned int index)
{
BLI_assert(index < this->outputsockets.size());
return this->outputsockets[index];
BLI_assert(index < this->m_outputsockets.size());
return this->m_outputsockets[index];
}
InputSocket *NodeBase::getInputSocket(unsigned int index)
{
BLI_assert(index < this->inputsockets.size());
return this->inputsockets[index];
BLI_assert(index < this->m_inputsockets.size());
return this->m_inputsockets[index];
}

12
source/blender/compositor/intern/COM_NodeBase.h
View File

@@ -47,23 +47,23 @@ private:
/**
* @brief the list of actual inputsockets @see InputSocket
*/
vector<InputSocket *> inputsockets;
vector<InputSocket *> m_inputsockets;
/**
* @brief the list of actual outputsockets @see OutputSocket
*/
vector<OutputSocket *> outputsockets;
vector<OutputSocket *> m_outputsockets;
protected:
/**
* @brief get access to the vector of input sockets
*/
inline vector<InputSocket *>& getInputSockets() { return this->inputsockets; }
inline vector<InputSocket *>& getInputSockets() { return this->m_inputsockets; }
/**
* @brief get access to the vector of input sockets
*/
inline vector<OutputSocket *>& getOutputSockets() { return this->outputsockets; }
inline vector<OutputSocket *>& getOutputSockets() { return this->m_outputsockets; }
public:
@@ -91,12 +91,12 @@ public:
/**
* @brief Return the number of input sockets of this node.
*/
const unsigned int getNumberOfInputSockets() const { return this->inputsockets.size(); }
const unsigned int getNumberOfInputSockets() const { return this->m_inputsockets.size(); }
/**
* @brief Return the number of output sockets of this node.
*/
const unsigned int getNumberOfOutputSockets() const { return this->outputsockets.size(); }
const unsigned int getNumberOfOutputSockets() const { return this->m_outputsockets.size(); }
/**
* get the reference to a certain outputsocket

30
source/blender/compositor/intern/COM_OpenCLDevice.cpp
View File

@@ -27,24 +27,24 @@ typedef enum COM_VendorID {NVIDIA=0x10DE, AMD=0x1002} COM_VendorID;
OpenCLDevice::OpenCLDevice(cl_context context, cl_device_id device, cl_program program, cl_int vendorId)
{
this->device = device;
this->context = context;
this->program = program;
this->queue = NULL;
this->vendorID = vendorId;
this->m_device = device;
this->m_context = context;
this->m_program = program;
this->m_queue = NULL;
this->m_vendorID = vendorId;
}
bool OpenCLDevice::initialize()
{
cl_int error;
queue = clCreateCommandQueue(context, device, 0, &error);
this->m_queue = clCreateCommandQueue(this->m_context, this->m_device, 0, &error);
return false;
}
void OpenCLDevice::deinitialize()
{
if (queue) {
clReleaseCommandQueue(queue);
if (this->m_queue) {
clReleaseCommandQueue(this->m_queue);
}
}
@@ -76,8 +76,8 @@ cl_mem OpenCLDevice::COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel,
CL_FLOAT
};
cl_mem clBuffer = clCreateImage2D(this->context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &imageFormat, result->getWidth(),
result->getHeight(), 0, result->getBuffer(), &error);
cl_mem clBuffer = clCreateImage2D(this->m_context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &imageFormat, result->getWidth(),
result->getHeight(), 0, result->getBuffer(), &error);
if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
if (error == CL_SUCCESS) cleanup->push_back(clBuffer);
@@ -124,7 +124,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
cl_int error;
const size_t size[] = {outputMemoryBuffer->getWidth(), outputMemoryBuffer->getHeight()};
error = clEnqueueNDRangeKernel(this->queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
}
@@ -139,7 +139,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
size_t size[2];
cl_int2 offset;
if (this->vendorID == NVIDIA){localSize = 32;}
if (this->m_vendorID == NVIDIA) {localSize = 32;}
bool breaked = false;
for (offsety = 0; offsety < height && (!breaked); offsety += localSize) {
offset[1] = offsety;
@@ -160,9 +160,9 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
error = clSetKernelArg(kernel, offsetIndex, sizeof(cl_int2), &offset);
if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
error = clEnqueueNDRangeKernel(this->queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
clFlush(this->queue);
clFlush(this->m_queue);
if (operation->isBreaked()) {
breaked = false;
}
@@ -173,7 +173,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
cl_kernel OpenCLDevice::COM_clCreateKernel(const char *kernelname, list<cl_kernel> *clKernelsToCleanUp)
{
cl_int error;
cl_kernel kernel = clCreateKernel(this->program, kernelname, &error);
cl_kernel kernel = clCreateKernel(this->m_program, kernelname, &error);
if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
else {
if (clKernelsToCleanUp) clKernelsToCleanUp->push_back(kernel);

14
source/blender/compositor/intern/COM_OpenCLDevice.h
View File

@@ -38,27 +38,27 @@ private:
/**
* @brief opencl context
*/
cl_context context;
cl_context m_context;
/**
* @brief opencl device
*/
cl_device_id device;
cl_device_id m_device;
/**
* @brief opencl program
*/
cl_program program;
cl_program m_program;
/**
* @brief opencl command queue
*/
cl_command_queue queue;
cl_command_queue m_queue;
/**
* @brief opencl vendor ID
*/
cl_int vendorID;
cl_int m_vendorID;
public:
/**
@@ -91,9 +91,9 @@ public:
*/
void execute(WorkPackage *work);
cl_context getContext(){return this->context;}
cl_context getContext(){ return this->m_context; }
cl_command_queue getQueue(){return this->queue;}
cl_command_queue getQueue(){ return this->m_queue; }
cl_mem COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel, int parameterIndex, int offsetIndex, list<cl_mem> *cleanup, MemoryBuffer **inputMemoryBuffers, SocketReader *reader);
void COM_clAttachMemoryBufferOffsetToKernelParameter(cl_kernel kernel, int offsetIndex, MemoryBuffer *memoryBuffers);

22
source/blender/compositor/intern/COM_OutputSocket.cpp
View File

@@ -31,7 +31,7 @@ OutputSocket::OutputSocket(DataType datatype) : Socket(datatype)
}
int OutputSocket::isOutputSocket() const { return true; }
const int OutputSocket::isConnected() const { return this->connections.size() != 0; }
const int OutputSocket::isConnected() const { return this->m_connections.size() != 0; }
void OutputSocket::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
{
@@ -51,37 +51,37 @@ void OutputSocket::determineResolution(unsigned int resolution[], unsigned int p
void OutputSocket::addConnection(SocketConnection *connection)
{
this->connections.push_back(connection);
this->m_connections.push_back(connection);
}
void OutputSocket::relinkConnections(OutputSocket *relinkToSocket, bool single)
{
if (isConnected()) {
if (single) {
SocketConnection *connection = this->connections[0];
SocketConnection *connection = this->m_connections[0];
connection->setFromSocket(relinkToSocket);
relinkToSocket->addConnection(connection);
this->connections.erase(this->connections.begin());
this->m_connections.erase(this->m_connections.begin());
}
else {
unsigned int index;
for (index = 0; index < this->connections.size(); index++) {
SocketConnection *connection = this->connections[index];
for (index = 0; index < this->m_connections.size(); index++) {
SocketConnection *connection = this->m_connections[index];
connection->setFromSocket(relinkToSocket);
relinkToSocket->addConnection(connection);
}
this->connections.clear();
this->m_connections.clear();
}
}
}
void OutputSocket::removeFirstConnection()
{
SocketConnection *connection = this->connections[0];
SocketConnection *connection = this->m_connections[0];
InputSocket *inputSocket = connection->getToSocket();
if (inputSocket != NULL) {
inputSocket->setConnection(NULL);
}
this->connections.erase(this->connections.begin());
this->m_connections.erase(this->m_connections.begin());
}
void OutputSocket::clearConnections()
@@ -94,8 +94,8 @@ void OutputSocket::clearConnections()
WriteBufferOperation *OutputSocket::findAttachedWriteBufferOperation() const
{
unsigned int index;
for (index = 0; index < this->connections.size(); index++) {
SocketConnection *connection = this->connections[index];
for (index = 0; index < this->m_connections.size(); index++) {
SocketConnection *connection = this->m_connections[index];
NodeBase *node = connection->getToNode();
if (node->isOperation()) {
NodeOperation *operation = (NodeOperation *)node;

6
source/blender/compositor/intern/COM_OutputSocket.h
View File

@@ -42,7 +42,7 @@ class WriteBufferOperation;
*/
class OutputSocket : public Socket {
private:
vector<SocketConnection *> connections;
vector<SocketConnection *> m_connections;
void removeFirstConnection();
public:
@@ -50,7 +50,7 @@ public:
OutputSocket(DataType datatype, int inputSocketDataTypeDeterminatorIndex);
OutputSocket(OutputSocket *from);
void addConnection(SocketConnection *connection);
SocketConnection *getConnection(unsigned int index) { return this->connections[index]; }
SocketConnection *getConnection(unsigned int index) { return this->m_connections[index]; }
const int isConnected() const;
int isOutputSocket() const;
@@ -66,7 +66,7 @@ public:
*/
void relinkConnections(OutputSocket *relinkToSocket) { this->relinkConnections(relinkToSocket, false); };
void relinkConnections(OutputSocket *relinkToSocket, bool single);
const int getNumberOfConnections() { return connections.size(); }
const int getNumberOfConnections() { return this->m_connections.size(); }
void clearConnections();

18
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
View File

@@ -24,7 +24,7 @@
SingleThreadedNodeOperation::SingleThreadedNodeOperation() : NodeOperation()
{
this->cachedInstance = NULL;
this->m_cachedInstance = NULL;
setComplex(true);
}
@@ -35,26 +35,26 @@ void SingleThreadedNodeOperation::initExecution()
void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
{
this->cachedInstance->read(color, x, y);
this->m_cachedInstance->read(color, x, y);
}
void SingleThreadedNodeOperation::deinitExecution()
{
deinitMutex();
if (this->cachedInstance) {
delete cachedInstance;
this->cachedInstance = NULL;
if (this->m_cachedInstance) {
delete this->m_cachedInstance;
this->m_cachedInstance = NULL;
}
}
void *SingleThreadedNodeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
{
if (this->cachedInstance) return this->cachedInstance;
if (this->m_cachedInstance) return this->m_cachedInstance;
lockMutex();
if (this->cachedInstance == NULL) {
if (this->m_cachedInstance == NULL) {
//
this->cachedInstance = createMemoryBuffer(rect, memoryBuffers);
this->m_cachedInstance = createMemoryBuffer(rect, memoryBuffers);
}
unlockMutex();
return this->cachedInstance;
return this->m_cachedInstance;
}

4
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
View File

@@ -26,11 +26,11 @@
class SingleThreadedNodeOperation : public NodeOperation {
private:
MemoryBuffer *cachedInstance;
MemoryBuffer *m_cachedInstance;
protected:
inline bool isCached() {
return cachedInstance != NULL;
return this->m_cachedInstance != NULL;
}
public:

12
source/blender/compositor/intern/COM_Socket.cpp
View File

@@ -26,18 +26,18 @@
Socket::Socket(DataType datatype)
{
this->datatype = datatype;
this->editorSocket = NULL;
this->node = NULL;
this->m_datatype = datatype;
this->m_editorSocket = NULL;
this->m_node = NULL;
}
DataType Socket::getDataType() const
{
return this->datatype;
return this->m_datatype;
}
int Socket::isInputSocket() const { return false; }
int Socket::isOutputSocket() const { return false; }
const int Socket::isConnected() const { return false; }
void Socket::setNode(NodeBase *node) { this->node = node; }
NodeBase *Socket::getNode() const { return this->node; }
void Socket::setNode(NodeBase *node) { this->m_node = node; }
NodeBase *Socket::getNode() const { return this->m_node; }

10
source/blender/compositor/intern/COM_Socket.h
View File

@@ -53,15 +53,15 @@ private:
/**
* Reference to the node where this Socket belongs to
*/
NodeBase *node;
NodeBase *m_node;
/**
* the datatype of this socket. Is used for automatically data transformation.
* @section data-conversion
*/
DataType datatype;
DataType m_datatype;
bNodeSocket *editorSocket;
bNodeSocket *m_editorSocket;
public:
Socket(DataType datatype);
@@ -75,8 +75,8 @@ public:
int isOutputSocket() const;
virtual void determineResolution(int resolution[], unsigned int preferredResolution[]) {}
void setEditorSocket(bNodeSocket *editorSocket) { this->editorSocket = editorSocket; }
bNodeSocket *getbNodeSocket() const { return this->editorSocket; }
void setEditorSocket(bNodeSocket *editorSocket) { this->m_editorSocket = editorSocket; }
bNodeSocket *getbNodeSocket() const { return this->m_editorSocket; }
#ifdef WITH_CXX_GUARDEDALLOC
MEM_CXX_CLASS_ALLOC_FUNCS("COM:Socket")

16
source/blender/compositor/intern/COM_SocketConnection.cpp
View File

@@ -25,8 +25,8 @@
SocketConnection::SocketConnection()
{
this->fromSocket = NULL;
this->toSocket = NULL;
this->m_fromSocket = NULL;
this->m_toSocket = NULL;
this->setIgnoreResizeCheck(false);
}
@@ -35,19 +35,19 @@ void SocketConnection::setFromSocket(OutputSocket *fromsocket)
if (fromsocket == NULL) {
throw "ERROR";
}
this->fromSocket = fromsocket;
this->m_fromSocket = fromsocket;
}
OutputSocket *SocketConnection::getFromSocket() const { return this->fromSocket; }
OutputSocket *SocketConnection::getFromSocket() const { return this->m_fromSocket; }
void SocketConnection::setToSocket(InputSocket *tosocket)
{
if (tosocket == NULL) {
throw "ERROR";
}
this->toSocket = tosocket;
this->m_toSocket = tosocket;
}
InputSocket *SocketConnection::getToSocket() const { return this->toSocket; }
InputSocket *SocketConnection::getToSocket() const { return this->m_toSocket; }
NodeBase *SocketConnection::getFromNode() const
{
@@ -79,10 +79,10 @@ bool SocketConnection::isValid() const
bool SocketConnection::needsResolutionConversion() const
{
if (this->ignoreResizeCheck) { return false; }
if (this->m_ignoreResizeCheck) { return false; }
NodeOperation *fromOperation = (NodeOperation *)this->getFromNode();
NodeOperation *toOperation = (NodeOperation *)this->getToNode();
if (this->toSocket->getResizeMode() == COM_SC_NO_RESIZE) { return false; }
if (this->m_toSocket->getResizeMode() == COM_SC_NO_RESIZE) { return false; }
const unsigned int fromWidth = fromOperation->getWidth();
const unsigned int fromHeight = fromOperation->getHeight();
const unsigned int toWidth = toOperation->getWidth();

10
source/blender/compositor/intern/COM_SocketConnection.h
View File

@@ -48,17 +48,17 @@ private:
/**
* @brief Startpoint of the connection
*/
OutputSocket *fromSocket;
OutputSocket *m_fromSocket;
/**
* @brief Endpoint of the connection
*/
InputSocket *toSocket;
InputSocket *m_toSocket;
/**
* @brief has the resize already been done for this connection
*/
bool ignoreResizeCheck;
bool m_ignoreResizeCheck;
public:
SocketConnection();
@@ -104,12 +104,12 @@ public:
/**
* @brief set, whether the resize has already been done for this SocketConnection
*/
void setIgnoreResizeCheck(bool check) { this->ignoreResizeCheck = check; }
void setIgnoreResizeCheck(bool check) { this->m_ignoreResizeCheck = check; }
/**
* @brief has the resize already been done for this SocketConnection
*/
bool isIgnoreResizeCheck() const { return this->ignoreResizeCheck; }
bool isIgnoreResizeCheck() const { return this->m_ignoreResizeCheck; }
/**
* @brief does this SocketConnection need resolution conversion

4
source/blender/compositor/intern/COM_WorkPackage.cpp
View File

@@ -24,6 +24,6 @@
WorkPackage::WorkPackage(ExecutionGroup *group, unsigned int chunkNumber)
{
this->executionGroup = group;
this->chunkNumber = chunkNumber;
this->m_executionGroup = group;
this->m_chunkNumber = chunkNumber;
}

8
source/blender/compositor/intern/COM_WorkPackage.h
View File

@@ -36,12 +36,12 @@ private:
/**
* @brief executionGroup with the operations-setup to be evaluated
*/
ExecutionGroup *executionGroup;
ExecutionGroup *m_executionGroup;
/**
* @brief number of the chunk to be executed
*/
unsigned int chunkNumber;
unsigned int m_chunkNumber;
public:
/**
* @constructor
@@ -53,12 +53,12 @@ public:
/**
* @brief get the ExecutionGroup
*/
ExecutionGroup *getExecutionGroup() const { return this->executionGroup; }
ExecutionGroup *getExecutionGroup() const { return this->m_executionGroup; }
/**
* @brief get the number of the chunk
*/
unsigned int getChunkNumber() const { return this->chunkNumber; }
unsigned int getChunkNumber() const { return this->m_chunkNumber; }
#ifdef WITH_CXX_GUARDEDALLOC
MEM_CXX_CLASS_ALLOC_FUNCS("COM:WorkPackage")

4
source/blender/compositor/nodes/COM_AlphaOverNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_AlphaOverNode_h
#define _COM_AlphaOverNode_h
#ifndef _COM_AlphaOverNode_h_
#define _COM_AlphaOverNode_h_
#include "COM_Node.h"

1
source/blender/compositor/nodes/COM_BlurNode.h
View File

@@ -29,7 +29,6 @@
* @brief BlurNode
* @ingroup Node
*/
class BlurNode : public Node {
public:
BlurNode(bNode *editorNode);

1
source/blender/compositor/nodes/COM_BokehBlurNode.h
View File

@@ -29,7 +29,6 @@
* @brief BokehBlurNode
* @ingroup Node
*/
class BokehBlurNode : public Node {
public:
BokehBlurNode(bNode *editorNode);

7
source/blender/compositor/nodes/COM_ChannelMatteNode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef COM_ChannelMatteNODE_H
#define COM_ChannelMatteNODE_H
#ifndef _COM_ChannelMatteNode_h_
#define _COM_ChannelMatteNode_h_
#include "COM_Node.h"
@@ -28,8 +28,7 @@
* @brief ChannelMatteNode
* @ingroup Node
*/
class ChannelMatteNode : public Node
{
class ChannelMatteNode : public Node {
public:
ChannelMatteNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

7
source/blender/compositor/nodes/COM_ChromaMatteNode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef COM_ChromaMatteNODE_H
#define COM_ChromaMatteNODE_H
#ifndef _COM_ChromaMatteNode_h_
#define _COM_ChromaMatteNode_h_
#include "COM_Node.h"
@@ -28,8 +28,7 @@
* @brief ChromaMatteNode
* @ingroup Node
*/
class ChromaMatteNode : public Node
{
class ChromaMatteNode : public Node {
public:
ChromaMatteNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

7
source/blender/compositor/nodes/COM_ColorBalanceNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef COM_ColorBalanceNODE_H
#define COM_ColorBalanceNODE_H
#ifndef _COM_ColorBalanceNode_h_
#define _COM_ColorBalanceNode_h_
#include "COM_Node.h"
@@ -29,8 +29,7 @@
* @brief ColorBalanceNode
* @ingroup Node
*/
class ColorBalanceNode : public Node
{
class ColorBalanceNode : public Node {
public:
ColorBalanceNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

7
source/blender/compositor/nodes/COM_ColorMatteNode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef COM_ColorMatteNODE_H
#define COM_ColorMatteNODE_H
#ifndef _COM_ColorMatteNode_h_
#define _COM_ColorMatteNode_h_
#include "COM_Node.h"
@@ -28,8 +28,7 @@
* @brief ColorMatteNode
* @ingroup Node
*/
class ColorMatteNode : public Node
{
class ColorMatteNode : public Node {
public:
ColorMatteNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

7
source/blender/compositor/nodes/COM_ColorRampNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef COM_ColorRampNODE_H
#define COM_ColorRampNODE_H
#ifndef _COM_ColorRampNode_h_
#define _COM_ColorRampNode_h_
#include "COM_Node.h"
@@ -29,8 +29,7 @@
* @brief ColorRampNode
* @ingroup Node
*/
class ColorRampNode : public Node
{
class ColorRampNode : public Node {
public:
ColorRampNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

7
source/blender/compositor/nodes/COM_ColorSpillNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef COM_ColorSpillNODE_H
#define COM_ColorSpillNODE_H
#ifndef _COM_ColorSpillNode_h_
#define _COM_ColorSpillNode_h_
#include "COM_Node.h"
@@ -29,8 +29,7 @@
* @brief ColorSpillNode
* @ingroup Node
*/
class ColorSpillNode : public Node
{
class ColorSpillNode : public Node {
public:
ColorSpillNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

4
source/blender/compositor/nodes/COM_ColorToBWNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_ColourToBWNode_h
#define _COM_ColourToBWNode_h
#ifndef _COM_ColourToBWNode_h_
#define _COM_ColourToBWNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_CombineHSVANode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_CombineHSVANode_h
#define _COM_CombineHSVANode_h
#ifndef _COM_CombineHSVANode_h_
#define _COM_CombineHSVANode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_CombineRGBANode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_CombineRGBANode_h
#define _COM_CombineRGBANode_h
#ifndef _COM_CombineRGBANode_h_
#define _COM_CombineRGBANode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_CombineYCCANode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef _COM_CombineYCCANode_h
#define _COM_CombineYCCANode_h
#ifndef _COM_CombineYCCANode_h_
#define _COM_CombineYCCANode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_CombineYUVANode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef _COM_CombineYUVANode_h
#define _COM_CombineYUVANode_h
#ifndef _COM_CombineYUVANode_h_
#define _COM_CombineYUVANode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_CompositorNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_CompositorNode_h
#define _COM_CompositorNode_h
#ifndef _COM_CompositorNode_h_
#define _COM_CompositorNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_ConvertAlphaNode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef _COM_ConvertAlphaNode_h
#define _COM_ConvertAlphaNode_h
#ifndef _COM_ConvertAlphaNode_h_
#define _COM_ConvertAlphaNode_h_
#include "COM_Node.h"

4
source/blender/compositor/nodes/COM_CropNode.h
View File

@@ -25,6 +25,10 @@
#include "COM_Node.h"
/**
* @brief CropNode
* @ingroup Node
*/
class CropNode : public Node {
public:
CropNode(bNode *editorNode);

1
source/blender/compositor/nodes/COM_DefocusNode.h
View File

@@ -29,7 +29,6 @@
* @brief DefocusNode
* @ingroup Node
*/
class DefocusNode : public Node {
public:
DefocusNode(bNode *editorNode);

7
source/blender/compositor/nodes/COM_DifferenceMatteNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef COM_DifferenceMatteNODE_H
#define COM_DifferenceMatteNODE_H
#ifndef _COM_DifferenceMatteNode_h_
#define _COM_DifferenceMatteNode_h_
#include "COM_Node.h"
@@ -29,8 +29,7 @@
* @brief DifferenceMatteNode
* @ingroup Node
*/
class DifferenceMatteNode : public Node
{
class DifferenceMatteNode : public Node {
public:
DifferenceMatteNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

2
source/blender/compositor/nodes/COM_DilateErodeNode.cpp
View File

@@ -77,7 +77,7 @@ void DilateErodeNode::convertToOperations(ExecutionSystem *graph, CompositorCont
CompositorQuality quality = context->getQuality();
/* initialize node data */
NodeBlurData *data = (NodeBlurData *)&this->alpha_blur;
NodeBlurData *data = (NodeBlurData *)&this->m_alpha_blur;
memset(data, 0, sizeof(*data));
data->filtertype = R_FILTER_GAUSS;

2
source/blender/compositor/nodes/COM_DilateErodeNode.h
View File

@@ -30,7 +30,7 @@
* @ingroup Node
*/
class DilateErodeNode : public Node {
NodeBlurData alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
public:
DilateErodeNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

4
source/blender/compositor/nodes/COM_DisplaceNode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef _COM_DisplaceNode_h
#define _COM_DisplaceNode_h
#ifndef _COM_DisplaceNode_h_
#define _COM_DisplaceNode_h_
#include "COM_Node.h"

7
source/blender/compositor/nodes/COM_DistanceMatteNode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef COM_DistanceMatteNODE_H
#define COM_DistanceMatteNODE_H
#ifndef _COM_DistanceMatteNode_h_
#define _COM_DistanceMatteNode_h_
#include "COM_Node.h"
@@ -28,8 +28,7 @@
* @brief DistanceMatteNode
* @ingroup Node
*/
class DistanceMatteNode : public Node
{
class DistanceMatteNode : public Node {
public:
DistanceMatteNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

9
source/blender/compositor/nodes/COM_FilterNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef COM_FILTERNODE_H
#define COM_FILTERNODE_H
#ifndef _COM_FilterNode_h_
#define _COM_FilterNode_h_
#include "COM_Node.h"
@@ -29,11 +29,10 @@
* @brief FilterNode
* @ingroup Node
*/
class FilterNode : public Node
{
class FilterNode : public Node {
public:
FilterNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
};
#endif // COM_FILTERNODE_H
#endif // _COM_FilterNode_h_

4
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_HueSaturationValueCorrectNode_h
#define _COM_HueSaturationValueCorrectNode_h
#ifndef _COM_HueSaturationValueCorrectNode_h_
#define _COM_HueSaturationValueCorrectNode_h_
#include "COM_Node.h"

4
source/blender/compositor/nodes/COM_HueSaturationValueNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_HueSaturationValueNode_h
#define _COM_HueSaturationValueNode_h
#ifndef _COM_HueSaturationValueNode_h_
#define _COM_HueSaturationValueNode_h_
#include "COM_Node.h"

1
source/blender/compositor/nodes/COM_ImageNode.h
View File

@@ -34,7 +34,6 @@ extern "C" {
* @ingroup Node
*/
class ImageNode : public Node {
private:
NodeOperation *doMultilayerCheck(ExecutionSystem *system, RenderLayer *rl, Image *image, ImageUser *user, int framenumber, int outputsocketIndex, int pass, DataType datatype);
public:

2
source/blender/compositor/nodes/COM_KeyingNode.cpp
View File

@@ -144,7 +144,7 @@ OutputSocket *KeyingNode::setupFeather(ExecutionSystem *graph, CompositorContext
CompositorQuality quality = context->getQuality();
/* initialize node data */
NodeBlurData *data = (NodeBlurData *)&this->alpha_blur;
NodeBlurData *data = (NodeBlurData *)&this->m_alpha_blur;
memset(data, 0, sizeof(*data));
data->filtertype = R_FILTER_GAUSS;

8
source/blender/compositor/nodes/COM_KeyingNode.h
View File

@@ -24,12 +24,12 @@
#include "COM_Node.h"
/**
* @brief KeyingNode
* @ingroup Node
*/
* @brief KeyingNode
* @ingroup Node
*/
class KeyingNode : public Node {
protected:
NodeBlurData alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
OutputSocket *setupPreBlur(ExecutionSystem *graph, InputSocket *inputImage, int size, OutputSocket **originalImage);
OutputSocket *setupPostBlur(ExecutionSystem *graph, OutputSocket *postBlurInput, int size);

6
source/blender/compositor/nodes/COM_KeyingScreenNode.h
View File

@@ -25,9 +25,9 @@
#include "DNA_node_types.h"
/**
* @brief KeyingScreenNode
* @ingroup Node
*/
* @brief KeyingScreenNode
* @ingroup Node
*/
class KeyingScreenNode : public Node {
public:
KeyingScreenNode(bNode *editorNode);

9
source/blender/compositor/nodes/COM_LuminanceMatteNode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef COM_LuminanceMatteNODE_H
#define COM_LuminanceMatteNODE_H
#ifndef _COM_LuminanceMatteNode_h_
#define _COM_LuminanceMatteNode_h_
#include "COM_Node.h"
@@ -28,11 +28,10 @@
* @brief LuminanceMatteNode
* @ingroup Node
*/
class LuminanceMatteNode : public Node
{
class LuminanceMatteNode : public Node {
public:
LuminanceMatteNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
};
#endif // COM_LuminanceMatteNODE_H
#endif // _COM_LuminanceMatteNode_h_

4
source/blender/compositor/nodes/COM_MapUVNode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef _COM_MapUVNode_h
#define _COM_MapUVNode_h
#ifndef _COM_MapUVNode_h_
#define _COM_MapUVNode_h_
#include "COM_Node.h"

7
source/blender/compositor/nodes/COM_MapValueNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_MapValueNode_h
#define _COM_MapValueNode_h
#ifndef _COM_MapValueNode_h_
#define _COM_MapValueNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"
@@ -34,4 +34,5 @@ public:
MapValueNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
};
#endif
#endif // _COM_MapValueNode_h_

7
source/blender/compositor/nodes/COM_MaskNode.h
View File

@@ -21,6 +21,9 @@
* Sergey Sharybin
*/
#ifndef _COM_MaskNode_h_
#define _COM_MaskNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"
@@ -29,10 +32,10 @@
* @ingroup Node
*/
class MaskNode : public Node {
public:
MaskNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
};
#endif // _COM_MaskNode_h_

4
source/blender/compositor/nodes/COM_MathNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_MathNode_h
#define _COM_MathNode_h
#ifndef _COM_MathNode_h_
#define _COM_MathNode_h_
#include "COM_Node.h"

4
source/blender/compositor/nodes/COM_MixNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_MixNode_h
#define _COM_MixNode_h
#ifndef _COM_MixNode_h_
#define _COM_MixNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

8
source/blender/compositor/nodes/COM_MovieClipNode.h
View File

@@ -20,6 +20,9 @@
* Monique Dewanchand
*/
#ifndef _COM_MovieClipNode_h_
#define _COM_MovieClipNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"
@@ -28,10 +31,9 @@
* @ingroup Node
*/
class MovieClipNode : public Node {
public:
MovieClipNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
};
#endif // _COM_MovieClipNode_h_

7
source/blender/compositor/nodes/COM_NormalNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef COM_NORMALNODE_H
#define COM_NORMALNODE_H
#ifndef _COM_NormalNode_h_
#define _COM_NormalNode_h_
#include "COM_Node.h"
@@ -29,8 +29,7 @@
* @brief NormalNode
* @ingroup Node
*/
class NormalNode : public Node
{
class NormalNode : public Node {
public:
NormalNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);

4
source/blender/compositor/nodes/COM_OutputFileNode.h
View File

@@ -21,8 +21,8 @@
* Lukas Tönne
*/
#ifndef _COM_OutputFileNode_h
#define _COM_OutputFileNode_h
#ifndef _COM_OutputFileNode_h_
#define _COM_OutputFileNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_SeparateHSVANode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_SeparateHSVANode_h
#define _COM_SeparateHSVANode_h
#ifndef _COM_SeparateHSVANode_h_
#define _COM_SeparateHSVANode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_SeparateRGBANode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_SeparateRGBANode_h
#define _COM_SeparateRGBANode_h
#ifndef _COM_SeparateRGBANode_h_
#define _COM_SeparateRGBANode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_SeparateYCCANode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef _COM_SeparateYCCANode_h
#define _COM_SeparateYCCANode_h
#ifndef _COM_SeparateYCCANode_h_
#define _COM_SeparateYCCANode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_SeparateYUVANode.h
View File

@@ -19,8 +19,8 @@
* Dalai Felinto
*/
#ifndef _COM_SeparateYUVANode_h
#define _COM_SeparateYUVANode_h
#ifndef _COM_SeparateYUVANode_h_
#define _COM_SeparateYUVANode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_SetAlphaNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_SetAlphaNode_h
#define _COM_SetAlphaNode_h
#ifndef _COM_SetAlphaNode_h_
#define _COM_SetAlphaNode_h_
#include "COM_Node.h"

4
source/blender/compositor/nodes/COM_SplitViewerNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_SplitViewerNode_h
#define _COM_SplitViewerNode_h
#ifndef _COM_SplitViewerNode_h_
#define _COM_SplitViewerNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

5
source/blender/compositor/nodes/COM_Stabilize2dNode.h
View File

@@ -20,6 +20,9 @@
* Monique Dewanchand
*/
#ifndef _COM_Stabilize2dNode_h_
#define _COM_Stabilize2dNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"
@@ -32,3 +35,5 @@ public:
Stabilize2dNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
};
#endif

4
source/blender/compositor/nodes/COM_SwitchNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_SwitchNode_h
#define _COM_SwitchNode_h
#ifndef _COM_SwitchNode_h_
#define _COM_SwitchNode_h_
#include "COM_Node.h"
#include "COM_NodeOperation.h"

5
source/blender/compositor/nodes/COM_TransformNode.h
View File

@@ -20,6 +20,9 @@
* Monique Dewanchand
*/
#ifndef _COM_TransformNode_h_
#define _COM_TransformNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"
@@ -32,3 +35,5 @@ public:
TransformNode(bNode *editorNode);
void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
};
#endif // _COM_TransformNode_h_

4
source/blender/compositor/nodes/COM_ViewerNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_ViewerNode_h
#define _COM_ViewerNode_h
#ifndef _COM_ViewerNode_h_
#define _COM_ViewerNode_h_
#include "COM_Node.h"
#include "DNA_node_types.h"

4
source/blender/compositor/nodes/COM_ZCombineNode.h
View File

@@ -20,8 +20,8 @@
* Monique Dewanchand
*/
#ifndef _COM_ZCombineNode_h
#define _COM_ZCombineNode_h
#ifndef _COM_ZCombineNode_h_
#define _COM_ZCombineNode_h_
#include "COM_Node.h"