rename remaining class members with m_ prefix.
[blender.git] / source / blender / compositor / intern / COM_ExecutionGroup.cpp
index 4dfb9c7d26c2b24e21bbb4883bca4eed25e8552a..5aa9ff210703ee2e2eecef8c3102affca20c031a 100644 (file)
 
 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();
                        }
 
@@ -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;
 }