[Bf-blender-cvs] [7bccbce512b] master: Cleanup: use snake case.
Jeroen Bakker
noreply at git.blender.org
Fri Mar 5 16:56:19 CET 2021
Commit: 7bccbce512bd715c113350cccc11962987cadc07
Author: Jeroen Bakker
Date: Fri Mar 5 16:16:41 2021 +0100
Branches: master
https://developer.blender.org/rB7bccbce512bd715c113350cccc11962987cadc07
Cleanup: use snake case.
===================================================================
M source/blender/compositor/intern/COM_ExecutionGroup.cpp
M source/blender/compositor/intern/COM_ExecutionGroup.h
===================================================================
diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.cpp b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
index 1286a07c4d0..37623228183 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.cpp
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
@@ -43,19 +43,19 @@
ExecutionGroup::ExecutionGroup()
{
- this->m_isOutput = false;
+ this->m_is_output = false;
this->m_complex = false;
this->m_bTree = nullptr;
this->m_height = 0;
this->m_width = 0;
this->m_max_read_buffer_offset = 0;
- this->m_numberOfXChunks = 0;
- this->m_numberOfYChunks = 0;
- this->m_numberOfChunks = 0;
+ this->m_x_chunks_len = 0;
+ this->m_y_chunks_len = 0;
+ this->m_chunks_len = 0;
this->m_initialized = false;
this->m_openCL = false;
this->m_singleThreaded = false;
- this->m_chunksFinished = 0;
+ this->m_chunks_finished = 0;
BLI_rcti_init(&this->m_viewerBorder, 0, 0, 0, 0);
this->m_executionStartTime = 0;
}
@@ -123,9 +123,9 @@ void ExecutionGroup::initExecution()
m_chunk_execution_states.clear();
determineNumberOfChunks();
- if (this->m_numberOfChunks != 0) {
- m_chunk_execution_states.resize(this->m_numberOfChunks);
- for (int index = 0; index < this->m_numberOfChunks; index++) {
+ if (this->m_chunks_len != 0) {
+ m_chunk_execution_states.resize(this->m_chunks_len);
+ for (int index = 0; index < this->m_chunks_len; index++) {
m_chunk_execution_states[index] = eChunkExecutionState::NOT_SCHEDULED;
}
}
@@ -146,9 +146,9 @@ void ExecutionGroup::initExecution()
void ExecutionGroup::deinitExecution()
{
m_chunk_execution_states.clear();
- this->m_numberOfChunks = 0;
- this->m_numberOfXChunks = 0;
- this->m_numberOfYChunks = 0;
+ this->m_chunks_len = 0;
+ this->m_x_chunks_len = 0;
+ this->m_y_chunks_len = 0;
this->m_read_operations.clear();
this->m_bTree = nullptr;
}
@@ -164,17 +164,17 @@ void ExecutionGroup::determineResolution(unsigned int resolution[2])
void ExecutionGroup::determineNumberOfChunks()
{
if (this->m_singleThreaded) {
- this->m_numberOfXChunks = 1;
- this->m_numberOfYChunks = 1;
- this->m_numberOfChunks = 1;
+ this->m_x_chunks_len = 1;
+ this->m_y_chunks_len = 1;
+ this->m_chunks_len = 1;
}
else {
const float chunkSizef = this->m_chunkSize;
const int border_width = BLI_rcti_size_x(&this->m_viewerBorder);
const int border_height = BLI_rcti_size_y(&this->m_viewerBorder);
- this->m_numberOfXChunks = ceil(border_width / chunkSizef);
- this->m_numberOfYChunks = ceil(border_height / chunkSizef);
- this->m_numberOfChunks = this->m_numberOfXChunks * this->m_numberOfYChunks;
+ this->m_x_chunks_len = ceil(border_width / chunkSizef);
+ this->m_y_chunks_len = ceil(border_height / chunkSizef);
+ this->m_chunks_len = this->m_x_chunks_len * this->m_y_chunks_len;
}
}
@@ -192,20 +192,20 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
if (bTree->test_break && bTree->test_break(bTree->tbh)) {
return;
} /** \note Early break out for blur and preview nodes. */
- if (this->m_numberOfChunks == 0) {
+ if (this->m_chunks_len == 0) {
return;
} /** \note Early break out. */
unsigned int chunkNumber;
this->m_executionStartTime = PIL_check_seconds_timer();
- this->m_chunksFinished = 0;
+ this->m_chunks_finished = 0;
this->m_bTree = bTree;
unsigned int index;
- unsigned int *chunkOrder = (unsigned int *)MEM_mallocN(
- sizeof(unsigned int) * this->m_numberOfChunks, __func__);
+ unsigned int *chunkOrder = (unsigned int *)MEM_mallocN(sizeof(unsigned int) * this->m_chunks_len,
+ __func__);
- for (chunkNumber = 0; chunkNumber < this->m_numberOfChunks; chunkNumber++) {
+ for (chunkNumber = 0; chunkNumber < this->m_chunks_len; chunkNumber++) {
chunkOrder[chunkNumber] = chunkNumber;
}
NodeOperation *operation = this->getOutputOperation();
@@ -225,9 +225,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
switch (chunkorder) {
case COM_TO_RANDOM:
- for (index = 0; index < 2 * this->m_numberOfChunks; index++) {
- int index1 = rand() % this->m_numberOfChunks;
- int index2 = rand() % this->m_numberOfChunks;
+ for (index = 0; index < 2 * this->m_chunks_len; index++) {
+ int index1 = rand() % this->m_chunks_len;
+ int index2 = rand() % this->m_chunks_len;
int s = chunkOrder[index1];
chunkOrder[index1] = chunkOrder[index2];
chunkOrder[index2] = s;
@@ -237,9 +237,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
ChunkOrderHotspot *hotspots[1];
hotspots[0] = new ChunkOrderHotspot(border_width * centerX, border_height * centerY, 0.0f);
rcti rect;
- ChunkOrder *chunkOrders = (ChunkOrder *)MEM_mallocN(
- sizeof(ChunkOrder) * this->m_numberOfChunks, __func__);
- for (index = 0; index < this->m_numberOfChunks; index++) {
+ ChunkOrder *chunkOrders = (ChunkOrder *)MEM_mallocN(sizeof(ChunkOrder) * this->m_chunks_len,
+ __func__);
+ for (index = 0; index < this->m_chunks_len; index++) {
determineChunkRect(&rect, index);
chunkOrders[index].number = index;
chunkOrders[index].x = rect.xmin - this->m_viewerBorder.xmin;
@@ -247,8 +247,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
chunkOrders[index].update_distance(hotspots, 1);
}
- std::sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks - 1]);
- for (index = 0; index < this->m_numberOfChunks; index++) {
+ std::sort(&chunkOrders[0], &chunkOrders[this->m_chunks_len - 1]);
+ for (index = 0; index < this->m_chunks_len; index++) {
chunkOrder[index] = chunkOrders[index].number;
}
@@ -265,7 +265,7 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
unsigned int bx = mx + 2 * tx;
unsigned int by = my + 2 * ty;
- float addition = this->m_numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER;
+ float addition = this->m_chunks_len / 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);
@@ -276,9 +276,9 @@ 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 = (ChunkOrder *)MEM_mallocN(
- sizeof(ChunkOrder) * this->m_numberOfChunks, __func__);
- for (index = 0; index < this->m_numberOfChunks; index++) {
+ ChunkOrder *chunkOrders = (ChunkOrder *)MEM_mallocN(sizeof(ChunkOrder) * this->m_chunks_len,
+ __func__);
+ for (index = 0; index < this->m_chunks_len; index++) {
determineChunkRect(&rect, index);
chunkOrders[index].number = index;
chunkOrders[index].x = rect.xmin - this->m_viewerBorder.xmin;
@@ -286,9 +286,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
chunkOrders[index].update_distance(hotspots, 9);
}
- std::sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks]);
+ std::sort(&chunkOrders[0], &chunkOrders[this->m_chunks_len]);
- for (index = 0; index < this->m_numberOfChunks; index++) {
+ for (index = 0; index < this->m_chunks_len; index++) {
chunkOrder[index] = chunkOrders[index].number;
}
@@ -322,12 +322,11 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
finished = true;
int numberEvaluated = 0;
- for (index = startIndex;
- index < this->m_numberOfChunks && numberEvaluated < maxNumberEvaluated;
+ for (index = startIndex; index < this->m_chunks_len && numberEvaluated < maxNumberEvaluated;
index++) {
chunkNumber = chunkOrder[index];
- int yChunk = chunkNumber / this->m_numberOfXChunks;
- int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
+ int yChunk = chunkNumber / this->m_x_chunks_len;
+ int xChunk = chunkNumber - (yChunk * this->m_x_chunks_len);
switch (m_chunk_execution_states[chunkNumber]) {
case eChunkExecutionState::NOT_SCHEDULED: {
scheduleChunkWhenPossible(graph, xChunk, yChunk);
@@ -401,7 +400,7 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
this->m_chunk_execution_states[chunkNumber] = eChunkExecutionState::EXECUTED;
}
- atomic_add_and_fetch_u(&this->m_chunksFinished, 1);
+ atomic_add_and_fetch_u(&this->m_chunks_finished, 1);
if (memoryBuffers) {
for (unsigned int index = 0; index < this->m_max_read_buffer_offset; index++) {
MemoryBuffer *buffer = memoryBuffers[index];
@@ -416,16 +415,16 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
}
if (this->m_bTree) {
// status report is only performed for top level Execution Groups.
- float progress = this->m_chunksFinished;
- progress /= this->m_numberOfChunks;
+ float progress = this->m_chunks_finished;
+ progress /= this->m_chunks_len;
this->m_bTree->progress(this->m_bTree->prh, progress);
char buf[128];
BLI_snprintf(buf,
sizeof(buf),
TIP_("Compositing | Tile %u-%u"),
- this->m_chunksFinished,
- this->m_numberOfChunks);
+ this->m_chunks_finished,
+ this->m_chunks_len);
this->m_bTree->stats_draw(this->m_bTree->sdh, buf);
}
}
@@ -456,8 +455,8 @@ inline void ExecutionGroup::determineChunkRect(rcti *rect,
void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int chunkNumber) const
{
- const unsigned int yChunk = chunkNumber / this->m_numberOfXChunks;
- const unsigned int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
+ const unsigned int yChunk = chunkNumber / this->m_x_chunks_len;
+ const unsigned int xChunk = chunkNumber - (yChunk * this->m_x_chunks_len);
determineChunkRect(rect, xChu
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list