Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/source/blender/compositor/intern/COM_ExecutionGroup.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/blender/compositor/intern/COM_ExecutionGroup.cpp')
-rw-r--r--source/blender/compositor/intern/COM_ExecutionGroup.cpp249
1 files changed, 126 insertions, 123 deletions
diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.cpp b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
index 4dfb9c7d26c..2d3d24b296f 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.cpp
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
@@ -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;
- }
- this->numberOfChunks = 0;
- this->numberOfXChunks = 0;
- this->numberOfYChunks = 0;
- this->cachedReadOperations.clear();
- this->bTree = NULL;
+ if (this->m_chunkExecutionStates != NULL) {
+ delete[] this->m_chunkExecutionStates;
+ this->m_chunkExecutionStates = 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();
}
@@ -333,16 +333,15 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
const int maxNumberEvaluated = BLI_system_thread_count() * 2;
while (!finished && !breaked) {
- unsigned int index;
bool startEvaluated = false;
finished = true;
int numberEvaluated = 0;
- for (index = startIndex; index < 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];
+ for (index = startIndex; index < this->m_numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) {
+ chunkNumber = chunkOrder[index];
+ 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 +374,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 +393,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 +418,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 +434,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,23 +476,27 @@ 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);
- const int maxxchunk = ceil((area->xmax - 1) / chunkSizef);
- const int minychunk = floor(area->ymin / chunkSizef);
- const int maxychunk = ceil((area->ymax - 1) / chunkSizef);
+ int minxchunk = floor(area->xmin / chunkSizef);
+ int maxxchunk = ceil((area->xmax - 1) / chunkSizef);
+ int minychunk = floor(area->ymin / chunkSizef);
+ int maxychunk = ceil((area->ymax - 1) / chunkSizef);
+ minxchunk = MAX2(minxchunk, 0);
+ minychunk = MAX2(minychunk, 0);
+ maxxchunk = MIN2(maxxchunk, this->m_numberOfXChunks);
+ maxychunk = MIN2(maxychunk, this->m_numberOfYChunks);
bool result = true;
- for (indexx = max(minxchunk, 0); indexx < maxxchunk; indexx++) {
- for (indexy = max(minychunk, 0); indexy < maxychunk; indexy++) {
+ for (indexx = minxchunk; indexx < maxxchunk; indexx++) {
+ for (indexy = minychunk; indexy < maxychunk; indexy++) {
if (!scheduleChunkWhenPossible(graph, indexx, indexy)) {
result = false;
}
@@ -505,8 +508,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 +518,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 +545,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 +577,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;
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-09 06:34:56 +0300