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

Cleanup: use snake case.

Browse Source
This commit is contained in:
Jeroen Bakker
2021-03-05 16:16:41 +01:00
parent 921138cf5f
commit 7bccbce512
2 changed files with 60 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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, xChunk, yChunk);
}
@@ -492,8 +491,8 @@ bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area
int maxychunk = (maxy + (int)m_chunkSize - 1) / (int)m_chunkSize;
minxchunk = max_ii(minxchunk, 0);
minychunk = max_ii(minychunk, 0);
maxxchunk = min_ii(maxxchunk, (int)m_numberOfXChunks);
maxychunk = min_ii(maxychunk, (int)m_numberOfYChunks);
maxxchunk = min_ii(maxxchunk, (int)m_x_chunks_len);
maxychunk = min_ii(maxychunk, (int)m_y_chunks_len);
bool result = true;
for (indexx = minxchunk; indexx < maxxchunk; indexx++) {
@@ -519,13 +518,13 @@ bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk)
{
if (xChunk < 0 || xChunk >= (int)this->m_numberOfXChunks) {
if (xChunk < 0 || xChunk >= (int)this->m_x_chunks_len) {
return true;
}
if (yChunk < 0 || yChunk >= (int)this->m_numberOfYChunks) {
if (yChunk < 0 || yChunk >= (int)this->m_y_chunks_len) {
return true;
}
int chunkNumber = yChunk * this->m_numberOfXChunks + xChunk;
int chunkNumber = yChunk * this->m_x_chunks_len + xChunk;
// chunk is already executed
if (this->m_chunk_execution_states[chunkNumber] == eChunkExecutionState::EXECUTED) {
return true;

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

@@ -76,7 +76,7 @@ class ExecutionGroup {
* an input execution group is a group that is at the end of the calculation
* (the output is important for the user).
*/
int m_isOutput;
bool m_is_output;
/**
* \brief Width of the output
@@ -97,17 +97,17 @@ class ExecutionGroup {
/**
* \brief number of chunks in the x-axis
*/
unsigned int m_numberOfXChunks;
unsigned int m_x_chunks_len;
/**
* \brief number of chunks in the y-axis
*/
unsigned int m_numberOfYChunks;
unsigned int m_y_chunks_len;
/**
* \brief total number of chunks
*/
unsigned int m_numberOfChunks;
unsigned int m_chunks_len;
/**
* \brief contains this ExecutionGroup a complex NodeOperation.
@@ -145,7 +145,7 @@ class ExecutionGroup {
/**
* \brief total number of chunks that have been calculated for this ExecutionGroup
*/
unsigned int m_chunksFinished;
unsigned int m_chunks_finished;
/**
* \brief m_chunk_execution_states holds per chunk the execution state. this state can be
@@ -269,18 +269,18 @@ class ExecutionGroup {
* \note ViewerOperation, CompositeOperation, PreviewOperation.
* \see NodeOperation.isOutputOperation
*/
int isOutputExecutionGroup() const
bool isOutputExecutionGroup() const
{
return this->m_isOutput;
return this->m_is_output;
}
/**
* \brief set whether this ExecutionGroup is an output
* \param isOutput:
*/
void setOutputExecutionGroup(int isOutput)
void setOutputExecutionGroup(bool is_output)
{
this->m_isOutput = isOutput;
this->m_is_output = is_output;
}
/**