diff options
Diffstat (limited to 'source/blender/compositor/operations')
219 files changed, 3743 insertions, 3762 deletions
diff --git a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cc b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cc index 5e056b3f52f..2e494d1adf3 100644 --- a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cc +++ b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cc @@ -34,9 +34,9 @@ void AlphaOverKeyOperation::executePixelSampled(float output[4], float inputOverColor[4]; float value[4]; - m_inputValueOperation->readSampled(value, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputOverColor, x, y, sampler); + inputValueOperation_->readSampled(value, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputOverColor, x, y, sampler); if (inputOverColor[3] <= 0.0f) { copy_v4_v4(output, inputColor1); diff --git a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cc b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cc index 61fab7b3bc8..1df74ffac8e 100644 --- a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cc +++ b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cc @@ -22,7 +22,7 @@ namespace blender::compositor { AlphaOverMixedOperation::AlphaOverMixedOperation() { - m_x = 0.0f; + x_ = 0.0f; this->flags.can_be_constant = true; } @@ -35,9 +35,9 @@ void AlphaOverMixedOperation::executePixelSampled(float output[4], float inputOverColor[4]; float value[4]; - m_inputValueOperation->readSampled(value, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputOverColor, x, y, sampler); + inputValueOperation_->readSampled(value, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputOverColor, x, y, sampler); if (inputOverColor[3] <= 0.0f) { copy_v4_v4(output, inputColor1); @@ -46,7 +46,7 @@ void AlphaOverMixedOperation::executePixelSampled(float output[4], copy_v4_v4(output, inputOverColor); } else { - float addfac = 1.0f - m_x + inputOverColor[3] * m_x; + float addfac = 1.0f - x_ + inputOverColor[3] * x_; float premul = value[0] * addfac; float mul = 1.0f - value[0] * inputOverColor[3]; @@ -71,7 +71,7 @@ void AlphaOverMixedOperation::update_memory_buffer_row(PixelCursor &p) copy_v4_v4(p.out, over_color); } else { - const float addfac = 1.0f - m_x + over_color[3] * m_x; + const float addfac = 1.0f - x_ + over_color[3] * x_; const float premul = value * addfac; const float mul = 1.0f - value * over_color[3]; diff --git a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h index 319176c8c9f..65967c03eb9 100644 --- a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h +++ b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h @@ -28,7 +28,7 @@ namespace blender::compositor { */ class AlphaOverMixedOperation : public MixBaseOperation { private: - float m_x; + float x_; public: /** @@ -43,7 +43,7 @@ class AlphaOverMixedOperation : public MixBaseOperation { void setX(float x) { - m_x = x; + x_ = x; } void update_memory_buffer_row(PixelCursor &p) override; diff --git a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cc b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cc index 47383706ba2..5af992c8809 100644 --- a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cc +++ b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cc @@ -34,9 +34,9 @@ void AlphaOverPremultiplyOperation::executePixelSampled(float output[4], float inputOverColor[4]; float value[4]; - m_inputValueOperation->readSampled(value, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputOverColor, x, y, sampler); + inputValueOperation_->readSampled(value, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputOverColor, x, y, sampler); /* Zero alpha values should still permit an add of RGB data */ if (inputOverColor[3] < 0.0f) { diff --git a/source/blender/compositor/operations/COM_AntiAliasOperation.cc b/source/blender/compositor/operations/COM_AntiAliasOperation.cc index 50e90111604..8a3b6f4df11 100644 --- a/source/blender/compositor/operations/COM_AntiAliasOperation.cc +++ b/source/blender/compositor/operations/COM_AntiAliasOperation.cc @@ -112,13 +112,13 @@ AntiAliasOperation::AntiAliasOperation() { this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_valueReader = nullptr; + valueReader_ = nullptr; this->flags.complex = true; } void AntiAliasOperation::initExecution() { - m_valueReader = this->getInputSocketReader(0); + valueReader_ = this->getInputSocketReader(0); } void AntiAliasOperation::executePixel(float output[4], int x, int y, void *data) @@ -175,7 +175,7 @@ void AntiAliasOperation::executePixel(float output[4], int x, int y, void *data) void AntiAliasOperation::deinitExecution() { - m_valueReader = nullptr; + valueReader_ = nullptr; } bool AntiAliasOperation::determineDependingAreaOfInterest(rcti *input, diff --git a/source/blender/compositor/operations/COM_AntiAliasOperation.h b/source/blender/compositor/operations/COM_AntiAliasOperation.h index b5048248425..48ae03a1aaa 100644 --- a/source/blender/compositor/operations/COM_AntiAliasOperation.h +++ b/source/blender/compositor/operations/COM_AntiAliasOperation.h @@ -33,7 +33,7 @@ class AntiAliasOperation : public MultiThreadedOperation { /** * \brief Cached reference to the reader */ - SocketReader *m_valueReader; + SocketReader *valueReader_; public: AntiAliasOperation(); diff --git a/source/blender/compositor/operations/COM_BilateralBlurOperation.cc b/source/blender/compositor/operations/COM_BilateralBlurOperation.cc index 4baaa416054..7368dcf0cad 100644 --- a/source/blender/compositor/operations/COM_BilateralBlurOperation.cc +++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.cc @@ -27,14 +27,14 @@ BilateralBlurOperation::BilateralBlurOperation() this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_inputColorProgram = nullptr; - m_inputDeterminatorProgram = nullptr; + inputColorProgram_ = nullptr; + inputDeterminatorProgram_ = nullptr; } void BilateralBlurOperation::initExecution() { - m_inputColorProgram = getInputSocketReader(0); - m_inputDeterminatorProgram = getInputSocketReader(1); + inputColorProgram_ = getInputSocketReader(0); + inputDeterminatorProgram_ = getInputSocketReader(1); QualityStepHelper::initExecution(COM_QH_INCREASE); } @@ -47,14 +47,14 @@ void BilateralBlurOperation::executePixel(float output[4], int x, int y, void *d float tempColor[4]; float blurColor[4]; float blurDivider; - float space = m_space; - float sigmacolor = m_data->sigma_color; + float space = space_; + float sigmacolor = data_->sigma_color; int minx = floor(x - space); int maxx = ceil(x + space); int miny = floor(y - space); int maxy = ceil(y + space); float deltaColor; - m_inputDeterminatorProgram->read(determinatorReferenceColor, x, y, data); + inputDeterminatorProgram_->read(determinatorReferenceColor, x, y, data); zero_v4(blurColor); blurDivider = 0.0f; @@ -65,14 +65,14 @@ void BilateralBlurOperation::executePixel(float output[4], int x, int y, void *d for (int yi = miny; yi < maxy; yi += QualityStepHelper::getStep()) { for (int xi = minx; xi < maxx; xi += QualityStepHelper::getStep()) { /* Read determinator. */ - m_inputDeterminatorProgram->read(determinator, xi, yi, data); + inputDeterminatorProgram_->read(determinator, xi, yi, data); deltaColor = (fabsf(determinatorReferenceColor[0] - determinator[0]) + fabsf(determinatorReferenceColor[1] - determinator[1]) + /* Do not take the alpha channel into account. */ fabsf(determinatorReferenceColor[2] - determinator[2])); if (deltaColor < sigmacolor) { /* Add this to the blur. */ - m_inputColorProgram->read(tempColor, xi, yi, data); + inputColorProgram_->read(tempColor, xi, yi, data); add_v4_v4(blurColor, tempColor); blurDivider += 1.0f; } @@ -92,8 +92,8 @@ void BilateralBlurOperation::executePixel(float output[4], int x, int y, void *d void BilateralBlurOperation::deinitExecution() { - m_inputColorProgram = nullptr; - m_inputDeterminatorProgram = nullptr; + inputColorProgram_ = nullptr; + inputDeterminatorProgram_ = nullptr; } bool BilateralBlurOperation::determineDependingAreaOfInterest(rcti *input, @@ -101,7 +101,7 @@ bool BilateralBlurOperation::determineDependingAreaOfInterest(rcti *input, rcti *output) { rcti newInput; - int add = ceil(m_space) + 1; + int add = ceil(space_) + 1; newInput.xmax = input->xmax + (add); newInput.xmin = input->xmin - (add); @@ -115,7 +115,7 @@ void BilateralBlurOperation::get_area_of_interest(const int UNUSED(input_idx), const rcti &output_area, rcti &r_input_area) { - const int add = ceil(m_space) + 1; + const int add = ceil(space_) + 1; r_input_area.xmax = output_area.xmax + (add); r_input_area.xmin = output_area.xmin - (add); @@ -174,10 +174,10 @@ void BilateralBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, { PixelCursor p = {}; p.step = QualityStepHelper::getStep(); - p.sigma_color = m_data->sigma_color; + p.sigma_color = data_->sigma_color; p.input_color = inputs[0]; p.input_determinator = inputs[1]; - const float space = m_space; + const float space = space_; for (int y = area.ymin; y < area.ymax; y++) { p.out = output->get_elem(area.xmin, y); /* This will be used as the reference color for the determinator. */ diff --git a/source/blender/compositor/operations/COM_BilateralBlurOperation.h b/source/blender/compositor/operations/COM_BilateralBlurOperation.h index a1884ddf1ab..aa94df1e254 100644 --- a/source/blender/compositor/operations/COM_BilateralBlurOperation.h +++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.h @@ -25,10 +25,10 @@ namespace blender::compositor { class BilateralBlurOperation : public MultiThreadedOperation, public QualityStepHelper { private: - SocketReader *m_inputColorProgram; - SocketReader *m_inputDeterminatorProgram; - NodeBilateralBlurData *m_data; - float m_space; + SocketReader *inputColorProgram_; + SocketReader *inputDeterminatorProgram_; + NodeBilateralBlurData *data_; + float space_; public: BilateralBlurOperation(); @@ -54,8 +54,8 @@ class BilateralBlurOperation : public MultiThreadedOperation, public QualityStep void setData(NodeBilateralBlurData *data) { - m_data = data; - m_space = data->sigma_space + data->iter; + data_ = data; + space_ = data->sigma_space + data->iter; } void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.cc b/source/blender/compositor/operations/COM_BlurBaseOperation.cc index f264603c8ba..3c43a16599b 100644 --- a/source/blender/compositor/operations/COM_BlurBaseOperation.cc +++ b/source/blender/compositor/operations/COM_BlurBaseOperation.cc @@ -30,11 +30,11 @@ BlurBaseOperation::BlurBaseOperation(DataType data_type) this->addInputSocket(DataType::Value); this->addOutputSocket(data_type); this->flags.complex = true; - m_inputProgram = nullptr; - memset(&m_data, 0, sizeof(NodeBlurData)); - m_size = 1.0f; - m_sizeavailable = false; - m_extend_bounds = false; + inputProgram_ = nullptr; + memset(&data_, 0, sizeof(NodeBlurData)); + size_ = 1.0f; + sizeavailable_ = false; + extend_bounds_ = false; use_variable_size_ = false; } @@ -44,32 +44,32 @@ void BlurBaseOperation::init_data() updateSize(); } - m_data.image_in_width = this->getWidth(); - m_data.image_in_height = this->getHeight(); - if (m_data.relative) { + data_.image_in_width = this->getWidth(); + data_.image_in_height = this->getHeight(); + if (data_.relative) { int sizex, sizey; - switch (m_data.aspect) { + switch (data_.aspect) { case CMP_NODE_BLUR_ASPECT_Y: - sizex = sizey = m_data.image_in_width; + sizex = sizey = data_.image_in_width; break; case CMP_NODE_BLUR_ASPECT_X: - sizex = sizey = m_data.image_in_height; + sizex = sizey = data_.image_in_height; break; default: - BLI_assert(m_data.aspect == CMP_NODE_BLUR_ASPECT_NONE); - sizex = m_data.image_in_width; - sizey = m_data.image_in_height; + BLI_assert(data_.aspect == CMP_NODE_BLUR_ASPECT_NONE); + sizex = data_.image_in_width; + sizey = data_.image_in_height; break; } - m_data.sizex = round_fl_to_int(m_data.percentx * 0.01f * sizex); - m_data.sizey = round_fl_to_int(m_data.percenty * 0.01f * sizey); + data_.sizex = round_fl_to_int(data_.percentx * 0.01f * sizex); + data_.sizey = round_fl_to_int(data_.percenty * 0.01f * sizey); } } void BlurBaseOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); - m_inputSize = this->getInputSocketReader(1); + inputProgram_ = this->getInputSocketReader(0); + inputSize_ = this->getInputSocketReader(1); QualityStepHelper::initExecution(COM_QH_MULTIPLY); } @@ -86,7 +86,7 @@ float *BlurBaseOperation::make_gausstab(float rad, int size) sum = 0.0f; float fac = (rad > 0.0f ? 1.0f / rad : 0.0f); for (i = -size; i <= size; i++) { - val = RE_filter_value(m_data.filtertype, (float)i * fac); + val = RE_filter_value(data_.filtertype, (float)i * fac); sum += val; gausstab[i + size] = val; } @@ -165,29 +165,29 @@ float *BlurBaseOperation::make_dist_fac_inverse(float rad, int size, int falloff void BlurBaseOperation::deinitExecution() { - m_inputProgram = nullptr; - m_inputSize = nullptr; + inputProgram_ = nullptr; + inputSize_ = nullptr; } void BlurBaseOperation::setData(const NodeBlurData *data) { - memcpy(&m_data, data, sizeof(NodeBlurData)); + memcpy(&data_, data, sizeof(NodeBlurData)); } int BlurBaseOperation::get_blur_size(eDimension dim) const { switch (dim) { case eDimension::X: - return m_data.sizex; + return data_.sizex; case eDimension::Y: - return m_data.sizey; + return data_.sizey; } return -1; } void BlurBaseOperation::updateSize() { - if (m_sizeavailable || use_variable_size_) { + if (sizeavailable_ || use_variable_size_) { return; } @@ -195,23 +195,23 @@ void BlurBaseOperation::updateSize() case eExecutionModel::Tiled: { float result[4]; this->getInputSocketReader(1)->readSampled(result, 0, 0, PixelSampler::Nearest); - m_size = result[0]; + size_ = result[0]; break; } case eExecutionModel::FullFrame: { NodeOperation *size_input = get_input_operation(SIZE_INPUT_INDEX); if (size_input->get_flags().is_constant_operation) { - m_size = *static_cast<ConstantOperation *>(size_input)->get_constant_elem(); + size_ = *static_cast<ConstantOperation *>(size_input)->get_constant_elem(); } /* Else use default. */ break; } } - m_sizeavailable = true; + sizeavailable_ = true; } void BlurBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { - if (!m_extend_bounds) { + if (!extend_bounds_) { NodeOperation::determine_canvas(preferred_area, r_area); return; } @@ -219,8 +219,8 @@ void BlurBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_are switch (execution_model_) { case eExecutionModel::Tiled: { NodeOperation::determine_canvas(preferred_area, r_area); - r_area.xmax += 2 * m_size * m_data.sizex; - r_area.ymax += 2 * m_size * m_data.sizey; + r_area.xmax += 2 * size_ * data_.sizex; + r_area.ymax += 2 * size_ * data_.sizey; break; } case eExecutionModel::FullFrame: { @@ -229,8 +229,8 @@ void BlurBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_are * operations. */ set_determined_canvas_modifier([=](rcti &canvas) { /* Rounding to even prevents jiggling in backdrop while switching size values. */ - canvas.xmax += round_to_even(2 * m_size * m_data.sizex); - canvas.ymax += round_to_even(2 * m_size * m_data.sizey); + canvas.xmax += round_to_even(2 * size_ * data_.sizex); + canvas.ymax += round_to_even(2 * size_ * data_.sizey); }); NodeOperation::determine_canvas(preferred_area, r_area); break; diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.h b/source/blender/compositor/operations/COM_BlurBaseOperation.h index d8fcd0f8364..b1dad2e868f 100644 --- a/source/blender/compositor/operations/COM_BlurBaseOperation.h +++ b/source/blender/compositor/operations/COM_BlurBaseOperation.h @@ -29,7 +29,7 @@ namespace blender::compositor { class BlurBaseOperation : public MultiThreadedOperation, public QualityStepHelper { private: - bool m_extend_bounds; + bool extend_bounds_; protected: static constexpr int IMAGE_INPUT_INDEX = 0; @@ -48,12 +48,12 @@ class BlurBaseOperation : public MultiThreadedOperation, public QualityStepHelpe /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; - SocketReader *m_inputSize; - NodeBlurData m_data; + SocketReader *inputProgram_; + SocketReader *inputSize_; + NodeBlurData data_; - float m_size; - bool m_sizeavailable; + float size_; + bool sizeavailable_; /* Flags for inheriting classes. */ bool use_variable_size_; @@ -74,13 +74,13 @@ class BlurBaseOperation : public MultiThreadedOperation, public QualityStepHelpe void setSize(float size) { - m_size = size; - m_sizeavailable = true; + size_ = size; + sizeavailable_ = true; } void setExtendBounds(bool extend_bounds) { - m_extend_bounds = extend_bounds; + extend_bounds_ = extend_bounds; } int get_blur_size(eDimension dim) const; diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.cc b/source/blender/compositor/operations/COM_BokehBlurOperation.cc index a9d1275805a..d00a18baf7b 100644 --- a/source/blender/compositor/operations/COM_BokehBlurOperation.cc +++ b/source/blender/compositor/operations/COM_BokehBlurOperation.cc @@ -39,13 +39,13 @@ BokehBlurOperation::BokehBlurOperation() flags.complex = true; flags.open_cl = true; - m_size = 1.0f; - m_sizeavailable = false; - m_inputProgram = nullptr; - m_inputBokehProgram = nullptr; - m_inputBoundingBoxReader = nullptr; + size_ = 1.0f; + sizeavailable_ = false; + inputProgram_ = nullptr; + inputBokehProgram_ = nullptr; + inputBoundingBoxReader_ = nullptr; - m_extend_bounds = false; + extend_bounds_ = false; } void BokehBlurOperation::init_data() @@ -60,15 +60,15 @@ void BokehBlurOperation::init_data() const float dimension = MIN2(width, height); - m_bokehMidX = width / 2.0f; - m_bokehMidY = height / 2.0f; - m_bokehDimension = dimension / 2.0f; + bokehMidX_ = width / 2.0f; + bokehMidY_ = height / 2.0f; + bokehDimension_ = dimension / 2.0f; } void *BokehBlurOperation::initializeTileData(rcti * /*rect*/) { lockMutex(); - if (!m_sizeavailable) { + if (!sizeavailable_) { updateSize(); } void *buffer = getInputOperation(0)->initializeTileData(nullptr); @@ -80,9 +80,9 @@ void BokehBlurOperation::initExecution() { initMutex(); - m_inputProgram = getInputSocketReader(0); - m_inputBokehProgram = getInputSocketReader(1); - m_inputBoundingBoxReader = getInputSocketReader(2); + inputProgram_ = getInputSocketReader(0); + inputBokehProgram_ = getInputSocketReader(1); + inputBoundingBoxReader_ = getInputSocketReader(2); QualityStepHelper::initExecution(COM_QH_INCREASE); } @@ -93,7 +93,7 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data) float tempBoundingBox[4]; float bokeh[4]; - m_inputBoundingBoxReader->readSampled(tempBoundingBox, x, y, PixelSampler::Nearest); + inputBoundingBoxReader_->readSampled(tempBoundingBox, x, y, PixelSampler::Nearest); if (tempBoundingBox[0] > 0.0f) { float multiplier_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; @@ -103,11 +103,11 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data) int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; const float max_dim = MAX2(this->getWidth(), this->getHeight()); - int pixelSize = m_size * max_dim / 100.0f; + int pixelSize = size_ * max_dim / 100.0f; zero_v4(color_accum); if (pixelSize < 2) { - m_inputProgram->readSampled(color_accum, x, y, PixelSampler::Nearest); + inputProgram_->readSampled(color_accum, x, y, PixelSampler::Nearest); multiplier_accum[0] = 1.0f; multiplier_accum[1] = 1.0f; multiplier_accum[2] = 1.0f; @@ -125,14 +125,14 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data) int step = getStep(); int offsetadd = getOffsetAdd() * COM_DATA_TYPE_COLOR_CHANNELS; - float m = m_bokehDimension / pixelSize; + float m = bokehDimension_ / pixelSize; for (int ny = miny; ny < maxy; ny += step) { int bufferindex = ((minx - bufferstartx) * COM_DATA_TYPE_COLOR_CHANNELS) + ((ny - bufferstarty) * COM_DATA_TYPE_COLOR_CHANNELS * bufferwidth); for (int nx = minx; nx < maxx; nx += step) { - float u = m_bokehMidX - (nx - x) * m; - float v = m_bokehMidY - (ny - y) * m; - m_inputBokehProgram->readSampled(bokeh, u, v, PixelSampler::Nearest); + float u = bokehMidX_ - (nx - x) * m; + float v = bokehMidY_ - (ny - y) * m; + inputBokehProgram_->readSampled(bokeh, u, v, PixelSampler::Nearest); madd_v4_v4v4(color_accum, bokeh, &buffer[bufferindex]); add_v4_v4(multiplier_accum, bokeh); bufferindex += offsetadd; @@ -144,16 +144,16 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data) output[3] = color_accum[3] * (1.0f / multiplier_accum[3]); } else { - m_inputProgram->readSampled(output, x, y, PixelSampler::Nearest); + inputProgram_->readSampled(output, x, y, PixelSampler::Nearest); } } void BokehBlurOperation::deinitExecution() { deinitMutex(); - m_inputProgram = nullptr; - m_inputBokehProgram = nullptr; - m_inputBoundingBoxReader = nullptr; + inputProgram_ = nullptr; + inputBokehProgram_ = nullptr; + inputBoundingBoxReader_ = nullptr; } bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input, @@ -164,11 +164,11 @@ bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input, rcti bokehInput; const float max_dim = MAX2(this->getWidth(), this->getHeight()); - if (m_sizeavailable) { - newInput.xmax = input->xmax + (m_size * max_dim / 100.0f); - newInput.xmin = input->xmin - (m_size * max_dim / 100.0f); - newInput.ymax = input->ymax + (m_size * max_dim / 100.0f); - newInput.ymin = input->ymin - (m_size * max_dim / 100.0f); + if (sizeavailable_) { + newInput.xmax = input->xmax + (size_ * max_dim / 100.0f); + newInput.xmin = input->xmin - (size_ * max_dim / 100.0f); + newInput.ymax = input->ymax + (size_ * max_dim / 100.0f); + newInput.ymin = input->ymin - (size_ * max_dim / 100.0f); } else { newInput.xmax = input->xmax + (10.0f * max_dim / 100.0f); @@ -193,7 +193,7 @@ bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input, if (operation->determineDependingAreaOfInterest(input, readOperation, output)) { return true; } - if (!m_sizeavailable) { + if (!sizeavailable_) { rcti sizeInput; sizeInput.xmin = 0; sizeInput.ymin = 0; @@ -215,19 +215,19 @@ void BokehBlurOperation::executeOpenCL(OpenCLDevice *device, std::list<cl_kernel> * /*clKernelsToCleanUp*/) { cl_kernel kernel = device->COM_clCreateKernel("bokehBlurKernel", nullptr); - if (!m_sizeavailable) { + if (!sizeavailable_) { updateSize(); } const float max_dim = MAX2(this->getWidth(), this->getHeight()); - cl_int radius = m_size * max_dim / 100.0f; + cl_int radius = size_ * max_dim / 100.0f; cl_int step = this->getStep(); device->COM_clAttachMemoryBufferToKernelParameter( - kernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, m_inputBoundingBoxReader); + kernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, inputBoundingBoxReader_); device->COM_clAttachMemoryBufferToKernelParameter( - kernel, 1, 4, clMemToCleanUp, inputMemoryBuffers, m_inputProgram); + kernel, 1, 4, clMemToCleanUp, inputMemoryBuffers, inputProgram_); device->COM_clAttachMemoryBufferToKernelParameter( - kernel, 2, -1, clMemToCleanUp, inputMemoryBuffers, m_inputBokehProgram); + kernel, 2, -1, clMemToCleanUp, inputMemoryBuffers, inputBokehProgram_); device->COM_clAttachOutputMemoryBufferToKernelParameter(kernel, 3, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter(kernel, 5, outputMemoryBuffer); clSetKernelArg(kernel, 6, sizeof(cl_int), &radius); @@ -239,7 +239,7 @@ void BokehBlurOperation::executeOpenCL(OpenCLDevice *device, void BokehBlurOperation::updateSize() { - if (m_sizeavailable) { + if (sizeavailable_) { return; } @@ -247,25 +247,25 @@ void BokehBlurOperation::updateSize() case eExecutionModel::Tiled: { float result[4]; this->getInputSocketReader(3)->readSampled(result, 0, 0, PixelSampler::Nearest); - m_size = result[0]; - CLAMP(m_size, 0.0f, 10.0f); + size_ = result[0]; + CLAMP(size_, 0.0f, 10.0f); break; } case eExecutionModel::FullFrame: { NodeOperation *size_input = get_input_operation(SIZE_INPUT_INDEX); if (size_input->get_flags().is_constant_operation) { - m_size = *static_cast<ConstantOperation *>(size_input)->get_constant_elem(); - CLAMP(m_size, 0.0f, 10.0f); + size_ = *static_cast<ConstantOperation *>(size_input)->get_constant_elem(); + CLAMP(size_, 0.0f, 10.0f); } /* Else use default. */ break; } } - m_sizeavailable = true; + sizeavailable_ = true; } void BokehBlurOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { - if (!m_extend_bounds) { + if (!extend_bounds_) { NodeOperation::determine_canvas(preferred_area, r_area); return; } @@ -274,15 +274,15 @@ void BokehBlurOperation::determine_canvas(const rcti &preferred_area, rcti &r_ar case eExecutionModel::Tiled: { NodeOperation::determine_canvas(preferred_area, r_area); const float max_dim = MAX2(BLI_rcti_size_x(&r_area), BLI_rcti_size_y(&r_area)); - r_area.xmax += 2 * m_size * max_dim / 100.0f; - r_area.ymax += 2 * m_size * max_dim / 100.0f; + r_area.xmax += 2 * size_ * max_dim / 100.0f; + r_area.ymax += 2 * size_ * max_dim / 100.0f; break; } case eExecutionModel::FullFrame: { set_determined_canvas_modifier([=](rcti &canvas) { const float max_dim = MAX2(BLI_rcti_size_x(&canvas), BLI_rcti_size_y(&canvas)); /* Rounding to even prevents image jiggling in backdrop while switching size values. */ - float add_size = round_to_even(2 * m_size * max_dim / 100.0f); + float add_size = round_to_even(2 * size_ * max_dim / 100.0f); canvas.xmax += add_size; canvas.ymax += add_size; }); @@ -299,7 +299,7 @@ void BokehBlurOperation::get_area_of_interest(const int input_idx, switch (input_idx) { case IMAGE_INPUT_INDEX: { const float max_dim = MAX2(this->getWidth(), this->getHeight()); - const float add_size = m_size * max_dim / 100.0f; + const float add_size = size_ * max_dim / 100.0f; r_input_area.xmin = output_area.xmin - add_size; r_input_area.xmax = output_area.xmax + add_size; r_input_area.ymin = output_area.ymin - add_size; @@ -326,8 +326,8 @@ void BokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> inputs) { const float max_dim = MAX2(this->getWidth(), this->getHeight()); - const int pixel_size = m_size * max_dim / 100.0f; - const float m = m_bokehDimension / pixel_size; + const int pixel_size = size_ * max_dim / 100.0f; + const float m = bokehDimension_ / pixel_size; const MemoryBuffer *image_input = inputs[IMAGE_INPUT_INDEX]; const MemoryBuffer *bokeh_input = inputs[BOKEH_INPUT_INDEX]; @@ -362,9 +362,9 @@ void BokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, const float *row_color = image_input->get_elem(minx, miny); for (int ny = miny; ny < maxy; ny += step, row_color += row_stride) { const float *color = row_color; - const float v = m_bokehMidY - (ny - y) * m; + const float v = bokehMidY_ - (ny - y) * m; for (int nx = minx; nx < maxx; nx += step, color += elem_stride) { - const float u = m_bokehMidX - (nx - x) * m; + const float u = bokehMidX_ - (nx - x) * m; float bokeh[4]; bokeh_input->read_elem_checked(u, v, bokeh); madd_v4_v4v4(color_accum, bokeh, color); diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.h b/source/blender/compositor/operations/COM_BokehBlurOperation.h index 7b0f0710a00..0b70b7a714a 100644 --- a/source/blender/compositor/operations/COM_BokehBlurOperation.h +++ b/source/blender/compositor/operations/COM_BokehBlurOperation.h @@ -25,17 +25,17 @@ namespace blender::compositor { class BokehBlurOperation : public MultiThreadedOperation, public QualityStepHelper { private: - SocketReader *m_inputProgram; - SocketReader *m_inputBokehProgram; - SocketReader *m_inputBoundingBoxReader; + SocketReader *inputProgram_; + SocketReader *inputBokehProgram_; + SocketReader *inputBoundingBoxReader_; void updateSize(); - float m_size; - bool m_sizeavailable; + float size_; + bool sizeavailable_; - float m_bokehMidX; - float m_bokehMidY; - float m_bokehDimension; - bool m_extend_bounds; + float bokehMidX_; + float bokehMidY_; + float bokehDimension_; + bool extend_bounds_; public: BokehBlurOperation(); @@ -64,8 +64,8 @@ class BokehBlurOperation : public MultiThreadedOperation, public QualityStepHelp void setSize(float size) { - m_size = size; - m_sizeavailable = true; + size_ = size; + sizeavailable_ = true; } void executeOpenCL(OpenCLDevice *device, @@ -77,7 +77,7 @@ class BokehBlurOperation : public MultiThreadedOperation, public QualityStepHelp void setExtendBounds(bool extend_bounds) { - m_extend_bounds = extend_bounds; + extend_bounds_ = extend_bounds; } void determine_canvas(const rcti &preferred_area, rcti &r_area) override; diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.cc b/source/blender/compositor/operations/COM_BokehImageOperation.cc index fb2799e378b..5389fa633b0 100644 --- a/source/blender/compositor/operations/COM_BokehImageOperation.cc +++ b/source/blender/compositor/operations/COM_BokehImageOperation.cc @@ -23,33 +23,33 @@ namespace blender::compositor { BokehImageOperation::BokehImageOperation() { this->addOutputSocket(DataType::Color); - m_deleteData = false; + deleteData_ = false; } void BokehImageOperation::initExecution() { - m_center[0] = getWidth() / 2; - m_center[1] = getHeight() / 2; - m_inverseRounding = 1.0f - m_data->rounding; - m_circularDistance = getWidth() / 2; - m_flapRad = (float)(M_PI * 2) / m_data->flaps; - m_flapRadAdd = m_data->angle; - while (m_flapRadAdd < 0.0f) { - m_flapRadAdd += (float)(M_PI * 2.0); + center_[0] = getWidth() / 2; + center_[1] = getHeight() / 2; + inverseRounding_ = 1.0f - data_->rounding; + circularDistance_ = getWidth() / 2; + flapRad_ = (float)(M_PI * 2) / data_->flaps; + flapRadAdd_ = data_->angle; + while (flapRadAdd_ < 0.0f) { + flapRadAdd_ += (float)(M_PI * 2.0); } - while (m_flapRadAdd > (float)M_PI) { - m_flapRadAdd -= (float)(M_PI * 2.0); + while (flapRadAdd_ > (float)M_PI) { + flapRadAdd_ -= (float)(M_PI * 2.0); } } void BokehImageOperation::detemineStartPointOfFlap(float r[2], int flapNumber, float distance) { - r[0] = sinf(m_flapRad * flapNumber + m_flapRadAdd) * distance + m_center[0]; - r[1] = cosf(m_flapRad * flapNumber + m_flapRadAdd) * distance + m_center[1]; + r[0] = sinf(flapRad_ * flapNumber + flapRadAdd_) * distance + center_[0]; + r[1] = cosf(flapRad_ * flapNumber + flapRadAdd_) * distance + center_[1]; } float BokehImageOperation::isInsideBokeh(float distance, float x, float y) { float insideBokeh = 0.0f; - const float deltaX = x - m_center[0]; - const float deltaY = y - m_center[1]; + const float deltaX = x - center_[0]; + const float deltaY = y - center_[1]; float closestPoint[2]; float lineP1[2]; float lineP2[2]; @@ -57,25 +57,25 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y) point[0] = x; point[1] = y; - const float distanceToCenter = len_v2v2(point, m_center); + const float distanceToCenter = len_v2v2(point, center_); const float bearing = (atan2f(deltaX, deltaY) + (float)(M_PI * 2.0)); - int flapNumber = (int)((bearing - m_flapRadAdd) / m_flapRad); + int flapNumber = (int)((bearing - flapRadAdd_) / flapRad_); detemineStartPointOfFlap(lineP1, flapNumber, distance); detemineStartPointOfFlap(lineP2, flapNumber + 1, distance); closest_to_line_v2(closestPoint, point, lineP1, lineP2); - const float distanceLineToCenter = len_v2v2(m_center, closestPoint); - const float distanceRoundingToCenter = m_inverseRounding * distanceLineToCenter + - m_data->rounding * distance; + const float distanceLineToCenter = len_v2v2(center_, closestPoint); + const float distanceRoundingToCenter = inverseRounding_ * distanceLineToCenter + + data_->rounding * distance; - const float catadioptricDistanceToCenter = distanceRoundingToCenter * m_data->catadioptric; + const float catadioptricDistanceToCenter = distanceRoundingToCenter * data_->catadioptric; if (distanceRoundingToCenter >= distanceToCenter && catadioptricDistanceToCenter <= distanceToCenter) { if (distanceRoundingToCenter - distanceToCenter < 1.0f) { insideBokeh = (distanceRoundingToCenter - distanceToCenter); } - else if (m_data->catadioptric != 0.0f && + else if (data_->catadioptric != 0.0f && distanceToCenter - catadioptricDistanceToCenter < 1.0f) { insideBokeh = (distanceToCenter - catadioptricDistanceToCenter); } @@ -90,9 +90,9 @@ void BokehImageOperation::executePixelSampled(float output[4], float y, PixelSampler /*sampler*/) { - float shift = m_data->lensshift; + float shift = data_->lensshift; float shift2 = shift / 2.0f; - float distance = m_circularDistance; + float distance = circularDistance_; float insideBokehMax = isInsideBokeh(distance, x, y); float insideBokehMed = isInsideBokeh(distance - fabsf(shift2 * distance), x, y); float insideBokehMin = isInsideBokeh(distance - fabsf(shift * distance), x, y); @@ -113,9 +113,9 @@ void BokehImageOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - const float shift = m_data->lensshift; + const float shift = data_->lensshift; const float shift2 = shift / 2.0f; - const float distance = m_circularDistance; + const float distance = circularDistance_; for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { const float insideBokehMax = isInsideBokeh(distance, it.x, it.y); const float insideBokehMed = isInsideBokeh(distance - fabsf(shift2 * distance), it.x, it.y); @@ -136,10 +136,10 @@ void BokehImageOperation::update_memory_buffer_partial(MemoryBuffer *output, void BokehImageOperation::deinitExecution() { - if (m_deleteData) { - if (m_data) { - delete m_data; - m_data = nullptr; + if (deleteData_) { + if (data_) { + delete data_; + data_ = nullptr; } } } diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.h b/source/blender/compositor/operations/COM_BokehImageOperation.h index 888446b4791..de1c05fe360 100644 --- a/source/blender/compositor/operations/COM_BokehImageOperation.h +++ b/source/blender/compositor/operations/COM_BokehImageOperation.h @@ -54,37 +54,37 @@ class BokehImageOperation : public MultiThreadedOperation { /** * \brief Settings of the bokeh image */ - NodeBokehImage *m_data; + NodeBokehImage *data_; /** * \brief precalculate center of the image */ - float m_center[2]; + float center_[2]; /** * \brief 1.0-rounding */ - float m_inverseRounding; + float inverseRounding_; /** * \brief distance of a full circle lens */ - float m_circularDistance; + float circularDistance_; /** * \brief radius when the first flap starts */ - float m_flapRad; + float flapRad_; /** * \brief radians of a single flap */ - float m_flapRadAdd; + float flapRadAdd_; /** - * \brief should the m_data field by deleted when this operation is finished + * \brief should the data_ field by deleted when this operation is finished */ - bool m_deleteData; + bool deleteData_; /** * \brief determine the coordinate of a flap corner. @@ -136,7 +136,7 @@ class BokehImageOperation : public MultiThreadedOperation { */ void setData(NodeBokehImage *data) { - m_data = data; + data_ = data; } /** @@ -148,7 +148,7 @@ class BokehImageOperation : public MultiThreadedOperation { */ void deleteDataOnFinish() { - m_deleteData = true; + deleteData_ = true; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_BoxMaskOperation.cc b/source/blender/compositor/operations/COM_BoxMaskOperation.cc index e79e86e5ed2..7263e6a1a59 100644 --- a/source/blender/compositor/operations/COM_BoxMaskOperation.cc +++ b/source/blender/compositor/operations/COM_BoxMaskOperation.cc @@ -25,19 +25,19 @@ BoxMaskOperation::BoxMaskOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_inputMask = nullptr; - m_inputValue = nullptr; - m_cosine = 0.0f; - m_sine = 0.0f; + inputMask_ = nullptr; + inputValue_ = nullptr; + cosine_ = 0.0f; + sine_ = 0.0f; } void BoxMaskOperation::initExecution() { - m_inputMask = this->getInputSocketReader(0); - m_inputValue = this->getInputSocketReader(1); - const double rad = (double)m_data->rotation; - m_cosine = cos(rad); - m_sine = sin(rad); - m_aspectRatio = ((float)this->getWidth()) / this->getHeight(); + inputMask_ = this->getInputSocketReader(0); + inputValue_ = this->getInputSocketReader(1); + const double rad = (double)data_->rotation; + cosine_ = cos(rad); + sine_ = sin(rad); + aspectRatio_ = ((float)this->getWidth()) / this->getHeight(); } void BoxMaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) @@ -48,20 +48,20 @@ void BoxMaskOperation::executePixelSampled(float output[4], float x, float y, Pi float rx = x / this->getWidth(); float ry = y / this->getHeight(); - const float dy = (ry - m_data->y) / m_aspectRatio; - const float dx = rx - m_data->x; - rx = m_data->x + (m_cosine * dx + m_sine * dy); - ry = m_data->y + (-m_sine * dx + m_cosine * dy); + const float dy = (ry - data_->y) / aspectRatio_; + const float dx = rx - data_->x; + rx = data_->x + (cosine_ * dx + sine_ * dy); + ry = data_->y + (-sine_ * dx + cosine_ * dy); - m_inputMask->readSampled(inputMask, x, y, sampler); - m_inputValue->readSampled(inputValue, x, y, sampler); + inputMask_->readSampled(inputMask, x, y, sampler); + inputValue_->readSampled(inputValue, x, y, sampler); - float halfHeight = m_data->height / 2.0f; - float halfWidth = m_data->width / 2.0f; - bool inside = (rx > m_data->x - halfWidth && rx < m_data->x + halfWidth && - ry > m_data->y - halfHeight && ry < m_data->y + halfHeight); + float halfHeight = data_->height / 2.0f; + float halfWidth = data_->width / 2.0f; + bool inside = (rx > data_->x - halfWidth && rx < data_->x + halfWidth && + ry > data_->y - halfHeight && ry < data_->y + halfHeight); - switch (m_maskType) { + switch (maskType_) { case CMP_NODE_MASKTYPE_ADD: if (inside) { output[0] = MAX2(inputMask[0], inputValue[0]); @@ -108,7 +108,7 @@ void BoxMaskOperation::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> inputs) { MaskFunc mask_func; - switch (m_maskType) { + switch (maskType_) { case CMP_NODE_MASKTYPE_ADD: mask_func = [](const bool is_inside, const float *mask, const float *value) { return is_inside ? MAX2(mask[0], value[0]) : mask[0]; @@ -143,18 +143,18 @@ void BoxMaskOperation::apply_mask(MemoryBuffer *output, { const float op_w = this->getWidth(); const float op_h = this->getHeight(); - const float half_w = m_data->width / 2.0f; - const float half_h = m_data->height / 2.0f; + const float half_w = data_->width / 2.0f; + const float half_h = data_->height / 2.0f; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const float op_ry = it.y / op_h; - const float dy = (op_ry - m_data->y) / m_aspectRatio; + const float dy = (op_ry - data_->y) / aspectRatio_; const float op_rx = it.x / op_w; - const float dx = op_rx - m_data->x; - const float rx = m_data->x + (m_cosine * dx + m_sine * dy); - const float ry = m_data->y + (-m_sine * dx + m_cosine * dy); + const float dx = op_rx - data_->x; + const float rx = data_->x + (cosine_ * dx + sine_ * dy); + const float ry = data_->y + (-sine_ * dx + cosine_ * dy); - const bool inside = (rx > m_data->x - half_w && rx < m_data->x + half_w && - ry > m_data->y - half_h && ry < m_data->y + half_h); + const bool inside = (rx > data_->x - half_w && rx < data_->x + half_w && + ry > data_->y - half_h && ry < data_->y + half_h); const float *mask = it.in(0); const float *value = it.in(1); *it.out = mask_func(inside, mask, value); @@ -163,8 +163,8 @@ void BoxMaskOperation::apply_mask(MemoryBuffer *output, void BoxMaskOperation::deinitExecution() { - m_inputMask = nullptr; - m_inputValue = nullptr; + inputMask_ = nullptr; + inputValue_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_BoxMaskOperation.h b/source/blender/compositor/operations/COM_BoxMaskOperation.h index 1f1365897cf..458cdf7ee16 100644 --- a/source/blender/compositor/operations/COM_BoxMaskOperation.h +++ b/source/blender/compositor/operations/COM_BoxMaskOperation.h @@ -29,15 +29,15 @@ class BoxMaskOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputMask; - SocketReader *m_inputValue; + SocketReader *inputMask_; + SocketReader *inputValue_; - float m_sine; - float m_cosine; - float m_aspectRatio; - int m_maskType; + float sine_; + float cosine_; + float aspectRatio_; + int maskType_; - NodeBoxMask *m_data; + NodeBoxMask *data_; public: BoxMaskOperation(); @@ -59,12 +59,12 @@ class BoxMaskOperation : public MultiThreadedOperation { void setData(NodeBoxMask *data) { - m_data = data; + data_ = data; } void setMaskType(int maskType) { - m_maskType = maskType; + maskType_ = maskType; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_BrightnessOperation.cc b/source/blender/compositor/operations/COM_BrightnessOperation.cc index 2f2313d87d8..77f30331767 100644 --- a/source/blender/compositor/operations/COM_BrightnessOperation.cc +++ b/source/blender/compositor/operations/COM_BrightnessOperation.cc @@ -26,21 +26,21 @@ BrightnessOperation::BrightnessOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; - m_use_premultiply = false; + inputProgram_ = nullptr; + use_premultiply_ = false; flags.can_be_constant = true; } void BrightnessOperation::setUsePremultiply(bool use_premultiply) { - m_use_premultiply = use_premultiply; + use_premultiply_ = use_premultiply; } void BrightnessOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); - m_inputBrightnessProgram = this->getInputSocketReader(1); - m_inputContrastProgram = this->getInputSocketReader(2); + inputProgram_ = this->getInputSocketReader(0); + inputBrightnessProgram_ = this->getInputSocketReader(1); + inputContrastProgram_ = this->getInputSocketReader(2); } void BrightnessOperation::executePixelSampled(float output[4], @@ -52,9 +52,9 @@ void BrightnessOperation::executePixelSampled(float output[4], float a, b; float inputBrightness[4]; float inputContrast[4]; - m_inputProgram->readSampled(inputValue, x, y, sampler); - m_inputBrightnessProgram->readSampled(inputBrightness, x, y, sampler); - m_inputContrastProgram->readSampled(inputContrast, x, y, sampler); + inputProgram_->readSampled(inputValue, x, y, sampler); + inputBrightnessProgram_->readSampled(inputBrightness, x, y, sampler); + inputContrastProgram_->readSampled(inputContrast, x, y, sampler); float brightness = inputBrightness[0]; float contrast = inputContrast[0]; brightness /= 100.0f; @@ -74,14 +74,14 @@ void BrightnessOperation::executePixelSampled(float output[4], a = max_ff(1.0f - delta * 2.0f, 0.0f); b = a * brightness + delta; } - if (m_use_premultiply) { + if (use_premultiply_) { premul_to_straight_v4(inputValue); } output[0] = a * inputValue[0] + b; output[1] = a * inputValue[1] + b; output[2] = a * inputValue[2] + b; output[3] = inputValue[3]; - if (m_use_premultiply) { + if (use_premultiply_) { straight_to_premul_v4(output); } } @@ -113,7 +113,7 @@ void BrightnessOperation::update_memory_buffer_partial(MemoryBuffer *output, b = a * brightness + delta; } const float *color; - if (m_use_premultiply) { + if (use_premultiply_) { premul_to_straight_v4_v4(tmp_color, in_color); color = tmp_color; } @@ -124,7 +124,7 @@ void BrightnessOperation::update_memory_buffer_partial(MemoryBuffer *output, it.out[1] = a * color[1] + b; it.out[2] = a * color[2] + b; it.out[3] = color[3]; - if (m_use_premultiply) { + if (use_premultiply_) { straight_to_premul_v4(it.out); } } @@ -132,9 +132,9 @@ void BrightnessOperation::update_memory_buffer_partial(MemoryBuffer *output, void BrightnessOperation::deinitExecution() { - m_inputProgram = nullptr; - m_inputBrightnessProgram = nullptr; - m_inputContrastProgram = nullptr; + inputProgram_ = nullptr; + inputBrightnessProgram_ = nullptr; + inputContrastProgram_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_BrightnessOperation.h b/source/blender/compositor/operations/COM_BrightnessOperation.h index 64b4fa0dbe2..0ecb8473319 100644 --- a/source/blender/compositor/operations/COM_BrightnessOperation.h +++ b/source/blender/compositor/operations/COM_BrightnessOperation.h @@ -27,11 +27,11 @@ class BrightnessOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; - SocketReader *m_inputBrightnessProgram; - SocketReader *m_inputContrastProgram; + SocketReader *inputProgram_; + SocketReader *inputBrightnessProgram_; + SocketReader *inputContrastProgram_; - bool m_use_premultiply; + bool use_premultiply_; public: BrightnessOperation(); diff --git a/source/blender/compositor/operations/COM_CalculateMeanOperation.cc b/source/blender/compositor/operations/COM_CalculateMeanOperation.cc index d8a34332242..ce2351cf759 100644 --- a/source/blender/compositor/operations/COM_CalculateMeanOperation.cc +++ b/source/blender/compositor/operations/COM_CalculateMeanOperation.cc @@ -28,26 +28,26 @@ CalculateMeanOperation::CalculateMeanOperation() { this->addInputSocket(DataType::Color, ResizeMode::Align); this->addOutputSocket(DataType::Value); - m_imageReader = nullptr; - m_iscalculated = false; - m_setting = 1; + imageReader_ = nullptr; + iscalculated_ = false; + setting_ = 1; this->flags.complex = true; } void CalculateMeanOperation::initExecution() { - m_imageReader = this->getInputSocketReader(0); - m_iscalculated = false; + imageReader_ = this->getInputSocketReader(0); + iscalculated_ = false; NodeOperation::initMutex(); } void CalculateMeanOperation::executePixel(float output[4], int /*x*/, int /*y*/, void * /*data*/) { - output[0] = m_result; + output[0] = result_; } void CalculateMeanOperation::deinitExecution() { - m_imageReader = nullptr; + imageReader_ = nullptr; NodeOperation::deinitMutex(); } @@ -56,7 +56,7 @@ bool CalculateMeanOperation::determineDependingAreaOfInterest(rcti * /*input*/, rcti *output) { rcti imageInput; - if (m_iscalculated) { + if (iscalculated_) { return false; } NodeOperation *operation = getInputOperation(0); @@ -73,10 +73,10 @@ bool CalculateMeanOperation::determineDependingAreaOfInterest(rcti * /*input*/, void *CalculateMeanOperation::initializeTileData(rcti *rect) { lockMutex(); - if (!m_iscalculated) { - MemoryBuffer *tile = (MemoryBuffer *)m_imageReader->initializeTileData(rect); + if (!iscalculated_) { + MemoryBuffer *tile = (MemoryBuffer *)imageReader_->initializeTileData(rect); calculateMean(tile); - m_iscalculated = true; + iscalculated_ = true; } unlockMutex(); return nullptr; @@ -84,7 +84,7 @@ void *CalculateMeanOperation::initializeTileData(rcti *rect) void CalculateMeanOperation::calculateMean(MemoryBuffer *tile) { - m_result = 0.0f; + result_ = 0.0f; float *buffer = tile->getBuffer(); int size = tile->getWidth() * tile->getHeight(); int pixels = 0; @@ -93,7 +93,7 @@ void CalculateMeanOperation::calculateMean(MemoryBuffer *tile) if (buffer[offset + 3] > 0) { pixels++; - switch (m_setting) { + switch (setting_) { case 1: { sum += IMB_colormanagement_get_luminance(&buffer[offset]); break; @@ -125,12 +125,12 @@ void CalculateMeanOperation::calculateMean(MemoryBuffer *tile) } } } - m_result = sum / pixels; + result_ = sum / pixels; } void CalculateMeanOperation::setSetting(int setting) { - m_setting = setting; + setting_ = setting; switch (setting) { case 1: { setting_func_ = IMB_colormanagement_get_luminance; @@ -171,10 +171,10 @@ void CalculateMeanOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(o const rcti &UNUSED(area), Span<MemoryBuffer *> inputs) { - if (!m_iscalculated) { + if (!iscalculated_) { MemoryBuffer *input = inputs[0]; - m_result = calc_mean(input); - m_iscalculated = true; + result_ = calc_mean(input); + iscalculated_ = true; } } @@ -182,7 +182,7 @@ void CalculateMeanOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - output->fill(area, &m_result); + output->fill(area, &result_); } float CalculateMeanOperation::calc_mean(const MemoryBuffer *input) diff --git a/source/blender/compositor/operations/COM_CalculateMeanOperation.h b/source/blender/compositor/operations/COM_CalculateMeanOperation.h index 779ca79b38a..a34bab45211 100644 --- a/source/blender/compositor/operations/COM_CalculateMeanOperation.h +++ b/source/blender/compositor/operations/COM_CalculateMeanOperation.h @@ -39,11 +39,11 @@ class CalculateMeanOperation : public MultiThreadedOperation { /** * \brief Cached reference to the reader */ - SocketReader *m_imageReader; + SocketReader *imageReader_; - bool m_iscalculated; - float m_result; - int m_setting; + bool iscalculated_; + float result_; + int setting_; std::function<float(const float *elem)> setting_func_; public: diff --git a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cc b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cc index cda77f0a83b..3c8d7f21801 100644 --- a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cc +++ b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cc @@ -29,26 +29,26 @@ void CalculateStandardDeviationOperation::executePixel(float output[4], int /*y*/, void * /*data*/) { - output[0] = m_standardDeviation; + output[0] = standardDeviation_; } void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect) { lockMutex(); - if (!m_iscalculated) { - MemoryBuffer *tile = (MemoryBuffer *)m_imageReader->initializeTileData(rect); + if (!iscalculated_) { + MemoryBuffer *tile = (MemoryBuffer *)imageReader_->initializeTileData(rect); CalculateMeanOperation::calculateMean(tile); - m_standardDeviation = 0.0f; + standardDeviation_ = 0.0f; float *buffer = tile->getBuffer(); int size = tile->getWidth() * tile->getHeight(); int pixels = 0; float sum = 0.0f; - float mean = m_result; + float mean = result_; for (int i = 0, offset = 0; i < size; i++, offset += 4) { if (buffer[offset + 3] > 0) { pixels++; - switch (m_setting) { + switch (setting_) { case 1: /* rgb combined */ { float value = IMB_colormanagement_get_luminance(&buffer[offset]); @@ -89,8 +89,8 @@ void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect) } } } - m_standardDeviation = sqrt(sum / (float)(pixels - 1)); - m_iscalculated = true; + standardDeviation_ = sqrt(sum / (float)(pixels - 1)); + iscalculated_ = true; } unlockMutex(); return nullptr; @@ -99,7 +99,7 @@ void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect) void CalculateStandardDeviationOperation::update_memory_buffer_started( MemoryBuffer *UNUSED(output), const rcti &UNUSED(area), Span<MemoryBuffer *> inputs) { - if (!m_iscalculated) { + if (!iscalculated_) { const MemoryBuffer *input = inputs[0]; const float mean = CalculateMeanOperation::calc_mean(input); @@ -112,16 +112,16 @@ void CalculateStandardDeviationOperation::update_memory_buffer_started( join.sum += chunk.sum; join.num_pixels += chunk.num_pixels; }); - m_standardDeviation = total.num_pixels <= 1 ? 0.0f : - sqrt(total.sum / (float)(total.num_pixels - 1)); - m_iscalculated = true; + standardDeviation_ = total.num_pixels <= 1 ? 0.0f : + sqrt(total.sum / (float)(total.num_pixels - 1)); + iscalculated_ = true; } } void CalculateStandardDeviationOperation::update_memory_buffer_partial( MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - output->fill(area, &m_standardDeviation); + output->fill(area, &standardDeviation_); } using PixelsSum = CalculateMeanOperation::PixelsSum; diff --git a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h index 20de4cf4701..29d9c45c986 100644 --- a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h +++ b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h @@ -31,7 +31,7 @@ namespace blender::compositor { */ class CalculateStandardDeviationOperation : public CalculateMeanOperation { protected: - float m_standardDeviation; + float standardDeviation_; public: /** diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.cc b/source/blender/compositor/operations/COM_ChangeHSVOperation.cc index 794574e95ca..7e240a0b95a 100644 --- a/source/blender/compositor/operations/COM_ChangeHSVOperation.cc +++ b/source/blender/compositor/operations/COM_ChangeHSVOperation.cc @@ -27,24 +27,24 @@ ChangeHSVOperation::ChangeHSVOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputOperation = nullptr; + inputOperation_ = nullptr; this->flags.can_be_constant = true; } void ChangeHSVOperation::initExecution() { - m_inputOperation = getInputSocketReader(0); - m_hueOperation = getInputSocketReader(1); - m_saturationOperation = getInputSocketReader(2); - m_valueOperation = getInputSocketReader(3); + inputOperation_ = getInputSocketReader(0); + hueOperation_ = getInputSocketReader(1); + saturationOperation_ = getInputSocketReader(2); + valueOperation_ = getInputSocketReader(3); } void ChangeHSVOperation::deinitExecution() { - m_inputOperation = nullptr; - m_hueOperation = nullptr; - m_saturationOperation = nullptr; - m_valueOperation = nullptr; + inputOperation_ = nullptr; + hueOperation_ = nullptr; + saturationOperation_ = nullptr; + valueOperation_ = nullptr; } void ChangeHSVOperation::executePixelSampled(float output[4], @@ -55,10 +55,10 @@ void ChangeHSVOperation::executePixelSampled(float output[4], float inputColor1[4]; float hue[4], saturation[4], value[4]; - m_inputOperation->readSampled(inputColor1, x, y, sampler); - m_hueOperation->readSampled(hue, x, y, sampler); - m_saturationOperation->readSampled(saturation, x, y, sampler); - m_valueOperation->readSampled(value, x, y, sampler); + inputOperation_->readSampled(inputColor1, x, y, sampler); + hueOperation_->readSampled(hue, x, y, sampler); + saturationOperation_->readSampled(saturation, x, y, sampler); + valueOperation_->readSampled(value, x, y, sampler); output[0] = inputColor1[0] + (hue[0] - 0.5f); if (output[0] > 1.0f) { diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.h b/source/blender/compositor/operations/COM_ChangeHSVOperation.h index e7bc3274f25..4b810a93816 100644 --- a/source/blender/compositor/operations/COM_ChangeHSVOperation.h +++ b/source/blender/compositor/operations/COM_ChangeHSVOperation.h @@ -28,10 +28,10 @@ namespace blender::compositor { */ class ChangeHSVOperation : public MultiThreadedOperation { private: - SocketReader *m_inputOperation; - SocketReader *m_hueOperation; - SocketReader *m_saturationOperation; - SocketReader *m_valueOperation; + SocketReader *inputOperation_; + SocketReader *hueOperation_; + SocketReader *saturationOperation_; + SocketReader *valueOperation_; public: /** diff --git a/source/blender/compositor/operations/COM_ChannelMatteOperation.cc b/source/blender/compositor/operations/COM_ChannelMatteOperation.cc index f3664c7e2de..cbc6d078ac1 100644 --- a/source/blender/compositor/operations/COM_ChannelMatteOperation.cc +++ b/source/blender/compositor/operations/COM_ChannelMatteOperation.cc @@ -25,46 +25,46 @@ ChannelMatteOperation::ChannelMatteOperation() addInputSocket(DataType::Color); addOutputSocket(DataType::Value); - m_inputImageProgram = nullptr; + inputImageProgram_ = nullptr; flags.can_be_constant = true; } void ChannelMatteOperation::initExecution() { - m_inputImageProgram = this->getInputSocketReader(0); + inputImageProgram_ = this->getInputSocketReader(0); - m_limit_range = m_limit_max - m_limit_min; + limit_range_ = limit_max_ - limit_min_; - switch (m_limit_method) { + switch (limit_method_) { /* SINGLE */ case 0: { /* 123 / RGB / HSV / YUV / YCC */ - const int matte_channel = m_matte_channel - 1; - const int limit_channel = m_limit_channel - 1; - m_ids[0] = matte_channel; - m_ids[1] = limit_channel; - m_ids[2] = limit_channel; + const int matte_channel = matte_channel_ - 1; + const int limit_channel = limit_channel_ - 1; + ids_[0] = matte_channel; + ids_[1] = limit_channel; + ids_[2] = limit_channel; break; } /* MAX */ case 1: { - switch (m_matte_channel) { + switch (matte_channel_) { case 1: { - m_ids[0] = 0; - m_ids[1] = 1; - m_ids[2] = 2; + ids_[0] = 0; + ids_[1] = 1; + ids_[2] = 2; break; } case 2: { - m_ids[0] = 1; - m_ids[1] = 0; - m_ids[2] = 2; + ids_[0] = 1; + ids_[1] = 0; + ids_[2] = 2; break; } case 3: { - m_ids[0] = 2; - m_ids[1] = 0; - m_ids[2] = 1; + ids_[0] = 2; + ids_[1] = 0; + ids_[2] = 1; break; } default: @@ -79,7 +79,7 @@ void ChannelMatteOperation::initExecution() void ChannelMatteOperation::deinitExecution() { - m_inputImageProgram = nullptr; + inputImageProgram_ = nullptr; } void ChannelMatteOperation::executePixelSampled(float output[4], @@ -90,14 +90,14 @@ void ChannelMatteOperation::executePixelSampled(float output[4], float inColor[4]; float alpha; - const float limit_max = m_limit_max; - const float limit_min = m_limit_min; - const float limit_range = m_limit_range; + const float limit_max = limit_max_; + const float limit_min = limit_min_; + const float limit_range = limit_range_; - m_inputImageProgram->readSampled(inColor, x, y, sampler); + inputImageProgram_->readSampled(inColor, x, y, sampler); /* matte operation */ - alpha = inColor[m_ids[0]] - MAX2(inColor[m_ids[1]], inColor[m_ids[2]]); + alpha = inColor[ids_[0]] - MAX2(inColor[ids_[1]], inColor[ids_[2]]); /* flip because 0.0 is transparent, not 1.0 */ alpha = 1.0f - alpha; @@ -129,20 +129,20 @@ void ChannelMatteOperation::update_memory_buffer_partial(MemoryBuffer *output, const float *color = it.in(0); /* Matte operation. */ - float alpha = color[m_ids[0]] - MAX2(color[m_ids[1]], color[m_ids[2]]); + float alpha = color[ids_[0]] - MAX2(color[ids_[1]], color[ids_[2]]); /* Flip because 0.0 is transparent, not 1.0. */ alpha = 1.0f - alpha; /* Test range. */ - if (alpha > m_limit_max) { + if (alpha > limit_max_) { alpha = color[3]; /* Whatever it was prior. */ } - else if (alpha < m_limit_min) { + else if (alpha < limit_min_) { alpha = 0.0f; } else { /* Blend. */ - alpha = (alpha - m_limit_min) / m_limit_range; + alpha = (alpha - limit_min_) / limit_range_; } /* Store matte(alpha) value in [0] to go with diff --git a/source/blender/compositor/operations/COM_ChannelMatteOperation.h b/source/blender/compositor/operations/COM_ChannelMatteOperation.h index 83f187ae443..f7bf58b99c5 100644 --- a/source/blender/compositor/operations/COM_ChannelMatteOperation.h +++ b/source/blender/compositor/operations/COM_ChannelMatteOperation.h @@ -28,16 +28,16 @@ namespace blender::compositor { */ class ChannelMatteOperation : public MultiThreadedOperation { private: - SocketReader *m_inputImageProgram; + SocketReader *inputImageProgram_; - /* int m_color_space; */ /* node->custom1 */ /* UNUSED */ /* TODO ? */ - int m_matte_channel; /* node->custom2 */ - int m_limit_method; /* node->algorithm */ - int m_limit_channel; /* node->channel */ - float m_limit_max; /* node->storage->t1 */ - float m_limit_min; /* node->storage->t2 */ + /* int color_space_; */ /* node->custom1 */ /* UNUSED */ /* TODO ? */ + int matte_channel_; /* node->custom2 */ + int limit_method_; /* node->algorithm */ + int limit_channel_; /* node->channel */ + float limit_max_; /* node->storage->t1 */ + float limit_min_; /* node->storage->t2 */ - float m_limit_range; + float limit_range_; /** ids to use for the operations (max and simple) * alpha = in[ids[0]] - MAX2(in[ids[1]], in[ids[2]]) @@ -47,7 +47,7 @@ class ChannelMatteOperation : public MultiThreadedOperation { * ids[2] = ids[1] * alpha = in[ids[0]] - MAX2(in[ids[1]], in[ids[2]]) */ - int m_ids[3]; + int ids_[3]; public: /** @@ -65,11 +65,11 @@ class ChannelMatteOperation : public MultiThreadedOperation { void setSettings(NodeChroma *nodeChroma, const int custom2) { - m_limit_max = nodeChroma->t1; - m_limit_min = nodeChroma->t2; - m_limit_method = nodeChroma->algorithm; - m_limit_channel = nodeChroma->channel; - m_matte_channel = custom2; + limit_max_ = nodeChroma->t1; + limit_min_ = nodeChroma->t2; + limit_method_ = nodeChroma->algorithm; + limit_channel_ = nodeChroma->channel; + matte_channel_ = custom2; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ChromaMatteOperation.cc b/source/blender/compositor/operations/COM_ChromaMatteOperation.cc index 7b2f3470efe..172460e9203 100644 --- a/source/blender/compositor/operations/COM_ChromaMatteOperation.cc +++ b/source/blender/compositor/operations/COM_ChromaMatteOperation.cc @@ -26,21 +26,21 @@ ChromaMatteOperation::ChromaMatteOperation() addInputSocket(DataType::Color); addOutputSocket(DataType::Value); - m_inputImageProgram = nullptr; - m_inputKeyProgram = nullptr; + inputImageProgram_ = nullptr; + inputKeyProgram_ = nullptr; flags.can_be_constant = true; } void ChromaMatteOperation::initExecution() { - m_inputImageProgram = this->getInputSocketReader(0); - m_inputKeyProgram = this->getInputSocketReader(1); + inputImageProgram_ = this->getInputSocketReader(0); + inputKeyProgram_ = this->getInputSocketReader(1); } void ChromaMatteOperation::deinitExecution() { - m_inputImageProgram = nullptr; - m_inputKeyProgram = nullptr; + inputImageProgram_ = nullptr; + inputKeyProgram_ = nullptr; } void ChromaMatteOperation::executePixelSampled(float output[4], @@ -51,16 +51,16 @@ void ChromaMatteOperation::executePixelSampled(float output[4], float inKey[4]; float inImage[4]; - const float acceptance = m_settings->t1; /* in radians */ - const float cutoff = m_settings->t2; /* in radians */ - const float gain = m_settings->fstrength; + const float acceptance = settings_->t1; /* in radians */ + const float cutoff = settings_->t2; /* in radians */ + const float gain = settings_->fstrength; float x_angle, z_angle, alpha; float theta, beta; float kfg; - m_inputKeyProgram->readSampled(inKey, x, y, sampler); - m_inputImageProgram->readSampled(inImage, x, y, sampler); + inputKeyProgram_->readSampled(inKey, x, y, sampler); + inputImageProgram_->readSampled(inImage, x, y, sampler); /* Store matte(alpha) value in [0] to go with * #COM_SetAlphaMultiplyOperation and the Value output. */ @@ -114,9 +114,9 @@ void ChromaMatteOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - const float acceptance = m_settings->t1; /* In radians. */ - const float cutoff = m_settings->t2; /* In radians. */ - const float gain = m_settings->fstrength; + const float acceptance = settings_->t1; /* In radians. */ + const float cutoff = settings_->t2; /* In radians. */ + const float gain = settings_->fstrength; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const float *in_image = it.in(0); const float *in_key = it.in(1); diff --git a/source/blender/compositor/operations/COM_ChromaMatteOperation.h b/source/blender/compositor/operations/COM_ChromaMatteOperation.h index 182d0baba76..913d0f27107 100644 --- a/source/blender/compositor/operations/COM_ChromaMatteOperation.h +++ b/source/blender/compositor/operations/COM_ChromaMatteOperation.h @@ -28,9 +28,9 @@ namespace blender::compositor { */ class ChromaMatteOperation : public MultiThreadedOperation { private: - NodeChroma *m_settings; - SocketReader *m_inputImageProgram; - SocketReader *m_inputKeyProgram; + NodeChroma *settings_; + SocketReader *inputImageProgram_; + SocketReader *inputKeyProgram_; public: /** @@ -48,7 +48,7 @@ class ChromaMatteOperation : public MultiThreadedOperation { void setSettings(NodeChroma *nodeChroma) { - m_settings = nodeChroma; + settings_ = nodeChroma; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cc b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cc index d4118503341..b6253c07f12 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cc +++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cc @@ -37,16 +37,16 @@ ColorBalanceASCCDLOperation::ColorBalanceASCCDLOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputValueOperation = nullptr; - m_inputColorOperation = nullptr; + inputValueOperation_ = nullptr; + inputColorOperation_ = nullptr; this->set_canvas_input_index(1); flags.can_be_constant = true; } void ColorBalanceASCCDLOperation::initExecution() { - m_inputValueOperation = this->getInputSocketReader(0); - m_inputColorOperation = this->getInputSocketReader(1); + inputValueOperation_ = this->getInputSocketReader(0); + inputColorOperation_ = this->getInputSocketReader(1); } void ColorBalanceASCCDLOperation::executePixelSampled(float output[4], @@ -57,19 +57,19 @@ void ColorBalanceASCCDLOperation::executePixelSampled(float output[4], float inputColor[4]; float value[4]; - m_inputValueOperation->readSampled(value, x, y, sampler); - m_inputColorOperation->readSampled(inputColor, x, y, sampler); + inputValueOperation_->readSampled(value, x, y, sampler); + inputColorOperation_->readSampled(inputColor, x, y, sampler); float fac = value[0]; fac = MIN2(1.0f, fac); const float mfac = 1.0f - fac; output[0] = mfac * inputColor[0] + - fac * colorbalance_cdl(inputColor[0], m_offset[0], m_power[0], m_slope[0]); + fac * colorbalance_cdl(inputColor[0], offset_[0], power_[0], slope_[0]); output[1] = mfac * inputColor[1] + - fac * colorbalance_cdl(inputColor[1], m_offset[1], m_power[1], m_slope[1]); + fac * colorbalance_cdl(inputColor[1], offset_[1], power_[1], slope_[1]); output[2] = mfac * inputColor[2] + - fac * colorbalance_cdl(inputColor[2], m_offset[2], m_power[2], m_slope[2]); + fac * colorbalance_cdl(inputColor[2], offset_[2], power_[2], slope_[2]); output[3] = inputColor[3]; } @@ -81,19 +81,19 @@ void ColorBalanceASCCDLOperation::update_memory_buffer_row(PixelCursor &p) const float fac = MIN2(1.0f, in_factor[0]); const float fac_m = 1.0f - fac; p.out[0] = fac_m * in_color[0] + - fac * colorbalance_cdl(in_color[0], m_offset[0], m_power[0], m_slope[0]); + fac * colorbalance_cdl(in_color[0], offset_[0], power_[0], slope_[0]); p.out[1] = fac_m * in_color[1] + - fac * colorbalance_cdl(in_color[1], m_offset[1], m_power[1], m_slope[1]); + fac * colorbalance_cdl(in_color[1], offset_[1], power_[1], slope_[1]); p.out[2] = fac_m * in_color[2] + - fac * colorbalance_cdl(in_color[2], m_offset[2], m_power[2], m_slope[2]); + fac * colorbalance_cdl(in_color[2], offset_[2], power_[2], slope_[2]); p.out[3] = in_color[3]; } } void ColorBalanceASCCDLOperation::deinitExecution() { - m_inputValueOperation = nullptr; - m_inputColorOperation = nullptr; + inputValueOperation_ = nullptr; + inputColorOperation_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h index b9b3d45a68b..79c5cc1a047 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h +++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h @@ -31,12 +31,12 @@ class ColorBalanceASCCDLOperation : public MultiThreadedRowOperation { /** * Prefetched reference to the inputProgram */ - SocketReader *m_inputValueOperation; - SocketReader *m_inputColorOperation; + SocketReader *inputValueOperation_; + SocketReader *inputColorOperation_; - float m_offset[3]; - float m_power[3]; - float m_slope[3]; + float offset_[3]; + float power_[3]; + float slope_[3]; public: /** @@ -61,15 +61,15 @@ class ColorBalanceASCCDLOperation : public MultiThreadedRowOperation { void setOffset(float offset[3]) { - copy_v3_v3(m_offset, offset); + copy_v3_v3(offset_, offset); } void setPower(float power[3]) { - copy_v3_v3(m_power, power); + copy_v3_v3(power_, power); } void setSlope(float slope[3]) { - copy_v3_v3(m_slope, slope); + copy_v3_v3(slope_, slope); } void update_memory_buffer_row(PixelCursor &p) override; diff --git a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cc b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cc index b6059d70b70..d7c7368a214 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cc +++ b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cc @@ -42,16 +42,16 @@ ColorBalanceLGGOperation::ColorBalanceLGGOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputValueOperation = nullptr; - m_inputColorOperation = nullptr; + inputValueOperation_ = nullptr; + inputColorOperation_ = nullptr; this->set_canvas_input_index(1); flags.can_be_constant = true; } void ColorBalanceLGGOperation::initExecution() { - m_inputValueOperation = this->getInputSocketReader(0); - m_inputColorOperation = this->getInputSocketReader(1); + inputValueOperation_ = this->getInputSocketReader(0); + inputColorOperation_ = this->getInputSocketReader(1); } void ColorBalanceLGGOperation::executePixelSampled(float output[4], @@ -62,19 +62,19 @@ void ColorBalanceLGGOperation::executePixelSampled(float output[4], float inputColor[4]; float value[4]; - m_inputValueOperation->readSampled(value, x, y, sampler); - m_inputColorOperation->readSampled(inputColor, x, y, sampler); + inputValueOperation_->readSampled(value, x, y, sampler); + inputColorOperation_->readSampled(inputColor, x, y, sampler); float fac = value[0]; fac = MIN2(1.0f, fac); const float mfac = 1.0f - fac; output[0] = mfac * inputColor[0] + - fac * colorbalance_lgg(inputColor[0], m_lift[0], m_gamma_inv[0], m_gain[0]); + fac * colorbalance_lgg(inputColor[0], lift_[0], gamma_inv_[0], gain_[0]); output[1] = mfac * inputColor[1] + - fac * colorbalance_lgg(inputColor[1], m_lift[1], m_gamma_inv[1], m_gain[1]); + fac * colorbalance_lgg(inputColor[1], lift_[1], gamma_inv_[1], gain_[1]); output[2] = mfac * inputColor[2] + - fac * colorbalance_lgg(inputColor[2], m_lift[2], m_gamma_inv[2], m_gain[2]); + fac * colorbalance_lgg(inputColor[2], lift_[2], gamma_inv_[2], gain_[2]); output[3] = inputColor[3]; } @@ -86,19 +86,19 @@ void ColorBalanceLGGOperation::update_memory_buffer_row(PixelCursor &p) const float fac = MIN2(1.0f, in_factor[0]); const float fac_m = 1.0f - fac; p.out[0] = fac_m * in_color[0] + - fac * colorbalance_lgg(in_color[0], m_lift[0], m_gamma_inv[0], m_gain[0]); + fac * colorbalance_lgg(in_color[0], lift_[0], gamma_inv_[0], gain_[0]); p.out[1] = fac_m * in_color[1] + - fac * colorbalance_lgg(in_color[1], m_lift[1], m_gamma_inv[1], m_gain[1]); + fac * colorbalance_lgg(in_color[1], lift_[1], gamma_inv_[1], gain_[1]); p.out[2] = fac_m * in_color[2] + - fac * colorbalance_lgg(in_color[2], m_lift[2], m_gamma_inv[2], m_gain[2]); + fac * colorbalance_lgg(in_color[2], lift_[2], gamma_inv_[2], gain_[2]); p.out[3] = in_color[3]; } } void ColorBalanceLGGOperation::deinitExecution() { - m_inputValueOperation = nullptr; - m_inputColorOperation = nullptr; + inputValueOperation_ = nullptr; + inputColorOperation_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h index 0a447f50514..9393f635f9e 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h +++ b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h @@ -31,12 +31,12 @@ class ColorBalanceLGGOperation : public MultiThreadedRowOperation { /** * Prefetched reference to the inputProgram */ - SocketReader *m_inputValueOperation; - SocketReader *m_inputColorOperation; + SocketReader *inputValueOperation_; + SocketReader *inputColorOperation_; - float m_gain[3]; - float m_lift[3]; - float m_gamma_inv[3]; + float gain_[3]; + float lift_[3]; + float gamma_inv_[3]; public: /** @@ -61,15 +61,15 @@ class ColorBalanceLGGOperation : public MultiThreadedRowOperation { void setGain(const float gain[3]) { - copy_v3_v3(m_gain, gain); + copy_v3_v3(gain_, gain); } void setLift(const float lift[3]) { - copy_v3_v3(m_lift, lift); + copy_v3_v3(lift_, lift); } void setGammaInv(const float gamma_inv[3]) { - copy_v3_v3(m_gamma_inv, gamma_inv); + copy_v3_v3(gamma_inv_, gamma_inv); } void update_memory_buffer_row(PixelCursor &p) override; diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cc b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cc index 9cbe9a16ade..128c7c80ea9 100644 --- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cc +++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cc @@ -27,17 +27,17 @@ ColorCorrectionOperation::ColorCorrectionOperation() this->addInputSocket(DataType::Color); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputImage = nullptr; - m_inputMask = nullptr; - m_redChannelEnabled = true; - m_greenChannelEnabled = true; - m_blueChannelEnabled = true; + inputImage_ = nullptr; + inputMask_ = nullptr; + redChannelEnabled_ = true; + greenChannelEnabled_ = true; + blueChannelEnabled_ = true; flags.can_be_constant = true; } void ColorCorrectionOperation::initExecution() { - m_inputImage = this->getInputSocketReader(0); - m_inputMask = this->getInputSocketReader(1); + inputImage_ = this->getInputSocketReader(0); + inputMask_ = this->getInputSocketReader(1); } /* Calculate x^y if the function is defined. Otherwise return the given fallback value. */ @@ -56,15 +56,15 @@ void ColorCorrectionOperation::executePixelSampled(float output[4], { float inputImageColor[4]; float inputMask[4]; - m_inputImage->readSampled(inputImageColor, x, y, sampler); - m_inputMask->readSampled(inputMask, x, y, sampler); + inputImage_->readSampled(inputImageColor, x, y, sampler); + inputMask_->readSampled(inputMask, x, y, sampler); float level = (inputImageColor[0] + inputImageColor[1] + inputImageColor[2]) / 3.0f; - float contrast = m_data->master.contrast; - float saturation = m_data->master.saturation; - float gamma = m_data->master.gamma; - float gain = m_data->master.gain; - float lift = m_data->master.lift; + float contrast = data_->master.contrast; + float saturation = data_->master.saturation; + float gamma = data_->master.gamma; + float gain = data_->master.gain; + float lift = data_->master.lift; float r, g, b; float value = inputMask[0]; @@ -76,18 +76,18 @@ void ColorCorrectionOperation::executePixelSampled(float output[4], float levelHighlights = 0.0; #define MARGIN 0.10f #define MARGIN_DIV (0.5f / MARGIN) - if (level < m_data->startmidtones - MARGIN) { + if (level < data_->startmidtones - MARGIN) { levelShadows = 1.0f; } - else if (level < m_data->startmidtones + MARGIN) { - levelMidtones = ((level - m_data->startmidtones) * MARGIN_DIV) + 0.5f; + else if (level < data_->startmidtones + MARGIN) { + levelMidtones = ((level - data_->startmidtones) * MARGIN_DIV) + 0.5f; levelShadows = 1.0f - levelMidtones; } - else if (level < m_data->endmidtones - MARGIN) { + else if (level < data_->endmidtones - MARGIN) { levelMidtones = 1.0f; } - else if (level < m_data->endmidtones + MARGIN) { - levelHighlights = ((level - m_data->endmidtones) * MARGIN_DIV) + 0.5f; + else if (level < data_->endmidtones + MARGIN) { + levelHighlights = ((level - data_->endmidtones) * MARGIN_DIV) + 0.5f; levelMidtones = 1.0f - levelHighlights; } else { @@ -95,18 +95,18 @@ void ColorCorrectionOperation::executePixelSampled(float output[4], } #undef MARGIN #undef MARGIN_DIV - contrast *= (levelShadows * m_data->shadows.contrast) + - (levelMidtones * m_data->midtones.contrast) + - (levelHighlights * m_data->highlights.contrast); - saturation *= (levelShadows * m_data->shadows.saturation) + - (levelMidtones * m_data->midtones.saturation) + - (levelHighlights * m_data->highlights.saturation); - gamma *= (levelShadows * m_data->shadows.gamma) + (levelMidtones * m_data->midtones.gamma) + - (levelHighlights * m_data->highlights.gamma); - gain *= (levelShadows * m_data->shadows.gain) + (levelMidtones * m_data->midtones.gain) + - (levelHighlights * m_data->highlights.gain); - lift += (levelShadows * m_data->shadows.lift) + (levelMidtones * m_data->midtones.lift) + - (levelHighlights * m_data->highlights.lift); + contrast *= (levelShadows * data_->shadows.contrast) + + (levelMidtones * data_->midtones.contrast) + + (levelHighlights * data_->highlights.contrast); + saturation *= (levelShadows * data_->shadows.saturation) + + (levelMidtones * data_->midtones.saturation) + + (levelHighlights * data_->highlights.saturation); + gamma *= (levelShadows * data_->shadows.gamma) + (levelMidtones * data_->midtones.gamma) + + (levelHighlights * data_->highlights.gamma); + gain *= (levelShadows * data_->shadows.gain) + (levelMidtones * data_->midtones.gain) + + (levelHighlights * data_->highlights.gain); + lift += (levelShadows * data_->shadows.lift) + (levelMidtones * data_->midtones.lift) + + (levelHighlights * data_->highlights.lift); float invgamma = 1.0f / gamma; float luma = IMB_colormanagement_get_luminance(inputImageColor); @@ -133,19 +133,19 @@ void ColorCorrectionOperation::executePixelSampled(float output[4], g = mvalue * inputImageColor[1] + value * g; b = mvalue * inputImageColor[2] + value * b; - if (m_redChannelEnabled) { + if (redChannelEnabled_) { output[0] = r; } else { output[0] = inputImageColor[0]; } - if (m_greenChannelEnabled) { + if (greenChannelEnabled_) { output[1] = g; } else { output[1] = inputImageColor[1]; } - if (m_blueChannelEnabled) { + if (blueChannelEnabled_) { output[2] = b; } else { @@ -166,40 +166,40 @@ void ColorCorrectionOperation::update_memory_buffer_row(PixelCursor &p) float level_highlights = 0.0f; constexpr float MARGIN = 0.10f; constexpr float MARGIN_DIV = 0.5f / MARGIN; - if (level < m_data->startmidtones - MARGIN) { + if (level < data_->startmidtones - MARGIN) { level_shadows = 1.0f; } - else if (level < m_data->startmidtones + MARGIN) { - level_midtones = ((level - m_data->startmidtones) * MARGIN_DIV) + 0.5f; + else if (level < data_->startmidtones + MARGIN) { + level_midtones = ((level - data_->startmidtones) * MARGIN_DIV) + 0.5f; level_shadows = 1.0f - level_midtones; } - else if (level < m_data->endmidtones - MARGIN) { + else if (level < data_->endmidtones - MARGIN) { level_midtones = 1.0f; } - else if (level < m_data->endmidtones + MARGIN) { - level_highlights = ((level - m_data->endmidtones) * MARGIN_DIV) + 0.5f; + else if (level < data_->endmidtones + MARGIN) { + level_highlights = ((level - data_->endmidtones) * MARGIN_DIV) + 0.5f; level_midtones = 1.0f - level_highlights; } else { level_highlights = 1.0f; } - float contrast = m_data->master.contrast; - float saturation = m_data->master.saturation; - float gamma = m_data->master.gamma; - float gain = m_data->master.gain; - float lift = m_data->master.lift; - contrast *= level_shadows * m_data->shadows.contrast + - level_midtones * m_data->midtones.contrast + - level_highlights * m_data->highlights.contrast; - saturation *= level_shadows * m_data->shadows.saturation + - level_midtones * m_data->midtones.saturation + - level_highlights * m_data->highlights.saturation; - gamma *= level_shadows * m_data->shadows.gamma + level_midtones * m_data->midtones.gamma + - level_highlights * m_data->highlights.gamma; - gain *= level_shadows * m_data->shadows.gain + level_midtones * m_data->midtones.gain + - level_highlights * m_data->highlights.gain; - lift += level_shadows * m_data->shadows.lift + level_midtones * m_data->midtones.lift + - level_highlights * m_data->highlights.lift; + float contrast = data_->master.contrast; + float saturation = data_->master.saturation; + float gamma = data_->master.gamma; + float gain = data_->master.gain; + float lift = data_->master.lift; + contrast *= level_shadows * data_->shadows.contrast + + level_midtones * data_->midtones.contrast + + level_highlights * data_->highlights.contrast; + saturation *= level_shadows * data_->shadows.saturation + + level_midtones * data_->midtones.saturation + + level_highlights * data_->highlights.saturation; + gamma *= level_shadows * data_->shadows.gamma + level_midtones * data_->midtones.gamma + + level_highlights * data_->highlights.gamma; + gain *= level_shadows * data_->shadows.gain + level_midtones * data_->midtones.gain + + level_highlights * data_->highlights.gain; + lift += level_shadows * data_->shadows.lift + level_midtones * data_->midtones.lift + + level_highlights * data_->highlights.lift; const float inv_gamma = 1.0f / gamma; const float luma = IMB_colormanagement_get_luminance(in_color); @@ -219,22 +219,22 @@ void ColorCorrectionOperation::update_memory_buffer_row(PixelCursor &p) /* Mix with mask. */ const float value = MIN2(1.0f, in_mask[0]); - const float m_value = 1.0f - value; - r = m_value * in_color[0] + value * r; - g = m_value * in_color[1] + value * g; - b = m_value * in_color[2] + value * b; - - p.out[0] = m_redChannelEnabled ? r : in_color[0]; - p.out[1] = m_greenChannelEnabled ? g : in_color[1]; - p.out[2] = m_blueChannelEnabled ? b : in_color[2]; + const float value_ = 1.0f - value; + r = value_ * in_color[0] + value * r; + g = value_ * in_color[1] + value * g; + b = value_ * in_color[2] + value * b; + + p.out[0] = redChannelEnabled_ ? r : in_color[0]; + p.out[1] = greenChannelEnabled_ ? g : in_color[1]; + p.out[2] = blueChannelEnabled_ ? b : in_color[2]; p.out[3] = in_color[3]; } } void ColorCorrectionOperation::deinitExecution() { - m_inputImage = nullptr; - m_inputMask = nullptr; + inputImage_ = nullptr; + inputMask_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.h b/source/blender/compositor/operations/COM_ColorCorrectionOperation.h index 64af049e48c..157babd299b 100644 --- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.h +++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.h @@ -27,13 +27,13 @@ class ColorCorrectionOperation : public MultiThreadedRowOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputImage; - SocketReader *m_inputMask; - NodeColorCorrection *m_data; + SocketReader *inputImage_; + SocketReader *inputMask_; + NodeColorCorrection *data_; - bool m_redChannelEnabled; - bool m_greenChannelEnabled; - bool m_blueChannelEnabled; + bool redChannelEnabled_; + bool greenChannelEnabled_; + bool blueChannelEnabled_; public: ColorCorrectionOperation(); @@ -55,19 +55,19 @@ class ColorCorrectionOperation : public MultiThreadedRowOperation { void setData(NodeColorCorrection *data) { - m_data = data; + data_ = data; } void setRedChannelEnabled(bool enabled) { - m_redChannelEnabled = enabled; + redChannelEnabled_ = enabled; } void setGreenChannelEnabled(bool enabled) { - m_greenChannelEnabled = enabled; + greenChannelEnabled_ = enabled; } void setBlueChannelEnabled(bool enabled) { - m_blueChannelEnabled = enabled; + blueChannelEnabled_ = enabled; } void update_memory_buffer_row(PixelCursor &p) override; diff --git a/source/blender/compositor/operations/COM_ColorCurveOperation.cc b/source/blender/compositor/operations/COM_ColorCurveOperation.cc index c103a3fc651..b88989ad224 100644 --- a/source/blender/compositor/operations/COM_ColorCurveOperation.cc +++ b/source/blender/compositor/operations/COM_ColorCurveOperation.cc @@ -30,22 +30,22 @@ ColorCurveOperation::ColorCurveOperation() this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputFacProgram = nullptr; - m_inputImageProgram = nullptr; - m_inputBlackProgram = nullptr; - m_inputWhiteProgram = nullptr; + inputFacProgram_ = nullptr; + inputImageProgram_ = nullptr; + inputBlackProgram_ = nullptr; + inputWhiteProgram_ = nullptr; this->set_canvas_input_index(1); } void ColorCurveOperation::initExecution() { CurveBaseOperation::initExecution(); - m_inputFacProgram = this->getInputSocketReader(0); - m_inputImageProgram = this->getInputSocketReader(1); - m_inputBlackProgram = this->getInputSocketReader(2); - m_inputWhiteProgram = this->getInputSocketReader(3); + inputFacProgram_ = this->getInputSocketReader(0); + inputImageProgram_ = this->getInputSocketReader(1); + inputBlackProgram_ = this->getInputSocketReader(2); + inputWhiteProgram_ = this->getInputSocketReader(3); - BKE_curvemapping_premultiply(m_curveMapping, 0); + BKE_curvemapping_premultiply(curveMapping_, 0); } void ColorCurveOperation::executePixelSampled(float output[4], @@ -53,7 +53,7 @@ void ColorCurveOperation::executePixelSampled(float output[4], float y, PixelSampler sampler) { - CurveMapping *cumap = m_curveMapping; + CurveMapping *cumap = curveMapping_; float fac[4]; float image[4]; @@ -63,15 +63,15 @@ void ColorCurveOperation::executePixelSampled(float output[4], float white[4]; float bwmul[3]; - m_inputBlackProgram->readSampled(black, x, y, sampler); - m_inputWhiteProgram->readSampled(white, x, y, sampler); + inputBlackProgram_->readSampled(black, x, y, sampler); + inputWhiteProgram_->readSampled(white, x, y, sampler); /* get our own local bwmul value, * since we can't be threadsafe and use cumap->bwmul & friends */ BKE_curvemapping_set_black_white_ex(black, white, bwmul); - m_inputFacProgram->readSampled(fac, x, y, sampler); - m_inputImageProgram->readSampled(image, x, y, sampler); + inputFacProgram_->readSampled(fac, x, y, sampler); + inputImageProgram_->readSampled(image, x, y, sampler); if (*fac >= 1.0f) { BKE_curvemapping_evaluate_premulRGBF_ex(cumap, output, image, black, bwmul); @@ -90,17 +90,17 @@ void ColorCurveOperation::executePixelSampled(float output[4], void ColorCurveOperation::deinitExecution() { CurveBaseOperation::deinitExecution(); - m_inputFacProgram = nullptr; - m_inputImageProgram = nullptr; - m_inputBlackProgram = nullptr; - m_inputWhiteProgram = nullptr; + inputFacProgram_ = nullptr; + inputImageProgram_ = nullptr; + inputBlackProgram_ = nullptr; + inputWhiteProgram_ = nullptr; } void ColorCurveOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - CurveMapping *cumap = m_curveMapping; + CurveMapping *cumap = curveMapping_; float bwmul[3]; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { /* Local versions of `cumap->black` and `cumap->white`. */ @@ -134,20 +134,20 @@ ConstantLevelColorCurveOperation::ConstantLevelColorCurveOperation() this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputFacProgram = nullptr; - m_inputImageProgram = nullptr; + inputFacProgram_ = nullptr; + inputImageProgram_ = nullptr; this->set_canvas_input_index(1); } void ConstantLevelColorCurveOperation::initExecution() { CurveBaseOperation::initExecution(); - m_inputFacProgram = this->getInputSocketReader(0); - m_inputImageProgram = this->getInputSocketReader(1); + inputFacProgram_ = this->getInputSocketReader(0); + inputImageProgram_ = this->getInputSocketReader(1); - BKE_curvemapping_premultiply(m_curveMapping, 0); + BKE_curvemapping_premultiply(curveMapping_, 0); - BKE_curvemapping_set_black_white(m_curveMapping, m_black, m_white); + BKE_curvemapping_set_black_white(curveMapping_, black_, white_); } void ConstantLevelColorCurveOperation::executePixelSampled(float output[4], @@ -158,18 +158,18 @@ void ConstantLevelColorCurveOperation::executePixelSampled(float output[4], float fac[4]; float image[4]; - m_inputFacProgram->readSampled(fac, x, y, sampler); - m_inputImageProgram->readSampled(image, x, y, sampler); + inputFacProgram_->readSampled(fac, x, y, sampler); + inputImageProgram_->readSampled(image, x, y, sampler); if (*fac >= 1.0f) { - BKE_curvemapping_evaluate_premulRGBF(m_curveMapping, output, image); + BKE_curvemapping_evaluate_premulRGBF(curveMapping_, output, image); } else if (*fac <= 0.0f) { copy_v3_v3(output, image); } else { float col[4]; - BKE_curvemapping_evaluate_premulRGBF(m_curveMapping, col, image); + BKE_curvemapping_evaluate_premulRGBF(curveMapping_, col, image); interp_v3_v3v3(output, image, col, *fac); } output[3] = image[3]; @@ -178,15 +178,15 @@ void ConstantLevelColorCurveOperation::executePixelSampled(float output[4], void ConstantLevelColorCurveOperation::deinitExecution() { CurveBaseOperation::deinitExecution(); - m_inputFacProgram = nullptr; - m_inputImageProgram = nullptr; + inputFacProgram_ = nullptr; + inputImageProgram_ = nullptr; } void ConstantLevelColorCurveOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - CurveMapping *cumap = m_curveMapping; + CurveMapping *cumap = curveMapping_; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const float fac = *it.in(0); const float *image = it.in(1); diff --git a/source/blender/compositor/operations/COM_ColorCurveOperation.h b/source/blender/compositor/operations/COM_ColorCurveOperation.h index b92640839ba..6f16c45d11e 100644 --- a/source/blender/compositor/operations/COM_ColorCurveOperation.h +++ b/source/blender/compositor/operations/COM_ColorCurveOperation.h @@ -27,10 +27,10 @@ class ColorCurveOperation : public CurveBaseOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputFacProgram; - SocketReader *m_inputImageProgram; - SocketReader *m_inputBlackProgram; - SocketReader *m_inputWhiteProgram; + SocketReader *inputFacProgram_; + SocketReader *inputImageProgram_; + SocketReader *inputBlackProgram_; + SocketReader *inputWhiteProgram_; public: ColorCurveOperation(); @@ -60,10 +60,10 @@ class ConstantLevelColorCurveOperation : public CurveBaseOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputFacProgram; - SocketReader *m_inputImageProgram; - float m_black[3]; - float m_white[3]; + SocketReader *inputFacProgram_; + SocketReader *inputImageProgram_; + float black_[3]; + float white_[3]; public: ConstantLevelColorCurveOperation(); @@ -85,11 +85,11 @@ class ConstantLevelColorCurveOperation : public CurveBaseOperation { void setBlackLevel(float black[3]) { - copy_v3_v3(m_black, black); + copy_v3_v3(black_, black); } void setWhiteLevel(float white[3]) { - copy_v3_v3(m_white, white); + copy_v3_v3(white_, white); } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ColorExposureOperation.cc b/source/blender/compositor/operations/COM_ColorExposureOperation.cc index 7886f2a619f..f0e6abe67f9 100644 --- a/source/blender/compositor/operations/COM_ColorExposureOperation.cc +++ b/source/blender/compositor/operations/COM_ColorExposureOperation.cc @@ -25,14 +25,14 @@ ExposureOperation::ExposureOperation() this->addInputSocket(DataType::Color); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; + inputProgram_ = nullptr; flags.can_be_constant = true; } void ExposureOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); - m_inputExposureProgram = this->getInputSocketReader(1); + inputProgram_ = this->getInputSocketReader(0); + inputExposureProgram_ = this->getInputSocketReader(1); } void ExposureOperation::executePixelSampled(float output[4], @@ -42,8 +42,8 @@ void ExposureOperation::executePixelSampled(float output[4], { float inputValue[4]; float inputExposure[4]; - m_inputProgram->readSampled(inputValue, x, y, sampler); - m_inputExposureProgram->readSampled(inputExposure, x, y, sampler); + inputProgram_->readSampled(inputValue, x, y, sampler); + inputExposureProgram_->readSampled(inputExposure, x, y, sampler); const float exposure = pow(2, inputExposure[0]); output[0] = inputValue[0] * exposure; @@ -68,8 +68,8 @@ void ExposureOperation::update_memory_buffer_row(PixelCursor &p) void ExposureOperation::deinitExecution() { - m_inputProgram = nullptr; - m_inputExposureProgram = nullptr; + inputProgram_ = nullptr; + inputExposureProgram_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ColorExposureOperation.h b/source/blender/compositor/operations/COM_ColorExposureOperation.h index 1eb790e8d52..1a0f912d6bd 100644 --- a/source/blender/compositor/operations/COM_ColorExposureOperation.h +++ b/source/blender/compositor/operations/COM_ColorExposureOperation.h @@ -27,8 +27,8 @@ class ExposureOperation : public MultiThreadedRowOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; - SocketReader *m_inputExposureProgram; + SocketReader *inputProgram_; + SocketReader *inputExposureProgram_; public: ExposureOperation(); diff --git a/source/blender/compositor/operations/COM_ColorMatteOperation.cc b/source/blender/compositor/operations/COM_ColorMatteOperation.cc index be211f6c966..c693e7d06e1 100644 --- a/source/blender/compositor/operations/COM_ColorMatteOperation.cc +++ b/source/blender/compositor/operations/COM_ColorMatteOperation.cc @@ -26,21 +26,21 @@ ColorMatteOperation::ColorMatteOperation() addInputSocket(DataType::Color); addOutputSocket(DataType::Value); - m_inputImageProgram = nullptr; - m_inputKeyProgram = nullptr; + inputImageProgram_ = nullptr; + inputKeyProgram_ = nullptr; flags.can_be_constant = true; } void ColorMatteOperation::initExecution() { - m_inputImageProgram = this->getInputSocketReader(0); - m_inputKeyProgram = this->getInputSocketReader(1); + inputImageProgram_ = this->getInputSocketReader(0); + inputKeyProgram_ = this->getInputSocketReader(1); } void ColorMatteOperation::deinitExecution() { - m_inputImageProgram = nullptr; - m_inputKeyProgram = nullptr; + inputImageProgram_ = nullptr; + inputKeyProgram_ = nullptr; } void ColorMatteOperation::executePixelSampled(float output[4], @@ -51,14 +51,14 @@ void ColorMatteOperation::executePixelSampled(float output[4], float inColor[4]; float inKey[4]; - const float hue = m_settings->t1; - const float sat = m_settings->t2; - const float val = m_settings->t3; + const float hue = settings_->t1; + const float sat = settings_->t2; + const float val = settings_->t3; float h_wrap; - m_inputImageProgram->readSampled(inColor, x, y, sampler); - m_inputKeyProgram->readSampled(inKey, x, y, sampler); + inputImageProgram_->readSampled(inColor, x, y, sampler); + inputKeyProgram_->readSampled(inKey, x, y, sampler); /* Store matte(alpha) value in [0] to go with * COM_SetAlphaMultiplyOperation and the Value output. @@ -86,9 +86,9 @@ void ColorMatteOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - const float hue = m_settings->t1; - const float sat = m_settings->t2; - const float val = m_settings->t3; + const float hue = settings_->t1; + const float sat = settings_->t2; + const float val = settings_->t3; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const float *in_color = it.in(0); const float *in_key = it.in(1); diff --git a/source/blender/compositor/operations/COM_ColorMatteOperation.h b/source/blender/compositor/operations/COM_ColorMatteOperation.h index f1fc2cf7e95..2037fa0cdc3 100644 --- a/source/blender/compositor/operations/COM_ColorMatteOperation.h +++ b/source/blender/compositor/operations/COM_ColorMatteOperation.h @@ -28,9 +28,9 @@ namespace blender::compositor { */ class ColorMatteOperation : public MultiThreadedOperation { private: - NodeChroma *m_settings; - SocketReader *m_inputImageProgram; - SocketReader *m_inputKeyProgram; + NodeChroma *settings_; + SocketReader *inputImageProgram_; + SocketReader *inputKeyProgram_; public: /** @@ -48,7 +48,7 @@ class ColorMatteOperation : public MultiThreadedOperation { void setSettings(NodeChroma *nodeChroma) { - m_settings = nodeChroma; + settings_ = nodeChroma; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ColorRampOperation.cc b/source/blender/compositor/operations/COM_ColorRampOperation.cc index 274e1cc3f0f..054bdcf5b04 100644 --- a/source/blender/compositor/operations/COM_ColorRampOperation.cc +++ b/source/blender/compositor/operations/COM_ColorRampOperation.cc @@ -27,13 +27,13 @@ ColorRampOperation::ColorRampOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; - m_colorBand = nullptr; + inputProgram_ = nullptr; + colorBand_ = nullptr; this->flags.can_be_constant = true; } void ColorRampOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void ColorRampOperation::executePixelSampled(float output[4], @@ -43,13 +43,13 @@ void ColorRampOperation::executePixelSampled(float output[4], { float values[4]; - m_inputProgram->readSampled(values, x, y, sampler); - BKE_colorband_evaluate(m_colorBand, values[0], output); + inputProgram_->readSampled(values, x, y, sampler); + BKE_colorband_evaluate(colorBand_, values[0], output); } void ColorRampOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void ColorRampOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -57,7 +57,7 @@ void ColorRampOperation::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> inputs) { for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { - BKE_colorband_evaluate(m_colorBand, *it.in(0), it.out); + BKE_colorband_evaluate(colorBand_, *it.in(0), it.out); } } diff --git a/source/blender/compositor/operations/COM_ColorRampOperation.h b/source/blender/compositor/operations/COM_ColorRampOperation.h index 21442e52800..3cb5a7d83e1 100644 --- a/source/blender/compositor/operations/COM_ColorRampOperation.h +++ b/source/blender/compositor/operations/COM_ColorRampOperation.h @@ -28,8 +28,8 @@ class ColorRampOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; - ColorBand *m_colorBand; + SocketReader *inputProgram_; + ColorBand *colorBand_; public: ColorRampOperation(); @@ -51,7 +51,7 @@ class ColorRampOperation : public MultiThreadedOperation { void setColorBand(ColorBand *colorBand) { - m_colorBand = colorBand; + colorBand_ = colorBand; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ColorSpillOperation.cc b/source/blender/compositor/operations/COM_ColorSpillOperation.cc index fde769fadc0..45197bf2b1d 100644 --- a/source/blender/compositor/operations/COM_ColorSpillOperation.cc +++ b/source/blender/compositor/operations/COM_ColorSpillOperation.cc @@ -27,60 +27,60 @@ ColorSpillOperation::ColorSpillOperation() addInputSocket(DataType::Value); addOutputSocket(DataType::Color); - m_inputImageReader = nullptr; - m_inputFacReader = nullptr; - m_spillChannel = 1; /* GREEN */ - m_spillMethod = 0; + inputImageReader_ = nullptr; + inputFacReader_ = nullptr; + spillChannel_ = 1; /* GREEN */ + spillMethod_ = 0; flags.can_be_constant = true; } void ColorSpillOperation::initExecution() { - m_inputImageReader = this->getInputSocketReader(0); - m_inputFacReader = this->getInputSocketReader(1); - if (m_spillChannel == 0) { - m_rmut = -1.0f; - m_gmut = 1.0f; - m_bmut = 1.0f; - m_channel2 = 1; - m_channel3 = 2; - if (m_settings->unspill == 0) { - m_settings->uspillr = 1.0f; - m_settings->uspillg = 0.0f; - m_settings->uspillb = 0.0f; + inputImageReader_ = this->getInputSocketReader(0); + inputFacReader_ = this->getInputSocketReader(1); + if (spillChannel_ == 0) { + rmut_ = -1.0f; + gmut_ = 1.0f; + bmut_ = 1.0f; + channel2_ = 1; + channel3_ = 2; + if (settings_->unspill == 0) { + settings_->uspillr = 1.0f; + settings_->uspillg = 0.0f; + settings_->uspillb = 0.0f; } } - else if (m_spillChannel == 1) { - m_rmut = 1.0f; - m_gmut = -1.0f; - m_bmut = 1.0f; - m_channel2 = 0; - m_channel3 = 2; - if (m_settings->unspill == 0) { - m_settings->uspillr = 0.0f; - m_settings->uspillg = 1.0f; - m_settings->uspillb = 0.0f; + else if (spillChannel_ == 1) { + rmut_ = 1.0f; + gmut_ = -1.0f; + bmut_ = 1.0f; + channel2_ = 0; + channel3_ = 2; + if (settings_->unspill == 0) { + settings_->uspillr = 0.0f; + settings_->uspillg = 1.0f; + settings_->uspillb = 0.0f; } } else { - m_rmut = 1.0f; - m_gmut = 1.0f; - m_bmut = -1.0f; + rmut_ = 1.0f; + gmut_ = 1.0f; + bmut_ = -1.0f; - m_channel2 = 0; - m_channel3 = 1; - if (m_settings->unspill == 0) { - m_settings->uspillr = 0.0f; - m_settings->uspillg = 0.0f; - m_settings->uspillb = 1.0f; + channel2_ = 0; + channel3_ = 1; + if (settings_->unspill == 0) { + settings_->uspillr = 0.0f; + settings_->uspillg = 0.0f; + settings_->uspillb = 1.0f; } } } void ColorSpillOperation::deinitExecution() { - m_inputImageReader = nullptr; - m_inputFacReader = nullptr; + inputImageReader_ = nullptr; + inputFacReader_ = nullptr; } void ColorSpillOperation::executePixelSampled(float output[4], @@ -90,25 +90,25 @@ void ColorSpillOperation::executePixelSampled(float output[4], { float fac[4]; float input[4]; - m_inputFacReader->readSampled(fac, x, y, sampler); - m_inputImageReader->readSampled(input, x, y, sampler); + inputFacReader_->readSampled(fac, x, y, sampler); + inputImageReader_->readSampled(input, x, y, sampler); float rfac = MIN2(1.0f, fac[0]); float map; - switch (m_spillMethod) { + switch (spillMethod_) { case 0: /* simple */ - map = rfac * (input[m_spillChannel] - (m_settings->limscale * input[m_settings->limchan])); + map = rfac * (input[spillChannel_] - (settings_->limscale * input[settings_->limchan])); break; default: /* average */ - map = rfac * (input[m_spillChannel] - - (m_settings->limscale * AVG(input[m_channel2], input[m_channel3]))); + map = rfac * (input[spillChannel_] - + (settings_->limscale * AVG(input[channel2_], input[channel3_]))); break; } if (map > 0.0f) { - output[0] = input[0] + m_rmut * (m_settings->uspillr * map); - output[1] = input[1] + m_gmut * (m_settings->uspillg * map); - output[2] = input[2] + m_bmut * (m_settings->uspillb * map); + output[0] = input[0] + rmut_ * (settings_->uspillr * map); + output[1] = input[1] + gmut_ * (settings_->uspillg * map); + output[2] = input[2] + bmut_ * (settings_->uspillb * map); output[3] = input[3]; } else { @@ -125,21 +125,20 @@ void ColorSpillOperation::update_memory_buffer_partial(MemoryBuffer *output, const float factor = MIN2(1.0f, *it.in(1)); float map; - switch (m_spillMethod) { + switch (spillMethod_) { case 0: /* simple */ - map = factor * - (color[m_spillChannel] - (m_settings->limscale * color[m_settings->limchan])); + map = factor * (color[spillChannel_] - (settings_->limscale * color[settings_->limchan])); break; default: /* average */ - map = factor * (color[m_spillChannel] - - (m_settings->limscale * AVG(color[m_channel2], color[m_channel3]))); + map = factor * (color[spillChannel_] - + (settings_->limscale * AVG(color[channel2_], color[channel3_]))); break; } if (map > 0.0f) { - it.out[0] = color[0] + m_rmut * (m_settings->uspillr * map); - it.out[1] = color[1] + m_gmut * (m_settings->uspillg * map); - it.out[2] = color[2] + m_bmut * (m_settings->uspillb * map); + it.out[0] = color[0] + rmut_ * (settings_->uspillr * map); + it.out[1] = color[1] + gmut_ * (settings_->uspillg * map); + it.out[2] = color[2] + bmut_ * (settings_->uspillb * map); it.out[3] = color[3]; } else { diff --git a/source/blender/compositor/operations/COM_ColorSpillOperation.h b/source/blender/compositor/operations/COM_ColorSpillOperation.h index 453eb8e88d9..aab74e68f41 100644 --- a/source/blender/compositor/operations/COM_ColorSpillOperation.h +++ b/source/blender/compositor/operations/COM_ColorSpillOperation.h @@ -28,14 +28,14 @@ namespace blender::compositor { */ class ColorSpillOperation : public MultiThreadedOperation { protected: - NodeColorspill *m_settings; - SocketReader *m_inputImageReader; - SocketReader *m_inputFacReader; - int m_spillChannel; - int m_spillMethod; - int m_channel2; - int m_channel3; - float m_rmut, m_gmut, m_bmut; + NodeColorspill *settings_; + SocketReader *inputImageReader_; + SocketReader *inputFacReader_; + int spillChannel_; + int spillMethod_; + int channel2_; + int channel3_; + float rmut_, gmut_, bmut_; public: /** @@ -53,15 +53,15 @@ class ColorSpillOperation : public MultiThreadedOperation { void setSettings(NodeColorspill *nodeColorSpill) { - m_settings = nodeColorSpill; + settings_ = nodeColorSpill; } void setSpillChannel(int channel) { - m_spillChannel = channel; + spillChannel_ = channel; } void setSpillMethod(int method) { - m_spillMethod = method; + spillMethod_ = method; } float calculateMapValue(float fac, float *input); diff --git a/source/blender/compositor/operations/COM_CompositorOperation.cc b/source/blender/compositor/operations/COM_CompositorOperation.cc index 481aca1a68b..029dec8c371 100644 --- a/source/blender/compositor/operations/COM_CompositorOperation.cc +++ b/source/blender/compositor/operations/COM_CompositorOperation.cc @@ -32,71 +32,71 @@ CompositorOperation::CompositorOperation() this->addInputSocket(DataType::Value); this->setRenderData(nullptr); - m_outputBuffer = nullptr; - m_depthBuffer = nullptr; - m_imageInput = nullptr; - m_alphaInput = nullptr; - m_depthInput = nullptr; + outputBuffer_ = nullptr; + depthBuffer_ = nullptr; + imageInput_ = nullptr; + alphaInput_ = nullptr; + depthInput_ = nullptr; - m_useAlphaInput = false; - m_active = false; + useAlphaInput_ = false; + active_ = false; - m_scene = nullptr; - m_sceneName[0] = '\0'; - m_viewName = nullptr; + scene_ = nullptr; + sceneName_[0] = '\0'; + viewName_ = nullptr; flags.use_render_border = true; } void CompositorOperation::initExecution() { - if (!m_active) { + if (!active_) { return; } /* When initializing the tree during initial load the width and height can be zero. */ - m_imageInput = getInputSocketReader(0); - m_alphaInput = getInputSocketReader(1); - m_depthInput = getInputSocketReader(2); + imageInput_ = getInputSocketReader(0); + alphaInput_ = getInputSocketReader(1); + depthInput_ = getInputSocketReader(2); if (this->getWidth() * this->getHeight() != 0) { - m_outputBuffer = (float *)MEM_callocN(sizeof(float[4]) * this->getWidth() * this->getHeight(), - "CompositorOperation"); - } - if (m_depthInput != nullptr) { - m_depthBuffer = (float *)MEM_callocN(sizeof(float) * this->getWidth() * this->getHeight(), + outputBuffer_ = (float *)MEM_callocN(sizeof(float[4]) * this->getWidth() * this->getHeight(), "CompositorOperation"); } + if (depthInput_ != nullptr) { + depthBuffer_ = (float *)MEM_callocN(sizeof(float) * this->getWidth() * this->getHeight(), + "CompositorOperation"); + } } void CompositorOperation::deinitExecution() { - if (!m_active) { + if (!active_) { return; } if (!isBraked()) { - Render *re = RE_GetSceneRender(m_scene); + Render *re = RE_GetSceneRender(scene_); RenderResult *rr = RE_AcquireResultWrite(re); if (rr) { - RenderView *rv = RE_RenderViewGetByName(rr, m_viewName); + RenderView *rv = RE_RenderViewGetByName(rr, viewName_); if (rv->rectf != nullptr) { MEM_freeN(rv->rectf); } - rv->rectf = m_outputBuffer; + rv->rectf = outputBuffer_; if (rv->rectz != nullptr) { MEM_freeN(rv->rectz); } - rv->rectz = m_depthBuffer; + rv->rectz = depthBuffer_; rr->have_combined = true; } else { - if (m_outputBuffer) { - MEM_freeN(m_outputBuffer); + if (outputBuffer_) { + MEM_freeN(outputBuffer_); } - if (m_depthBuffer) { - MEM_freeN(m_depthBuffer); + if (depthBuffer_) { + MEM_freeN(depthBuffer_); } } @@ -113,26 +113,26 @@ void CompositorOperation::deinitExecution() BLI_thread_unlock(LOCK_DRAW_IMAGE); } else { - if (m_outputBuffer) { - MEM_freeN(m_outputBuffer); + if (outputBuffer_) { + MEM_freeN(outputBuffer_); } - if (m_depthBuffer) { - MEM_freeN(m_depthBuffer); + if (depthBuffer_) { + MEM_freeN(depthBuffer_); } } - m_outputBuffer = nullptr; - m_depthBuffer = nullptr; - m_imageInput = nullptr; - m_alphaInput = nullptr; - m_depthInput = nullptr; + outputBuffer_ = nullptr; + depthBuffer_ = nullptr; + imageInput_ = nullptr; + alphaInput_ = nullptr; + depthInput_ = nullptr; } void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) { float color[8]; // 7 is enough - float *buffer = m_outputBuffer; - float *zbuffer = m_depthBuffer; + float *buffer = outputBuffer_; + float *zbuffer = depthBuffer_; if (!buffer) { return; @@ -150,7 +150,7 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) int dx = 0, dy = 0; #if 0 - const RenderData *rd = m_rd; + const RenderData *rd = rd_; if (rd->mode & R_BORDER && rd->mode & R_CROP) { /** @@ -192,14 +192,14 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) for (x = x1; x < x2 && (!breaked); x++) { int input_x = x + dx, input_y = y + dy; - m_imageInput->readSampled(color, input_x, input_y, PixelSampler::Nearest); - if (m_useAlphaInput) { - m_alphaInput->readSampled(&(color[3]), input_x, input_y, PixelSampler::Nearest); + imageInput_->readSampled(color, input_x, input_y, PixelSampler::Nearest); + if (useAlphaInput_) { + alphaInput_->readSampled(&(color[3]), input_x, input_y, PixelSampler::Nearest); } copy_v4_v4(buffer + offset4, color); - m_depthInput->readSampled(color, input_x, input_y, PixelSampler::Nearest); + depthInput_->readSampled(color, input_x, input_y, PixelSampler::Nearest); zbuffer[offset] = color[0]; offset4 += COM_DATA_TYPE_COLOR_CHANNELS; offset++; @@ -216,26 +216,26 @@ void CompositorOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(outp const rcti &area, Span<MemoryBuffer *> inputs) { - if (!m_outputBuffer) { + if (!outputBuffer_) { return; } - MemoryBuffer output_buf(m_outputBuffer, COM_DATA_TYPE_COLOR_CHANNELS, getWidth(), getHeight()); + MemoryBuffer output_buf(outputBuffer_, COM_DATA_TYPE_COLOR_CHANNELS, getWidth(), getHeight()); output_buf.copy_from(inputs[0], area); - if (m_useAlphaInput) { + if (useAlphaInput_) { output_buf.copy_from(inputs[1], area, 0, COM_DATA_TYPE_VALUE_CHANNELS, 3); } - MemoryBuffer depth_buf(m_depthBuffer, COM_DATA_TYPE_VALUE_CHANNELS, getWidth(), getHeight()); + MemoryBuffer depth_buf(depthBuffer_, COM_DATA_TYPE_VALUE_CHANNELS, getWidth(), getHeight()); depth_buf.copy_from(inputs[2], area); } void CompositorOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area) { - int width = m_rd->xsch * m_rd->size / 100; - int height = m_rd->ysch * m_rd->size / 100; + int width = rd_->xsch * rd_->size / 100; + int height = rd_->ysch * rd_->size / 100; /* Check actual render resolution with cropping it may differ with cropped border.rendering * Fix for T31777 Border Crop gives black (easy). */ - Render *re = RE_GetSceneRender(m_scene); + Render *re = RE_GetSceneRender(scene_); if (re) { RenderResult *rr = RE_AcquireResultRead(re); if (rr) { diff --git a/source/blender/compositor/operations/COM_CompositorOperation.h b/source/blender/compositor/operations/COM_CompositorOperation.h index c63613b7b35..e9539ae66fd 100644 --- a/source/blender/compositor/operations/COM_CompositorOperation.h +++ b/source/blender/compositor/operations/COM_CompositorOperation.h @@ -29,79 +29,79 @@ namespace blender::compositor { */ class CompositorOperation : public MultiThreadedOperation { private: - const struct Scene *m_scene; + const struct Scene *scene_; /** * \brief Scene name, used for getting the render output, includes 'SC' prefix. */ - char m_sceneName[MAX_ID_NAME]; + char sceneName_[MAX_ID_NAME]; /** * \brief local reference to the scene */ - const RenderData *m_rd; + const RenderData *rd_; /** * \brief reference to the output float buffer */ - float *m_outputBuffer; + float *outputBuffer_; /** * \brief reference to the output depth float buffer */ - float *m_depthBuffer; + float *depthBuffer_; /** * \brief local reference to the input image operation */ - SocketReader *m_imageInput; + SocketReader *imageInput_; /** * \brief local reference to the input alpha operation */ - SocketReader *m_alphaInput; + SocketReader *alphaInput_; /** * \brief local reference to the depth operation */ - SocketReader *m_depthInput; + SocketReader *depthInput_; /** * \brief Ignore any alpha input */ - bool m_useAlphaInput; + bool useAlphaInput_; /** * \brief operation is active for calculating final compo result */ - bool m_active; + bool active_; /** * \brief View name, used for multiview */ - const char *m_viewName; + const char *viewName_; public: CompositorOperation(); bool isActiveCompositorOutput() const { - return m_active; + return active_; } void executeRegion(rcti *rect, unsigned int tileNumber) override; void setScene(const struct Scene *scene) { - m_scene = scene; + scene_ = scene; } void setSceneName(const char *sceneName) { - BLI_strncpy(m_sceneName, sceneName, sizeof(m_sceneName)); + BLI_strncpy(sceneName_, sceneName, sizeof(sceneName_)); } void setViewName(const char *viewName) { - m_viewName = viewName; + viewName_ = viewName; } void setRenderData(const RenderData *rd) { - m_rd = rd; + rd_ = rd; } bool isOutputOperation(bool /*rendering*/) const override { @@ -116,11 +116,11 @@ class CompositorOperation : public MultiThreadedOperation { void determine_canvas(const rcti &preferred_area, rcti &r_area) override; void setUseAlphaInput(bool value) { - m_useAlphaInput = value; + useAlphaInput_ = value; } void setActive(bool active) { - m_active = active; + active_ = active; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cc b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cc index 09a1541985b..4f78c919695 100644 --- a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cc +++ b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cc @@ -26,13 +26,13 @@ ConvertColorProfileOperation::ConvertColorProfileOperation() { this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputOperation = nullptr; - m_predivided = false; + inputOperation_ = nullptr; + predivided_ = false; } void ConvertColorProfileOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); } void ConvertColorProfileOperation::executePixelSampled(float output[4], @@ -41,14 +41,13 @@ void ConvertColorProfileOperation::executePixelSampled(float output[4], PixelSampler sampler) { float color[4]; - m_inputOperation->readSampled(color, x, y, sampler); - IMB_buffer_float_from_float( - output, color, 4, m_toProfile, m_fromProfile, m_predivided, 1, 1, 0, 0); + inputOperation_->readSampled(color, x, y, sampler); + IMB_buffer_float_from_float(output, color, 4, toProfile_, fromProfile_, predivided_, 1, 1, 0, 0); } void ConvertColorProfileOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h index 6d7b19aa859..532fad86091 100644 --- a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h +++ b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h @@ -31,22 +31,22 @@ class ConvertColorProfileOperation : public NodeOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputOperation; + SocketReader *inputOperation_; /** * \brief color profile where to convert from */ - int m_fromProfile; + int fromProfile_; /** * \brief color profile where to convert to */ - int m_toProfile; + int toProfile_; /** * \brief is color predivided */ - bool m_predivided; + bool predivided_; public: /** @@ -71,15 +71,15 @@ class ConvertColorProfileOperation : public NodeOperation { void setFromColorProfile(int colorProfile) { - m_fromProfile = colorProfile; + fromProfile_ = colorProfile; } void setToColorProfile(int colorProfile) { - m_toProfile = colorProfile; + toProfile_ = colorProfile; } void setPredivided(bool predivided) { - m_predivided = predivided; + predivided_ = predivided; } }; diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc index ee2a62f6147..fcd9d26c3f0 100644 --- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc +++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc @@ -26,19 +26,19 @@ ConvertDepthToRadiusOperation::ConvertDepthToRadiusOperation() { this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_inputOperation = nullptr; - m_fStop = 128.0f; - m_cameraObject = nullptr; - m_maxRadius = 32.0f; - m_blurPostOperation = nullptr; + inputOperation_ = nullptr; + fStop_ = 128.0f; + cameraObject_ = nullptr; + maxRadius_ = 32.0f; + blurPostOperation_ = nullptr; } float ConvertDepthToRadiusOperation::determineFocalDistance() { - if (m_cameraObject && m_cameraObject->type == OB_CAMERA) { - Camera *camera = (Camera *)m_cameraObject->data; - m_cam_lens = camera->lens; - return BKE_camera_object_dof_distance(m_cameraObject); + if (cameraObject_ && cameraObject_->type == OB_CAMERA) { + Camera *camera = (Camera *)cameraObject_->data; + cam_lens_ = camera->lens; + return BKE_camera_object_dof_distance(cameraObject_); } return 10.0f; @@ -49,27 +49,27 @@ void ConvertDepthToRadiusOperation::initExecution() float cam_sensor = DEFAULT_SENSOR_WIDTH; Camera *camera = nullptr; - if (m_cameraObject && m_cameraObject->type == OB_CAMERA) { - camera = (Camera *)m_cameraObject->data; + if (cameraObject_ && cameraObject_->type == OB_CAMERA) { + camera = (Camera *)cameraObject_->data; cam_sensor = BKE_camera_sensor_size(camera->sensor_fit, camera->sensor_x, camera->sensor_y); } - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); float focalDistance = determineFocalDistance(); if (focalDistance == 0.0f) { focalDistance = 1e10f; /* If the DOF is 0.0 then set it to be far away. */ } - m_inverseFocalDistance = 1.0f / focalDistance; - m_aspect = (this->getWidth() > this->getHeight()) ? - (this->getHeight() / (float)this->getWidth()) : - (this->getWidth() / (float)this->getHeight()); - m_aperture = 0.5f * (m_cam_lens / (m_aspect * cam_sensor)) / m_fStop; + inverseFocalDistance_ = 1.0f / focalDistance; + aspect_ = (this->getWidth() > this->getHeight()) ? + (this->getHeight() / (float)this->getWidth()) : + (this->getWidth() / (float)this->getHeight()); + aperture_ = 0.5f * (cam_lens_ / (aspect_ * cam_sensor)) / fStop_; const float minsz = MIN2(getWidth(), getHeight()); - m_dof_sp = minsz / ((cam_sensor / 2.0f) / - m_cam_lens); /* <- == `aspect * MIN2(img->x, img->y) / tan(0.5f * fov)` */ + dof_sp_ = minsz / ((cam_sensor / 2.0f) / + cam_lens_); /* <- == `aspect * MIN2(img->x, img->y) / tan(0.5f * fov)` */ - if (m_blurPostOperation) { - m_blurPostOperation->setSigma(MIN2(m_aperture * 128.0f, m_maxRadius)); + if (blurPostOperation_) { + blurPostOperation_->setSigma(MIN2(aperture_ * 128.0f, maxRadius_)); } } @@ -81,7 +81,7 @@ void ConvertDepthToRadiusOperation::executePixelSampled(float output[4], float inputValue[4]; float z; float radius; - m_inputOperation->readSampled(inputValue, x, y, sampler); + inputOperation_->readSampled(inputValue, x, y, sampler); z = inputValue[0]; if (z != 0.0f) { float iZ = (1.0f / z); @@ -92,14 +92,14 @@ void ConvertDepthToRadiusOperation::executePixelSampled(float output[4], /* Scale crad back to original maximum and blend. */ crad->rect[px] = bcrad + wts->rect[px] * (scf * crad->rect[px] - bcrad); #endif - radius = 0.5f * fabsf(m_aperture * (m_dof_sp * (m_inverseFocalDistance - iZ) - 1.0f)); + radius = 0.5f * fabsf(aperture_ * (dof_sp_ * (inverseFocalDistance_ - iZ) - 1.0f)); /* 'bug' T6615, limit minimum radius to 1 pixel, * not really a solution, but somewhat mitigates the problem. */ if (radius < 0.0f) { radius = 0.0f; } - if (radius > m_maxRadius) { - radius = m_maxRadius; + if (radius > maxRadius_) { + radius = maxRadius_; } output[0] = radius; } @@ -110,7 +110,7 @@ void ConvertDepthToRadiusOperation::executePixelSampled(float output[4], void ConvertDepthToRadiusOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void ConvertDepthToRadiusOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -133,10 +133,10 @@ void ConvertDepthToRadiusOperation::update_memory_buffer_partial(MemoryBuffer *o * `crad->rect[px] = bcrad + wts->rect[px] * (scf * crad->rect[px] - bcrad);` */ #endif const float radius = 0.5f * - fabsf(m_aperture * (m_dof_sp * (m_inverseFocalDistance - inv_z) - 1.0f)); + fabsf(aperture_ * (dof_sp_ * (inverseFocalDistance_ - inv_z) - 1.0f)); /* Bug T6615, limit minimum radius to 1 pixel, * not really a solution, but somewhat mitigates the problem. */ - *it.out = CLAMPIS(radius, 0.0f, m_maxRadius); + *it.out = CLAMPIS(radius, 0.0f, maxRadius_); } } diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h index 746cb89b6c0..d3beff60207 100644 --- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h +++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h @@ -33,17 +33,17 @@ class ConvertDepthToRadiusOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputOperation; - float m_fStop; - float m_aspect; - float m_maxRadius; - float m_inverseFocalDistance; - float m_aperture; - float m_cam_lens; - float m_dof_sp; - Object *m_cameraObject; + SocketReader *inputOperation_; + float fStop_; + float aspect_; + float maxRadius_; + float inverseFocalDistance_; + float aperture_; + float cam_lens_; + float dof_sp_; + Object *cameraObject_; - FastGaussianBlurValueOperation *m_blurPostOperation; + FastGaussianBlurValueOperation *blurPostOperation_; public: /** @@ -68,20 +68,20 @@ class ConvertDepthToRadiusOperation : public MultiThreadedOperation { void setfStop(float fStop) { - m_fStop = fStop; + fStop_ = fStop; } void setMaxRadius(float maxRadius) { - m_maxRadius = maxRadius; + maxRadius_ = maxRadius; } void setCameraObject(Object *camera) { - m_cameraObject = camera; + cameraObject_ = camera; } float determineFocalDistance(); void setPostBlur(FastGaussianBlurValueOperation *operation) { - m_blurPostOperation = operation; + blurPostOperation_ = operation; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ConvertOperation.cc b/source/blender/compositor/operations/COM_ConvertOperation.cc index 1cef0490ff5..88de54e8c41 100644 --- a/source/blender/compositor/operations/COM_ConvertOperation.cc +++ b/source/blender/compositor/operations/COM_ConvertOperation.cc @@ -26,18 +26,18 @@ namespace blender::compositor { ConvertBaseOperation::ConvertBaseOperation() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; this->flags.can_be_constant = true; } void ConvertBaseOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); } void ConvertBaseOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void ConvertBaseOperation::hash_output_params() @@ -66,7 +66,7 @@ void ConvertValueToColorOperation::executePixelSampled(float output[4], PixelSampler sampler) { float value; - m_inputOperation->readSampled(&value, x, y, sampler); + inputOperation_->readSampled(&value, x, y, sampler); output[0] = output[1] = output[2] = value; output[3] = 1.0f; } @@ -93,7 +93,7 @@ void ConvertColorToValueOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputOperation->readSampled(inputColor, x, y, sampler); + inputOperation_->readSampled(inputColor, x, y, sampler); output[0] = (inputColor[0] + inputColor[1] + inputColor[2]) / 3.0f; } @@ -119,7 +119,7 @@ void ConvertColorToBWOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputOperation->readSampled(inputColor, x, y, sampler); + inputOperation_->readSampled(inputColor, x, y, sampler); output[0] = IMB_colormanagement_get_luminance(inputColor); } @@ -144,7 +144,7 @@ void ConvertColorToVectorOperation::executePixelSampled(float output[4], PixelSampler sampler) { float color[4]; - m_inputOperation->readSampled(color, x, y, sampler); + inputOperation_->readSampled(color, x, y, sampler); copy_v3_v3(output, color); } @@ -169,7 +169,7 @@ void ConvertValueToVectorOperation::executePixelSampled(float output[4], PixelSampler sampler) { float value; - m_inputOperation->readSampled(&value, x, y, sampler); + inputOperation_->readSampled(&value, x, y, sampler); output[0] = output[1] = output[2] = value; } @@ -193,7 +193,7 @@ void ConvertVectorToColorOperation::executePixelSampled(float output[4], float y, PixelSampler sampler) { - m_inputOperation->readSampled(output, x, y, sampler); + inputOperation_->readSampled(output, x, y, sampler); output[3] = 1.0f; } @@ -219,7 +219,7 @@ void ConvertVectorToValueOperation::executePixelSampled(float output[4], PixelSampler sampler) { float input[4]; - m_inputOperation->readSampled(input, x, y, sampler); + inputOperation_->readSampled(input, x, y, sampler); output[0] = (input[0] + input[1] + input[2]) / 3.0f; } @@ -243,14 +243,14 @@ void ConvertRGBToYCCOperation::setMode(int mode) { switch (mode) { case 0: - m_mode = BLI_YCC_ITU_BT601; + mode_ = BLI_YCC_ITU_BT601; break; case 2: - m_mode = BLI_YCC_JFIF_0_255; + mode_ = BLI_YCC_JFIF_0_255; break; case 1: default: - m_mode = BLI_YCC_ITU_BT709; + mode_ = BLI_YCC_ITU_BT709; break; } } @@ -263,9 +263,8 @@ void ConvertRGBToYCCOperation::executePixelSampled(float output[4], float inputColor[4]; float color[3]; - m_inputOperation->readSampled(inputColor, x, y, sampler); - rgb_to_ycc( - inputColor[0], inputColor[1], inputColor[2], &color[0], &color[1], &color[2], m_mode); + inputOperation_->readSampled(inputColor, x, y, sampler); + rgb_to_ycc(inputColor[0], inputColor[1], inputColor[2], &color[0], &color[1], &color[2], mode_); /* divided by 255 to normalize for viewing in */ /* R,G,B --> Y,Cb,Cr */ @@ -276,14 +275,14 @@ void ConvertRGBToYCCOperation::executePixelSampled(float output[4], void ConvertRGBToYCCOperation::hash_output_params() { ConvertBaseOperation::hash_output_params(); - hash_param(m_mode); + hash_param(mode_); } void ConvertRGBToYCCOperation::update_memory_buffer_partial(BuffersIterator<float> &it) { for (; !it.is_end(); ++it) { const float *in = it.in(0); - rgb_to_ycc(in[0], in[1], in[2], &it.out[0], &it.out[1], &it.out[2], m_mode); + rgb_to_ycc(in[0], in[1], in[2], &it.out[0], &it.out[1], &it.out[2], mode_); /* Normalize for viewing (#rgb_to_ycc returns 0-255 values). */ mul_v3_fl(it.out, 1.0f / 255.0f); @@ -303,14 +302,14 @@ void ConvertYCCToRGBOperation::setMode(int mode) { switch (mode) { case 0: - m_mode = BLI_YCC_ITU_BT601; + mode_ = BLI_YCC_ITU_BT601; break; case 2: - m_mode = BLI_YCC_JFIF_0_255; + mode_ = BLI_YCC_JFIF_0_255; break; case 1: default: - m_mode = BLI_YCC_ITU_BT709; + mode_ = BLI_YCC_ITU_BT709; break; } } @@ -321,26 +320,21 @@ void ConvertYCCToRGBOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputOperation->readSampled(inputColor, x, y, sampler); + inputOperation_->readSampled(inputColor, x, y, sampler); /* need to un-normalize the data */ /* R,G,B --> Y,Cb,Cr */ mul_v3_fl(inputColor, 255.0f); - ycc_to_rgb(inputColor[0], - inputColor[1], - inputColor[2], - &output[0], - &output[1], - &output[2], - m_mode); + ycc_to_rgb( + inputColor[0], inputColor[1], inputColor[2], &output[0], &output[1], &output[2], mode_); output[3] = inputColor[3]; } void ConvertYCCToRGBOperation::hash_output_params() { ConvertBaseOperation::hash_output_params(); - hash_param(m_mode); + hash_param(mode_); } void ConvertYCCToRGBOperation::update_memory_buffer_partial(BuffersIterator<float> &it) @@ -348,13 +342,8 @@ void ConvertYCCToRGBOperation::update_memory_buffer_partial(BuffersIterator<floa for (; !it.is_end(); ++it) { const float *in = it.in(0); /* Multiply by 255 to un-normalize (#ycc_to_rgb needs input values in 0-255 range). */ - ycc_to_rgb(in[0] * 255.0f, - in[1] * 255.0f, - in[2] * 255.0f, - &it.out[0], - &it.out[1], - &it.out[2], - m_mode); + ycc_to_rgb( + in[0] * 255.0f, in[1] * 255.0f, in[2] * 255.0f, &it.out[0], &it.out[1], &it.out[2], mode_); it.out[3] = in[3]; } } @@ -373,7 +362,7 @@ void ConvertRGBToYUVOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputOperation->readSampled(inputColor, x, y, sampler); + inputOperation_->readSampled(inputColor, x, y, sampler); rgb_to_yuv(inputColor[0], inputColor[1], inputColor[2], @@ -407,7 +396,7 @@ void ConvertYUVToRGBOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputOperation->readSampled(inputColor, x, y, sampler); + inputOperation_->readSampled(inputColor, x, y, sampler); yuv_to_rgb(inputColor[0], inputColor[1], inputColor[2], @@ -441,7 +430,7 @@ void ConvertRGBToHSVOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputOperation->readSampled(inputColor, x, y, sampler); + inputOperation_->readSampled(inputColor, x, y, sampler); rgb_to_hsv_v(inputColor, output); output[3] = inputColor[3]; } @@ -469,7 +458,7 @@ void ConvertHSVToRGBOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputOperation->readSampled(inputColor, x, y, sampler); + inputOperation_->readSampled(inputColor, x, y, sampler); hsv_to_rgb_v(inputColor, output); output[0] = max_ff(output[0], 0.0f); output[1] = max_ff(output[1], 0.0f); @@ -503,7 +492,7 @@ void ConvertPremulToStraightOperation::executePixelSampled(float output[4], PixelSampler sampler) { ColorSceneLinear4f<eAlpha::Premultiplied> input; - m_inputOperation->readSampled(input, x, y, sampler); + inputOperation_->readSampled(input, x, y, sampler); ColorSceneLinear4f<eAlpha::Straight> converted = input.unpremultiply_alpha(); copy_v4_v4(output, converted); } @@ -529,7 +518,7 @@ void ConvertStraightToPremulOperation::executePixelSampled(float output[4], PixelSampler sampler) { ColorSceneLinear4f<eAlpha::Straight> input; - m_inputOperation->readSampled(input, x, y, sampler); + inputOperation_->readSampled(input, x, y, sampler); ColorSceneLinear4f<eAlpha::Premultiplied> converted = input.premultiply_alpha(); copy_v4_v4(output, converted); } @@ -547,16 +536,16 @@ SeparateChannelOperation::SeparateChannelOperation() { this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Value); - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void SeparateChannelOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); } void SeparateChannelOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void SeparateChannelOperation::executePixelSampled(float output[4], @@ -565,8 +554,8 @@ void SeparateChannelOperation::executePixelSampled(float output[4], PixelSampler sampler) { float input[4]; - m_inputOperation->readSampled(input, x, y, sampler); - output[0] = input[m_channel]; + inputOperation_->readSampled(input, x, y, sampler); + output[0] = input[channel_]; } void SeparateChannelOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -574,7 +563,7 @@ void SeparateChannelOperation::update_memory_buffer_partial(MemoryBuffer *output Span<MemoryBuffer *> inputs) { for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { - it.out[0] = it.in(0)[m_channel]; + it.out[0] = it.in(0)[channel_]; } } @@ -588,26 +577,26 @@ CombineChannelsOperation::CombineChannelsOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); this->set_canvas_input_index(0); - m_inputChannel1Operation = nullptr; - m_inputChannel2Operation = nullptr; - m_inputChannel3Operation = nullptr; - m_inputChannel4Operation = nullptr; + inputChannel1Operation_ = nullptr; + inputChannel2Operation_ = nullptr; + inputChannel3Operation_ = nullptr; + inputChannel4Operation_ = nullptr; } void CombineChannelsOperation::initExecution() { - m_inputChannel1Operation = this->getInputSocketReader(0); - m_inputChannel2Operation = this->getInputSocketReader(1); - m_inputChannel3Operation = this->getInputSocketReader(2); - m_inputChannel4Operation = this->getInputSocketReader(3); + inputChannel1Operation_ = this->getInputSocketReader(0); + inputChannel2Operation_ = this->getInputSocketReader(1); + inputChannel3Operation_ = this->getInputSocketReader(2); + inputChannel4Operation_ = this->getInputSocketReader(3); } void CombineChannelsOperation::deinitExecution() { - m_inputChannel1Operation = nullptr; - m_inputChannel2Operation = nullptr; - m_inputChannel3Operation = nullptr; - m_inputChannel4Operation = nullptr; + inputChannel1Operation_ = nullptr; + inputChannel2Operation_ = nullptr; + inputChannel3Operation_ = nullptr; + inputChannel4Operation_ = nullptr; } void CombineChannelsOperation::executePixelSampled(float output[4], @@ -616,20 +605,20 @@ void CombineChannelsOperation::executePixelSampled(float output[4], PixelSampler sampler) { float input[4]; - if (m_inputChannel1Operation) { - m_inputChannel1Operation->readSampled(input, x, y, sampler); + if (inputChannel1Operation_) { + inputChannel1Operation_->readSampled(input, x, y, sampler); output[0] = input[0]; } - if (m_inputChannel2Operation) { - m_inputChannel2Operation->readSampled(input, x, y, sampler); + if (inputChannel2Operation_) { + inputChannel2Operation_->readSampled(input, x, y, sampler); output[1] = input[0]; } - if (m_inputChannel3Operation) { - m_inputChannel3Operation->readSampled(input, x, y, sampler); + if (inputChannel3Operation_) { + inputChannel3Operation_->readSampled(input, x, y, sampler); output[2] = input[0]; } - if (m_inputChannel4Operation) { - m_inputChannel4Operation->readSampled(input, x, y, sampler); + if (inputChannel4Operation_) { + inputChannel4Operation_->readSampled(input, x, y, sampler); output[3] = input[0]; } } diff --git a/source/blender/compositor/operations/COM_ConvertOperation.h b/source/blender/compositor/operations/COM_ConvertOperation.h index cd8e3016e97..9d4539c8faa 100644 --- a/source/blender/compositor/operations/COM_ConvertOperation.h +++ b/source/blender/compositor/operations/COM_ConvertOperation.h @@ -24,7 +24,7 @@ namespace blender::compositor { class ConvertBaseOperation : public MultiThreadedOperation { protected: - SocketReader *m_inputOperation; + SocketReader *inputOperation_; public: ConvertBaseOperation(); @@ -114,7 +114,7 @@ class ConvertVectorToValueOperation : public ConvertBaseOperation { class ConvertRGBToYCCOperation : public ConvertBaseOperation { private: /** YCbCr mode (Jpeg, ITU601, ITU709) */ - int m_mode; + int mode_; public: ConvertRGBToYCCOperation(); @@ -132,7 +132,7 @@ class ConvertRGBToYCCOperation : public ConvertBaseOperation { class ConvertYCCToRGBOperation : public ConvertBaseOperation { private: /** YCbCr mode (Jpeg, ITU601, ITU709) */ - int m_mode; + int mode_; public: ConvertYCCToRGBOperation(); @@ -209,8 +209,8 @@ class ConvertStraightToPremulOperation : public ConvertBaseOperation { class SeparateChannelOperation : public MultiThreadedOperation { private: - SocketReader *m_inputOperation; - int m_channel; + SocketReader *inputOperation_; + int channel_; public: SeparateChannelOperation(); @@ -221,7 +221,7 @@ class SeparateChannelOperation : public MultiThreadedOperation { void setChannel(int channel) { - m_channel = channel; + channel_ = channel; } void update_memory_buffer_partial(MemoryBuffer *output, @@ -231,10 +231,10 @@ class SeparateChannelOperation : public MultiThreadedOperation { class CombineChannelsOperation : public MultiThreadedOperation { private: - SocketReader *m_inputChannel1Operation; - SocketReader *m_inputChannel2Operation; - SocketReader *m_inputChannel3Operation; - SocketReader *m_inputChannel4Operation; + SocketReader *inputChannel1Operation_; + SocketReader *inputChannel2Operation_; + SocketReader *inputChannel3Operation_; + SocketReader *inputChannel4Operation_; public: CombineChannelsOperation(); diff --git a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cc b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cc index b768a5e80ba..343cc32b625 100644 --- a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cc +++ b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cc @@ -38,44 +38,44 @@ void ConvolutionEdgeFilterOperation::executePixel(float output[4], int x, int y, CLAMP(y3, 0, getHeight() - 1); float value[4]; - m_inputValueOperation->read(value, x2, y2, nullptr); + inputValueOperation_->read(value, x2, y2, nullptr); float mval = 1.0f - value[0]; - m_inputOperation->read(in1, x1, y1, nullptr); - madd_v3_v3fl(res1, in1, m_filter[0]); - madd_v3_v3fl(res2, in1, m_filter[0]); + inputOperation_->read(in1, x1, y1, nullptr); + madd_v3_v3fl(res1, in1, filter_[0]); + madd_v3_v3fl(res2, in1, filter_[0]); - m_inputOperation->read(in1, x2, y1, nullptr); - madd_v3_v3fl(res1, in1, m_filter[1]); - madd_v3_v3fl(res2, in1, m_filter[3]); + inputOperation_->read(in1, x2, y1, nullptr); + madd_v3_v3fl(res1, in1, filter_[1]); + madd_v3_v3fl(res2, in1, filter_[3]); - m_inputOperation->read(in1, x3, y1, nullptr); - madd_v3_v3fl(res1, in1, m_filter[2]); - madd_v3_v3fl(res2, in1, m_filter[6]); + inputOperation_->read(in1, x3, y1, nullptr); + madd_v3_v3fl(res1, in1, filter_[2]); + madd_v3_v3fl(res2, in1, filter_[6]); - m_inputOperation->read(in1, x1, y2, nullptr); - madd_v3_v3fl(res1, in1, m_filter[3]); - madd_v3_v3fl(res2, in1, m_filter[1]); + inputOperation_->read(in1, x1, y2, nullptr); + madd_v3_v3fl(res1, in1, filter_[3]); + madd_v3_v3fl(res2, in1, filter_[1]); - m_inputOperation->read(in2, x2, y2, nullptr); - madd_v3_v3fl(res1, in2, m_filter[4]); - madd_v3_v3fl(res2, in2, m_filter[4]); + inputOperation_->read(in2, x2, y2, nullptr); + madd_v3_v3fl(res1, in2, filter_[4]); + madd_v3_v3fl(res2, in2, filter_[4]); - m_inputOperation->read(in1, x3, y2, nullptr); - madd_v3_v3fl(res1, in1, m_filter[5]); - madd_v3_v3fl(res2, in1, m_filter[7]); + inputOperation_->read(in1, x3, y2, nullptr); + madd_v3_v3fl(res1, in1, filter_[5]); + madd_v3_v3fl(res2, in1, filter_[7]); - m_inputOperation->read(in1, x1, y3, nullptr); - madd_v3_v3fl(res1, in1, m_filter[6]); - madd_v3_v3fl(res2, in1, m_filter[2]); + inputOperation_->read(in1, x1, y3, nullptr); + madd_v3_v3fl(res1, in1, filter_[6]); + madd_v3_v3fl(res2, in1, filter_[2]); - m_inputOperation->read(in1, x2, y3, nullptr); - madd_v3_v3fl(res1, in1, m_filter[7]); - madd_v3_v3fl(res2, in1, m_filter[5]); + inputOperation_->read(in1, x2, y3, nullptr); + madd_v3_v3fl(res1, in1, filter_[7]); + madd_v3_v3fl(res2, in1, filter_[5]); - m_inputOperation->read(in1, x3, y3, nullptr); - madd_v3_v3fl(res1, in1, m_filter[8]); - madd_v3_v3fl(res2, in1, m_filter[8]); + inputOperation_->read(in1, x3, y3, nullptr); + madd_v3_v3fl(res1, in1, filter_[8]); + madd_v3_v3fl(res2, in1, filter_[8]); output[0] = sqrt(res1[0] * res1[0] + res2[0] * res2[0]); output[1] = sqrt(res1[1] * res1[1] + res2[1] * res2[1]); @@ -112,44 +112,44 @@ void ConvolutionEdgeFilterOperation::update_memory_buffer_partial(MemoryBuffer * float res2[4] = {0}; const float *color = center_color + down_offset + left_offset; - madd_v3_v3fl(res1, color, m_filter[0]); + madd_v3_v3fl(res1, color, filter_[0]); copy_v3_v3(res2, res1); color = center_color + down_offset; - madd_v3_v3fl(res1, color, m_filter[1]); - madd_v3_v3fl(res2, color, m_filter[3]); + madd_v3_v3fl(res1, color, filter_[1]); + madd_v3_v3fl(res2, color, filter_[3]); color = center_color + down_offset + right_offset; - madd_v3_v3fl(res1, color, m_filter[2]); - madd_v3_v3fl(res2, color, m_filter[6]); + madd_v3_v3fl(res1, color, filter_[2]); + madd_v3_v3fl(res2, color, filter_[6]); color = center_color + left_offset; - madd_v3_v3fl(res1, color, m_filter[3]); - madd_v3_v3fl(res2, color, m_filter[1]); + madd_v3_v3fl(res1, color, filter_[3]); + madd_v3_v3fl(res2, color, filter_[1]); { float rgb_filtered[3]; - mul_v3_v3fl(rgb_filtered, center_color, m_filter[4]); + mul_v3_v3fl(rgb_filtered, center_color, filter_[4]); add_v3_v3(res1, rgb_filtered); add_v3_v3(res2, rgb_filtered); } color = center_color + right_offset; - madd_v3_v3fl(res1, color, m_filter[5]); - madd_v3_v3fl(res2, color, m_filter[7]); + madd_v3_v3fl(res1, color, filter_[5]); + madd_v3_v3fl(res2, color, filter_[7]); color = center_color + up_offset + left_offset; - madd_v3_v3fl(res1, color, m_filter[6]); - madd_v3_v3fl(res2, color, m_filter[2]); + madd_v3_v3fl(res1, color, filter_[6]); + madd_v3_v3fl(res2, color, filter_[2]); color = center_color + up_offset; - madd_v3_v3fl(res1, color, m_filter[7]); - madd_v3_v3fl(res2, color, m_filter[5]); + madd_v3_v3fl(res1, color, filter_[7]); + madd_v3_v3fl(res2, color, filter_[5]); { color = center_color + up_offset + right_offset; float rgb_filtered[3]; - mul_v3_v3fl(rgb_filtered, color, m_filter[8]); + mul_v3_v3fl(rgb_filtered, color, filter_[8]); add_v3_v3(res1, rgb_filtered); add_v3_v3(res2, rgb_filtered); } @@ -159,10 +159,10 @@ void ConvolutionEdgeFilterOperation::update_memory_buffer_partial(MemoryBuffer * it.out[2] = sqrt(res1[2] * res1[2] + res2[2] * res2[2]); const float factor = *it.in(FACTOR_INPUT_INDEX); - const float m_factor = 1.0f - factor; - it.out[0] = it.out[0] * factor + center_color[0] * m_factor; - it.out[1] = it.out[1] * factor + center_color[1] * m_factor; - it.out[2] = it.out[2] * factor + center_color[2] * m_factor; + const float factor_ = 1.0f - factor; + it.out[0] = it.out[0] * factor + center_color[0] * factor_; + it.out[1] = it.out[1] * factor + center_color[1] * factor_; + it.out[2] = it.out[2] * factor + center_color[2] * factor_; it.out[3] = center_color[3]; diff --git a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cc b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cc index f438f01e11a..a4ef88e7a33 100644 --- a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cc +++ b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cc @@ -26,35 +26,35 @@ ConvolutionFilterOperation::ConvolutionFilterOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); this->set_canvas_input_index(0); - m_inputOperation = nullptr; + inputOperation_ = nullptr; this->flags.complex = true; } void ConvolutionFilterOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); - m_inputValueOperation = this->getInputSocketReader(1); + inputOperation_ = this->getInputSocketReader(0); + inputValueOperation_ = this->getInputSocketReader(1); } void ConvolutionFilterOperation::set3x3Filter( float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9) { - m_filter[0] = f1; - m_filter[1] = f2; - m_filter[2] = f3; - m_filter[3] = f4; - m_filter[4] = f5; - m_filter[5] = f6; - m_filter[6] = f7; - m_filter[7] = f8; - m_filter[8] = f9; - m_filterHeight = 3; - m_filterWidth = 3; + filter_[0] = f1; + filter_[1] = f2; + filter_[2] = f3; + filter_[3] = f4; + filter_[4] = f5; + filter_[5] = f6; + filter_[6] = f7; + filter_[7] = f8; + filter_[8] = f9; + filterHeight_ = 3; + filterWidth_ = 3; } void ConvolutionFilterOperation::deinitExecution() { - m_inputOperation = nullptr; - m_inputValueOperation = nullptr; + inputOperation_ = nullptr; + inputValueOperation_ = nullptr; } void ConvolutionFilterOperation::executePixel(float output[4], int x, int y, void * /*data*/) @@ -74,28 +74,28 @@ void ConvolutionFilterOperation::executePixel(float output[4], int x, int y, voi CLAMP(y2, 0, getHeight() - 1); CLAMP(y3, 0, getHeight() - 1); float value[4]; - m_inputValueOperation->read(value, x2, y2, nullptr); + inputValueOperation_->read(value, x2, y2, nullptr); const float mval = 1.0f - value[0]; zero_v4(output); - m_inputOperation->read(in1, x1, y1, nullptr); - madd_v4_v4fl(output, in1, m_filter[0]); - m_inputOperation->read(in1, x2, y1, nullptr); - madd_v4_v4fl(output, in1, m_filter[1]); - m_inputOperation->read(in1, x3, y1, nullptr); - madd_v4_v4fl(output, in1, m_filter[2]); - m_inputOperation->read(in1, x1, y2, nullptr); - madd_v4_v4fl(output, in1, m_filter[3]); - m_inputOperation->read(in2, x2, y2, nullptr); - madd_v4_v4fl(output, in2, m_filter[4]); - m_inputOperation->read(in1, x3, y2, nullptr); - madd_v4_v4fl(output, in1, m_filter[5]); - m_inputOperation->read(in1, x1, y3, nullptr); - madd_v4_v4fl(output, in1, m_filter[6]); - m_inputOperation->read(in1, x2, y3, nullptr); - madd_v4_v4fl(output, in1, m_filter[7]); - m_inputOperation->read(in1, x3, y3, nullptr); - madd_v4_v4fl(output, in1, m_filter[8]); + inputOperation_->read(in1, x1, y1, nullptr); + madd_v4_v4fl(output, in1, filter_[0]); + inputOperation_->read(in1, x2, y1, nullptr); + madd_v4_v4fl(output, in1, filter_[1]); + inputOperation_->read(in1, x3, y1, nullptr); + madd_v4_v4fl(output, in1, filter_[2]); + inputOperation_->read(in1, x1, y2, nullptr); + madd_v4_v4fl(output, in1, filter_[3]); + inputOperation_->read(in2, x2, y2, nullptr); + madd_v4_v4fl(output, in2, filter_[4]); + inputOperation_->read(in1, x3, y2, nullptr); + madd_v4_v4fl(output, in1, filter_[5]); + inputOperation_->read(in1, x1, y3, nullptr); + madd_v4_v4fl(output, in1, filter_[6]); + inputOperation_->read(in1, x2, y3, nullptr); + madd_v4_v4fl(output, in1, filter_[7]); + inputOperation_->read(in1, x3, y3, nullptr); + madd_v4_v4fl(output, in1, filter_[8]); output[0] = output[0] * value[0] + in2[0] * mval; output[1] = output[1] * value[0] + in2[1] * mval; @@ -113,8 +113,8 @@ bool ConvolutionFilterOperation::determineDependingAreaOfInterest( rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newInput; - int addx = (m_filterWidth - 1) / 2 + 1; - int addy = (m_filterHeight - 1) / 2 + 1; + int addx = (filterWidth_ - 1) / 2 + 1; + int addy = (filterHeight_ - 1) / 2 + 1; newInput.xmax = input->xmax + addx; newInput.xmin = input->xmin - addx; newInput.ymax = input->ymax + addy; @@ -129,8 +129,8 @@ void ConvolutionFilterOperation::get_area_of_interest(const int input_idx, { switch (input_idx) { case IMAGE_INPUT_INDEX: { - const int add_x = (m_filterWidth - 1) / 2 + 1; - const int add_y = (m_filterHeight - 1) / 2 + 1; + const int add_x = (filterWidth_ - 1) / 2 + 1; + const int add_y = (filterHeight_ - 1) / 2 + 1; r_input_area.xmin = output_area.xmin - add_x; r_input_area.xmax = output_area.xmax + add_x; r_input_area.ymin = output_area.ymin - add_y; @@ -159,22 +159,22 @@ void ConvolutionFilterOperation::update_memory_buffer_partial(MemoryBuffer *outp const float *center_color = it.in(IMAGE_INPUT_INDEX); zero_v4(it.out); - madd_v4_v4fl(it.out, center_color + down_offset + left_offset, m_filter[0]); - madd_v4_v4fl(it.out, center_color + down_offset, m_filter[1]); - madd_v4_v4fl(it.out, center_color + down_offset + right_offset, m_filter[2]); - madd_v4_v4fl(it.out, center_color + left_offset, m_filter[3]); - madd_v4_v4fl(it.out, center_color, m_filter[4]); - madd_v4_v4fl(it.out, center_color + right_offset, m_filter[5]); - madd_v4_v4fl(it.out, center_color + up_offset + left_offset, m_filter[6]); - madd_v4_v4fl(it.out, center_color + up_offset, m_filter[7]); - madd_v4_v4fl(it.out, center_color + up_offset + right_offset, m_filter[8]); + madd_v4_v4fl(it.out, center_color + down_offset + left_offset, filter_[0]); + madd_v4_v4fl(it.out, center_color + down_offset, filter_[1]); + madd_v4_v4fl(it.out, center_color + down_offset + right_offset, filter_[2]); + madd_v4_v4fl(it.out, center_color + left_offset, filter_[3]); + madd_v4_v4fl(it.out, center_color, filter_[4]); + madd_v4_v4fl(it.out, center_color + right_offset, filter_[5]); + madd_v4_v4fl(it.out, center_color + up_offset + left_offset, filter_[6]); + madd_v4_v4fl(it.out, center_color + up_offset, filter_[7]); + madd_v4_v4fl(it.out, center_color + up_offset + right_offset, filter_[8]); const float factor = *it.in(FACTOR_INPUT_INDEX); - const float m_factor = 1.0f - factor; - it.out[0] = it.out[0] * factor + center_color[0] * m_factor; - it.out[1] = it.out[1] * factor + center_color[1] * m_factor; - it.out[2] = it.out[2] * factor + center_color[2] * m_factor; - it.out[3] = it.out[3] * factor + center_color[3] * m_factor; + const float factor_ = 1.0f - factor; + it.out[0] = it.out[0] * factor + center_color[0] * factor_; + it.out[1] = it.out[1] * factor + center_color[1] * factor_; + it.out[2] = it.out[2] * factor + center_color[2] * factor_; + it.out[3] = it.out[3] * factor + center_color[3] * factor_; /* Make sure we don't return negative color. */ CLAMP4_MIN(it.out, 0.0f); diff --git a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h index 7e12c7faa5c..7000a0f69d6 100644 --- a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h +++ b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h @@ -28,13 +28,13 @@ class ConvolutionFilterOperation : public MultiThreadedOperation { static constexpr int FACTOR_INPUT_INDEX = 1; private: - int m_filterWidth; - int m_filterHeight; + int filterWidth_; + int filterHeight_; protected: - SocketReader *m_inputOperation; - SocketReader *m_inputValueOperation; - float m_filter[9]; + SocketReader *inputOperation_; + SocketReader *inputValueOperation_; + float filter_[9]; public: ConvolutionFilterOperation(); diff --git a/source/blender/compositor/operations/COM_CropOperation.cc b/source/blender/compositor/operations/COM_CropOperation.cc index d1443e3e571..d8a402cc582 100644 --- a/source/blender/compositor/operations/COM_CropOperation.cc +++ b/source/blender/compositor/operations/COM_CropOperation.cc @@ -24,8 +24,8 @@ CropBaseOperation::CropBaseOperation() { this->addInputSocket(DataType::Color, ResizeMode::Align); this->addOutputSocket(DataType::Color); - m_inputOperation = nullptr; - m_settings = nullptr; + inputOperation_ = nullptr; + settings_ = nullptr; } void CropBaseOperation::updateArea() @@ -33,10 +33,10 @@ void CropBaseOperation::updateArea() SocketReader *inputReference = this->getInputSocketReader(0); float width = inputReference->getWidth(); float height = inputReference->getHeight(); - NodeTwoXYs local_settings = *m_settings; + NodeTwoXYs local_settings = *settings_; if (width > 0.0f && height > 0.0f) { - if (m_relative) { + if (relative_) { local_settings.x1 = width * local_settings.fac_x1; local_settings.x2 = width * local_settings.fac_x2; local_settings.y1 = height * local_settings.fac_y1; @@ -55,28 +55,28 @@ void CropBaseOperation::updateArea() local_settings.y2 = height - 1; } - m_xmax = MAX2(local_settings.x1, local_settings.x2) + 1; - m_xmin = MIN2(local_settings.x1, local_settings.x2); - m_ymax = MAX2(local_settings.y1, local_settings.y2) + 1; - m_ymin = MIN2(local_settings.y1, local_settings.y2); + xmax_ = MAX2(local_settings.x1, local_settings.x2) + 1; + xmin_ = MIN2(local_settings.x1, local_settings.x2); + ymax_ = MAX2(local_settings.y1, local_settings.y2) + 1; + ymin_ = MIN2(local_settings.y1, local_settings.y2); } else { - m_xmax = 0; - m_xmin = 0; - m_ymax = 0; - m_ymin = 0; + xmax_ = 0; + xmin_ = 0; + ymax_ = 0; + ymin_ = 0; } } void CropBaseOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); updateArea(); } void CropBaseOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } CropOperation::CropOperation() : CropBaseOperation() @@ -86,8 +86,8 @@ CropOperation::CropOperation() : CropBaseOperation() void CropOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) { - if ((x < m_xmax && x >= m_xmin) && (y < m_ymax && y >= m_ymin)) { - m_inputOperation->readSampled(output, x, y, sampler); + if ((x < xmax_ && x >= xmin_) && (y < ymax_ && y >= ymin_)) { + inputOperation_->readSampled(output, x, y, sampler); } else { zero_v4(output); @@ -99,7 +99,7 @@ void CropOperation::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> inputs) { rcti crop_area; - BLI_rcti_init(&crop_area, m_xmin, m_xmax, m_ymin, m_ymax); + BLI_rcti_init(&crop_area, xmin_, xmax_, ymin_, ymax_); for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { if (BLI_rcti_isect_pt(&crop_area, it.x, it.y)) { copy_v4_v4(it.out, it.in(0)); @@ -121,10 +121,10 @@ bool CropImageOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - newInput.xmax = input->xmax + m_xmin; - newInput.xmin = input->xmin + m_xmin; - newInput.ymax = input->ymax + m_ymin; - newInput.ymin = input->ymin + m_ymin; + newInput.xmax = input->xmax + xmin_; + newInput.xmin = input->xmin + xmin_; + newInput.ymax = input->ymax + ymin_; + newInput.ymin = input->ymin + ymin_; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -135,18 +135,18 @@ void CropImageOperation::get_area_of_interest(const int input_idx, { BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - r_input_area.xmax = output_area.xmax + m_xmin; - r_input_area.xmin = output_area.xmin + m_xmin; - r_input_area.ymax = output_area.ymax + m_ymin; - r_input_area.ymin = output_area.ymin + m_ymin; + r_input_area.xmax = output_area.xmax + xmin_; + r_input_area.xmin = output_area.xmin + xmin_; + r_input_area.ymax = output_area.ymax + ymin_; + r_input_area.ymin = output_area.ymin + ymin_; } void CropImageOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { NodeOperation::determine_canvas(preferred_area, r_area); updateArea(); - r_area.xmax = r_area.xmin + (m_xmax - m_xmin); - r_area.ymax = r_area.ymin + (m_ymax - m_ymin); + r_area.xmax = r_area.xmin + (xmax_ - xmin_); + r_area.ymax = r_area.ymin + (ymax_ - ymin_); } void CropImageOperation::executePixelSampled(float output[4], @@ -155,7 +155,7 @@ void CropImageOperation::executePixelSampled(float output[4], PixelSampler sampler) { if (x >= 0 && x < getWidth() && y >= 0 && y < getHeight()) { - m_inputOperation->readSampled(output, (x + m_xmin), (y + m_ymin), sampler); + inputOperation_->readSampled(output, (x + xmin_), (y + ymin_), sampler); } else { zero_v4(output); @@ -171,7 +171,7 @@ void CropImageOperation::update_memory_buffer_partial(MemoryBuffer *output, const MemoryBuffer *input = inputs[0]; for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { if (BLI_rcti_isect_pt(&op_area, it.x, it.y)) { - input->read_elem_checked(it.x + m_xmin, it.y + m_ymin, it.out); + input->read_elem_checked(it.x + xmin_, it.y + ymin_, it.out); } else { zero_v4(it.out); diff --git a/source/blender/compositor/operations/COM_CropOperation.h b/source/blender/compositor/operations/COM_CropOperation.h index 49d0a70fb4e..50d4d3c5126 100644 --- a/source/blender/compositor/operations/COM_CropOperation.h +++ b/source/blender/compositor/operations/COM_CropOperation.h @@ -24,13 +24,13 @@ namespace blender::compositor { class CropBaseOperation : public MultiThreadedOperation { protected: - SocketReader *m_inputOperation; - NodeTwoXYs *m_settings; - bool m_relative; - int m_xmax; - int m_xmin; - int m_ymax; - int m_ymin; + SocketReader *inputOperation_; + NodeTwoXYs *settings_; + bool relative_; + int xmax_; + int xmin_; + int ymax_; + int ymin_; void updateArea(); @@ -40,11 +40,11 @@ class CropBaseOperation : public MultiThreadedOperation { void deinitExecution() override; void setCropSettings(NodeTwoXYs *settings) { - m_settings = settings; + settings_ = settings; } void setRelative(bool rel) { - m_relative = rel; + relative_ = rel; } }; diff --git a/source/blender/compositor/operations/COM_CryptomatteOperation.cc b/source/blender/compositor/operations/COM_CryptomatteOperation.cc index 02e7c5607d8..a6b9e2c2ee4 100644 --- a/source/blender/compositor/operations/COM_CryptomatteOperation.cc +++ b/source/blender/compositor/operations/COM_CryptomatteOperation.cc @@ -40,7 +40,7 @@ void CryptomatteOperation::initExecution() void CryptomatteOperation::addObjectIndex(float objectIndex) { if (objectIndex != 0.0f) { - m_objectIndex.append(objectIndex); + objectIndex_.append(objectIndex); } } @@ -60,7 +60,7 @@ void CryptomatteOperation::executePixel(float output[4], int x, int y, void *dat output[1] = ((float)(m3hash << 8) / (float)UINT32_MAX); output[2] = ((float)(m3hash << 16) / (float)UINT32_MAX); } - for (float hash : m_objectIndex) { + for (float hash : objectIndex_) { if (input[0] == hash) { output[3] += input[1]; } @@ -89,7 +89,7 @@ void CryptomatteOperation::update_memory_buffer_partial(MemoryBuffer *output, it.out[1] = ((float)(m3hash << 8) / (float)UINT32_MAX); it.out[2] = ((float)(m3hash << 16) / (float)UINT32_MAX); } - for (const float hash : m_objectIndex) { + for (const float hash : objectIndex_) { if (input[0] == hash) { it.out[3] += input[1]; } diff --git a/source/blender/compositor/operations/COM_CryptomatteOperation.h b/source/blender/compositor/operations/COM_CryptomatteOperation.h index f1bf4cdf624..039b4e3b07a 100644 --- a/source/blender/compositor/operations/COM_CryptomatteOperation.h +++ b/source/blender/compositor/operations/COM_CryptomatteOperation.h @@ -24,7 +24,7 @@ namespace blender::compositor { class CryptomatteOperation : public MultiThreadedOperation { private: - Vector<float> m_objectIndex; + Vector<float> objectIndex_; public: Vector<SocketReader *> inputs; diff --git a/source/blender/compositor/operations/COM_CurveBaseOperation.cc b/source/blender/compositor/operations/COM_CurveBaseOperation.cc index 5a0d6581f2c..9ae4cad73d3 100644 --- a/source/blender/compositor/operations/COM_CurveBaseOperation.cc +++ b/source/blender/compositor/operations/COM_CurveBaseOperation.cc @@ -24,37 +24,37 @@ namespace blender::compositor { CurveBaseOperation::CurveBaseOperation() { - m_curveMapping = nullptr; + curveMapping_ = nullptr; this->flags.can_be_constant = true; } CurveBaseOperation::~CurveBaseOperation() { - if (m_curveMapping) { - BKE_curvemapping_free(m_curveMapping); - m_curveMapping = nullptr; + if (curveMapping_) { + BKE_curvemapping_free(curveMapping_); + curveMapping_ = nullptr; } } void CurveBaseOperation::initExecution() { - BKE_curvemapping_init(m_curveMapping); + BKE_curvemapping_init(curveMapping_); } void CurveBaseOperation::deinitExecution() { - if (m_curveMapping) { - BKE_curvemapping_free(m_curveMapping); - m_curveMapping = nullptr; + if (curveMapping_) { + BKE_curvemapping_free(curveMapping_); + curveMapping_ = nullptr; } } void CurveBaseOperation::setCurveMapping(CurveMapping *mapping) { /* duplicate the curve to avoid glitches while drawing, see bug T32374. */ - if (m_curveMapping) { - BKE_curvemapping_free(m_curveMapping); + if (curveMapping_) { + BKE_curvemapping_free(curveMapping_); } - m_curveMapping = BKE_curvemapping_copy(mapping); + curveMapping_ = BKE_curvemapping_copy(mapping); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_CurveBaseOperation.h b/source/blender/compositor/operations/COM_CurveBaseOperation.h index 27d3a68608c..70e9fa9da76 100644 --- a/source/blender/compositor/operations/COM_CurveBaseOperation.h +++ b/source/blender/compositor/operations/COM_CurveBaseOperation.h @@ -29,7 +29,7 @@ class CurveBaseOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - CurveMapping *m_curveMapping; + CurveMapping *curveMapping_; public: CurveBaseOperation(); diff --git a/source/blender/compositor/operations/COM_DenoiseOperation.cc b/source/blender/compositor/operations/COM_DenoiseOperation.cc index fa702558a20..2e41181559e 100644 --- a/source/blender/compositor/operations/COM_DenoiseOperation.cc +++ b/source/blender/compositor/operations/COM_DenoiseOperation.cc @@ -160,21 +160,21 @@ DenoiseOperation::DenoiseOperation() this->addInputSocket(DataType::Vector); this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_settings = nullptr; + settings_ = nullptr; } void DenoiseOperation::initExecution() { SingleThreadedOperation::initExecution(); - m_inputProgramColor = getInputSocketReader(0); - m_inputProgramNormal = getInputSocketReader(1); - m_inputProgramAlbedo = getInputSocketReader(2); + inputProgramColor_ = getInputSocketReader(0); + inputProgramNormal_ = getInputSocketReader(1); + inputProgramAlbedo_ = getInputSocketReader(2); } void DenoiseOperation::deinitExecution() { - m_inputProgramColor = nullptr; - m_inputProgramNormal = nullptr; - m_inputProgramAlbedo = nullptr; + inputProgramColor_ = nullptr; + inputProgramNormal_ = nullptr; + inputProgramAlbedo_ = nullptr; SingleThreadedOperation::deinitExecution(); } @@ -192,23 +192,23 @@ static bool are_guiding_passes_noise_free(NodeDenoise *settings) void DenoiseOperation::hash_output_params() { - if (m_settings) { - hash_params((int)m_settings->hdr, are_guiding_passes_noise_free(m_settings)); + if (settings_) { + hash_params((int)settings_->hdr, are_guiding_passes_noise_free(settings_)); } } MemoryBuffer *DenoiseOperation::createMemoryBuffer(rcti *rect2) { - MemoryBuffer *tileColor = (MemoryBuffer *)m_inputProgramColor->initializeTileData(rect2); - MemoryBuffer *tileNormal = (MemoryBuffer *)m_inputProgramNormal->initializeTileData(rect2); - MemoryBuffer *tileAlbedo = (MemoryBuffer *)m_inputProgramAlbedo->initializeTileData(rect2); + MemoryBuffer *tileColor = (MemoryBuffer *)inputProgramColor_->initializeTileData(rect2); + MemoryBuffer *tileNormal = (MemoryBuffer *)inputProgramNormal_->initializeTileData(rect2); + MemoryBuffer *tileAlbedo = (MemoryBuffer *)inputProgramAlbedo_->initializeTileData(rect2); rcti rect; rect.xmin = 0; rect.ymin = 0; rect.xmax = getWidth(); rect.ymax = getHeight(); MemoryBuffer *result = new MemoryBuffer(DataType::Color, rect); - this->generateDenoise(result, tileColor, tileNormal, tileAlbedo, m_settings); + this->generateDenoise(result, tileColor, tileNormal, tileAlbedo, settings_); return result; } @@ -270,7 +270,7 @@ void DenoiseOperation::update_memory_buffer(MemoryBuffer *output, Span<MemoryBuffer *> inputs) { if (!output_rendered_) { - this->generateDenoise(output, inputs[0], inputs[1], inputs[2], m_settings); + this->generateDenoise(output, inputs[0], inputs[1], inputs[2], settings_); output_rendered_ = true; } } diff --git a/source/blender/compositor/operations/COM_DenoiseOperation.h b/source/blender/compositor/operations/COM_DenoiseOperation.h index e5b7ebbfeca..24852009e6d 100644 --- a/source/blender/compositor/operations/COM_DenoiseOperation.h +++ b/source/blender/compositor/operations/COM_DenoiseOperation.h @@ -45,14 +45,14 @@ class DenoiseOperation : public DenoiseBaseOperation { /** * \brief Cached reference to the input programs */ - SocketReader *m_inputProgramColor; - SocketReader *m_inputProgramAlbedo; - SocketReader *m_inputProgramNormal; + SocketReader *inputProgramColor_; + SocketReader *inputProgramAlbedo_; + SocketReader *inputProgramNormal_; /** * \brief settings of the denoise node. */ - NodeDenoise *m_settings; + NodeDenoise *settings_; public: DenoiseOperation(); @@ -68,7 +68,7 @@ class DenoiseOperation : public DenoiseBaseOperation { void setDenoiseSettings(NodeDenoise *settings) { - m_settings = settings; + settings_ = settings; } void update_memory_buffer(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_DespeckleOperation.cc b/source/blender/compositor/operations/COM_DespeckleOperation.cc index a317cdcc7f0..f655c17fdf2 100644 --- a/source/blender/compositor/operations/COM_DespeckleOperation.cc +++ b/source/blender/compositor/operations/COM_DespeckleOperation.cc @@ -28,19 +28,19 @@ DespeckleOperation::DespeckleOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); this->set_canvas_input_index(0); - m_inputOperation = nullptr; + inputOperation_ = nullptr; this->flags.complex = true; } void DespeckleOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); - m_inputValueOperation = this->getInputSocketReader(1); + inputOperation_ = this->getInputSocketReader(0); + inputValueOperation_ = this->getInputSocketReader(1); } void DespeckleOperation::deinitExecution() { - m_inputOperation = nullptr; - m_inputValueOperation = nullptr; + inputOperation_ = nullptr; + inputValueOperation_ = nullptr; } BLI_INLINE int color_diff(const float a[3], const float b[3], const float threshold) @@ -69,10 +69,10 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da CLAMP(y2, 0, getHeight() - 1); CLAMP(y3, 0, getHeight() - 1); float value[4]; - m_inputValueOperation->read(value, x2, y2, nullptr); + inputValueOperation_->read(value, x2, y2, nullptr); // const float mval = 1.0f - value[0]; - m_inputOperation->read(color_org, x2, y2, nullptr); + inputOperation_->read(color_org, x2, y2, nullptr); #define TOT_DIV_ONE 1.0f #define TOT_DIV_CNR (float)M_SQRT1_2 @@ -82,7 +82,7 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da #define COLOR_ADD(fac) \ { \ madd_v4_v4fl(color_mid, in1, fac); \ - if (color_diff(in1, color_org, m_threshold)) { \ + if (color_diff(in1, color_org, threshold_)) { \ w += fac; \ madd_v4_v4fl(color_mid_ok, in1, fac); \ } \ @@ -91,34 +91,34 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da zero_v4(color_mid); zero_v4(color_mid_ok); - m_inputOperation->read(in1, x1, y1, nullptr); + inputOperation_->read(in1, x1, y1, nullptr); COLOR_ADD(TOT_DIV_CNR) - m_inputOperation->read(in1, x2, y1, nullptr); + inputOperation_->read(in1, x2, y1, nullptr); COLOR_ADD(TOT_DIV_ONE) - m_inputOperation->read(in1, x3, y1, nullptr); + inputOperation_->read(in1, x3, y1, nullptr); COLOR_ADD(TOT_DIV_CNR) - m_inputOperation->read(in1, x1, y2, nullptr); + inputOperation_->read(in1, x1, y2, nullptr); COLOR_ADD(TOT_DIV_ONE) #if 0 - m_inputOperation->read(in2, x2, y2, nullptr); - madd_v4_v4fl(color_mid, in2, m_filter[4]); + inputOperation_->read(in2, x2, y2, nullptr); + madd_v4_v4fl(color_mid, in2, filter_[4]); #endif - m_inputOperation->read(in1, x3, y2, nullptr); + inputOperation_->read(in1, x3, y2, nullptr); COLOR_ADD(TOT_DIV_ONE) - m_inputOperation->read(in1, x1, y3, nullptr); + inputOperation_->read(in1, x1, y3, nullptr); COLOR_ADD(TOT_DIV_CNR) - m_inputOperation->read(in1, x2, y3, nullptr); + inputOperation_->read(in1, x2, y3, nullptr); COLOR_ADD(TOT_DIV_ONE) - m_inputOperation->read(in1, x3, y3, nullptr); + inputOperation_->read(in1, x3, y3, nullptr); COLOR_ADD(TOT_DIV_CNR) mul_v4_fl(color_mid, 1.0f / (4.0f + (4.0f * (float)M_SQRT1_2))); // mul_v4_fl(color_mid, 1.0f / w); - if ((w != 0.0f) && ((w / WTOT) > (m_threshold_neighbor)) && - color_diff(color_mid, color_org, m_threshold)) { + if ((w != 0.0f) && ((w / WTOT) > (threshold_neighbor_)) && + color_diff(color_mid, color_org, threshold_)) { mul_v4_fl(color_mid_ok, 1.0f / w); interp_v4_v4v4(output, color_org, color_mid_ok, value[0]); } @@ -137,8 +137,8 @@ bool DespeckleOperation::determineDependingAreaOfInterest(rcti *input, rcti *output) { rcti newInput; - int addx = 2; //(m_filterWidth - 1) / 2 + 1; - int addy = 2; //(m_filterHeight - 1) / 2 + 1; + int addx = 2; //(filterWidth_ - 1) / 2 + 1; + int addy = 2; //(filterHeight_ - 1) / 2 + 1; newInput.xmax = input->xmax + addx; newInput.xmin = input->xmin - addx; newInput.ymax = input->ymax + addy; @@ -153,8 +153,8 @@ void DespeckleOperation::get_area_of_interest(const int input_idx, { switch (input_idx) { case IMAGE_INPUT_INDEX: { - const int add_x = 2; //(m_filterWidth - 1) / 2 + 1; - const int add_y = 2; //(m_filterHeight - 1) / 2 + 1; + const int add_x = 2; //(filterWidth_ - 1) / 2 + 1; + const int add_y = 2; //(filterHeight_ - 1) / 2 + 1; r_input_area.xmin = output_area.xmin - add_x; r_input_area.xmax = output_area.xmax + add_x; r_input_area.ymin = output_area.ymin - add_y; @@ -197,7 +197,7 @@ void DespeckleOperation::update_memory_buffer_partial(MemoryBuffer *output, #define COLOR_ADD(fac) \ { \ madd_v4_v4fl(color_mid, in1, fac); \ - if (color_diff(in1, color_org, m_threshold)) { \ + if (color_diff(in1, color_org, threshold_)) { \ w += fac; \ madd_v4_v4fl(color_mid_ok, in1, fac); \ } \ @@ -217,7 +217,7 @@ void DespeckleOperation::update_memory_buffer_partial(MemoryBuffer *output, #if 0 const float* in2 = image->get_elem(x2, y2); - madd_v4_v4fl(color_mid, in2, m_filter[4]); + madd_v4_v4fl(color_mid, in2, filter_[4]); #endif in1 = image->get_elem(x3, y2); @@ -232,8 +232,8 @@ void DespeckleOperation::update_memory_buffer_partial(MemoryBuffer *output, mul_v4_fl(color_mid, 1.0f / (4.0f + (4.0f * (float)M_SQRT1_2))); // mul_v4_fl(color_mid, 1.0f / w); - if ((w != 0.0f) && ((w / WTOT) > (m_threshold_neighbor)) && - color_diff(color_mid, color_org, m_threshold)) { + if ((w != 0.0f) && ((w / WTOT) > (threshold_neighbor_)) && + color_diff(color_mid, color_org, threshold_)) { const float factor = *it.in(FACTOR_INPUT_INDEX); mul_v4_fl(color_mid_ok, 1.0f / w); interp_v4_v4v4(it.out, color_org, color_mid_ok, factor); diff --git a/source/blender/compositor/operations/COM_DespeckleOperation.h b/source/blender/compositor/operations/COM_DespeckleOperation.h index a77010f1853..9aca01000a7 100644 --- a/source/blender/compositor/operations/COM_DespeckleOperation.h +++ b/source/blender/compositor/operations/COM_DespeckleOperation.h @@ -27,15 +27,15 @@ class DespeckleOperation : public MultiThreadedOperation { constexpr static int IMAGE_INPUT_INDEX = 0; constexpr static int FACTOR_INPUT_INDEX = 1; - float m_threshold; - float m_threshold_neighbor; + float threshold_; + float threshold_neighbor_; - // int m_filterWidth; - // int m_filterHeight; + // int filterWidth_; + // int filterHeight_; protected: - SocketReader *m_inputOperation; - SocketReader *m_inputValueOperation; + SocketReader *inputOperation_; + SocketReader *inputValueOperation_; public: DespeckleOperation(); @@ -46,11 +46,11 @@ class DespeckleOperation : public MultiThreadedOperation { void setThreshold(float threshold) { - m_threshold = threshold; + threshold_ = threshold; } void setThresholdNeighbor(float threshold) { - m_threshold_neighbor = threshold; + threshold_neighbor_ = threshold; } void initExecution() override; diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cc b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cc index 25004d947aa..d5f11ff8e35 100644 --- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cc +++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cc @@ -26,20 +26,20 @@ DifferenceMatteOperation::DifferenceMatteOperation() addInputSocket(DataType::Color); addOutputSocket(DataType::Value); - m_inputImage1Program = nullptr; - m_inputImage2Program = nullptr; + inputImage1Program_ = nullptr; + inputImage2Program_ = nullptr; flags.can_be_constant = true; } void DifferenceMatteOperation::initExecution() { - m_inputImage1Program = this->getInputSocketReader(0); - m_inputImage2Program = this->getInputSocketReader(1); + inputImage1Program_ = this->getInputSocketReader(0); + inputImage2Program_ = this->getInputSocketReader(1); } void DifferenceMatteOperation::deinitExecution() { - m_inputImage1Program = nullptr; - m_inputImage2Program = nullptr; + inputImage1Program_ = nullptr; + inputImage2Program_ = nullptr; } void DifferenceMatteOperation::executePixelSampled(float output[4], @@ -50,13 +50,13 @@ void DifferenceMatteOperation::executePixelSampled(float output[4], float inColor1[4]; float inColor2[4]; - const float tolerance = m_settings->t1; - const float falloff = m_settings->t2; + const float tolerance = settings_->t1; + const float falloff = settings_->t2; float difference; float alpha; - m_inputImage1Program->readSampled(inColor1, x, y, sampler); - m_inputImage2Program->readSampled(inColor2, x, y, sampler); + inputImage1Program_->readSampled(inColor1, x, y, sampler); + inputImage2Program_->readSampled(inColor2, x, y, sampler); difference = (fabsf(inColor2[0] - inColor1[0]) + fabsf(inColor2[1] - inColor1[1]) + fabsf(inColor2[2] - inColor1[2])); @@ -100,8 +100,8 @@ void DifferenceMatteOperation::update_memory_buffer_partial(MemoryBuffer *output /* Average together the distances. */ difference = difference / 3.0f; - const float tolerance = m_settings->t1; - const float falloff = m_settings->t2; + const float tolerance = settings_->t1; + const float falloff = settings_->t2; /* Make 100% transparent. */ if (difference <= tolerance) { diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.h b/source/blender/compositor/operations/COM_DifferenceMatteOperation.h index f95c78a38de..31ce0d3dbe5 100644 --- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.h +++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.h @@ -28,9 +28,9 @@ namespace blender::compositor { */ class DifferenceMatteOperation : public MultiThreadedOperation { private: - NodeChroma *m_settings; - SocketReader *m_inputImage1Program; - SocketReader *m_inputImage2Program; + NodeChroma *settings_; + SocketReader *inputImage1Program_; + SocketReader *inputImage2Program_; public: /** @@ -48,7 +48,7 @@ class DifferenceMatteOperation : public MultiThreadedOperation { void setSettings(NodeChroma *nodeChroma) { - m_settings = nodeChroma; + settings_ = nodeChroma; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_DilateErodeOperation.cc b/source/blender/compositor/operations/COM_DilateErodeOperation.cc index 60f6bd42144..1366eb43776 100644 --- a/source/blender/compositor/operations/COM_DilateErodeOperation.cc +++ b/source/blender/compositor/operations/COM_DilateErodeOperation.cc @@ -27,58 +27,58 @@ DilateErodeThresholdOperation::DilateErodeThresholdOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); this->flags.complex = true; - m_inputProgram = nullptr; - m_inset = 0.0f; - m__switch = 0.5f; - m_distance = 0.0f; + inputProgram_ = nullptr; + inset_ = 0.0f; + switch_ = 0.5f; + distance_ = 0.0f; } void DilateErodeThresholdOperation::init_data() { - if (m_distance < 0.0f) { - m_scope = -m_distance + m_inset; + if (distance_ < 0.0f) { + scope_ = -distance_ + inset_; } else { - if (m_inset * 2 > m_distance) { - m_scope = MAX2(m_inset * 2 - m_distance, m_distance); + if (inset_ * 2 > distance_) { + scope_ = MAX2(inset_ * 2 - distance_, distance_); } else { - m_scope = m_distance; + scope_ = distance_; } } - if (m_scope < 3) { - m_scope = 3; + if (scope_ < 3) { + scope_ = 3; } } void DilateErodeThresholdOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void *DilateErodeThresholdOperation::initializeTileData(rcti * /*rect*/) { - void *buffer = m_inputProgram->initializeTileData(nullptr); + void *buffer = inputProgram_->initializeTileData(nullptr); return buffer; } void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y, void *data) { float inputValue[4]; - const float sw = m__switch; - const float distance = m_distance; + const float sw = switch_; + const float distance = distance_; float pixelvalue; - const float rd = m_scope * m_scope; - const float inset = m_inset; + const float rd = scope_ * scope_; + const float inset = inset_; float mindist = rd * 2; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); const rcti &input_rect = inputBuffer->get_rect(); - const int minx = MAX2(x - m_scope, input_rect.xmin); - const int miny = MAX2(y - m_scope, input_rect.ymin); - const int maxx = MIN2(x + m_scope, input_rect.xmax); - const int maxy = MIN2(y + m_scope, input_rect.ymax); + const int minx = MAX2(x - scope_, input_rect.xmin); + const int miny = MAX2(y - scope_, input_rect.ymin); + const int maxx = MIN2(x + scope_, input_rect.xmax); + const int maxy = MIN2(y + scope_, input_rect.ymax); const int bufferWidth = inputBuffer->getWidth(); int offset; @@ -146,7 +146,7 @@ void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y, void DilateErodeThresholdOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; } bool DilateErodeThresholdOperation::determineDependingAreaOfInterest( @@ -154,10 +154,10 @@ bool DilateErodeThresholdOperation::determineDependingAreaOfInterest( { rcti newInput; - newInput.xmax = input->xmax + m_scope; - newInput.xmin = input->xmin - m_scope; - newInput.ymax = input->ymax + m_scope; - newInput.ymin = input->ymin - m_scope; + newInput.xmax = input->xmax + scope_; + newInput.xmin = input->xmin - scope_; + newInput.ymax = input->ymax + scope_; + newInput.ymin = input->ymin - scope_; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -168,10 +168,10 @@ void DilateErodeThresholdOperation::get_area_of_interest(const int input_idx, { BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - r_input_area.xmin = output_area.xmin - m_scope; - r_input_area.xmax = output_area.xmax + m_scope; - r_input_area.ymin = output_area.ymin - m_scope; - r_input_area.ymax = output_area.ymax + m_scope; + r_input_area.xmin = output_area.xmin - scope_; + r_input_area.xmax = output_area.xmax + scope_; + r_input_area.ymin = output_area.ymin - scope_; + r_input_area.ymax = output_area.ymax + scope_; } struct DilateErodeThresholdOperation::PixelData { @@ -222,21 +222,21 @@ void DilateErodeThresholdOperation::update_memory_buffer_partial(MemoryBuffer *o { const MemoryBuffer *input = inputs[0]; const rcti &input_rect = input->get_rect(); - const float rd = m_scope * m_scope; - const float inset = m_inset; + const float rd = scope_ * scope_; + const float inset = inset_; PixelData p; - p.sw = m__switch; + p.sw = switch_; p.distance = rd * 2; p.elem_stride = input->elem_stride; p.row_stride = input->row_stride; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { p.x = it.x; p.y = it.y; - p.xmin = MAX2(p.x - m_scope, input_rect.xmin); - p.ymin = MAX2(p.y - m_scope, input_rect.ymin); - p.xmax = MIN2(p.x + m_scope, input_rect.xmax); - p.ymax = MIN2(p.y + m_scope, input_rect.ymax); + p.xmin = MAX2(p.x - scope_, input_rect.xmin); + p.ymin = MAX2(p.y - scope_, input_rect.ymin); + p.xmax = MIN2(p.x + scope_, input_rect.xmax); + p.ymax = MIN2(p.y + scope_, input_rect.ymax); p.elem = it.in(0); float pixel_value; @@ -247,8 +247,8 @@ void DilateErodeThresholdOperation::update_memory_buffer_partial(MemoryBuffer *o pixel_value = sqrtf(get_min_distance<std::greater>(p)); } - if (m_distance > 0.0f) { - const float delta = m_distance - pixel_value; + if (distance_ > 0.0f) { + const float delta = distance_ - pixel_value; if (delta >= 0.0f) { *it.out = delta >= inset ? 1.0f : delta / inset; } @@ -257,7 +257,7 @@ void DilateErodeThresholdOperation::update_memory_buffer_partial(MemoryBuffer *o } } else { - const float delta = -m_distance + pixel_value; + const float delta = -distance_ + pixel_value; if (delta < 0.0f) { *it.out = delta < -inset ? 1.0f : (-delta) / inset; } @@ -273,43 +273,43 @@ DilateDistanceOperation::DilateDistanceOperation() { this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_inputProgram = nullptr; - m_distance = 0.0f; + inputProgram_ = nullptr; + distance_ = 0.0f; flags.complex = true; flags.open_cl = true; } void DilateDistanceOperation::init_data() { - m_scope = m_distance; - if (m_scope < 3) { - m_scope = 3; + scope_ = distance_; + if (scope_ < 3) { + scope_ = 3; } } void DilateDistanceOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void *DilateDistanceOperation::initializeTileData(rcti * /*rect*/) { - void *buffer = m_inputProgram->initializeTileData(nullptr); + void *buffer = inputProgram_->initializeTileData(nullptr); return buffer; } void DilateDistanceOperation::executePixel(float output[4], int x, int y, void *data) { - const float distance = m_distance; + const float distance = distance_; const float mindist = distance * distance; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); const rcti &input_rect = inputBuffer->get_rect(); - const int minx = MAX2(x - m_scope, input_rect.xmin); - const int miny = MAX2(y - m_scope, input_rect.ymin); - const int maxx = MIN2(x + m_scope, input_rect.xmax); - const int maxy = MIN2(y + m_scope, input_rect.ymax); + const int minx = MAX2(x - scope_, input_rect.xmin); + const int miny = MAX2(y - scope_, input_rect.ymin); + const int maxx = MIN2(x + scope_, input_rect.xmax); + const int maxy = MIN2(y + scope_, input_rect.ymax); const int bufferWidth = inputBuffer->getWidth(); int offset; @@ -332,7 +332,7 @@ void DilateDistanceOperation::executePixel(float output[4], int x, int y, void * void DilateDistanceOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; } bool DilateDistanceOperation::determineDependingAreaOfInterest(rcti *input, @@ -341,10 +341,10 @@ bool DilateDistanceOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - newInput.xmax = input->xmax + m_scope; - newInput.xmin = input->xmin - m_scope; - newInput.ymax = input->ymax + m_scope; - newInput.ymin = input->ymin - m_scope; + newInput.xmax = input->xmax + scope_; + newInput.xmin = input->xmin - scope_; + newInput.ymax = input->ymax + scope_; + newInput.ymin = input->ymin - scope_; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -358,11 +358,11 @@ void DilateDistanceOperation::executeOpenCL(OpenCLDevice *device, { cl_kernel dilateKernel = device->COM_clCreateKernel("dilateKernel", nullptr); - cl_int distanceSquared = m_distance * m_distance; - cl_int scope = m_scope; + cl_int distanceSquared = distance_ * distance_; + cl_int scope = scope_; device->COM_clAttachMemoryBufferToKernelParameter( - dilateKernel, 0, 2, clMemToCleanUp, inputMemoryBuffers, m_inputProgram); + dilateKernel, 0, 2, clMemToCleanUp, inputMemoryBuffers, inputProgram_); device->COM_clAttachOutputMemoryBufferToKernelParameter(dilateKernel, 1, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter(dilateKernel, 3, outputMemoryBuffer); clSetKernelArg(dilateKernel, 4, sizeof(cl_int), &scope); @@ -377,10 +377,10 @@ void DilateDistanceOperation::get_area_of_interest(const int input_idx, { BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - r_input_area.xmin = output_area.xmin - m_scope; - r_input_area.xmax = output_area.xmax + m_scope; - r_input_area.ymin = output_area.ymin - m_scope; - r_input_area.ymax = output_area.ymax + m_scope; + r_input_area.xmin = output_area.xmin - scope_; + r_input_area.xmax = output_area.xmax + scope_; + r_input_area.ymin = output_area.ymin - scope_; + r_input_area.ymax = output_area.ymax + scope_; } struct DilateDistanceOperation::PixelData { @@ -450,7 +450,7 @@ void DilateDistanceOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - PixelData p(inputs[0], m_distance, m_scope); + PixelData p(inputs[0], distance_, scope_); for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { p.update(it); *it.out = get_distance_value<std::greater>(p, 0.0f); @@ -465,16 +465,16 @@ ErodeDistanceOperation::ErodeDistanceOperation() : DilateDistanceOperation() void ErodeDistanceOperation::executePixel(float output[4], int x, int y, void *data) { - const float distance = m_distance; + const float distance = distance_; const float mindist = distance * distance; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); const rcti &input_rect = inputBuffer->get_rect(); - const int minx = MAX2(x - m_scope, input_rect.xmin); - const int miny = MAX2(y - m_scope, input_rect.ymin); - const int maxx = MIN2(x + m_scope, input_rect.xmax); - const int maxy = MIN2(y + m_scope, input_rect.ymax); + const int minx = MAX2(x - scope_, input_rect.xmin); + const int miny = MAX2(y - scope_, input_rect.ymin); + const int maxx = MIN2(x + scope_, input_rect.xmax); + const int maxy = MIN2(y + scope_, input_rect.ymax); const int bufferWidth = inputBuffer->getWidth(); int offset; @@ -504,11 +504,11 @@ void ErodeDistanceOperation::executeOpenCL(OpenCLDevice *device, { cl_kernel erodeKernel = device->COM_clCreateKernel("erodeKernel", nullptr); - cl_int distanceSquared = m_distance * m_distance; - cl_int scope = m_scope; + cl_int distanceSquared = distance_ * distance_; + cl_int scope = scope_; device->COM_clAttachMemoryBufferToKernelParameter( - erodeKernel, 0, 2, clMemToCleanUp, inputMemoryBuffers, m_inputProgram); + erodeKernel, 0, 2, clMemToCleanUp, inputMemoryBuffers, inputProgram_); device->COM_clAttachOutputMemoryBufferToKernelParameter(erodeKernel, 1, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter(erodeKernel, 3, outputMemoryBuffer); clSetKernelArg(erodeKernel, 4, sizeof(cl_int), &scope); @@ -521,7 +521,7 @@ void ErodeDistanceOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - PixelData p(inputs[0], m_distance, m_scope); + PixelData p(inputs[0], distance_, scope_); for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { p.update(it); *it.out = get_distance_value<std::less>(p, 1.0f); @@ -534,11 +534,11 @@ DilateStepOperation::DilateStepOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); this->flags.complex = true; - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void DilateStepOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } /* Small helper to pass data from initializeTileData to executePixel. */ @@ -563,13 +563,13 @@ static tile_info *create_cache(int xmin, int xmax, int ymin, int ymax) void *DilateStepOperation::initializeTileData(rcti *rect) { - MemoryBuffer *tile = (MemoryBuffer *)m_inputProgram->initializeTileData(nullptr); + MemoryBuffer *tile = (MemoryBuffer *)inputProgram_->initializeTileData(nullptr); int x, y, i; int width = tile->getWidth(); int height = tile->getHeight(); float *buffer = tile->getBuffer(); - int half_window = m_iterations; + int half_window = iterations_; int window = half_window * 2 + 1; int xmin = MAX2(0, rect->xmin - half_window); @@ -661,7 +661,7 @@ void DilateStepOperation::executePixel(float output[4], int x, int y, void *data void DilateStepOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void DilateStepOperation::deinitializeTileData(rcti * /*rect*/, void *data) @@ -676,7 +676,7 @@ bool DilateStepOperation::determineDependingAreaOfInterest(rcti *input, rcti *output) { rcti newInput; - int it = m_iterations; + int it = iterations_; newInput.xmax = input->xmax + it; newInput.xmin = input->xmin - it; newInput.ymax = input->ymax + it; @@ -691,10 +691,10 @@ void DilateStepOperation::get_area_of_interest(const int input_idx, { BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - r_input_area.xmin = output_area.xmin - m_iterations; - r_input_area.xmax = output_area.xmax + m_iterations; - r_input_area.ymin = output_area.ymin - m_iterations; - r_input_area.ymax = output_area.ymax + m_iterations; + r_input_area.xmin = output_area.xmin - iterations_; + r_input_area.xmax = output_area.xmax + iterations_; + r_input_area.ymin = output_area.ymin - iterations_; + r_input_area.ymax = output_area.ymax + iterations_; } template<typename TCompareSelector> @@ -803,7 +803,7 @@ void DilateStepOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - step_update_memory_buffer<Max2Selector>(output, inputs[0], area, m_iterations, -FLT_MAX); + step_update_memory_buffer<Max2Selector>(output, inputs[0], area, iterations_, -FLT_MAX); } /* Erode step */ @@ -814,13 +814,13 @@ ErodeStepOperation::ErodeStepOperation() : DilateStepOperation() void *ErodeStepOperation::initializeTileData(rcti *rect) { - MemoryBuffer *tile = (MemoryBuffer *)m_inputProgram->initializeTileData(nullptr); + MemoryBuffer *tile = (MemoryBuffer *)inputProgram_->initializeTileData(nullptr); int x, y, i; int width = tile->getWidth(); int height = tile->getHeight(); float *buffer = tile->getBuffer(); - int half_window = m_iterations; + int half_window = iterations_; int window = half_window * 2 + 1; int xmin = MAX2(0, rect->xmin - half_window); @@ -913,7 +913,7 @@ void ErodeStepOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - step_update_memory_buffer<Min2Selector>(output, inputs[0], area, m_iterations, FLT_MAX); + step_update_memory_buffer<Min2Selector>(output, inputs[0], area, iterations_, FLT_MAX); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_DilateErodeOperation.h b/source/blender/compositor/operations/COM_DilateErodeOperation.h index fb22a72fb70..1919c926710 100644 --- a/source/blender/compositor/operations/COM_DilateErodeOperation.h +++ b/source/blender/compositor/operations/COM_DilateErodeOperation.h @@ -30,17 +30,17 @@ class DilateErodeThresholdOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; - float m_distance; - float m__switch; - float m_inset; + float distance_; + float switch_; + float inset_; /** * determines the area of interest to track pixels * keep this one as small as possible for speed gain. */ - int m_scope; + int scope_; public: DilateErodeThresholdOperation(); @@ -64,15 +64,15 @@ class DilateErodeThresholdOperation : public MultiThreadedOperation { void setDistance(float distance) { - m_distance = distance; + distance_ = distance; } void setSwitch(float sw) { - m__switch = sw; + switch_ = sw; } void setInset(float inset) { - m_inset = inset; + inset_ = inset; } bool determineDependingAreaOfInterest(rcti *input, @@ -93,9 +93,9 @@ class DilateDistanceOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; - float m_distance; - int m_scope; + SocketReader *inputProgram_; + float distance_; + int scope_; public: DilateDistanceOperation(); @@ -119,7 +119,7 @@ class DilateDistanceOperation : public MultiThreadedOperation { void setDistance(float distance) { - m_distance = distance; + distance_ = distance; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, @@ -164,9 +164,9 @@ class DilateStepOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; - int m_iterations; + int iterations_; public: DilateStepOperation(); @@ -190,7 +190,7 @@ class DilateStepOperation : public MultiThreadedOperation { void setIterations(int iterations) { - m_iterations = iterations; + iterations_ = iterations; } bool determineDependingAreaOfInterest(rcti *input, diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cc b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cc index 7a6f3d972a4..3cf3ee3b0c8 100644 --- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cc +++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cc @@ -27,20 +27,20 @@ DirectionalBlurOperation::DirectionalBlurOperation() this->addOutputSocket(DataType::Color); flags.complex = true; flags.open_cl = true; - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void DirectionalBlurOperation::initExecution() { - m_inputProgram = getInputSocketReader(0); + inputProgram_ = getInputSocketReader(0); QualityStepHelper::initExecution(COM_QH_INCREASE); - const float angle = m_data->angle; - const float zoom = m_data->zoom; - const float spin = m_data->spin; - const float iterations = m_data->iter; - const float distance = m_data->distance; - const float center_x = m_data->center_x; - const float center_y = m_data->center_y; + const float angle = data_->angle; + const float zoom = data_->zoom; + const float spin = data_->spin; + const float iterations = data_->iter; + const float distance = data_->distance; + const float center_x = data_->center_x; + const float center_y = data_->center_y; const float width = getWidth(); const float height = getHeight(); @@ -49,45 +49,45 @@ void DirectionalBlurOperation::initExecution() float D; D = distance * sqrtf(width * width + height * height); - m_center_x_pix = center_x * width; - m_center_y_pix = center_y * height; + center_x_pix_ = center_x * width; + center_y_pix_ = center_y * height; - m_tx = itsc * D * cosf(a); - m_ty = -itsc * D * sinf(a); - m_sc = itsc * zoom; - m_rot = itsc * spin; + tx_ = itsc * D * cosf(a); + ty_ = -itsc * D * sinf(a); + sc_ = itsc * zoom; + rot_ = itsc * spin; } void DirectionalBlurOperation::executePixel(float output[4], int x, int y, void * /*data*/) { - const int iterations = pow(2.0f, m_data->iter); + const int iterations = pow(2.0f, data_->iter); float col[4] = {0.0f, 0.0f, 0.0f, 0.0f}; float col2[4] = {0.0f, 0.0f, 0.0f, 0.0f}; - m_inputProgram->readSampled(col2, x, y, PixelSampler::Bilinear); - float ltx = m_tx; - float lty = m_ty; - float lsc = m_sc; - float lrot = m_rot; + inputProgram_->readSampled(col2, x, y, PixelSampler::Bilinear); + float ltx = tx_; + float lty = ty_; + float lsc = sc_; + float lrot = rot_; /* blur the image */ for (int i = 0; i < iterations; i++) { const float cs = cosf(lrot), ss = sinf(lrot); const float isc = 1.0f / (1.0f + lsc); - const float v = isc * (y - m_center_y_pix) + lty; - const float u = isc * (x - m_center_x_pix) + ltx; + const float v = isc * (y - center_y_pix_) + lty; + const float u = isc * (x - center_x_pix_) + ltx; - m_inputProgram->readSampled(col, - cs * u + ss * v + m_center_x_pix, - cs * v - ss * u + m_center_y_pix, - PixelSampler::Bilinear); + inputProgram_->readSampled(col, + cs * u + ss * v + center_x_pix_, + cs * v - ss * u + center_y_pix_, + PixelSampler::Bilinear); add_v4_v4(col2, col); /* double transformations */ - ltx += m_tx; - lty += m_ty; - lrot += m_rot; - lsc += m_sc; + ltx += tx_; + lty += ty_; + lrot += rot_; + lsc += sc_; } mul_v4_v4fl(output, col2, 1.0f / (iterations + 1)); @@ -102,14 +102,14 @@ void DirectionalBlurOperation::executeOpenCL(OpenCLDevice *device, { cl_kernel directionalBlurKernel = device->COM_clCreateKernel("directionalBlurKernel", nullptr); - cl_int iterations = pow(2.0f, m_data->iter); - cl_float2 ltxy = {{m_tx, m_ty}}; - cl_float2 centerpix = {{m_center_x_pix, m_center_y_pix}}; - cl_float lsc = m_sc; - cl_float lrot = m_rot; + cl_int iterations = pow(2.0f, data_->iter); + cl_float2 ltxy = {{tx_, ty_}}; + cl_float2 centerpix = {{center_x_pix_, center_y_pix_}}; + cl_float lsc = sc_; + cl_float lrot = rot_; device->COM_clAttachMemoryBufferToKernelParameter( - directionalBlurKernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, m_inputProgram); + directionalBlurKernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, inputProgram_); device->COM_clAttachOutputMemoryBufferToKernelParameter( directionalBlurKernel, 1, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter( @@ -125,7 +125,7 @@ void DirectionalBlurOperation::executeOpenCL(OpenCLDevice *device, void DirectionalBlurOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; } bool DirectionalBlurOperation::determineDependingAreaOfInterest(rcti * /*input*/, @@ -156,7 +156,7 @@ void DirectionalBlurOperation::update_memory_buffer_partial(MemoryBuffer *output Span<MemoryBuffer *> inputs) { const MemoryBuffer *input = inputs[0]; - const int iterations = pow(2.0f, m_data->iter); + const int iterations = pow(2.0f, data_->iter); for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { const int x = it.x; const int y = it.y; @@ -166,27 +166,27 @@ void DirectionalBlurOperation::update_memory_buffer_partial(MemoryBuffer *output /* Blur pixel. */ /* TODO(manzanilla): Many values used on iterations can be calculated beforehand. Create a * table on operation initialization. */ - float ltx = m_tx; - float lty = m_ty; - float lsc = m_sc; - float lrot = m_rot; + float ltx = tx_; + float lty = ty_; + float lsc = sc_; + float lrot = rot_; for (int i = 0; i < iterations; i++) { const float cs = cosf(lrot), ss = sinf(lrot); const float isc = 1.0f / (1.0f + lsc); - const float v = isc * (y - m_center_y_pix) + lty; - const float u = isc * (x - m_center_x_pix) + ltx; + const float v = isc * (y - center_y_pix_) + lty; + const float u = isc * (x - center_x_pix_) + ltx; float color[4]; input->read_elem_bilinear( - cs * u + ss * v + m_center_x_pix, cs * v - ss * u + m_center_y_pix, color); + cs * u + ss * v + center_x_pix_, cs * v - ss * u + center_y_pix_, color); add_v4_v4(color_accum, color); /* Double transformations. */ - ltx += m_tx; - lty += m_ty; - lrot += m_rot; - lsc += m_sc; + ltx += tx_; + lty += ty_; + lrot += rot_; + lsc += sc_; } mul_v4_v4fl(it.out, color_accum, 1.0f / (iterations + 1)); diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.h b/source/blender/compositor/operations/COM_DirectionalBlurOperation.h index 20d4b41b326..0687ff4ae5d 100644 --- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.h +++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.h @@ -25,12 +25,12 @@ namespace blender::compositor { class DirectionalBlurOperation : public MultiThreadedOperation, public QualityStepHelper { private: - SocketReader *m_inputProgram; - NodeDBlurData *m_data; + SocketReader *inputProgram_; + NodeDBlurData *data_; - float m_center_x_pix, m_center_y_pix; - float m_tx, m_ty; - float m_sc, m_rot; + float center_x_pix_, center_y_pix_; + float tx_, ty_; + float sc_, rot_; public: DirectionalBlurOperation(); @@ -56,7 +56,7 @@ class DirectionalBlurOperation : public MultiThreadedOperation, public QualitySt void setData(NodeDBlurData *data) { - m_data = data; + data_ = data; } void executeOpenCL(OpenCLDevice *device, diff --git a/source/blender/compositor/operations/COM_DisplaceOperation.cc b/source/blender/compositor/operations/COM_DisplaceOperation.cc index dd4618ff827..8476db73b32 100644 --- a/source/blender/compositor/operations/COM_DisplaceOperation.cc +++ b/source/blender/compositor/operations/COM_DisplaceOperation.cc @@ -29,12 +29,12 @@ DisplaceOperation::DisplaceOperation() this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_inputColorProgram = nullptr; + inputColorProgram_ = nullptr; } void DisplaceOperation::initExecution() { - m_inputColorProgram = this->getInputSocketReader(0); + inputColorProgram_ = this->getInputSocketReader(0); NodeOperation *vector = this->getInputSocketReader(1); NodeOperation *scale_x = this->getInputSocketReader(2); NodeOperation *scale_y = this->getInputSocketReader(3); @@ -50,8 +50,8 @@ void DisplaceOperation::initExecution() }; } - m_width_x4 = this->getWidth() * 4; - m_height_x4 = this->getHeight() * 4; + width_x4_ = this->getWidth() * 4; + height_x4_ = this->getHeight() * 4; input_vector_width_ = vector->getWidth(); input_vector_height_ = vector->getHeight(); } @@ -66,11 +66,11 @@ void DisplaceOperation::executePixelSampled(float output[4], pixelTransform(xy, uv, deriv); if (is_zero_v2(deriv[0]) && is_zero_v2(deriv[1])) { - m_inputColorProgram->readSampled(output, uv[0], uv[1], PixelSampler::Bilinear); + inputColorProgram_->readSampled(output, uv[0], uv[1], PixelSampler::Bilinear); } else { /* EWA filtering (without nearest it gets blurry with NO distortion) */ - m_inputColorProgram->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); + inputColorProgram_->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); } } @@ -104,8 +104,8 @@ void DisplaceOperation::pixelTransform(const float xy[2], float r_uv[2], float r float ys = col[0]; /* clamp x and y displacement to triple image resolution - * to prevent hangs from huge values mistakenly plugged in eg. z buffers */ - CLAMP(xs, -m_width_x4, m_width_x4); - CLAMP(ys, -m_height_x4, m_height_x4); + CLAMP(xs, -width_x4_, width_x4_); + CLAMP(ys, -height_x4_, height_x4_); /* displaced pixel in uv coords, for image sampling */ read_displacement(xy[0], xy[1], xs, ys, xy, r_uv[0], r_uv[1]); @@ -153,7 +153,7 @@ void DisplaceOperation::pixelTransform(const float xy[2], float r_uv[2], float r void DisplaceOperation::deinitExecution() { - m_inputColorProgram = nullptr; + inputColorProgram_ = nullptr; vector_read_fn_ = nullptr; scale_x_read_fn_ = nullptr; scale_y_read_fn_ = nullptr; diff --git a/source/blender/compositor/operations/COM_DisplaceOperation.h b/source/blender/compositor/operations/COM_DisplaceOperation.h index 5be914ab672..56cd1c1f2a6 100644 --- a/source/blender/compositor/operations/COM_DisplaceOperation.h +++ b/source/blender/compositor/operations/COM_DisplaceOperation.h @@ -27,10 +27,10 @@ class DisplaceOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputColorProgram; + SocketReader *inputColorProgram_; - float m_width_x4; - float m_height_x4; + float width_x4_; + float height_x4_; int input_vector_width_; int input_vector_height_; diff --git a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cc b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cc index fa7c4199fca..77d7831c680 100644 --- a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cc +++ b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cc @@ -28,21 +28,21 @@ DisplaceSimpleOperation::DisplaceSimpleOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputColorProgram = nullptr; - m_inputVectorProgram = nullptr; - m_inputScaleXProgram = nullptr; - m_inputScaleYProgram = nullptr; + inputColorProgram_ = nullptr; + inputVectorProgram_ = nullptr; + inputScaleXProgram_ = nullptr; + inputScaleYProgram_ = nullptr; } void DisplaceSimpleOperation::initExecution() { - m_inputColorProgram = this->getInputSocketReader(0); - m_inputVectorProgram = this->getInputSocketReader(1); - m_inputScaleXProgram = this->getInputSocketReader(2); - m_inputScaleYProgram = this->getInputSocketReader(3); + inputColorProgram_ = this->getInputSocketReader(0); + inputVectorProgram_ = this->getInputSocketReader(1); + inputScaleXProgram_ = this->getInputSocketReader(2); + inputScaleYProgram_ = this->getInputSocketReader(3); - m_width_x4 = this->getWidth() * 4; - m_height_x4 = this->getHeight() * 4; + width_x4_ = this->getWidth() * 4; + height_x4_ = this->getHeight() * 4; } /* minimum distance (in pixels) a pixel has to be displaced @@ -60,17 +60,17 @@ void DisplaceSimpleOperation::executePixelSampled(float output[4], float p_dx, p_dy; /* main displacement in pixel space */ float u, v; - m_inputScaleXProgram->readSampled(inScale, x, y, sampler); + inputScaleXProgram_->readSampled(inScale, x, y, sampler); float xs = inScale[0]; - m_inputScaleYProgram->readSampled(inScale, x, y, sampler); + inputScaleYProgram_->readSampled(inScale, x, y, sampler); float ys = inScale[0]; /* clamp x and y displacement to triple image resolution - * to prevent hangs from huge values mistakenly plugged in eg. z buffers */ - CLAMP(xs, -m_width_x4, m_width_x4); - CLAMP(ys, -m_height_x4, m_height_x4); + CLAMP(xs, -width_x4_, width_x4_); + CLAMP(ys, -height_x4_, height_x4_); - m_inputVectorProgram->readSampled(inVector, x, y, sampler); + inputVectorProgram_->readSampled(inVector, x, y, sampler); p_dx = inVector[0] * xs; p_dy = inVector[1] * ys; @@ -81,15 +81,15 @@ void DisplaceSimpleOperation::executePixelSampled(float output[4], CLAMP(u, 0.0f, this->getWidth() - 1.0f); CLAMP(v, 0.0f, this->getHeight() - 1.0f); - m_inputColorProgram->readSampled(output, u, v, sampler); + inputColorProgram_->readSampled(output, u, v, sampler); } void DisplaceSimpleOperation::deinitExecution() { - m_inputColorProgram = nullptr; - m_inputVectorProgram = nullptr; - m_inputScaleXProgram = nullptr; - m_inputScaleYProgram = nullptr; + inputColorProgram_ = nullptr; + inputVectorProgram_ = nullptr; + inputScaleXProgram_ = nullptr; + inputScaleYProgram_ = nullptr; } bool DisplaceSimpleOperation::determineDependingAreaOfInterest(rcti *input, @@ -160,8 +160,8 @@ void DisplaceSimpleOperation::update_memory_buffer_partial(MemoryBuffer *output, /* Clamp x and y displacement to triple image resolution - * to prevent hangs from huge values mistakenly plugged in eg. z buffers. */ - CLAMP(scale_x, -m_width_x4, m_width_x4); - CLAMP(scale_y, -m_height_x4, m_height_x4); + CLAMP(scale_x, -width_x4_, width_x4_); + CLAMP(scale_y, -height_x4_, height_x4_); /* Main displacement in pixel space. */ const float *vector = it.in(0); diff --git a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h index 99f52155466..1baf8c8275c 100644 --- a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h +++ b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h @@ -27,13 +27,13 @@ class DisplaceSimpleOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputColorProgram; - SocketReader *m_inputVectorProgram; - SocketReader *m_inputScaleXProgram; - SocketReader *m_inputScaleYProgram; + SocketReader *inputColorProgram_; + SocketReader *inputVectorProgram_; + SocketReader *inputScaleXProgram_; + SocketReader *inputScaleYProgram_; - float m_width_x4; - float m_height_x4; + float width_x4_; + float height_x4_; public: DisplaceSimpleOperation(); diff --git a/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cc b/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cc index 0439cb35ba8..e076bf4ae7d 100644 --- a/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cc +++ b/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cc @@ -26,21 +26,21 @@ DistanceRGBMatteOperation::DistanceRGBMatteOperation() this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Value); - m_inputImageProgram = nullptr; - m_inputKeyProgram = nullptr; + inputImageProgram_ = nullptr; + inputKeyProgram_ = nullptr; flags.can_be_constant = true; } void DistanceRGBMatteOperation::initExecution() { - m_inputImageProgram = this->getInputSocketReader(0); - m_inputKeyProgram = this->getInputSocketReader(1); + inputImageProgram_ = this->getInputSocketReader(0); + inputKeyProgram_ = this->getInputSocketReader(1); } void DistanceRGBMatteOperation::deinitExecution() { - m_inputImageProgram = nullptr; - m_inputKeyProgram = nullptr; + inputImageProgram_ = nullptr; + inputKeyProgram_ = nullptr; } float DistanceRGBMatteOperation::calculateDistance(const float key[4], const float image[4]) @@ -56,14 +56,14 @@ void DistanceRGBMatteOperation::executePixelSampled(float output[4], float inKey[4]; float inImage[4]; - const float tolerance = m_settings->t1; - const float falloff = m_settings->t2; + const float tolerance = settings_->t1; + const float falloff = settings_->t2; float distance; float alpha; - m_inputKeyProgram->readSampled(inKey, x, y, sampler); - m_inputImageProgram->readSampled(inImage, x, y, sampler); + inputKeyProgram_->readSampled(inKey, x, y, sampler); + inputImageProgram_->readSampled(inImage, x, y, sampler); distance = this->calculateDistance(inKey, inImage); @@ -102,8 +102,8 @@ void DistanceRGBMatteOperation::update_memory_buffer_partial(MemoryBuffer *outpu const float *in_key = it.in(1); float distance = this->calculateDistance(in_key, in_image); - const float tolerance = m_settings->t1; - const float falloff = m_settings->t2; + const float tolerance = settings_->t1; + const float falloff = settings_->t2; /* Store matte(alpha) value in [0] to go with * COM_SetAlphaMultiplyOperation and the Value output. diff --git a/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h b/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h index 0effad2accd..e741a9b80d5 100644 --- a/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h +++ b/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h @@ -28,9 +28,9 @@ namespace blender::compositor { */ class DistanceRGBMatteOperation : public MultiThreadedOperation { protected: - NodeChroma *m_settings; - SocketReader *m_inputImageProgram; - SocketReader *m_inputKeyProgram; + NodeChroma *settings_; + SocketReader *inputImageProgram_; + SocketReader *inputKeyProgram_; virtual float calculateDistance(const float key[4], const float image[4]); @@ -50,7 +50,7 @@ class DistanceRGBMatteOperation : public MultiThreadedOperation { void setSettings(NodeChroma *nodeChroma) { - m_settings = nodeChroma; + settings_ = nodeChroma; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_DotproductOperation.cc b/source/blender/compositor/operations/COM_DotproductOperation.cc index 86df465ca31..ef309392d4d 100644 --- a/source/blender/compositor/operations/COM_DotproductOperation.cc +++ b/source/blender/compositor/operations/COM_DotproductOperation.cc @@ -26,20 +26,20 @@ DotproductOperation::DotproductOperation() this->addInputSocket(DataType::Vector); this->addOutputSocket(DataType::Value); this->set_canvas_input_index(0); - m_input1Operation = nullptr; - m_input2Operation = nullptr; + input1Operation_ = nullptr; + input2Operation_ = nullptr; flags.can_be_constant = true; } void DotproductOperation::initExecution() { - m_input1Operation = this->getInputSocketReader(0); - m_input2Operation = this->getInputSocketReader(1); + input1Operation_ = this->getInputSocketReader(0); + input2Operation_ = this->getInputSocketReader(1); } void DotproductOperation::deinitExecution() { - m_input1Operation = nullptr; - m_input2Operation = nullptr; + input1Operation_ = nullptr; + input2Operation_ = nullptr; } /** \todo current implementation is the inverse of a dot-product. not 'logically' correct @@ -51,8 +51,8 @@ void DotproductOperation::executePixelSampled(float output[4], { float input1[4]; float input2[4]; - m_input1Operation->readSampled(input1, x, y, sampler); - m_input2Operation->readSampled(input2, x, y, sampler); + input1Operation_->readSampled(input1, x, y, sampler); + input2Operation_->readSampled(input2, x, y, sampler); output[0] = -(input1[0] * input2[0] + input1[1] * input2[1] + input1[2] * input2[2]); } diff --git a/source/blender/compositor/operations/COM_DotproductOperation.h b/source/blender/compositor/operations/COM_DotproductOperation.h index c3f39d43fff..5190a161533 100644 --- a/source/blender/compositor/operations/COM_DotproductOperation.h +++ b/source/blender/compositor/operations/COM_DotproductOperation.h @@ -24,8 +24,8 @@ namespace blender::compositor { class DotproductOperation : public MultiThreadedOperation { private: - SocketReader *m_input1Operation; - SocketReader *m_input2Operation; + SocketReader *input1Operation_; + SocketReader *input2Operation_; public: DotproductOperation(); diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc index b83d7f343bd..2ae33d5451f 100644 --- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc +++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc @@ -1267,8 +1267,8 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float * * Each version has slightly different criteria for detecting an edge pixel. */ - if (m_adjacentOnly) { /* If "adjacent only" inner edge mode is turned on. */ - if (m_keepInside) { /* If "keep inside" buffer edge mode is turned on. */ + if (adjacentOnly_) { /* If "adjacent only" inner edge mode is turned on. */ + if (keepInside_) { /* If "keep inside" buffer edge mode is turned on. */ do_adjacentKeepBorders(t, rw, limask, lomask, lres, res, rsize); } else { /* "bleed out" buffer edge mode is turned on. */ @@ -1281,8 +1281,8 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float /* Detect edges in all non-border pixels in the buffer. */ do_adjacentEdgeDetection(t, rw, limask, lomask, lres, res, rsize, isz, osz, gsz); } - else { /* "all" inner edge mode is turned on. */ - if (m_keepInside) { /* If "keep inside" buffer edge mode is turned on. */ + else { /* "all" inner edge mode is turned on. */ + if (keepInside_) { /* If "keep inside" buffer edge mode is turned on. */ do_allKeepBorders(t, rw, limask, lomask, lres, res, rsize); } else { /* "bleed out" buffer edge mode is turned on. */ @@ -1322,10 +1322,10 @@ DoubleEdgeMaskOperation::DoubleEdgeMaskOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_inputInnerMask = nullptr; - m_inputOuterMask = nullptr; - m_adjacentOnly = false; - m_keepInside = false; + inputInnerMask_ = nullptr; + inputOuterMask_ = nullptr; + adjacentOnly_ = false; + keepInside_ = false; this->flags.complex = true; is_output_rendered_ = false; } @@ -1334,7 +1334,7 @@ bool DoubleEdgeMaskOperation::determineDependingAreaOfInterest(rcti * /*input*/, ReadBufferOperation *readOperation, rcti *output) { - if (m_cachedInstance == nullptr) { + if (cachedInstance_ == nullptr) { rcti newInput; newInput.xmax = this->getWidth(); newInput.xmin = 0; @@ -1348,31 +1348,31 @@ bool DoubleEdgeMaskOperation::determineDependingAreaOfInterest(rcti * /*input*/, void DoubleEdgeMaskOperation::initExecution() { - m_inputInnerMask = this->getInputSocketReader(0); - m_inputOuterMask = this->getInputSocketReader(1); + inputInnerMask_ = this->getInputSocketReader(0); + inputOuterMask_ = this->getInputSocketReader(1); initMutex(); - m_cachedInstance = nullptr; + cachedInstance_ = nullptr; } void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect) { - if (m_cachedInstance) { - return m_cachedInstance; + if (cachedInstance_) { + return cachedInstance_; } lockMutex(); - if (m_cachedInstance == nullptr) { - MemoryBuffer *innerMask = (MemoryBuffer *)m_inputInnerMask->initializeTileData(rect); - MemoryBuffer *outerMask = (MemoryBuffer *)m_inputOuterMask->initializeTileData(rect); + if (cachedInstance_ == nullptr) { + MemoryBuffer *innerMask = (MemoryBuffer *)inputInnerMask_->initializeTileData(rect); + MemoryBuffer *outerMask = (MemoryBuffer *)inputOuterMask_->initializeTileData(rect); float *data = (float *)MEM_mallocN(sizeof(float) * this->getWidth() * this->getHeight(), __func__); float *imask = innerMask->getBuffer(); float *omask = outerMask->getBuffer(); doDoubleEdgeMask(imask, omask, data); - m_cachedInstance = data; + cachedInstance_ = data; } unlockMutex(); - return m_cachedInstance; + return cachedInstance_; } void DoubleEdgeMaskOperation::executePixel(float output[4], int x, int y, void *data) { @@ -1383,12 +1383,12 @@ void DoubleEdgeMaskOperation::executePixel(float output[4], int x, int y, void * void DoubleEdgeMaskOperation::deinitExecution() { - m_inputInnerMask = nullptr; - m_inputOuterMask = nullptr; + inputInnerMask_ = nullptr; + inputOuterMask_ = nullptr; deinitMutex(); - if (m_cachedInstance) { - MEM_freeN(m_cachedInstance); - m_cachedInstance = nullptr; + if (cachedInstance_) { + MEM_freeN(cachedInstance_); + cachedInstance_ = nullptr; } } diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h index 091310dc9e3..29cb40c29af 100644 --- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h +++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h @@ -27,13 +27,13 @@ class DoubleEdgeMaskOperation : public NodeOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputOuterMask; - SocketReader *m_inputInnerMask; - bool m_adjacentOnly; - bool m_keepInside; + SocketReader *inputOuterMask_; + SocketReader *inputInnerMask_; + bool adjacentOnly_; + bool keepInside_; /* TODO(manzanilla): To be removed with tiled implementation. */ - float *m_cachedInstance; + float *cachedInstance_; bool is_output_rendered_; @@ -64,11 +64,11 @@ class DoubleEdgeMaskOperation : public NodeOperation { void setAdjecentOnly(bool adjacentOnly) { - m_adjacentOnly = adjacentOnly; + adjacentOnly_ = adjacentOnly; } void setKeepInside(bool keepInside) { - m_keepInside = keepInside; + keepInside_ = keepInside; } void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; diff --git a/source/blender/compositor/operations/COM_EllipseMaskOperation.cc b/source/blender/compositor/operations/COM_EllipseMaskOperation.cc index e3649fc9013..57cd3cb1423 100644 --- a/source/blender/compositor/operations/COM_EllipseMaskOperation.cc +++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.cc @@ -25,19 +25,19 @@ EllipseMaskOperation::EllipseMaskOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_inputMask = nullptr; - m_inputValue = nullptr; - m_cosine = 0.0f; - m_sine = 0.0f; + inputMask_ = nullptr; + inputValue_ = nullptr; + cosine_ = 0.0f; + sine_ = 0.0f; } void EllipseMaskOperation::initExecution() { - m_inputMask = this->getInputSocketReader(0); - m_inputValue = this->getInputSocketReader(1); - const double rad = (double)m_data->rotation; - m_cosine = cos(rad); - m_sine = sin(rad); - m_aspectRatio = ((float)this->getWidth()) / this->getHeight(); + inputMask_ = this->getInputSocketReader(0); + inputValue_ = this->getInputSocketReader(1); + const double rad = (double)data_->rotation; + cosine_ = cos(rad); + sine_ = sin(rad); + aspectRatio_ = ((float)this->getWidth()) / this->getHeight(); } void EllipseMaskOperation::executePixelSampled(float output[4], @@ -51,26 +51,26 @@ void EllipseMaskOperation::executePixelSampled(float output[4], float rx = x / this->getWidth(); float ry = y / this->getHeight(); - const float dy = (ry - m_data->y) / m_aspectRatio; - const float dx = rx - m_data->x; - rx = m_data->x + (m_cosine * dx + m_sine * dy); - ry = m_data->y + (-m_sine * dx + m_cosine * dy); + const float dy = (ry - data_->y) / aspectRatio_; + const float dx = rx - data_->x; + rx = data_->x + (cosine_ * dx + sine_ * dy); + ry = data_->y + (-sine_ * dx + cosine_ * dy); - m_inputMask->readSampled(inputMask, x, y, sampler); - m_inputValue->readSampled(inputValue, x, y, sampler); + inputMask_->readSampled(inputMask, x, y, sampler); + inputValue_->readSampled(inputValue, x, y, sampler); - const float halfHeight = (m_data->height) / 2.0f; - const float halfWidth = m_data->width / 2.0f; - float sx = rx - m_data->x; + const float halfHeight = (data_->height) / 2.0f; + const float halfWidth = data_->width / 2.0f; + float sx = rx - data_->x; sx *= sx; const float tx = halfWidth * halfWidth; - float sy = ry - m_data->y; + float sy = ry - data_->y; sy *= sy; const float ty = halfHeight * halfHeight; bool inside = ((sx / tx) + (sy / ty)) < 1.0f; - switch (m_maskType) { + switch (maskType_) { case CMP_NODE_MASKTYPE_ADD: if (inside) { output[0] = MAX2(inputMask[0], inputValue[0]); @@ -117,7 +117,7 @@ void EllipseMaskOperation::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> inputs) { MaskFunc mask_func; - switch (m_maskType) { + switch (maskType_) { case CMP_NODE_MASKTYPE_ADD: mask_func = [](const bool is_inside, const float *mask, const float *value) { return is_inside ? MAX2(mask[0], value[0]) : mask[0]; @@ -154,24 +154,24 @@ void EllipseMaskOperation::apply_mask(MemoryBuffer *output, const MemoryBuffer *input_value = inputs[1]; const float op_w = this->getWidth(); const float op_h = this->getHeight(); - const float half_w = m_data->width / 2.0f; - const float half_h = m_data->height / 2.0f; + const float half_w = data_->width / 2.0f; + const float half_h = data_->height / 2.0f; const float tx = half_w * half_w; const float ty = half_h * half_h; for (int y = area.ymin; y < area.ymax; y++) { const float op_ry = y / op_h; - const float dy = (op_ry - m_data->y) / m_aspectRatio; + const float dy = (op_ry - data_->y) / aspectRatio_; float *out = output->get_elem(area.xmin, y); const float *mask = input_mask->get_elem(area.xmin, y); const float *value = input_value->get_elem(area.xmin, y); for (int x = area.xmin; x < area.xmax; x++) { const float op_rx = x / op_w; - const float dx = op_rx - m_data->x; - const float rx = m_data->x + (m_cosine * dx + m_sine * dy); - const float ry = m_data->y + (-m_sine * dx + m_cosine * dy); - float sx = rx - m_data->x; + const float dx = op_rx - data_->x; + const float rx = data_->x + (cosine_ * dx + sine_ * dy); + const float ry = data_->y + (-sine_ * dx + cosine_ * dy); + float sx = rx - data_->x; sx *= sx; - float sy = ry - m_data->y; + float sy = ry - data_->y; sy *= sy; const bool inside = ((sx / tx) + (sy / ty)) < 1.0f; out[0] = mask_func(inside, mask, value); @@ -185,8 +185,8 @@ void EllipseMaskOperation::apply_mask(MemoryBuffer *output, void EllipseMaskOperation::deinitExecution() { - m_inputMask = nullptr; - m_inputValue = nullptr; + inputMask_ = nullptr; + inputValue_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_EllipseMaskOperation.h b/source/blender/compositor/operations/COM_EllipseMaskOperation.h index b0bebb5b80d..ec6fb4624f7 100644 --- a/source/blender/compositor/operations/COM_EllipseMaskOperation.h +++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.h @@ -29,15 +29,15 @@ class EllipseMaskOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputMask; - SocketReader *m_inputValue; + SocketReader *inputMask_; + SocketReader *inputValue_; - float m_sine; - float m_cosine; - float m_aspectRatio; - int m_maskType; + float sine_; + float cosine_; + float aspectRatio_; + int maskType_; - NodeEllipseMask *m_data; + NodeEllipseMask *data_; public: EllipseMaskOperation(); @@ -59,12 +59,12 @@ class EllipseMaskOperation : public MultiThreadedOperation { void setData(NodeEllipseMask *data) { - m_data = data; + data_ = data; } void setMaskType(int maskType) { - m_maskType = maskType; + maskType_ = maskType; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cc b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cc index ea24a23522c..b1843a225e0 100644 --- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cc +++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cc @@ -24,7 +24,7 @@ namespace blender::compositor { FastGaussianBlurOperation::FastGaussianBlurOperation() : BlurBaseOperation(DataType::Color) { - m_iirgaus = nullptr; + iirgaus_ = nullptr; } void FastGaussianBlurOperation::executePixel(float output[4], int x, int y, void *data) @@ -48,7 +48,7 @@ bool FastGaussianBlurOperation::determineDependingAreaOfInterest( return true; } - if (m_iirgaus) { + if (iirgaus_) { return false; } @@ -63,8 +63,8 @@ bool FastGaussianBlurOperation::determineDependingAreaOfInterest( void FastGaussianBlurOperation::init_data() { BlurBaseOperation::init_data(); - m_sx = m_data.sizex * m_size / 2.0f; - m_sy = m_data.sizey * m_size / 2.0f; + sx_ = data_.sizex * size_ / 2.0f; + sy_ = data_.sizey * size_ / 2.0f; } void FastGaussianBlurOperation::initExecution() @@ -75,9 +75,9 @@ void FastGaussianBlurOperation::initExecution() void FastGaussianBlurOperation::deinitExecution() { - if (m_iirgaus) { - delete m_iirgaus; - m_iirgaus = nullptr; + if (iirgaus_) { + delete iirgaus_; + iirgaus_ = nullptr; } BlurBaseOperation::deinitMutex(); } @@ -85,36 +85,36 @@ void FastGaussianBlurOperation::deinitExecution() void *FastGaussianBlurOperation::initializeTileData(rcti *rect) { lockMutex(); - if (!m_iirgaus) { - MemoryBuffer *newBuf = (MemoryBuffer *)m_inputProgram->initializeTileData(rect); + if (!iirgaus_) { + MemoryBuffer *newBuf = (MemoryBuffer *)inputProgram_->initializeTileData(rect); MemoryBuffer *copy = new MemoryBuffer(*newBuf); updateSize(); int c; - m_sx = m_data.sizex * m_size / 2.0f; - m_sy = m_data.sizey * m_size / 2.0f; + sx_ = data_.sizex * size_ / 2.0f; + sy_ = data_.sizey * size_ / 2.0f; - if ((m_sx == m_sy) && (m_sx > 0.0f)) { + if ((sx_ == sy_) && (sx_ > 0.0f)) { for (c = 0; c < COM_DATA_TYPE_COLOR_CHANNELS; c++) { - IIR_gauss(copy, m_sx, c, 3); + IIR_gauss(copy, sx_, c, 3); } } else { - if (m_sx > 0.0f) { + if (sx_ > 0.0f) { for (c = 0; c < COM_DATA_TYPE_COLOR_CHANNELS; c++) { - IIR_gauss(copy, m_sx, c, 1); + IIR_gauss(copy, sx_, c, 1); } } - if (m_sy > 0.0f) { + if (sy_ > 0.0f) { for (c = 0; c < COM_DATA_TYPE_COLOR_CHANNELS; c++) { - IIR_gauss(copy, m_sy, c, 2); + IIR_gauss(copy, sy_, c, 2); } } } - m_iirgaus = copy; + iirgaus_ = copy; } unlockMutex(); - return m_iirgaus; + return iirgaus_; } void FastGaussianBlurOperation::IIR_gauss(MemoryBuffer *src, @@ -294,20 +294,20 @@ void FastGaussianBlurOperation::update_memory_buffer_started(MemoryBuffer *outpu } image->copy_from(input, area); - if ((m_sx == m_sy) && (m_sx > 0.0f)) { + if ((sx_ == sy_) && (sx_ > 0.0f)) { for (const int c : IndexRange(COM_DATA_TYPE_COLOR_CHANNELS)) { - IIR_gauss(image, m_sx, c, 3); + IIR_gauss(image, sx_, c, 3); } } else { - if (m_sx > 0.0f) { + if (sx_ > 0.0f) { for (const int c : IndexRange(COM_DATA_TYPE_COLOR_CHANNELS)) { - IIR_gauss(image, m_sx, c, 1); + IIR_gauss(image, sx_, c, 1); } } - if (m_sy > 0.0f) { + if (sy_ > 0.0f) { for (const int c : IndexRange(COM_DATA_TYPE_COLOR_CHANNELS)) { - IIR_gauss(image, m_sy, c, 2); + IIR_gauss(image, sy_, c, 2); } } } @@ -322,10 +322,10 @@ FastGaussianBlurValueOperation::FastGaussianBlurValueOperation() { this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_iirgaus = nullptr; - m_inputprogram = nullptr; - m_sigma = 1.0f; - m_overlay = 0; + iirgaus_ = nullptr; + inputprogram_ = nullptr; + sigma_ = 1.0f; + overlay_ = 0; flags.complex = true; } @@ -340,7 +340,7 @@ bool FastGaussianBlurValueOperation::determineDependingAreaOfInterest( { rcti newInput; - if (m_iirgaus) { + if (iirgaus_) { return false; } @@ -354,15 +354,15 @@ bool FastGaussianBlurValueOperation::determineDependingAreaOfInterest( void FastGaussianBlurValueOperation::initExecution() { - m_inputprogram = getInputSocketReader(0); + inputprogram_ = getInputSocketReader(0); initMutex(); } void FastGaussianBlurValueOperation::deinitExecution() { - if (m_iirgaus) { - delete m_iirgaus; - m_iirgaus = nullptr; + if (iirgaus_) { + delete iirgaus_; + iirgaus_ = nullptr; } deinitMutex(); } @@ -370,12 +370,12 @@ void FastGaussianBlurValueOperation::deinitExecution() void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect) { lockMutex(); - if (!m_iirgaus) { - MemoryBuffer *newBuf = (MemoryBuffer *)m_inputprogram->initializeTileData(rect); + if (!iirgaus_) { + MemoryBuffer *newBuf = (MemoryBuffer *)inputprogram_->initializeTileData(rect); MemoryBuffer *copy = new MemoryBuffer(*newBuf); - FastGaussianBlurOperation::IIR_gauss(copy, m_sigma, 0, 3); + FastGaussianBlurOperation::IIR_gauss(copy, sigma_, 0, 3); - if (m_overlay == FAST_GAUSS_OVERLAY_MIN) { + if (overlay_ == FAST_GAUSS_OVERLAY_MIN) { float *src = newBuf->getBuffer(); float *dst = copy->getBuffer(); for (int i = copy->getWidth() * copy->getHeight(); i != 0; @@ -385,7 +385,7 @@ void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect) } } } - else if (m_overlay == FAST_GAUSS_OVERLAY_MAX) { + else if (overlay_ == FAST_GAUSS_OVERLAY_MAX) { float *src = newBuf->getBuffer(); float *dst = copy->getBuffer(); for (int i = copy->getWidth() * copy->getHeight(); i != 0; @@ -396,10 +396,10 @@ void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect) } } - m_iirgaus = copy; + iirgaus_ = copy; } unlockMutex(); - return m_iirgaus; + return iirgaus_; } void FastGaussianBlurValueOperation::get_area_of_interest(const int UNUSED(input_idx), @@ -413,11 +413,11 @@ void FastGaussianBlurValueOperation::update_memory_buffer_started(MemoryBuffer * const rcti &UNUSED(area), Span<MemoryBuffer *> inputs) { - if (m_iirgaus == nullptr) { + if (iirgaus_ == nullptr) { const MemoryBuffer *image = inputs[0]; MemoryBuffer *gauss = new MemoryBuffer(*image); - FastGaussianBlurOperation::IIR_gauss(gauss, m_sigma, 0, 3); - m_iirgaus = gauss; + FastGaussianBlurOperation::IIR_gauss(gauss, sigma_, 0, 3); + iirgaus_ = gauss; } } @@ -426,13 +426,13 @@ void FastGaussianBlurValueOperation::update_memory_buffer_partial(MemoryBuffer * Span<MemoryBuffer *> inputs) { MemoryBuffer *image = inputs[0]; - BuffersIterator<float> it = output->iterate_with({image, m_iirgaus}, area); - if (m_overlay == FAST_GAUSS_OVERLAY_MIN) { + BuffersIterator<float> it = output->iterate_with({image, iirgaus_}, area); + if (overlay_ == FAST_GAUSS_OVERLAY_MIN) { for (; !it.is_end(); ++it) { *it.out = MIN2(*it.in(0), *it.in(1)); } } - else if (m_overlay == FAST_GAUSS_OVERLAY_MAX) { + else if (overlay_ == FAST_GAUSS_OVERLAY_MAX) { for (; !it.is_end(); ++it) { *it.out = MAX2(*it.in(0), *it.in(1)); } diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h index b2ad199f17d..2a0ed078612 100644 --- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h +++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h @@ -25,9 +25,9 @@ namespace blender::compositor { class FastGaussianBlurOperation : public BlurBaseOperation { private: - float m_sx; - float m_sy; - MemoryBuffer *m_iirgaus; + float sx_; + float sy_; + MemoryBuffer *iirgaus_; public: FastGaussianBlurOperation(); @@ -61,15 +61,15 @@ enum { class FastGaussianBlurValueOperation : public MultiThreadedOperation { private: - float m_sigma; - MemoryBuffer *m_iirgaus; - SocketReader *m_inputprogram; + float sigma_; + MemoryBuffer *iirgaus_; + SocketReader *inputprogram_; /** * -1: re-mix with darker * 0: do nothing * 1 re-mix with lighter */ - int m_overlay; + int overlay_; public: FastGaussianBlurValueOperation(); @@ -83,13 +83,13 @@ class FastGaussianBlurValueOperation : public MultiThreadedOperation { void initExecution() override; void setSigma(float sigma) { - m_sigma = sigma; + sigma_ = sigma; } /* used for DOF blurring ZBuffer */ void setOverlay(int overlay) { - m_overlay = overlay; + overlay_ = overlay; } void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; diff --git a/source/blender/compositor/operations/COM_FlipOperation.cc b/source/blender/compositor/operations/COM_FlipOperation.cc index c08dce2fc01..ae2aa21131a 100644 --- a/source/blender/compositor/operations/COM_FlipOperation.cc +++ b/source/blender/compositor/operations/COM_FlipOperation.cc @@ -25,26 +25,26 @@ FlipOperation::FlipOperation() this->addInputSocket(DataType::Color, ResizeMode::None); this->addOutputSocket(DataType::Color); this->set_canvas_input_index(0); - m_inputOperation = nullptr; - m_flipX = true; - m_flipY = false; + inputOperation_ = nullptr; + flipX_ = true; + flipY_ = false; } void FlipOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); } void FlipOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void FlipOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) { - float nx = m_flipX ? ((int)this->getWidth() - 1) - x : x; - float ny = m_flipY ? ((int)this->getHeight() - 1) - y : y; + float nx = flipX_ ? ((int)this->getWidth() - 1) - x : x; + float ny = flipY_ ? ((int)this->getHeight() - 1) - y : y; - m_inputOperation->readSampled(output, nx, ny, sampler); + inputOperation_->readSampled(output, nx, ny, sampler); } bool FlipOperation::determineDependingAreaOfInterest(rcti *input, @@ -53,7 +53,7 @@ bool FlipOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - if (m_flipX) { + if (flipX_) { const int w = (int)this->getWidth() - 1; newInput.xmax = (w - input->xmin) + 1; newInput.xmin = (w - input->xmax) - 1; @@ -62,7 +62,7 @@ bool FlipOperation::determineDependingAreaOfInterest(rcti *input, newInput.xmin = input->xmin; newInput.xmax = input->xmax; } - if (m_flipY) { + if (flipY_) { const int h = (int)this->getHeight() - 1; newInput.ymax = (h - input->ymin) + 1; newInput.ymin = (h - input->ymax) - 1; @@ -80,12 +80,12 @@ void FlipOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) NodeOperation::determine_canvas(preferred_area, r_area); if (execution_model_ == eExecutionModel::FullFrame) { rcti input_area = r_area; - if (m_flipX) { + if (flipX_) { const int width = BLI_rcti_size_x(&input_area) - 1; r_area.xmax = (width - input_area.xmin) + 1; r_area.xmin = (width - input_area.xmax) + 1; } - if (m_flipY) { + if (flipY_) { const int height = BLI_rcti_size_y(&input_area) - 1; r_area.ymax = (height - input_area.ymin) + 1; r_area.ymin = (height - input_area.ymax) + 1; @@ -99,7 +99,7 @@ void FlipOperation::get_area_of_interest(const int input_idx, { BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - if (m_flipX) { + if (flipX_) { const int w = (int)this->getWidth() - 1; r_input_area.xmax = (w - output_area.xmin) + 1; r_input_area.xmin = (w - output_area.xmax) + 1; @@ -108,7 +108,7 @@ void FlipOperation::get_area_of_interest(const int input_idx, r_input_area.xmin = output_area.xmin; r_input_area.xmax = output_area.xmax; } - if (m_flipY) { + if (flipY_) { const int h = (int)this->getHeight() - 1; r_input_area.ymax = (h - output_area.ymin) + 1; r_input_area.ymin = (h - output_area.ymax) + 1; @@ -127,8 +127,8 @@ void FlipOperation::update_memory_buffer_partial(MemoryBuffer *output, const int input_offset_x = input_img->get_rect().xmin; const int input_offset_y = input_img->get_rect().ymin; for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { - const int nx = m_flipX ? ((int)this->getWidth() - 1) - it.x : it.x; - const int ny = m_flipY ? ((int)this->getHeight() - 1) - it.y : it.y; + const int nx = flipX_ ? ((int)this->getWidth() - 1) - it.x : it.x; + const int ny = flipY_ ? ((int)this->getHeight() - 1) - it.y : it.y; input_img->read_elem(input_offset_x + nx, input_offset_y + ny, it.out); } } diff --git a/source/blender/compositor/operations/COM_FlipOperation.h b/source/blender/compositor/operations/COM_FlipOperation.h index b43c3a33495..3310819051a 100644 --- a/source/blender/compositor/operations/COM_FlipOperation.h +++ b/source/blender/compositor/operations/COM_FlipOperation.h @@ -24,9 +24,9 @@ namespace blender::compositor { class FlipOperation : public MultiThreadedOperation { private: - SocketReader *m_inputOperation; - bool m_flipX; - bool m_flipY; + SocketReader *inputOperation_; + bool flipX_; + bool flipY_; public: FlipOperation(); @@ -39,11 +39,11 @@ class FlipOperation : public MultiThreadedOperation { void deinitExecution() override; void setFlipX(bool flipX) { - m_flipX = flipX; + flipX_ = flipX; } void setFlipY(bool flipY) { - m_flipY = flipY; + flipY_ = flipY; } void determine_canvas(const rcti &preferred_area, rcti &r_area) override; diff --git a/source/blender/compositor/operations/COM_GammaCorrectOperation.cc b/source/blender/compositor/operations/COM_GammaCorrectOperation.cc index 886ff9d09c2..9a51c789943 100644 --- a/source/blender/compositor/operations/COM_GammaCorrectOperation.cc +++ b/source/blender/compositor/operations/COM_GammaCorrectOperation.cc @@ -24,12 +24,12 @@ GammaCorrectOperation::GammaCorrectOperation() { this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; + inputProgram_ = nullptr; flags.can_be_constant = true; } void GammaCorrectOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void GammaCorrectOperation::executePixelSampled(float output[4], @@ -38,7 +38,7 @@ void GammaCorrectOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputProgram->readSampled(inputColor, x, y, sampler); + inputProgram_->readSampled(inputColor, x, y, sampler); if (inputColor[3] > 0.0f) { inputColor[0] /= inputColor[3]; inputColor[1] /= inputColor[3]; @@ -88,19 +88,19 @@ void GammaCorrectOperation::update_memory_buffer_partial(MemoryBuffer *output, void GammaCorrectOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; } GammaUncorrectOperation::GammaUncorrectOperation() { this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; + inputProgram_ = nullptr; flags.can_be_constant = true; } void GammaUncorrectOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void GammaUncorrectOperation::executePixelSampled(float output[4], @@ -109,7 +109,7 @@ void GammaUncorrectOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inputColor[4]; - m_inputProgram->readSampled(inputColor, x, y, sampler); + inputProgram_->readSampled(inputColor, x, y, sampler); if (inputColor[3] > 0.0f) { inputColor[0] /= inputColor[3]; @@ -158,7 +158,7 @@ void GammaUncorrectOperation::update_memory_buffer_partial(MemoryBuffer *output, void GammaUncorrectOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GammaCorrectOperation.h b/source/blender/compositor/operations/COM_GammaCorrectOperation.h index 2a9fde70e87..5c6307fe6d0 100644 --- a/source/blender/compositor/operations/COM_GammaCorrectOperation.h +++ b/source/blender/compositor/operations/COM_GammaCorrectOperation.h @@ -27,7 +27,7 @@ class GammaCorrectOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; public: GammaCorrectOperation(); @@ -57,7 +57,7 @@ class GammaUncorrectOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; public: GammaUncorrectOperation(); diff --git a/source/blender/compositor/operations/COM_GammaOperation.cc b/source/blender/compositor/operations/COM_GammaOperation.cc index 21430a68848..a809b16f523 100644 --- a/source/blender/compositor/operations/COM_GammaOperation.cc +++ b/source/blender/compositor/operations/COM_GammaOperation.cc @@ -25,14 +25,14 @@ GammaOperation::GammaOperation() this->addInputSocket(DataType::Color); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; - m_inputGammaProgram = nullptr; + inputProgram_ = nullptr; + inputGammaProgram_ = nullptr; flags.can_be_constant = true; } void GammaOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); - m_inputGammaProgram = this->getInputSocketReader(1); + inputProgram_ = this->getInputSocketReader(0); + inputGammaProgram_ = this->getInputSocketReader(1); } void GammaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) @@ -40,8 +40,8 @@ void GammaOperation::executePixelSampled(float output[4], float x, float y, Pixe float inputValue[4]; float inputGamma[4]; - m_inputProgram->readSampled(inputValue, x, y, sampler); - m_inputGammaProgram->readSampled(inputGamma, x, y, sampler); + inputProgram_->readSampled(inputValue, x, y, sampler); + inputGammaProgram_->readSampled(inputGamma, x, y, sampler); const float gamma = inputGamma[0]; /* check for negative to avoid nan's */ output[0] = inputValue[0] > 0.0f ? powf(inputValue[0], gamma) : inputValue[0]; @@ -67,8 +67,8 @@ void GammaOperation::update_memory_buffer_row(PixelCursor &p) void GammaOperation::deinitExecution() { - m_inputProgram = nullptr; - m_inputGammaProgram = nullptr; + inputProgram_ = nullptr; + inputGammaProgram_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GammaOperation.h b/source/blender/compositor/operations/COM_GammaOperation.h index 713d3d8484f..9b68a2c8a1b 100644 --- a/source/blender/compositor/operations/COM_GammaOperation.h +++ b/source/blender/compositor/operations/COM_GammaOperation.h @@ -27,8 +27,8 @@ class GammaOperation : public MultiThreadedRowOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; - SocketReader *m_inputGammaProgram; + SocketReader *inputProgram_; + SocketReader *inputGammaProgram_; public: GammaOperation(); diff --git a/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.cc b/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.cc index 20459a8b038..fa742775f24 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.cc @@ -23,9 +23,9 @@ namespace blender::compositor { GaussianAlphaBlurBaseOperation::GaussianAlphaBlurBaseOperation(eDimension dim) : BlurBaseOperation(DataType::Value) { - m_gausstab = nullptr; - m_filtersize = 0; - m_falloff = -1; /* Intentionally invalid, so we can detect uninitialized values. */ + gausstab_ = nullptr; + filtersize_ = 0; + falloff_ = -1; /* Intentionally invalid, so we can detect uninitialized values. */ dimension_ = dim; } @@ -33,9 +33,9 @@ void GaussianAlphaBlurBaseOperation::init_data() { BlurBaseOperation::init_data(); if (execution_model_ == eExecutionModel::FullFrame) { - rad_ = max_ff(m_size * this->get_blur_size(dimension_), 0.0f); + rad_ = max_ff(size_ * this->get_blur_size(dimension_), 0.0f); rad_ = min_ff(rad_, MAX_GAUSSTAB_RADIUS); - m_filtersize = min_ii(ceil(rad_), MAX_GAUSSTAB_RADIUS); + filtersize_ = min_ii(ceil(rad_), MAX_GAUSSTAB_RADIUS); } } @@ -43,8 +43,8 @@ void GaussianAlphaBlurBaseOperation::initExecution() { BlurBaseOperation::initExecution(); if (execution_model_ == eExecutionModel::FullFrame) { - m_gausstab = BlurBaseOperation::make_gausstab(rad_, m_filtersize); - m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad_, m_filtersize, m_falloff); + gausstab_ = BlurBaseOperation::make_gausstab(rad_, filtersize_); + distbuf_inv_ = BlurBaseOperation::make_dist_fac_inverse(rad_, filtersize_, falloff_); } } @@ -52,14 +52,14 @@ void GaussianAlphaBlurBaseOperation::deinitExecution() { BlurBaseOperation::deinitExecution(); - if (m_gausstab) { - MEM_freeN(m_gausstab); - m_gausstab = nullptr; + if (gausstab_) { + MEM_freeN(gausstab_); + gausstab_ = nullptr; } - if (m_distbuf_inv) { - MEM_freeN(m_distbuf_inv); - m_distbuf_inv = nullptr; + if (distbuf_inv_) { + MEM_freeN(distbuf_inv_); + distbuf_inv_ = nullptr; } } @@ -75,12 +75,12 @@ void GaussianAlphaBlurBaseOperation::get_area_of_interest(const int input_idx, r_input_area = output_area; switch (dimension_) { case eDimension::X: - r_input_area.xmin = output_area.xmin - m_filtersize - 1; - r_input_area.xmax = output_area.xmax + m_filtersize + 1; + r_input_area.xmin = output_area.xmin - filtersize_ - 1; + r_input_area.xmax = output_area.xmax + filtersize_ + 1; break; case eDimension::Y: - r_input_area.ymin = output_area.ymin - m_filtersize - 1; - r_input_area.ymax = output_area.ymax + m_filtersize + 1; + r_input_area.ymin = output_area.ymin - filtersize_ - 1; + r_input_area.ymax = output_area.ymax + filtersize_ + 1; break; } } @@ -119,8 +119,8 @@ void GaussianAlphaBlurBaseOperation::update_memory_buffer_partial(MemoryBuffer * for (; !it.is_end(); ++it) { const int coord = get_current_coord(); - const int coord_min = max_ii(coord - m_filtersize, min_input_coord); - const int coord_max = min_ii(coord + m_filtersize + 1, max_input_coord); + const int coord_min = max_ii(coord - filtersize_, min_input_coord); + const int coord_max = min_ii(coord + filtersize_ + 1, max_input_coord); /* *** This is the main part which is different to #GaussianBlurBaseOperation. *** */ /* Gauss. */ @@ -128,7 +128,7 @@ void GaussianAlphaBlurBaseOperation::update_memory_buffer_partial(MemoryBuffer * float multiplier_accum = 0.0f; /* Dilate. */ - const bool do_invert = m_do_subtract; + const bool do_invert = do_subtract_; /* Init with the current color to avoid unneeded lookups. */ float value_max = finv_test(*it.in(0), do_invert); float distfacinv_max = 1.0f; /* 0 to 1 */ @@ -136,19 +136,19 @@ void GaussianAlphaBlurBaseOperation::update_memory_buffer_partial(MemoryBuffer * const int step = QualityStepHelper::getStep(); const float *in = it.in(0) + ((intptr_t)coord_min - coord) * elem_stride; const int in_stride = elem_stride * step; - int index = (coord_min - coord) + m_filtersize; + int index = (coord_min - coord) + filtersize_; const int index_end = index + (coord_max - coord_min); for (; index < index_end; in += in_stride, index += step) { float value = finv_test(*in, do_invert); /* Gauss. */ - float multiplier = m_gausstab[index]; + float multiplier = gausstab_[index]; alpha_accum += value * multiplier; multiplier_accum += multiplier; /* Dilate - find most extreme color. */ if (value > value_max) { - multiplier = m_distbuf_inv[index]; + multiplier = distbuf_inv_[index]; value *= multiplier; if (value > value_max) { value_max = value; diff --git a/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.h b/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.h index bb03b672a34..307d8b0dff5 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.h +++ b/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.h @@ -24,11 +24,11 @@ namespace blender::compositor { class GaussianAlphaBlurBaseOperation : public BlurBaseOperation { protected: - float *m_gausstab; - float *m_distbuf_inv; - int m_falloff; /* Falloff for #distbuf_inv. */ - bool m_do_subtract; - int m_filtersize; + float *gausstab_; + float *distbuf_inv_; + int falloff_; /* Falloff for #distbuf_inv. */ + bool do_subtract_; + int filtersize_; float rad_; eDimension dimension_; @@ -51,11 +51,11 @@ class GaussianAlphaBlurBaseOperation : public BlurBaseOperation { */ void setSubtract(bool subtract) { - m_do_subtract = subtract; + do_subtract_ = subtract; } void setFalloff(int falloff) { - m_falloff = falloff; + falloff_ = falloff; } }; diff --git a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cc index 4900c12f13a..b854ea736b3 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cc @@ -28,7 +28,7 @@ GaussianAlphaXBlurOperation::GaussianAlphaXBlurOperation() void *GaussianAlphaXBlurOperation::initializeTileData(rcti * /*rect*/) { lockMutex(); - if (!m_sizeavailable) { + if (!sizeavailable_) { updateGauss(); } void *buffer = getInputOperation(0)->initializeTileData(nullptr); @@ -42,32 +42,32 @@ void GaussianAlphaXBlurOperation::initExecution() initMutex(); - if (m_sizeavailable && execution_model_ == eExecutionModel::Tiled) { - float rad = max_ff(m_size * m_data.sizex, 0.0f); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + if (sizeavailable_ && execution_model_ == eExecutionModel::Tiled) { + float rad = max_ff(size_ * data_.sizex, 0.0f); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); - m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, m_filtersize, m_falloff); + gausstab_ = BlurBaseOperation::make_gausstab(rad, filtersize_); + distbuf_inv_ = BlurBaseOperation::make_dist_fac_inverse(rad, filtersize_, falloff_); } } void GaussianAlphaXBlurOperation::updateGauss() { - if (m_gausstab == nullptr) { + if (gausstab_ == nullptr) { updateSize(); - float rad = max_ff(m_size * m_data.sizex, 0.0f); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + float rad = max_ff(size_ * data_.sizex, 0.0f); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); + gausstab_ = BlurBaseOperation::make_gausstab(rad, filtersize_); } - if (m_distbuf_inv == nullptr) { + if (distbuf_inv_ == nullptr) { updateSize(); - float rad = max_ff(m_size * m_data.sizex, 0.0f); + float rad = max_ff(size_ * data_.sizex, 0.0f); rad = min_ff(rad, MAX_GAUSSTAB_RADIUS); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, m_filtersize, m_falloff); + distbuf_inv_ = BlurBaseOperation::make_dist_fac_inverse(rad, filtersize_, falloff_); } } @@ -78,7 +78,7 @@ BLI_INLINE float finv_test(const float f, const bool test) void GaussianAlphaXBlurOperation::executePixel(float output[4], int x, int y, void *data) { - const bool do_invert = m_do_subtract; + const bool do_invert = do_subtract_; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); int bufferwidth = inputBuffer->getWidth(); @@ -87,8 +87,8 @@ void GaussianAlphaXBlurOperation::executePixel(float output[4], int x, int y, vo int bufferstarty = input_rect.ymin; const rcti &rect = inputBuffer->get_rect(); - int xmin = max_ii(x - m_filtersize, rect.xmin); - int xmax = min_ii(x + m_filtersize + 1, rect.xmax); + int xmin = max_ii(x - filtersize_, rect.xmin); + int xmax = min_ii(x + filtersize_ + 1, rect.xmax); int ymin = max_ii(y, rect.ymin); /* *** this is the main part which is different to 'GaussianXBlurOperation' *** */ @@ -106,20 +106,20 @@ void GaussianAlphaXBlurOperation::executePixel(float output[4], int x, int y, vo float distfacinv_max = 1.0f; /* 0 to 1 */ for (int nx = xmin; nx < xmax; nx += step) { - const int index = (nx - x) + m_filtersize; + const int index = (nx - x) + filtersize_; float value = finv_test(buffer[bufferindex], do_invert); float multiplier; /* gauss */ { - multiplier = m_gausstab[index]; + multiplier = gausstab_[index]; alpha_accum += value * multiplier; multiplier_accum += multiplier; } /* dilate - find most extreme color */ if (value > value_max) { - multiplier = m_distbuf_inv[index]; + multiplier = distbuf_inv_[index]; value *= multiplier; if (value > value_max) { value_max = value; @@ -139,14 +139,14 @@ void GaussianAlphaXBlurOperation::deinitExecution() { GaussianAlphaBlurBaseOperation::deinitExecution(); - if (m_gausstab) { - MEM_freeN(m_gausstab); - m_gausstab = nullptr; + if (gausstab_) { + MEM_freeN(gausstab_); + gausstab_ = nullptr; } - if (m_distbuf_inv) { - MEM_freeN(m_distbuf_inv); - m_distbuf_inv = nullptr; + if (distbuf_inv_) { + MEM_freeN(distbuf_inv_); + distbuf_inv_ = nullptr; } deinitMutex(); @@ -170,9 +170,9 @@ bool GaussianAlphaXBlurOperation::determineDependingAreaOfInterest( else #endif { - if (m_sizeavailable && m_gausstab != nullptr) { - newInput.xmax = input->xmax + m_filtersize + 1; - newInput.xmin = input->xmin - m_filtersize - 1; + if (sizeavailable_ && gausstab_ != nullptr) { + newInput.xmax = input->xmax + filtersize_ + 1; + newInput.xmin = input->xmin - filtersize_ - 1; newInput.ymax = input->ymax; newInput.ymin = input->ymin; } diff --git a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cc index 49f5902ba9c..eaf3abc18cd 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cc @@ -28,7 +28,7 @@ GaussianAlphaYBlurOperation::GaussianAlphaYBlurOperation() void *GaussianAlphaYBlurOperation::initializeTileData(rcti * /*rect*/) { lockMutex(); - if (!m_sizeavailable) { + if (!sizeavailable_) { updateGauss(); } void *buffer = getInputOperation(0)->initializeTileData(nullptr); @@ -43,33 +43,33 @@ void GaussianAlphaYBlurOperation::initExecution() initMutex(); - if (m_sizeavailable && execution_model_ == eExecutionModel::Tiled) { - float rad = max_ff(m_size * m_data.sizey, 0.0f); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + if (sizeavailable_ && execution_model_ == eExecutionModel::Tiled) { + float rad = max_ff(size_ * data_.sizey, 0.0f); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); - m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, m_filtersize, m_falloff); + gausstab_ = BlurBaseOperation::make_gausstab(rad, filtersize_); + distbuf_inv_ = BlurBaseOperation::make_dist_fac_inverse(rad, filtersize_, falloff_); } } /* TODO(manzanilla): to be removed with tiled implementation. */ void GaussianAlphaYBlurOperation::updateGauss() { - if (m_gausstab == nullptr) { + if (gausstab_ == nullptr) { updateSize(); - float rad = max_ff(m_size * m_data.sizey, 0.0f); + float rad = max_ff(size_ * data_.sizey, 0.0f); rad = min_ff(rad, MAX_GAUSSTAB_RADIUS); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); + gausstab_ = BlurBaseOperation::make_gausstab(rad, filtersize_); } - if (m_distbuf_inv == nullptr) { + if (distbuf_inv_ == nullptr) { updateSize(); - float rad = max_ff(m_size * m_data.sizey, 0.0f); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + float rad = max_ff(size_ * data_.sizey, 0.0f); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, m_filtersize, m_falloff); + distbuf_inv_ = BlurBaseOperation::make_dist_fac_inverse(rad, filtersize_, falloff_); } } @@ -80,7 +80,7 @@ BLI_INLINE float finv_test(const float f, const bool test) void GaussianAlphaYBlurOperation::executePixel(float output[4], int x, int y, void *data) { - const bool do_invert = m_do_subtract; + const bool do_invert = do_subtract_; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; const rcti &input_rect = inputBuffer->get_rect(); float *buffer = inputBuffer->getBuffer(); @@ -89,8 +89,8 @@ void GaussianAlphaYBlurOperation::executePixel(float output[4], int x, int y, vo int bufferstarty = input_rect.ymin; int xmin = max_ii(x, input_rect.xmin); - int ymin = max_ii(y - m_filtersize, input_rect.ymin); - int ymax = min_ii(y + m_filtersize + 1, input_rect.ymax); + int ymin = max_ii(y - filtersize_, input_rect.ymin); + int ymax = min_ii(y + filtersize_ + 1, input_rect.ymax); /* *** this is the main part which is different to 'GaussianYBlurOperation' *** */ int step = getStep(); @@ -108,20 +108,20 @@ void GaussianAlphaYBlurOperation::executePixel(float output[4], int x, int y, vo for (int ny = ymin; ny < ymax; ny += step) { int bufferindex = ((xmin - bufferstartx)) + ((ny - bufferstarty) * bufferwidth); - const int index = (ny - y) + m_filtersize; + const int index = (ny - y) + filtersize_; float value = finv_test(buffer[bufferindex], do_invert); float multiplier; /* gauss */ { - multiplier = m_gausstab[index]; + multiplier = gausstab_[index]; alpha_accum += value * multiplier; multiplier_accum += multiplier; } /* dilate - find most extreme color */ if (value > value_max) { - multiplier = m_distbuf_inv[index]; + multiplier = distbuf_inv_[index]; value *= multiplier; if (value > value_max) { value_max = value; @@ -140,14 +140,14 @@ void GaussianAlphaYBlurOperation::deinitExecution() { GaussianAlphaBlurBaseOperation::deinitExecution(); - if (m_gausstab) { - MEM_freeN(m_gausstab); - m_gausstab = nullptr; + if (gausstab_) { + MEM_freeN(gausstab_); + gausstab_ = nullptr; } - if (m_distbuf_inv) { - MEM_freeN(m_distbuf_inv); - m_distbuf_inv = nullptr; + if (distbuf_inv_) { + MEM_freeN(distbuf_inv_); + distbuf_inv_ = nullptr; } deinitMutex(); @@ -171,11 +171,11 @@ bool GaussianAlphaYBlurOperation::determineDependingAreaOfInterest( else #endif { - if (m_sizeavailable && m_gausstab != nullptr) { + if (sizeavailable_ && gausstab_ != nullptr) { newInput.xmax = input->xmax; newInput.xmin = input->xmin; - newInput.ymax = input->ymax + m_filtersize + 1; - newInput.ymin = input->ymin - m_filtersize - 1; + newInput.ymax = input->ymax + filtersize_ + 1; + newInput.ymin = input->ymin - filtersize_ - 1; } else { newInput.xmax = this->getWidth(); diff --git a/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.cc b/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.cc index 959f599fab4..e6d3b3d4424 100644 --- a/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.cc @@ -23,11 +23,11 @@ namespace blender::compositor { GaussianBlurBaseOperation::GaussianBlurBaseOperation(eDimension dim) : BlurBaseOperation(DataType::Color) { - m_gausstab = nullptr; + gausstab_ = nullptr; #ifdef BLI_HAVE_SSE2 - m_gausstab_sse = nullptr; + gausstab_sse_ = nullptr; #endif - m_filtersize = 0; + filtersize_ = 0; rad_ = 0.0f; dimension_ = dim; } @@ -36,9 +36,9 @@ void GaussianBlurBaseOperation::init_data() { BlurBaseOperation::init_data(); if (execution_model_ == eExecutionModel::FullFrame) { - rad_ = max_ff(m_size * this->get_blur_size(dimension_), 0.0f); + rad_ = max_ff(size_ * this->get_blur_size(dimension_), 0.0f); rad_ = min_ff(rad_, MAX_GAUSSTAB_RADIUS); - m_filtersize = min_ii(ceil(rad_), MAX_GAUSSTAB_RADIUS); + filtersize_ = min_ii(ceil(rad_), MAX_GAUSSTAB_RADIUS); } } @@ -46,9 +46,9 @@ void GaussianBlurBaseOperation::initExecution() { BlurBaseOperation::initExecution(); if (execution_model_ == eExecutionModel::FullFrame) { - m_gausstab = BlurBaseOperation::make_gausstab(rad_, m_filtersize); + gausstab_ = BlurBaseOperation::make_gausstab(rad_, filtersize_); #ifdef BLI_HAVE_SSE2 - m_gausstab_sse = BlurBaseOperation::convert_gausstab_sse(m_gausstab, m_filtersize); + gausstab_sse_ = BlurBaseOperation::convert_gausstab_sse(gausstab_, filtersize_); #endif } } @@ -57,14 +57,14 @@ void GaussianBlurBaseOperation::deinitExecution() { BlurBaseOperation::deinitExecution(); - if (m_gausstab) { - MEM_freeN(m_gausstab); - m_gausstab = nullptr; + if (gausstab_) { + MEM_freeN(gausstab_); + gausstab_ = nullptr; } #ifdef BLI_HAVE_SSE2 - if (m_gausstab_sse) { - MEM_freeN(m_gausstab_sse); - m_gausstab_sse = nullptr; + if (gausstab_sse_) { + MEM_freeN(gausstab_sse_); + gausstab_sse_ = nullptr; } #endif } @@ -81,12 +81,12 @@ void GaussianBlurBaseOperation::get_area_of_interest(const int input_idx, r_input_area = output_area; switch (dimension_) { case eDimension::X: - r_input_area.xmin = output_area.xmin - m_filtersize - 1; - r_input_area.xmax = output_area.xmax + m_filtersize + 1; + r_input_area.xmin = output_area.xmin - filtersize_ - 1; + r_input_area.xmax = output_area.xmax + filtersize_ + 1; break; case eDimension::Y: - r_input_area.ymin = output_area.ymin - m_filtersize - 1; - r_input_area.ymax = output_area.ymax + m_filtersize + 1; + r_input_area.ymin = output_area.ymin - filtersize_ - 1; + r_input_area.ymax = output_area.ymax + filtersize_ + 1; break; } } @@ -120,8 +120,8 @@ void GaussianBlurBaseOperation::update_memory_buffer_partial(MemoryBuffer *outpu for (; !it.is_end(); ++it) { const int coord = get_current_coord(); - const int coord_min = max_ii(coord - m_filtersize, min_input_coord); - const int coord_max = min_ii(coord + m_filtersize + 1, max_input_coord); + const int coord_min = max_ii(coord - filtersize_, min_input_coord); + const int coord_max = min_ii(coord + filtersize_ + 1, max_input_coord); float ATTR_ALIGN(16) color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; float multiplier_accum = 0.0f; @@ -129,20 +129,20 @@ void GaussianBlurBaseOperation::update_memory_buffer_partial(MemoryBuffer *outpu const int step = QualityStepHelper::getStep(); const float *in = it.in(0) + ((intptr_t)coord_min - coord) * elem_stride; const int in_stride = elem_stride * step; - int gauss_idx = (coord_min - coord) + m_filtersize; + int gauss_idx = (coord_min - coord) + filtersize_; const int gauss_end = gauss_idx + (coord_max - coord_min); #ifdef BLI_HAVE_SSE2 __m128 accum_r = _mm_load_ps(color_accum); for (; gauss_idx < gauss_end; in += in_stride, gauss_idx += step) { __m128 reg_a = _mm_load_ps(in); - reg_a = _mm_mul_ps(reg_a, m_gausstab_sse[gauss_idx]); + reg_a = _mm_mul_ps(reg_a, gausstab_sse_[gauss_idx]); accum_r = _mm_add_ps(accum_r, reg_a); - multiplier_accum += m_gausstab[gauss_idx]; + multiplier_accum += gausstab_[gauss_idx]; } _mm_store_ps(color_accum, accum_r); #else for (; gauss_idx < gauss_end; in += in_stride, gauss_idx += step) { - const float multiplier = m_gausstab[gauss_idx]; + const float multiplier = gausstab_[gauss_idx]; madd_v4_v4fl(color_accum, in, multiplier); multiplier_accum += multiplier; } diff --git a/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.h b/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.h index c0b27078a24..0e3a86e63ec 100644 --- a/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.h +++ b/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.h @@ -24,11 +24,11 @@ namespace blender::compositor { class GaussianBlurBaseOperation : public BlurBaseOperation { protected: - float *m_gausstab; + float *gausstab_; #ifdef BLI_HAVE_SSE2 - __m128 *m_gausstab_sse; + __m128 *gausstab_sse_; #endif - int m_filtersize; + int filtersize_; float rad_; eDimension dimension_; diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cc index 670eb3196c6..b5d6aa69423 100644 --- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cc @@ -24,13 +24,13 @@ namespace blender::compositor { GaussianBokehBlurOperation::GaussianBokehBlurOperation() : BlurBaseOperation(DataType::Color) { - m_gausstab = nullptr; + gausstab_ = nullptr; } void *GaussianBokehBlurOperation::initializeTileData(rcti * /*rect*/) { lockMutex(); - if (!m_sizeavailable) { + if (!sizeavailable_) { updateGauss(); } void *buffer = getInputOperation(0)->initializeTileData(nullptr); @@ -44,19 +44,19 @@ void GaussianBokehBlurOperation::init_data() const float width = this->getWidth(); const float height = this->getHeight(); - if (!m_sizeavailable) { + if (!sizeavailable_) { updateSize(); } - radxf_ = m_size * (float)m_data.sizex; + radxf_ = size_ * (float)data_.sizex; CLAMP(radxf_, 0.0f, width / 2.0f); /* Vertical. */ - radyf_ = m_size * (float)m_data.sizey; + radyf_ = size_ * (float)data_.sizey; CLAMP(radyf_, 0.0f, height / 2.0f); - m_radx = ceil(radxf_); - m_rady = ceil(radyf_); + radx_ = ceil(radxf_); + rady_ = ceil(radyf_); } void GaussianBokehBlurOperation::initExecution() @@ -65,16 +65,16 @@ void GaussianBokehBlurOperation::initExecution() initMutex(); - if (m_sizeavailable) { + if (sizeavailable_) { updateGauss(); } } void GaussianBokehBlurOperation::updateGauss() { - if (m_gausstab == nullptr) { - int ddwidth = 2 * m_radx + 1; - int ddheight = 2 * m_rady + 1; + if (gausstab_ == nullptr) { + int ddwidth = 2 * radx_ + 1; + int ddheight = 2 * rady_ + 1; int n = ddwidth * ddheight; /* create a full filter image */ float *ddgauss = (float *)MEM_mallocN(sizeof(float) * n, __func__); @@ -82,12 +82,12 @@ void GaussianBokehBlurOperation::updateGauss() float sum = 0.0f; float facx = (radxf_ > 0.0f ? 1.0f / radxf_ : 0.0f); float facy = (radyf_ > 0.0f ? 1.0f / radyf_ : 0.0f); - for (int j = -m_rady; j <= m_rady; j++) { - for (int i = -m_radx; i <= m_radx; i++, dgauss++) { + for (int j = -rady_; j <= rady_; j++) { + for (int i = -radx_; i <= radx_; i++, dgauss++) { float fj = (float)j * facy; float fi = (float)i * facx; float dist = sqrt(fj * fj + fi * fi); - *dgauss = RE_filter_value(m_data.filtertype, dist); + *dgauss = RE_filter_value(data_.filtertype, dist); sum += *dgauss; } @@ -101,11 +101,11 @@ void GaussianBokehBlurOperation::updateGauss() } } else { - int center = m_rady * ddwidth + m_radx; + int center = rady_ * ddwidth + radx_; ddgauss[center] = 1.0f; } - m_gausstab = ddgauss; + gausstab_ = ddgauss; } } @@ -124,21 +124,21 @@ void GaussianBokehBlurOperation::executePixel(float output[4], int x, int y, voi int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; - int ymin = max_ii(y - m_rady, input_rect.ymin); - int ymax = min_ii(y + m_rady + 1, input_rect.ymax); - int xmin = max_ii(x - m_radx, input_rect.xmin); - int xmax = min_ii(x + m_radx + 1, input_rect.xmax); + int ymin = max_ii(y - rady_, input_rect.ymin); + int ymax = min_ii(y + rady_ + 1, input_rect.ymax); + int xmin = max_ii(x - radx_, input_rect.xmin); + int xmax = min_ii(x + radx_ + 1, input_rect.xmax); int index; int step = QualityStepHelper::getStep(); int offsetadd = QualityStepHelper::getOffsetAdd(); - const int addConst = (xmin - x + m_radx); - const int mulConst = (m_radx * 2 + 1); + const int addConst = (xmin - x + radx_); + const int mulConst = (radx_ * 2 + 1); for (int ny = ymin; ny < ymax; ny += step) { - index = ((ny - y) + m_rady) * mulConst + addConst; + index = ((ny - y) + rady_) * mulConst + addConst; int bufferindex = ((xmin - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth); for (int nx = xmin; nx < xmax; nx += step) { - const float multiplier = m_gausstab[index]; + const float multiplier = gausstab_[index]; madd_v4_v4fl(tempColor, &buffer[bufferindex], multiplier); multiplier_accum += multiplier; index += step; @@ -153,9 +153,9 @@ void GaussianBokehBlurOperation::deinitExecution() { BlurBaseOperation::deinitExecution(); - if (m_gausstab) { - MEM_freeN(m_gausstab); - m_gausstab = nullptr; + if (gausstab_) { + MEM_freeN(gausstab_); + gausstab_ = nullptr; } deinitMutex(); @@ -176,15 +176,15 @@ bool GaussianBokehBlurOperation::determineDependingAreaOfInterest( return true; } - if (m_sizeavailable && m_gausstab != nullptr) { + if (sizeavailable_ && gausstab_ != nullptr) { newInput.xmin = 0; newInput.ymin = 0; newInput.xmax = this->getWidth(); newInput.ymax = this->getHeight(); } else { - int addx = m_radx; - int addy = m_rady; + int addx = radx_; + int addy = rady_; newInput.xmax = input->xmax + addx; newInput.xmin = input->xmin - addx; newInput.ymax = input->ymax + addy; @@ -202,10 +202,10 @@ void GaussianBokehBlurOperation::get_area_of_interest(const int input_idx, return; } - r_input_area.xmax = output_area.xmax + m_radx; - r_input_area.xmin = output_area.xmin - m_radx; - r_input_area.ymax = output_area.ymax + m_rady; - r_input_area.ymin = output_area.ymin - m_rady; + r_input_area.xmax = output_area.xmax + radx_; + r_input_area.xmin = output_area.xmin - radx_; + r_input_area.ymax = output_area.ymax + rady_; + r_input_area.ymin = output_area.ymin - rady_; } void GaussianBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -219,23 +219,23 @@ void GaussianBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *outp const int x = it.x; const int y = it.y; - const int ymin = max_ii(y - m_rady, input_rect.ymin); - const int ymax = min_ii(y + m_rady + 1, input_rect.ymax); - const int xmin = max_ii(x - m_radx, input_rect.xmin); - const int xmax = min_ii(x + m_radx + 1, input_rect.xmax); + const int ymin = max_ii(y - rady_, input_rect.ymin); + const int ymax = min_ii(y + rady_ + 1, input_rect.ymax); + const int xmin = max_ii(x - radx_, input_rect.xmin); + const int xmax = min_ii(x + radx_ + 1, input_rect.xmax); float tempColor[4] = {0}; float multiplier_accum = 0; const int step = QualityStepHelper::getStep(); const int elem_step = step * input->elem_stride; - const int add_const = (xmin - x + m_radx); - const int mul_const = (m_radx * 2 + 1); + const int add_const = (xmin - x + radx_); + const int mul_const = (radx_ * 2 + 1); for (int ny = ymin; ny < ymax; ny += step) { const float *color = input->get_elem(xmin, ny); - int gauss_index = ((ny - y) + m_rady) * mul_const + add_const; + int gauss_index = ((ny - y) + rady_) * mul_const + add_const; const int gauss_end = gauss_index + (xmax - xmin); for (; gauss_index < gauss_end; gauss_index += step, color += elem_step) { - const float multiplier = m_gausstab[gauss_index]; + const float multiplier = gausstab_[gauss_index]; madd_v4_v4fl(tempColor, color, multiplier); multiplier_accum += multiplier; } @@ -249,53 +249,53 @@ void GaussianBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *outp GaussianBlurReferenceOperation::GaussianBlurReferenceOperation() : BlurBaseOperation(DataType::Color) { - m_maintabs = nullptr; + maintabs_ = nullptr; use_variable_size_ = true; } void GaussianBlurReferenceOperation::init_data() { /* Setup variables for gausstab and area of interest. */ - m_data.image_in_width = this->getWidth(); - m_data.image_in_height = this->getHeight(); - if (m_data.relative) { - switch (m_data.aspect) { + data_.image_in_width = this->getWidth(); + data_.image_in_height = this->getHeight(); + if (data_.relative) { + switch (data_.aspect) { case CMP_NODE_BLUR_ASPECT_NONE: - m_data.sizex = (int)(m_data.percentx * 0.01f * m_data.image_in_width); - m_data.sizey = (int)(m_data.percenty * 0.01f * m_data.image_in_height); + data_.sizex = (int)(data_.percentx * 0.01f * data_.image_in_width); + data_.sizey = (int)(data_.percenty * 0.01f * data_.image_in_height); break; case CMP_NODE_BLUR_ASPECT_Y: - m_data.sizex = (int)(m_data.percentx * 0.01f * m_data.image_in_width); - m_data.sizey = (int)(m_data.percenty * 0.01f * m_data.image_in_width); + data_.sizex = (int)(data_.percentx * 0.01f * data_.image_in_width); + data_.sizey = (int)(data_.percenty * 0.01f * data_.image_in_width); break; case CMP_NODE_BLUR_ASPECT_X: - m_data.sizex = (int)(m_data.percentx * 0.01f * m_data.image_in_height); - m_data.sizey = (int)(m_data.percenty * 0.01f * m_data.image_in_height); + data_.sizex = (int)(data_.percentx * 0.01f * data_.image_in_height); + data_.sizey = (int)(data_.percenty * 0.01f * data_.image_in_height); break; } } /* Horizontal. */ - m_filtersizex = (float)m_data.sizex; + filtersizex_ = (float)data_.sizex; int imgx = getWidth() / 2; - if (m_filtersizex > imgx) { - m_filtersizex = imgx; + if (filtersizex_ > imgx) { + filtersizex_ = imgx; } - else if (m_filtersizex < 1) { - m_filtersizex = 1; + else if (filtersizex_ < 1) { + filtersizex_ = 1; } - m_radx = (float)m_filtersizex; + radx_ = (float)filtersizex_; /* Vertical. */ - m_filtersizey = (float)m_data.sizey; + filtersizey_ = (float)data_.sizey; int imgy = getHeight() / 2; - if (m_filtersizey > imgy) { - m_filtersizey = imgy; + if (filtersizey_ > imgy) { + filtersizey_ = imgy; } - else if (m_filtersizey < 1) { - m_filtersizey = 1; + else if (filtersizey_ < 1) { + filtersizey_ = 1; } - m_rady = (float)m_filtersizey; + rady_ = (float)filtersizey_; } void *GaussianBlurReferenceOperation::initializeTileData(rcti * /*rect*/) @@ -314,10 +314,10 @@ void GaussianBlurReferenceOperation::initExecution() void GaussianBlurReferenceOperation::updateGauss() { int i; - int x = MAX2(m_filtersizex, m_filtersizey); - m_maintabs = (float **)MEM_mallocN(x * sizeof(float *), "gauss array"); + int x = MAX2(filtersizex_, filtersizey_); + maintabs_ = (float **)MEM_mallocN(x * sizeof(float *), "gauss array"); for (i = 0; i < x; i++) { - m_maintabs[i] = make_gausstab(i + 1, i + 1); + maintabs_[i] = make_gausstab(i + 1, i + 1); } } @@ -334,18 +334,18 @@ void GaussianBlurReferenceOperation::executePixel(float output[4], int x, int y, int imgx = getWidth(); int imgy = getHeight(); float tempSize[4]; - m_inputSize->read(tempSize, x, y, data); + inputSize_->read(tempSize, x, y, data); float refSize = tempSize[0]; - int refradx = (int)(refSize * m_radx); - int refrady = (int)(refSize * m_rady); - if (refradx > m_filtersizex) { - refradx = m_filtersizex; + int refradx = (int)(refSize * radx_); + int refrady = (int)(refSize * rady_); + if (refradx > filtersizex_) { + refradx = filtersizex_; } else if (refradx < 1) { refradx = 1; } - if (refrady > m_filtersizey) { - refrady = m_filtersizey; + if (refrady > filtersizey_) { + refrady = filtersizey_; } else if (refrady < 1) { refrady = 1; @@ -362,9 +362,9 @@ void GaussianBlurReferenceOperation::executePixel(float output[4], int x, int y, float *srcd = buffer + COM_DATA_TYPE_COLOR_CHANNELS * ((y + minyr) * imgx + x + minxr); - gausstabx = m_maintabs[refradx - 1]; + gausstabx = maintabs_[refradx - 1]; gausstabcentx = gausstabx + refradx; - gausstaby = m_maintabs[refrady - 1]; + gausstaby = maintabs_[refrady - 1]; gausstabcenty = gausstaby + refrady; sum = gval = rval = bval = aval = 0.0f; @@ -391,11 +391,11 @@ void GaussianBlurReferenceOperation::executePixel(float output[4], int x, int y, void GaussianBlurReferenceOperation::deinitExecution() { int x, i; - x = MAX2(m_filtersizex, m_filtersizey); + x = MAX2(filtersizex_, filtersizey_); for (i = 0; i < x; i++) { - MEM_freeN(m_maintabs[i]); + MEM_freeN(maintabs_[i]); } - MEM_freeN(m_maintabs); + MEM_freeN(maintabs_); BlurBaseOperation::deinitExecution(); } @@ -409,8 +409,8 @@ bool GaussianBlurReferenceOperation::determineDependingAreaOfInterest( return true; } - int addx = m_data.sizex + 2; - int addy = m_data.sizey + 2; + int addx = data_.sizex + 2; + int addy = data_.sizey + 2; newInput.xmax = input->xmax + addx; newInput.xmin = input->xmin - addx; newInput.ymax = input->ymax + addy; @@ -427,8 +427,8 @@ void GaussianBlurReferenceOperation::get_area_of_interest(const int input_idx, return; } - const int add_x = m_data.sizex + 2; - const int add_y = m_data.sizey + 2; + const int add_x = data_.sizex + 2; + const int add_y = data_.sizey + 2; r_input_area.xmax = output_area.xmax + add_x; r_input_area.xmin = output_area.xmin - add_x; r_input_area.ymax = output_area.ymax + add_y; @@ -443,16 +443,16 @@ void GaussianBlurReferenceOperation::update_memory_buffer_partial(MemoryBuffer * MemoryBuffer *size_input = inputs[SIZE_INPUT_INDEX]; for (BuffersIterator<float> it = output->iterate_with({size_input}, area); !it.is_end(); ++it) { const float ref_size = *it.in(0); - int ref_radx = (int)(ref_size * m_radx); - int ref_rady = (int)(ref_size * m_rady); - if (ref_radx > m_filtersizex) { - ref_radx = m_filtersizex; + int ref_radx = (int)(ref_size * radx_); + int ref_rady = (int)(ref_size * rady_); + if (ref_radx > filtersizex_) { + ref_radx = filtersizex_; } else if (ref_radx < 1) { ref_radx = 1; } - if (ref_rady > m_filtersizey) { - ref_rady = m_filtersizey; + if (ref_rady > filtersizey_) { + ref_rady = filtersizey_; } else if (ref_rady < 1) { ref_rady = 1; @@ -472,9 +472,9 @@ void GaussianBlurReferenceOperation::update_memory_buffer_partial(MemoryBuffer * const int minyr = y - ref_rady < 0 ? -y : -ref_rady; const int maxyr = y + ref_rady > height ? height - y : ref_rady; - const float *gausstabx = m_maintabs[ref_radx - 1]; + const float *gausstabx = maintabs_[ref_radx - 1]; const float *gausstabcentx = gausstabx + ref_radx; - const float *gausstaby = m_maintabs[ref_rady - 1]; + const float *gausstaby = maintabs_[ref_rady - 1]; const float *gausstabcenty = gausstaby + ref_rady; float gauss_sum = 0.0f; diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h index a64b5b327b0..5e6eeefa512 100644 --- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h @@ -26,8 +26,8 @@ namespace blender::compositor { class GaussianBokehBlurOperation : public BlurBaseOperation { private: - float *m_gausstab; - int m_radx, m_rady; + float *gausstab_; + int radx_, rady_; float radxf_; float radyf_; void updateGauss(); @@ -61,13 +61,13 @@ class GaussianBokehBlurOperation : public BlurBaseOperation { class GaussianBlurReferenceOperation : public BlurBaseOperation { private: - float **m_maintabs; + float **maintabs_; void updateGauss(); - int m_filtersizex; - int m_filtersizey; - float m_radx; - float m_rady; + int filtersizex_; + int filtersizey_; + float radx_; + float rady_; public: GaussianBlurReferenceOperation(); diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cc index 6208820e280..4720b3f69d0 100644 --- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cc @@ -28,7 +28,7 @@ GaussianXBlurOperation::GaussianXBlurOperation() : GaussianBlurBaseOperation(eDi void *GaussianXBlurOperation::initializeTileData(rcti * /*rect*/) { lockMutex(); - if (!m_sizeavailable) { + if (!sizeavailable_) { updateGauss(); } void *buffer = getInputOperation(0)->initializeTileData(nullptr); @@ -43,14 +43,14 @@ void GaussianXBlurOperation::initExecution() initMutex(); - if (m_sizeavailable && execution_model_ == eExecutionModel::Tiled) { - float rad = max_ff(m_size * m_data.sizex, 0.0f); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + if (sizeavailable_ && execution_model_ == eExecutionModel::Tiled) { + float rad = max_ff(size_ * data_.sizex, 0.0f); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); /* TODO(sergey): De-duplicate with the case below and Y blur. */ - m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); + gausstab_ = BlurBaseOperation::make_gausstab(rad, filtersize_); #ifdef BLI_HAVE_SSE2 - m_gausstab_sse = BlurBaseOperation::convert_gausstab_sse(m_gausstab, m_filtersize); + gausstab_sse_ = BlurBaseOperation::convert_gausstab_sse(gausstab_, filtersize_); #endif } } @@ -58,15 +58,15 @@ void GaussianXBlurOperation::initExecution() /* TODO(manzanilla): to be removed with tiled implementation. */ void GaussianXBlurOperation::updateGauss() { - if (m_gausstab == nullptr) { + if (gausstab_ == nullptr) { updateSize(); - float rad = max_ff(m_size * m_data.sizex, 0.0f); + float rad = max_ff(size_ * data_.sizex, 0.0f); rad = min_ff(rad, MAX_GAUSSTAB_RADIUS); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); + gausstab_ = BlurBaseOperation::make_gausstab(rad, filtersize_); #ifdef BLI_HAVE_SSE2 - m_gausstab_sse = BlurBaseOperation::convert_gausstab_sse(m_gausstab, m_filtersize); + gausstab_sse_ = BlurBaseOperation::convert_gausstab_sse(gausstab_, filtersize_); #endif } } @@ -82,8 +82,8 @@ void GaussianXBlurOperation::executePixel(float output[4], int x, int y, void *d int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; - int xmin = max_ii(x - m_filtersize, input_rect.xmin); - int xmax = min_ii(x + m_filtersize + 1, input_rect.xmax); + int xmin = max_ii(x - filtersize_, input_rect.xmin); + int xmax = min_ii(x + filtersize_ + 1, input_rect.xmax); int ymin = max_ii(y, input_rect.ymin); int step = getStep(); @@ -92,17 +92,17 @@ void GaussianXBlurOperation::executePixel(float output[4], int x, int y, void *d #ifdef BLI_HAVE_SSE2 __m128 accum_r = _mm_load_ps(color_accum); - for (int nx = xmin, index = (xmin - x) + m_filtersize; nx < xmax; nx += step, index += step) { + for (int nx = xmin, index = (xmin - x) + filtersize_; nx < xmax; nx += step, index += step) { __m128 reg_a = _mm_load_ps(&buffer[bufferindex]); - reg_a = _mm_mul_ps(reg_a, m_gausstab_sse[index]); + reg_a = _mm_mul_ps(reg_a, gausstab_sse_[index]); accum_r = _mm_add_ps(accum_r, reg_a); - multiplier_accum += m_gausstab[index]; + multiplier_accum += gausstab_[index]; bufferindex += offsetadd; } _mm_store_ps(color_accum, accum_r); #else - for (int nx = xmin, index = (xmin - x) + m_filtersize; nx < xmax; nx += step, index += step) { - const float multiplier = m_gausstab[index]; + for (int nx = xmin, index = (xmin - x) + filtersize_; nx < xmax; nx += step, index += step) { + const float multiplier = gausstab_[index]; madd_v4_v4fl(color_accum, &buffer[bufferindex], multiplier); multiplier_accum += multiplier; bufferindex += offsetadd; @@ -120,16 +120,16 @@ void GaussianXBlurOperation::executeOpenCL(OpenCLDevice *device, { cl_kernel gaussianXBlurOperationKernel = device->COM_clCreateKernel( "gaussianXBlurOperationKernel", nullptr); - cl_int filter_size = m_filtersize; + cl_int filter_size = filtersize_; cl_mem gausstab = clCreateBuffer(device->getContext(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, - sizeof(float) * (m_filtersize * 2 + 1), - m_gausstab, + sizeof(float) * (filtersize_ * 2 + 1), + gausstab_, nullptr); device->COM_clAttachMemoryBufferToKernelParameter( - gaussianXBlurOperationKernel, 0, 1, clMemToCleanUp, inputMemoryBuffers, m_inputProgram); + gaussianXBlurOperationKernel, 0, 1, clMemToCleanUp, inputMemoryBuffers, inputProgram_); device->COM_clAttachOutputMemoryBufferToKernelParameter( gaussianXBlurOperationKernel, 2, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter( @@ -147,14 +147,14 @@ void GaussianXBlurOperation::deinitExecution() { GaussianBlurBaseOperation::deinitExecution(); - if (m_gausstab) { - MEM_freeN(m_gausstab); - m_gausstab = nullptr; + if (gausstab_) { + MEM_freeN(gausstab_); + gausstab_ = nullptr; } #ifdef BLI_HAVE_SSE2 - if (m_gausstab_sse) { - MEM_freeN(m_gausstab_sse); - m_gausstab_sse = nullptr; + if (gausstab_sse_) { + MEM_freeN(gausstab_sse_); + gausstab_sse_ = nullptr; } #endif @@ -167,7 +167,7 @@ bool GaussianXBlurOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - if (!m_sizeavailable) { + if (!sizeavailable_) { rcti sizeInput; sizeInput.xmin = 0; sizeInput.ymin = 0; @@ -179,9 +179,9 @@ bool GaussianXBlurOperation::determineDependingAreaOfInterest(rcti *input, } } { - if (m_sizeavailable && m_gausstab != nullptr) { - newInput.xmax = input->xmax + m_filtersize + 1; - newInput.xmin = input->xmin - m_filtersize - 1; + if (sizeavailable_ && gausstab_ != nullptr) { + newInput.xmax = input->xmax + filtersize_ + 1; + newInput.xmin = input->xmin - filtersize_ - 1; newInput.ymax = input->ymax; newInput.ymin = input->ymin; } diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.h b/source/blender/compositor/operations/COM_GaussianXBlurOperation.h index e09e57bad67..1bb77031056 100644 --- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.h @@ -59,7 +59,7 @@ class GaussianXBlurOperation : public GaussianBlurBaseOperation { void checkOpenCL() { - flags.open_cl = (m_data.sizex >= 128); + flags.open_cl = (data_.sizex >= 128); } }; diff --git a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cc index 8a95721992c..50edc0bea29 100644 --- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cc @@ -28,7 +28,7 @@ GaussianYBlurOperation::GaussianYBlurOperation() : GaussianBlurBaseOperation(eDi void *GaussianYBlurOperation::initializeTileData(rcti * /*rect*/) { lockMutex(); - if (!m_sizeavailable) { + if (!sizeavailable_) { updateGauss(); } void *buffer = getInputOperation(0)->initializeTileData(nullptr); @@ -42,28 +42,28 @@ void GaussianYBlurOperation::initExecution() initMutex(); - if (m_sizeavailable && execution_model_ == eExecutionModel::Tiled) { - float rad = max_ff(m_size * m_data.sizey, 0.0f); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + if (sizeavailable_ && execution_model_ == eExecutionModel::Tiled) { + float rad = max_ff(size_ * data_.sizey, 0.0f); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); + gausstab_ = BlurBaseOperation::make_gausstab(rad, filtersize_); #ifdef BLI_HAVE_SSE2 - m_gausstab_sse = BlurBaseOperation::convert_gausstab_sse(m_gausstab, m_filtersize); + gausstab_sse_ = BlurBaseOperation::convert_gausstab_sse(gausstab_, filtersize_); #endif } } void GaussianYBlurOperation::updateGauss() { - if (m_gausstab == nullptr) { + if (gausstab_ == nullptr) { updateSize(); - float rad = max_ff(m_size * m_data.sizey, 0.0f); + float rad = max_ff(size_ * data_.sizey, 0.0f); rad = min_ff(rad, MAX_GAUSSTAB_RADIUS); - m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); + filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); - m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); + gausstab_ = BlurBaseOperation::make_gausstab(rad, filtersize_); #ifdef BLI_HAVE_SSE2 - m_gausstab_sse = BlurBaseOperation::convert_gausstab_sse(m_gausstab, m_filtersize); + gausstab_sse_ = BlurBaseOperation::convert_gausstab_sse(gausstab_, filtersize_); #endif } } @@ -80,8 +80,8 @@ void GaussianYBlurOperation::executePixel(float output[4], int x, int y, void *d int bufferstarty = input_rect.ymin; int xmin = max_ii(x, input_rect.xmin); - int ymin = max_ii(y - m_filtersize, input_rect.ymin); - int ymax = min_ii(y + m_filtersize + 1, input_rect.ymax); + int ymin = max_ii(y - filtersize_, input_rect.ymin); + int ymax = min_ii(y + filtersize_ + 1, input_rect.ymax); int index; int step = getStep(); @@ -90,20 +90,20 @@ void GaussianYBlurOperation::executePixel(float output[4], int x, int y, void *d #ifdef BLI_HAVE_SSE2 __m128 accum_r = _mm_load_ps(color_accum); for (int ny = ymin; ny < ymax; ny += step) { - index = (ny - y) + m_filtersize; + index = (ny - y) + filtersize_; int bufferindex = bufferIndexx + ((ny - bufferstarty) * 4 * bufferwidth); - const float multiplier = m_gausstab[index]; + const float multiplier = gausstab_[index]; __m128 reg_a = _mm_load_ps(&buffer[bufferindex]); - reg_a = _mm_mul_ps(reg_a, m_gausstab_sse[index]); + reg_a = _mm_mul_ps(reg_a, gausstab_sse_[index]); accum_r = _mm_add_ps(accum_r, reg_a); multiplier_accum += multiplier; } _mm_store_ps(color_accum, accum_r); #else for (int ny = ymin; ny < ymax; ny += step) { - index = (ny - y) + m_filtersize; + index = (ny - y) + filtersize_; int bufferindex = bufferIndexx + ((ny - bufferstarty) * 4 * bufferwidth); - const float multiplier = m_gausstab[index]; + const float multiplier = gausstab_[index]; madd_v4_v4fl(color_accum, &buffer[bufferindex], multiplier); multiplier_accum += multiplier; } @@ -120,16 +120,16 @@ void GaussianYBlurOperation::executeOpenCL(OpenCLDevice *device, { cl_kernel gaussianYBlurOperationKernel = device->COM_clCreateKernel( "gaussianYBlurOperationKernel", nullptr); - cl_int filter_size = m_filtersize; + cl_int filter_size = filtersize_; cl_mem gausstab = clCreateBuffer(device->getContext(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, - sizeof(float) * (m_filtersize * 2 + 1), - m_gausstab, + sizeof(float) * (filtersize_ * 2 + 1), + gausstab_, nullptr); device->COM_clAttachMemoryBufferToKernelParameter( - gaussianYBlurOperationKernel, 0, 1, clMemToCleanUp, inputMemoryBuffers, m_inputProgram); + gaussianYBlurOperationKernel, 0, 1, clMemToCleanUp, inputMemoryBuffers, inputProgram_); device->COM_clAttachOutputMemoryBufferToKernelParameter( gaussianYBlurOperationKernel, 2, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter( @@ -147,14 +147,14 @@ void GaussianYBlurOperation::deinitExecution() { GaussianBlurBaseOperation::deinitExecution(); - if (m_gausstab) { - MEM_freeN(m_gausstab); - m_gausstab = nullptr; + if (gausstab_) { + MEM_freeN(gausstab_); + gausstab_ = nullptr; } #ifdef BLI_HAVE_SSE2 - if (m_gausstab_sse) { - MEM_freeN(m_gausstab_sse); - m_gausstab_sse = nullptr; + if (gausstab_sse_) { + MEM_freeN(gausstab_sse_); + gausstab_sse_ = nullptr; } #endif @@ -167,7 +167,7 @@ bool GaussianYBlurOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - if (!m_sizeavailable) { + if (!sizeavailable_) { rcti sizeInput; sizeInput.xmin = 0; sizeInput.ymin = 0; @@ -179,11 +179,11 @@ bool GaussianYBlurOperation::determineDependingAreaOfInterest(rcti *input, } } { - if (m_sizeavailable && m_gausstab != nullptr) { + if (sizeavailable_ && gausstab_ != nullptr) { newInput.xmax = input->xmax; newInput.xmin = input->xmin; - newInput.ymax = input->ymax + m_filtersize + 1; - newInput.ymin = input->ymin - m_filtersize - 1; + newInput.ymax = input->ymax + filtersize_ + 1; + newInput.ymin = input->ymin - filtersize_ - 1; } else { newInput.xmax = this->getWidth(); diff --git a/source/blender/compositor/operations/COM_GaussianYBlurOperation.h b/source/blender/compositor/operations/COM_GaussianYBlurOperation.h index bb33f8b74cb..92c2d71f487 100644 --- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.h @@ -59,7 +59,7 @@ class GaussianYBlurOperation : public GaussianBlurBaseOperation { void checkOpenCL() { - flags.open_cl = (m_data.sizex >= 128); + flags.open_cl = (data_.sizex >= 128); } }; diff --git a/source/blender/compositor/operations/COM_GlareBaseOperation.cc b/source/blender/compositor/operations/COM_GlareBaseOperation.cc index 6e05705163f..0987f0efb31 100644 --- a/source/blender/compositor/operations/COM_GlareBaseOperation.cc +++ b/source/blender/compositor/operations/COM_GlareBaseOperation.cc @@ -24,25 +24,25 @@ GlareBaseOperation::GlareBaseOperation() { this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_settings = nullptr; + settings_ = nullptr; flags.is_fullframe_operation = true; is_output_rendered_ = false; } void GlareBaseOperation::initExecution() { SingleThreadedOperation::initExecution(); - m_inputProgram = getInputSocketReader(0); + inputProgram_ = getInputSocketReader(0); } void GlareBaseOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; SingleThreadedOperation::deinitExecution(); } MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2) { - MemoryBuffer *tile = (MemoryBuffer *)m_inputProgram->initializeTileData(rect2); + MemoryBuffer *tile = (MemoryBuffer *)inputProgram_->initializeTileData(rect2); rcti rect; rect.xmin = 0; rect.ymin = 0; @@ -50,7 +50,7 @@ MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2) rect.ymax = getHeight(); MemoryBuffer *result = new MemoryBuffer(DataType::Color, rect); float *data = result->getBuffer(); - this->generateGlare(data, tile, m_settings); + this->generateGlare(data, tile, settings_); return result; } @@ -93,7 +93,7 @@ void GlareBaseOperation::update_memory_buffer(MemoryBuffer *output, input = input->inflate(); } - this->generateGlare(output->getBuffer(), input, m_settings); + this->generateGlare(output->getBuffer(), input, settings_); is_output_rendered_ = true; if (is_input_inflated) { diff --git a/source/blender/compositor/operations/COM_GlareBaseOperation.h b/source/blender/compositor/operations/COM_GlareBaseOperation.h index 1d0c080ab8d..a50042f1ff4 100644 --- a/source/blender/compositor/operations/COM_GlareBaseOperation.h +++ b/source/blender/compositor/operations/COM_GlareBaseOperation.h @@ -42,12 +42,12 @@ class GlareBaseOperation : public SingleThreadedOperation { /** * \brief Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; /** * \brief settings of the glare node. */ - NodeGlare *m_settings; + NodeGlare *settings_; bool is_output_rendered_; @@ -64,7 +64,7 @@ class GlareBaseOperation : public SingleThreadedOperation { void setGlareSettings(NodeGlare *settings) { - m_settings = settings; + settings_ = settings; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, diff --git a/source/blender/compositor/operations/COM_GlareThresholdOperation.cc b/source/blender/compositor/operations/COM_GlareThresholdOperation.cc index 22e5e987aad..7135155cb68 100644 --- a/source/blender/compositor/operations/COM_GlareThresholdOperation.cc +++ b/source/blender/compositor/operations/COM_GlareThresholdOperation.cc @@ -26,21 +26,21 @@ GlareThresholdOperation::GlareThresholdOperation() { this->addInputSocket(DataType::Color, ResizeMode::FitAny); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void GlareThresholdOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { NodeOperation::determine_canvas(preferred_area, r_area); - const int width = BLI_rcti_size_x(&r_area) / (1 << m_settings->quality); - const int height = BLI_rcti_size_y(&r_area) / (1 << m_settings->quality); + const int width = BLI_rcti_size_x(&r_area) / (1 << settings_->quality); + const int height = BLI_rcti_size_y(&r_area) / (1 << settings_->quality); r_area.xmax = r_area.xmin + width; r_area.ymax = r_area.ymin + height; } void GlareThresholdOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void GlareThresholdOperation::executePixelSampled(float output[4], @@ -48,9 +48,9 @@ void GlareThresholdOperation::executePixelSampled(float output[4], float y, PixelSampler sampler) { - const float threshold = m_settings->threshold; + const float threshold = settings_->threshold; - m_inputProgram->readSampled(output, x, y, sampler); + inputProgram_->readSampled(output, x, y, sampler); if (IMB_colormanagement_get_luminance(output) >= threshold) { output[0] -= threshold; output[1] -= threshold; @@ -67,14 +67,14 @@ void GlareThresholdOperation::executePixelSampled(float output[4], void GlareThresholdOperation::deinitExecution() { - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void GlareThresholdOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - const float threshold = m_settings->threshold; + const float threshold = settings_->threshold; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const float *color = it.in(0); if (IMB_colormanagement_get_luminance(color) >= threshold) { diff --git a/source/blender/compositor/operations/COM_GlareThresholdOperation.h b/source/blender/compositor/operations/COM_GlareThresholdOperation.h index 1917f016f72..f37020b61a8 100644 --- a/source/blender/compositor/operations/COM_GlareThresholdOperation.h +++ b/source/blender/compositor/operations/COM_GlareThresholdOperation.h @@ -28,12 +28,12 @@ class GlareThresholdOperation : public MultiThreadedOperation { /** * \brief Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; /** * \brief settings of the glare node. */ - NodeGlare *m_settings; + NodeGlare *settings_; public: GlareThresholdOperation(); @@ -55,7 +55,7 @@ class GlareThresholdOperation : public MultiThreadedOperation { void setGlareSettings(NodeGlare *settings) { - m_settings = settings; + settings_ = settings; } void determine_canvas(const rcti &preferred_area, rcti &r_area) override; diff --git a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cc b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cc index 54f07f6f4a6..e2f4552c69c 100644 --- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cc +++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cc @@ -29,12 +29,12 @@ HueSaturationValueCorrectOperation::HueSaturationValueCorrectOperation() this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void HueSaturationValueCorrectOperation::initExecution() { CurveBaseOperation::initExecution(); - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void HueSaturationValueCorrectOperation::executePixelSampled(float output[4], @@ -44,18 +44,18 @@ void HueSaturationValueCorrectOperation::executePixelSampled(float output[4], { float hsv[4], f; - m_inputProgram->readSampled(hsv, x, y, sampler); + inputProgram_->readSampled(hsv, x, y, sampler); /* adjust hue, scaling returned default 0.5 up to 1 */ - f = BKE_curvemapping_evaluateF(m_curveMapping, 0, hsv[0]); + f = BKE_curvemapping_evaluateF(curveMapping_, 0, hsv[0]); hsv[0] += f - 0.5f; /* adjust saturation, scaling returned default 0.5 up to 1 */ - f = BKE_curvemapping_evaluateF(m_curveMapping, 1, hsv[0]); + f = BKE_curvemapping_evaluateF(curveMapping_, 1, hsv[0]); hsv[1] *= (f * 2.0f); /* adjust value, scaling returned default 0.5 up to 1 */ - f = BKE_curvemapping_evaluateF(m_curveMapping, 2, hsv[0]); + f = BKE_curvemapping_evaluateF(curveMapping_, 2, hsv[0]); hsv[2] *= (f * 2.0f); hsv[0] = hsv[0] - floorf(hsv[0]); /* mod 1.0 */ @@ -70,7 +70,7 @@ void HueSaturationValueCorrectOperation::executePixelSampled(float output[4], void HueSaturationValueCorrectOperation::deinitExecution() { CurveBaseOperation::deinitExecution(); - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void HueSaturationValueCorrectOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -82,15 +82,15 @@ void HueSaturationValueCorrectOperation::update_memory_buffer_partial(MemoryBuff copy_v4_v4(hsv, it.in(0)); /* Adjust hue, scaling returned default 0.5 up to 1. */ - float f = BKE_curvemapping_evaluateF(m_curveMapping, 0, hsv[0]); + float f = BKE_curvemapping_evaluateF(curveMapping_, 0, hsv[0]); hsv[0] += f - 0.5f; /* Adjust saturation, scaling returned default 0.5 up to 1. */ - f = BKE_curvemapping_evaluateF(m_curveMapping, 1, hsv[0]); + f = BKE_curvemapping_evaluateF(curveMapping_, 1, hsv[0]); hsv[1] *= (f * 2.0f); /* Adjust value, scaling returned default 0.5 up to 1. */ - f = BKE_curvemapping_evaluateF(m_curveMapping, 2, hsv[0]); + f = BKE_curvemapping_evaluateF(curveMapping_, 2, hsv[0]); hsv[2] *= (f * 2.0f); hsv[0] = hsv[0] - floorf(hsv[0]); /* Mod 1.0. */ diff --git a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h index 6c1b66aba1f..26792a54d26 100644 --- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h +++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h @@ -28,7 +28,7 @@ class HueSaturationValueCorrectOperation : public CurveBaseOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; public: HueSaturationValueCorrectOperation(); diff --git a/source/blender/compositor/operations/COM_IDMaskOperation.cc b/source/blender/compositor/operations/COM_IDMaskOperation.cc index 56bd88b0ddd..677d0a8ccff 100644 --- a/source/blender/compositor/operations/COM_IDMaskOperation.cc +++ b/source/blender/compositor/operations/COM_IDMaskOperation.cc @@ -40,7 +40,7 @@ void IDMaskOperation::executePixel(float output[4], int x, int y, void *data) const int buffer_width = input_buffer->getWidth(); float *buffer = input_buffer->getBuffer(); int buffer_index = (y * buffer_width + x); - output[0] = (roundf(buffer[buffer_index]) == m_objectIndex) ? 1.0f : 0.0f; + output[0] = (roundf(buffer[buffer_index]) == objectIndex_) ? 1.0f : 0.0f; } void IDMaskOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -54,7 +54,7 @@ void IDMaskOperation::update_memory_buffer_partial(MemoryBuffer *output, const float *in = input->get_elem(area.xmin, y); const float *row_end = out + width * output->elem_stride; while (out < row_end) { - out[0] = (roundf(in[0]) == m_objectIndex) ? 1.0f : 0.0f; + out[0] = (roundf(in[0]) == objectIndex_) ? 1.0f : 0.0f; in += input->elem_stride; out += output->elem_stride; } diff --git a/source/blender/compositor/operations/COM_IDMaskOperation.h b/source/blender/compositor/operations/COM_IDMaskOperation.h index ed6d065216f..333f9eeee98 100644 --- a/source/blender/compositor/operations/COM_IDMaskOperation.h +++ b/source/blender/compositor/operations/COM_IDMaskOperation.h @@ -24,7 +24,7 @@ namespace blender::compositor { class IDMaskOperation : public MultiThreadedOperation { private: - float m_objectIndex; + float objectIndex_; public: IDMaskOperation(); @@ -34,7 +34,7 @@ class IDMaskOperation : public MultiThreadedOperation { void setObjectIndex(float objectIndex) { - m_objectIndex = objectIndex; + objectIndex_ = objectIndex; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ImageOperation.cc b/source/blender/compositor/operations/COM_ImageOperation.cc index 6c4f860df1a..84c5b9654ce 100644 --- a/source/blender/compositor/operations/COM_ImageOperation.cc +++ b/source/blender/compositor/operations/COM_ImageOperation.cc @@ -28,19 +28,19 @@ namespace blender::compositor { BaseImageOperation::BaseImageOperation() { - m_image = nullptr; - m_buffer = nullptr; - m_imageFloatBuffer = nullptr; - m_imageByteBuffer = nullptr; - m_imageUser = nullptr; - m_imagewidth = 0; - m_imageheight = 0; - m_framenumber = 0; - m_depthBuffer = nullptr; + image_ = nullptr; + buffer_ = nullptr; + imageFloatBuffer_ = nullptr; + imageByteBuffer_ = nullptr; + imageUser_ = nullptr; + imagewidth_ = 0; + imageheight_ = 0; + framenumber_ = 0; + depthBuffer_ = nullptr; depth_buffer_ = nullptr; - m_numberOfChannels = 0; - m_rd = nullptr; - m_viewName = nullptr; + numberOfChannels_ = 0; + rd_ = nullptr; + viewName_ = nullptr; } ImageOperation::ImageOperation() : BaseImageOperation() { @@ -58,20 +58,20 @@ ImageDepthOperation::ImageDepthOperation() : BaseImageOperation() ImBuf *BaseImageOperation::getImBuf() { ImBuf *ibuf; - ImageUser iuser = *m_imageUser; + ImageUser iuser = *imageUser_; - if (m_image == nullptr) { + if (image_ == nullptr) { return nullptr; } /* local changes to the original ImageUser */ - if (BKE_image_is_multilayer(m_image) == false) { - iuser.multi_index = BKE_scene_multiview_view_id_get(m_rd, m_viewName); + if (BKE_image_is_multilayer(image_) == false) { + iuser.multi_index = BKE_scene_multiview_view_id_get(rd_, viewName_); } - ibuf = BKE_image_acquire_ibuf(m_image, &iuser, nullptr); + ibuf = BKE_image_acquire_ibuf(image_, &iuser, nullptr); if (ibuf == nullptr || (ibuf->rect == nullptr && ibuf->rect_float == nullptr)) { - BKE_image_release_ibuf(m_image, ibuf, nullptr); + BKE_image_release_ibuf(image_, ibuf, nullptr); return nullptr; } return ibuf; @@ -80,25 +80,25 @@ ImBuf *BaseImageOperation::getImBuf() void BaseImageOperation::initExecution() { ImBuf *stackbuf = getImBuf(); - m_buffer = stackbuf; + buffer_ = stackbuf; if (stackbuf) { - m_imageFloatBuffer = stackbuf->rect_float; - m_imageByteBuffer = stackbuf->rect; - m_depthBuffer = stackbuf->zbuf_float; + imageFloatBuffer_ = stackbuf->rect_float; + imageByteBuffer_ = stackbuf->rect; + depthBuffer_ = stackbuf->zbuf_float; if (stackbuf->zbuf_float) { depth_buffer_ = new MemoryBuffer(stackbuf->zbuf_float, 1, stackbuf->x, stackbuf->y); } - m_imagewidth = stackbuf->x; - m_imageheight = stackbuf->y; - m_numberOfChannels = stackbuf->channels; + imagewidth_ = stackbuf->x; + imageheight_ = stackbuf->y; + numberOfChannels_ = stackbuf->channels; } } void BaseImageOperation::deinitExecution() { - m_imageFloatBuffer = nullptr; - m_imageByteBuffer = nullptr; - BKE_image_release_ibuf(m_image, m_buffer, nullptr); + imageFloatBuffer_ = nullptr; + imageByteBuffer_ = nullptr; + BKE_image_release_ibuf(image_, buffer_, nullptr); if (depth_buffer_) { delete depth_buffer_; depth_buffer_ = nullptr; @@ -115,7 +115,7 @@ void BaseImageOperation::determine_canvas(const rcti &UNUSED(preferred_area), rc BLI_rcti_init(&r_area, 0, stackbuf->x, 0, stackbuf->y); } - BKE_image_release_ibuf(m_image, stackbuf, nullptr); + BKE_image_release_ibuf(image_, stackbuf, nullptr); } static void sampleImageAtLocation( @@ -157,14 +157,14 @@ static void sampleImageAtLocation( void ImageOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) { int ix = x, iy = y; - if (m_imageFloatBuffer == nullptr && m_imageByteBuffer == nullptr) { + if (imageFloatBuffer_ == nullptr && imageByteBuffer_ == nullptr) { zero_v4(output); } - else if (ix < 0 || iy < 0 || ix >= m_buffer->x || iy >= m_buffer->y) { + else if (ix < 0 || iy < 0 || ix >= buffer_->x || iy >= buffer_->y) { zero_v4(output); } else { - sampleImageAtLocation(m_buffer, x, y, sampler, true, output); + sampleImageAtLocation(buffer_, x, y, sampler, true, output); } } @@ -172,7 +172,7 @@ void ImageOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - output->copy_from(m_buffer, area, true); + output->copy_from(buffer_, area, true); } void ImageAlphaOperation::executePixelSampled(float output[4], @@ -182,12 +182,12 @@ void ImageAlphaOperation::executePixelSampled(float output[4], { float tempcolor[4]; - if (m_imageFloatBuffer == nullptr && m_imageByteBuffer == nullptr) { + if (imageFloatBuffer_ == nullptr && imageByteBuffer_ == nullptr) { output[0] = 0.0f; } else { tempcolor[3] = 1.0f; - sampleImageAtLocation(m_buffer, x, y, sampler, false, tempcolor); + sampleImageAtLocation(buffer_, x, y, sampler, false, tempcolor); output[0] = tempcolor[3]; } } @@ -196,7 +196,7 @@ void ImageAlphaOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - output->copy_from(m_buffer, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0); + output->copy_from(buffer_, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0); } void ImageDepthOperation::executePixelSampled(float output[4], @@ -204,7 +204,7 @@ void ImageDepthOperation::executePixelSampled(float output[4], float y, PixelSampler /*sampler*/) { - if (m_depthBuffer == nullptr) { + if (depthBuffer_ == nullptr) { output[0] = 0.0f; } else { @@ -213,7 +213,7 @@ void ImageDepthOperation::executePixelSampled(float output[4], } else { int offset = y * getWidth() + x; - output[0] = m_depthBuffer[offset]; + output[0] = depthBuffer_[offset]; } } } diff --git a/source/blender/compositor/operations/COM_ImageOperation.h b/source/blender/compositor/operations/COM_ImageOperation.h index b82b89290ad..40ef9f38f79 100644 --- a/source/blender/compositor/operations/COM_ImageOperation.h +++ b/source/blender/compositor/operations/COM_ImageOperation.h @@ -34,21 +34,21 @@ namespace blender::compositor { */ class BaseImageOperation : public MultiThreadedOperation { protected: - ImBuf *m_buffer; - Image *m_image; - ImageUser *m_imageUser; + ImBuf *buffer_; + Image *image_; + ImageUser *imageUser_; /* TODO: Remove raw buffers when removing Tiled implementation. */ - float *m_imageFloatBuffer; - unsigned int *m_imageByteBuffer; - float *m_depthBuffer; + float *imageFloatBuffer_; + unsigned int *imageByteBuffer_; + float *depthBuffer_; MemoryBuffer *depth_buffer_; - int m_imageheight; - int m_imagewidth; - int m_framenumber; - int m_numberOfChannels; - const RenderData *m_rd; - const char *m_viewName; + int imageheight_; + int imagewidth_; + int framenumber_; + int numberOfChannels_; + const RenderData *rd_; + const char *viewName_; BaseImageOperation(); /** @@ -63,23 +63,23 @@ class BaseImageOperation : public MultiThreadedOperation { void deinitExecution() override; void setImage(Image *image) { - m_image = image; + image_ = image; } void setImageUser(ImageUser *imageuser) { - m_imageUser = imageuser; + imageUser_ = imageuser; } void setRenderData(const RenderData *rd) { - m_rd = rd; + rd_ = rd; } void setViewName(const char *viewName) { - m_viewName = viewName; + viewName_ = viewName; } void setFramenumber(int framenumber) { - m_framenumber = framenumber; + framenumber_ = framenumber; } }; class ImageOperation : public BaseImageOperation { diff --git a/source/blender/compositor/operations/COM_InpaintOperation.cc b/source/blender/compositor/operations/COM_InpaintOperation.cc index 1b7b42706bc..45b163c7e8b 100644 --- a/source/blender/compositor/operations/COM_InpaintOperation.cc +++ b/source/blender/compositor/operations/COM_InpaintOperation.cc @@ -31,21 +31,21 @@ InpaintSimpleOperation::InpaintSimpleOperation() this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_inputImageProgram = nullptr; - m_pixelorder = nullptr; - m_manhattan_distance = nullptr; - m_cached_buffer = nullptr; - m_cached_buffer_ready = false; + inputImageProgram_ = nullptr; + pixelorder_ = nullptr; + manhattan_distance_ = nullptr; + cached_buffer_ = nullptr; + cached_buffer_ready_ = false; flags.is_fullframe_operation = true; } void InpaintSimpleOperation::initExecution() { - m_inputImageProgram = this->getInputSocketReader(0); + inputImageProgram_ = this->getInputSocketReader(0); - m_pixelorder = nullptr; - m_manhattan_distance = nullptr; - m_cached_buffer = nullptr; - m_cached_buffer_ready = false; + pixelorder_ = nullptr; + manhattan_distance_ = nullptr; + cached_buffer_ = nullptr; + cached_buffer_ready_ = false; this->initMutex(); } @@ -76,8 +76,8 @@ float *InpaintSimpleOperation::get_pixel(int x, int y) ASSERT_XY_RANGE(x, y); - return &m_cached_buffer[y * width * COM_DATA_TYPE_COLOR_CHANNELS + - x * COM_DATA_TYPE_COLOR_CHANNELS]; + return &cached_buffer_[y * width * COM_DATA_TYPE_COLOR_CHANNELS + + x * COM_DATA_TYPE_COLOR_CHANNELS]; } int InpaintSimpleOperation::mdist(int x, int y) @@ -86,18 +86,18 @@ int InpaintSimpleOperation::mdist(int x, int y) ASSERT_XY_RANGE(x, y); - return m_manhattan_distance[y * width + x]; + return manhattan_distance_[y * width + x]; } bool InpaintSimpleOperation::next_pixel(int &x, int &y, int &curr, int iters) { int width = this->getWidth(); - if (curr >= m_area_size) { + if (curr >= area_size_) { return false; } - int r = m_pixelorder[curr++]; + int r = pixelorder_[curr++]; x = r % width; y = r / width; @@ -113,7 +113,7 @@ void InpaintSimpleOperation::calc_manhattan_distance() { int width = this->getWidth(); int height = this->getHeight(); - short *m = m_manhattan_distance = (short *)MEM_mallocN(sizeof(short) * width * height, __func__); + short *m = manhattan_distance_ = (short *)MEM_mallocN(sizeof(short) * width * height, __func__); int *offsets; offsets = (int *)MEM_callocN(sizeof(int) * (width + height + 1), @@ -159,12 +159,12 @@ void InpaintSimpleOperation::calc_manhattan_distance() offsets[i] += offsets[i - 1]; } - m_area_size = offsets[width + height]; - m_pixelorder = (int *)MEM_mallocN(sizeof(int) * m_area_size, __func__); + area_size_ = offsets[width + height]; + pixelorder_ = (int *)MEM_mallocN(sizeof(int) * area_size_, __func__); for (int i = 0; i < width * height; i++) { if (m[i] > 0) { - m_pixelorder[offsets[m[i] - 1]++] = i; + pixelorder_[offsets[m[i] - 1]++] = i; } } @@ -215,27 +215,27 @@ void InpaintSimpleOperation::pix_step(int x, int y) void *InpaintSimpleOperation::initializeTileData(rcti *rect) { - if (m_cached_buffer_ready) { - return m_cached_buffer; + if (cached_buffer_ready_) { + return cached_buffer_; } lockMutex(); - if (!m_cached_buffer_ready) { - MemoryBuffer *buf = (MemoryBuffer *)m_inputImageProgram->initializeTileData(rect); - m_cached_buffer = (float *)MEM_dupallocN(buf->getBuffer()); + if (!cached_buffer_ready_) { + MemoryBuffer *buf = (MemoryBuffer *)inputImageProgram_->initializeTileData(rect); + cached_buffer_ = (float *)MEM_dupallocN(buf->getBuffer()); this->calc_manhattan_distance(); int curr = 0; int x, y; - while (this->next_pixel(x, y, curr, m_iterations)) { + while (this->next_pixel(x, y, curr, iterations_)) { this->pix_step(x, y); } - m_cached_buffer_ready = true; + cached_buffer_ready_ = true; } unlockMutex(); - return m_cached_buffer; + return cached_buffer_; } void InpaintSimpleOperation::executePixel(float output[4], int x, int y, void * /*data*/) @@ -246,30 +246,30 @@ void InpaintSimpleOperation::executePixel(float output[4], int x, int y, void * void InpaintSimpleOperation::deinitExecution() { - m_inputImageProgram = nullptr; + inputImageProgram_ = nullptr; this->deinitMutex(); - if (m_cached_buffer) { - MEM_freeN(m_cached_buffer); - m_cached_buffer = nullptr; + if (cached_buffer_) { + MEM_freeN(cached_buffer_); + cached_buffer_ = nullptr; } - if (m_pixelorder) { - MEM_freeN(m_pixelorder); - m_pixelorder = nullptr; + if (pixelorder_) { + MEM_freeN(pixelorder_); + pixelorder_ = nullptr; } - if (m_manhattan_distance) { - MEM_freeN(m_manhattan_distance); - m_manhattan_distance = nullptr; + if (manhattan_distance_) { + MEM_freeN(manhattan_distance_); + manhattan_distance_ = nullptr; } - m_cached_buffer_ready = false; + cached_buffer_ready_ = false; } bool InpaintSimpleOperation::determineDependingAreaOfInterest(rcti * /*input*/, ReadBufferOperation *readOperation, rcti *output) { - if (m_cached_buffer_ready) { + if (cached_buffer_ready_) { return false; } @@ -298,28 +298,28 @@ void InpaintSimpleOperation::update_memory_buffer(MemoryBuffer *output, { /* TODO(manzanilla): once tiled implementation is removed, run multi-threaded where possible. */ MemoryBuffer *input = inputs[0]; - if (!m_cached_buffer_ready) { + if (!cached_buffer_ready_) { if (input->is_a_single_elem()) { MemoryBuffer *tmp = input->inflate(); - m_cached_buffer = tmp->release_ownership_buffer(); + cached_buffer_ = tmp->release_ownership_buffer(); delete tmp; } else { - m_cached_buffer = (float *)MEM_dupallocN(input->getBuffer()); + cached_buffer_ = (float *)MEM_dupallocN(input->getBuffer()); } this->calc_manhattan_distance(); int curr = 0; int x, y; - while (this->next_pixel(x, y, curr, m_iterations)) { + while (this->next_pixel(x, y, curr, iterations_)) { this->pix_step(x, y); } - m_cached_buffer_ready = true; + cached_buffer_ready_ = true; } const int num_channels = COM_data_type_num_channels(getOutputSocket()->getDataType()); - MemoryBuffer buf(m_cached_buffer, num_channels, input->getWidth(), input->getHeight()); + MemoryBuffer buf(cached_buffer_, num_channels, input->getWidth(), input->getHeight()); output->copy_from(&buf, area); } diff --git a/source/blender/compositor/operations/COM_InpaintOperation.h b/source/blender/compositor/operations/COM_InpaintOperation.h index 87839dcb802..4187099f346 100644 --- a/source/blender/compositor/operations/COM_InpaintOperation.h +++ b/source/blender/compositor/operations/COM_InpaintOperation.h @@ -27,16 +27,16 @@ class InpaintSimpleOperation : public NodeOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputImageProgram; + SocketReader *inputImageProgram_; - int m_iterations; + int iterations_; - float *m_cached_buffer; - bool m_cached_buffer_ready; + float *cached_buffer_; + bool cached_buffer_ready_; - int *m_pixelorder; - int m_area_size; - short *m_manhattan_distance; + int *pixelorder_; + int area_size_; + short *manhattan_distance_; public: InpaintSimpleOperation(); @@ -59,7 +59,7 @@ class InpaintSimpleOperation : public NodeOperation { void setIterations(int iterations) { - m_iterations = iterations; + iterations_ = iterations; } bool determineDependingAreaOfInterest(rcti *input, diff --git a/source/blender/compositor/operations/COM_InvertOperation.cc b/source/blender/compositor/operations/COM_InvertOperation.cc index f9f08a1d377..ba36dd35e47 100644 --- a/source/blender/compositor/operations/COM_InvertOperation.cc +++ b/source/blender/compositor/operations/COM_InvertOperation.cc @@ -25,30 +25,30 @@ InvertOperation::InvertOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputValueProgram = nullptr; - m_inputColorProgram = nullptr; - m_color = true; - m_alpha = false; + inputValueProgram_ = nullptr; + inputColorProgram_ = nullptr; + color_ = true; + alpha_ = false; set_canvas_input_index(1); this->flags.can_be_constant = true; } void InvertOperation::initExecution() { - m_inputValueProgram = this->getInputSocketReader(0); - m_inputColorProgram = this->getInputSocketReader(1); + inputValueProgram_ = this->getInputSocketReader(0); + inputColorProgram_ = this->getInputSocketReader(1); } void InvertOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) { float inputValue[4]; float inputColor[4]; - m_inputValueProgram->readSampled(inputValue, x, y, sampler); - m_inputColorProgram->readSampled(inputColor, x, y, sampler); + inputValueProgram_->readSampled(inputValue, x, y, sampler); + inputColorProgram_->readSampled(inputColor, x, y, sampler); const float value = inputValue[0]; const float invertedValue = 1.0f - value; - if (m_color) { + if (color_) { output[0] = (1.0f - inputColor[0]) * value + inputColor[0] * invertedValue; output[1] = (1.0f - inputColor[1]) * value + inputColor[1] * invertedValue; output[2] = (1.0f - inputColor[2]) * value + inputColor[2] * invertedValue; @@ -57,7 +57,7 @@ void InvertOperation::executePixelSampled(float output[4], float x, float y, Pix copy_v3_v3(output, inputColor); } - if (m_alpha) { + if (alpha_) { output[3] = (1.0f - inputColor[3]) * value + inputColor[3] * invertedValue; } else { @@ -67,8 +67,8 @@ void InvertOperation::executePixelSampled(float output[4], float x, float y, Pix void InvertOperation::deinitExecution() { - m_inputValueProgram = nullptr; - m_inputColorProgram = nullptr; + inputValueProgram_ = nullptr; + inputColorProgram_ = nullptr; } void InvertOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -80,7 +80,7 @@ void InvertOperation::update_memory_buffer_partial(MemoryBuffer *output, const float inverted_value = 1.0f - value; const float *color = it.in(1); - if (m_color) { + if (color_) { it.out[0] = (1.0f - color[0]) * value + color[0] * inverted_value; it.out[1] = (1.0f - color[1]) * value + color[1] * inverted_value; it.out[2] = (1.0f - color[2]) * value + color[2] * inverted_value; @@ -89,7 +89,7 @@ void InvertOperation::update_memory_buffer_partial(MemoryBuffer *output, copy_v3_v3(it.out, color); } - if (m_alpha) { + if (alpha_) { it.out[3] = (1.0f - color[3]) * value + color[3] * inverted_value; } else { diff --git a/source/blender/compositor/operations/COM_InvertOperation.h b/source/blender/compositor/operations/COM_InvertOperation.h index cb77c51f2b7..7db0394ad7a 100644 --- a/source/blender/compositor/operations/COM_InvertOperation.h +++ b/source/blender/compositor/operations/COM_InvertOperation.h @@ -27,11 +27,11 @@ class InvertOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputValueProgram; - SocketReader *m_inputColorProgram; + SocketReader *inputValueProgram_; + SocketReader *inputColorProgram_; - bool m_alpha; - bool m_color; + bool alpha_; + bool color_; public: InvertOperation(); @@ -53,11 +53,11 @@ class InvertOperation : public MultiThreadedOperation { void setColor(bool color) { - m_color = color; + color_ = color; } void setAlpha(bool alpha) { - m_alpha = alpha; + alpha_ = alpha; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_KeyingBlurOperation.cc b/source/blender/compositor/operations/COM_KeyingBlurOperation.cc index b5c93ad2888..fcf304de174 100644 --- a/source/blender/compositor/operations/COM_KeyingBlurOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingBlurOperation.cc @@ -25,8 +25,8 @@ KeyingBlurOperation::KeyingBlurOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_size = 0; - m_axis = BLUR_AXIS_X; + size_ = 0; + axis_ = BLUR_AXIS_X; this->flags.complex = true; } @@ -46,8 +46,8 @@ void KeyingBlurOperation::executePixel(float output[4], int x, int y, void *data int count = 0; float average = 0.0f; - if (m_axis == 0) { - const int start = MAX2(0, x - m_size + 1), end = MIN2(bufferWidth, x + m_size); + if (axis_ == 0) { + const int start = MAX2(0, x - size_ + 1), end = MIN2(bufferWidth, x + size_); for (int cx = start; cx < end; cx++) { int bufferIndex = (y * bufferWidth + cx); average += buffer[bufferIndex]; @@ -55,7 +55,7 @@ void KeyingBlurOperation::executePixel(float output[4], int x, int y, void *data } } else { - const int start = MAX2(0, y - m_size + 1), end = MIN2(inputBuffer->getHeight(), y + m_size); + const int start = MAX2(0, y - size_ + 1), end = MIN2(inputBuffer->getHeight(), y + size_); for (int cy = start; cy < end; cy++) { int bufferIndex = (cy * bufferWidth + x); average += buffer[bufferIndex]; @@ -74,17 +74,17 @@ bool KeyingBlurOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - if (m_axis == BLUR_AXIS_X) { - newInput.xmin = input->xmin - m_size; + if (axis_ == BLUR_AXIS_X) { + newInput.xmin = input->xmin - size_; newInput.ymin = input->ymin; - newInput.xmax = input->xmax + m_size; + newInput.xmax = input->xmax + size_; newInput.ymax = input->ymax; } else { newInput.xmin = input->xmin; - newInput.ymin = input->ymin - m_size; + newInput.ymin = input->ymin - size_; newInput.xmax = input->xmax; - newInput.ymax = input->ymax + m_size; + newInput.ymax = input->ymax + size_; } return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); @@ -94,18 +94,18 @@ void KeyingBlurOperation::get_area_of_interest(const int UNUSED(input_idx), const rcti &output_area, rcti &r_input_area) { - switch (m_axis) { + switch (axis_) { case BLUR_AXIS_X: - r_input_area.xmin = output_area.xmin - m_size; + r_input_area.xmin = output_area.xmin - size_; r_input_area.ymin = output_area.ymin; - r_input_area.xmax = output_area.xmax + m_size; + r_input_area.xmax = output_area.xmax + size_; r_input_area.ymax = output_area.ymax; break; case BLUR_AXIS_Y: r_input_area.xmin = output_area.xmin; - r_input_area.ymin = output_area.ymin - m_size; + r_input_area.ymin = output_area.ymin - size_; r_input_area.xmax = output_area.xmax; - r_input_area.ymax = output_area.ymax + m_size; + r_input_area.ymax = output_area.ymax + size_; break; default: BLI_assert_msg(0, "Unknown axis"); @@ -123,7 +123,7 @@ void KeyingBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, int coord_max; int elem_stride; std::function<int()> get_current_coord; - switch (m_axis) { + switch (axis_) { case BLUR_AXIS_X: get_current_coord = [&] { return it.x; }; coord_max = this->getWidth(); @@ -138,8 +138,8 @@ void KeyingBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, for (; !it.is_end(); ++it) { const int coord = get_current_coord(); - const int start_coord = MAX2(0, coord - m_size + 1); - const int end_coord = MIN2(coord_max, coord + m_size); + const int start_coord = MAX2(0, coord - size_ + 1); + const int end_coord = MIN2(coord_max, coord + size_); const int count = end_coord - start_coord; float sum = 0.0f; diff --git a/source/blender/compositor/operations/COM_KeyingBlurOperation.h b/source/blender/compositor/operations/COM_KeyingBlurOperation.h index 9f312c86747..56fa0f84880 100644 --- a/source/blender/compositor/operations/COM_KeyingBlurOperation.h +++ b/source/blender/compositor/operations/COM_KeyingBlurOperation.h @@ -27,8 +27,8 @@ namespace blender::compositor { */ class KeyingBlurOperation : public MultiThreadedOperation { protected: - int m_size; - int m_axis; + int size_; + int axis_; public: enum BlurAxis { @@ -40,11 +40,11 @@ class KeyingBlurOperation : public MultiThreadedOperation { void setSize(int value) { - m_size = value; + size_ = value; } void setAxis(int value) { - m_axis = value; + axis_ = value; } void *initializeTileData(rcti *rect) override; diff --git a/source/blender/compositor/operations/COM_KeyingClipOperation.cc b/source/blender/compositor/operations/COM_KeyingClipOperation.cc index b5a3b28e54e..e6097dd71a6 100644 --- a/source/blender/compositor/operations/COM_KeyingClipOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingClipOperation.cc @@ -25,13 +25,13 @@ KeyingClipOperation::KeyingClipOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_kernelRadius = 3; - m_kernelTolerance = 0.1f; + kernelRadius_ = 3; + kernelTolerance_ = 0.1f; - m_clipBlack = 0.0f; - m_clipWhite = 1.0f; + clipBlack_ = 0.0f; + clipWhite_ = 1.0f; - m_isEdgeMatte = false; + isEdgeMatte_ = false; this->flags.complex = true; } @@ -45,8 +45,8 @@ void *KeyingClipOperation::initializeTileData(rcti *rect) void KeyingClipOperation::executePixel(float output[4], int x, int y, void *data) { - const int delta = m_kernelRadius; - const float tolerance = m_kernelTolerance; + const int delta = kernelRadius_; + const float tolerance = kernelTolerance_; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); @@ -86,7 +86,7 @@ void KeyingClipOperation::executePixel(float output[4], int x, int y, void *data } } - if (m_isEdgeMatte) { + if (isEdgeMatte_) { if (ok) { output[0] = 0.0f; } @@ -98,14 +98,14 @@ void KeyingClipOperation::executePixel(float output[4], int x, int y, void *data output[0] = value; if (ok) { - if (output[0] < m_clipBlack) { + if (output[0] < clipBlack_) { output[0] = 0.0f; } - else if (output[0] >= m_clipWhite) { + else if (output[0] >= clipWhite_) { output[0] = 1.0f; } else { - output[0] = (output[0] - m_clipBlack) / (m_clipWhite - m_clipBlack); + output[0] = (output[0] - clipBlack_) / (clipWhite_ - clipBlack_); } } } @@ -117,10 +117,10 @@ bool KeyingClipOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - newInput.xmin = input->xmin - m_kernelRadius; - newInput.ymin = input->ymin - m_kernelRadius; - newInput.xmax = input->xmax + m_kernelRadius; - newInput.ymax = input->ymax + m_kernelRadius; + newInput.xmin = input->xmin - kernelRadius_; + newInput.ymin = input->ymin - kernelRadius_; + newInput.xmax = input->xmax + kernelRadius_; + newInput.ymax = input->ymax + kernelRadius_; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -131,10 +131,10 @@ void KeyingClipOperation::get_area_of_interest(const int input_idx, { BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - r_input_area.xmin = output_area.xmin - m_kernelRadius; - r_input_area.xmax = output_area.xmax + m_kernelRadius; - r_input_area.ymin = output_area.ymin - m_kernelRadius; - r_input_area.ymax = output_area.ymax + m_kernelRadius; + r_input_area.xmin = output_area.xmin - kernelRadius_; + r_input_area.xmax = output_area.xmax + kernelRadius_; + r_input_area.ymin = output_area.ymin - kernelRadius_; + r_input_area.ymax = output_area.ymax + kernelRadius_; } void KeyingClipOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -144,8 +144,8 @@ void KeyingClipOperation::update_memory_buffer_partial(MemoryBuffer *output, const MemoryBuffer *input = inputs[0]; BuffersIterator<float> it = output->iterate_with(inputs, area); - const int delta = m_kernelRadius; - const float tolerance = m_kernelTolerance; + const int delta = kernelRadius_; + const float tolerance = kernelTolerance_; const int width = this->getWidth(); const int height = this->getHeight(); const int row_stride = input->row_stride; @@ -190,21 +190,21 @@ void KeyingClipOperation::update_memory_buffer_partial(MemoryBuffer *output, } } - if (m_isEdgeMatte) { + if (isEdgeMatte_) { *it.out = ok ? 0.0f : 1.0f; } else { if (!ok) { *it.out = value; } - else if (value < m_clipBlack) { + else if (value < clipBlack_) { *it.out = 0.0f; } - else if (value >= m_clipWhite) { + else if (value >= clipWhite_) { *it.out = 1.0f; } else { - *it.out = (value - m_clipBlack) / (m_clipWhite - m_clipBlack); + *it.out = (value - clipBlack_) / (clipWhite_ - clipBlack_); } } } diff --git a/source/blender/compositor/operations/COM_KeyingClipOperation.h b/source/blender/compositor/operations/COM_KeyingClipOperation.h index adbb792d7b8..422d79597ce 100644 --- a/source/blender/compositor/operations/COM_KeyingClipOperation.h +++ b/source/blender/compositor/operations/COM_KeyingClipOperation.h @@ -27,38 +27,38 @@ namespace blender::compositor { */ class KeyingClipOperation : public MultiThreadedOperation { protected: - float m_clipBlack; - float m_clipWhite; + float clipBlack_; + float clipWhite_; - int m_kernelRadius; - float m_kernelTolerance; + int kernelRadius_; + float kernelTolerance_; - bool m_isEdgeMatte; + bool isEdgeMatte_; public: KeyingClipOperation(); void setClipBlack(float value) { - m_clipBlack = value; + clipBlack_ = value; } void setClipWhite(float value) { - m_clipWhite = value; + clipWhite_ = value; } void setKernelRadius(int value) { - m_kernelRadius = value; + kernelRadius_ = value; } void setKernelTolerance(float value) { - m_kernelTolerance = value; + kernelTolerance_ = value; } void setIsEdgeMatte(bool value) { - m_isEdgeMatte = value; + isEdgeMatte_ = value; } void *initializeTileData(rcti *rect) override; diff --git a/source/blender/compositor/operations/COM_KeyingDespillOperation.cc b/source/blender/compositor/operations/COM_KeyingDespillOperation.cc index e107fee6bb4..8b090d5dc38 100644 --- a/source/blender/compositor/operations/COM_KeyingDespillOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingDespillOperation.cc @@ -26,24 +26,24 @@ KeyingDespillOperation::KeyingDespillOperation() this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_despillFactor = 0.5f; - m_colorBalance = 0.5f; + despillFactor_ = 0.5f; + colorBalance_ = 0.5f; - m_pixelReader = nullptr; - m_screenReader = nullptr; + pixelReader_ = nullptr; + screenReader_ = nullptr; flags.can_be_constant = true; } void KeyingDespillOperation::initExecution() { - m_pixelReader = this->getInputSocketReader(0); - m_screenReader = this->getInputSocketReader(1); + pixelReader_ = this->getInputSocketReader(0); + screenReader_ = this->getInputSocketReader(1); } void KeyingDespillOperation::deinitExecution() { - m_pixelReader = nullptr; - m_screenReader = nullptr; + pixelReader_ = nullptr; + screenReader_ = nullptr; } void KeyingDespillOperation::executePixelSampled(float output[4], @@ -54,8 +54,8 @@ void KeyingDespillOperation::executePixelSampled(float output[4], float pixelColor[4]; float screenColor[4]; - m_pixelReader->readSampled(pixelColor, x, y, sampler); - m_screenReader->readSampled(screenColor, x, y, sampler); + pixelReader_->readSampled(pixelColor, x, y, sampler); + screenReader_->readSampled(screenColor, x, y, sampler); const int screen_primary_channel = max_axis_v3(screenColor); const int other_1 = (screen_primary_channel + 1) % 3; @@ -66,13 +66,13 @@ void KeyingDespillOperation::executePixelSampled(float output[4], float average_value, amount; - average_value = m_colorBalance * pixelColor[min_channel] + - (1.0f - m_colorBalance) * pixelColor[max_channel]; + average_value = colorBalance_ * pixelColor[min_channel] + + (1.0f - colorBalance_) * pixelColor[max_channel]; amount = (pixelColor[screen_primary_channel] - average_value); copy_v4_v4(output, pixelColor); - const float amount_despill = m_despillFactor * amount; + const float amount_despill = despillFactor_ * amount; if (amount_despill > 0.0f) { output[screen_primary_channel] = pixelColor[screen_primary_channel] - amount_despill; } @@ -93,13 +93,13 @@ void KeyingDespillOperation::update_memory_buffer_partial(MemoryBuffer *output, const int min_channel = MIN2(other_1, other_2); const int max_channel = MAX2(other_1, other_2); - const float average_value = m_colorBalance * pixel_color[min_channel] + - (1.0f - m_colorBalance) * pixel_color[max_channel]; + const float average_value = colorBalance_ * pixel_color[min_channel] + + (1.0f - colorBalance_) * pixel_color[max_channel]; const float amount = (pixel_color[screen_primary_channel] - average_value); copy_v4_v4(it.out, pixel_color); - const float amount_despill = m_despillFactor * amount; + const float amount_despill = despillFactor_ * amount; if (amount_despill > 0.0f) { it.out[screen_primary_channel] = pixel_color[screen_primary_channel] - amount_despill; } diff --git a/source/blender/compositor/operations/COM_KeyingDespillOperation.h b/source/blender/compositor/operations/COM_KeyingDespillOperation.h index 257c24f3b58..51efa44ce1c 100644 --- a/source/blender/compositor/operations/COM_KeyingDespillOperation.h +++ b/source/blender/compositor/operations/COM_KeyingDespillOperation.h @@ -27,10 +27,10 @@ namespace blender::compositor { */ class KeyingDespillOperation : public MultiThreadedOperation { protected: - SocketReader *m_pixelReader; - SocketReader *m_screenReader; - float m_despillFactor; - float m_colorBalance; + SocketReader *pixelReader_; + SocketReader *screenReader_; + float despillFactor_; + float colorBalance_; public: KeyingDespillOperation(); @@ -40,11 +40,11 @@ class KeyingDespillOperation : public MultiThreadedOperation { void setDespillFactor(float value) { - m_despillFactor = value; + despillFactor_ = value; } void setColorBalance(float value) { - m_colorBalance = value; + colorBalance_ = value; } void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; diff --git a/source/blender/compositor/operations/COM_KeyingOperation.cc b/source/blender/compositor/operations/COM_KeyingOperation.cc index 7b0b80b5796..7a7fe716fb5 100644 --- a/source/blender/compositor/operations/COM_KeyingOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingOperation.cc @@ -42,22 +42,22 @@ KeyingOperation::KeyingOperation() this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Value); - m_screenBalance = 0.5f; + screenBalance_ = 0.5f; - m_pixelReader = nullptr; - m_screenReader = nullptr; + pixelReader_ = nullptr; + screenReader_ = nullptr; } void KeyingOperation::initExecution() { - m_pixelReader = this->getInputSocketReader(0); - m_screenReader = this->getInputSocketReader(1); + pixelReader_ = this->getInputSocketReader(0); + screenReader_ = this->getInputSocketReader(1); } void KeyingOperation::deinitExecution() { - m_pixelReader = nullptr; - m_screenReader = nullptr; + pixelReader_ = nullptr; + screenReader_ = nullptr; } void KeyingOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) @@ -65,8 +65,8 @@ void KeyingOperation::executePixelSampled(float output[4], float x, float y, Pix float pixel_color[4]; float screen_color[4]; - m_pixelReader->readSampled(pixel_color, x, y, sampler); - m_screenReader->readSampled(screen_color, x, y, sampler); + pixelReader_->readSampled(pixel_color, x, y, sampler); + screenReader_->readSampled(screen_color, x, y, sampler); const int primary_channel = max_axis_v3(screen_color); const float min_pixel_color = min_fff(pixel_color[0], pixel_color[1], pixel_color[2]); @@ -80,8 +80,8 @@ void KeyingOperation::executePixelSampled(float output[4], float x, float y, Pix output[0] = 1.0f; } else { - float saturation = get_pixel_saturation(pixel_color, m_screenBalance, primary_channel); - float screen_saturation = get_pixel_saturation(screen_color, m_screenBalance, primary_channel); + float saturation = get_pixel_saturation(pixel_color, screenBalance_, primary_channel); + float screen_saturation = get_pixel_saturation(screen_color, screenBalance_, primary_channel); if (saturation < 0) { /* means main channel of pixel is different from screen, @@ -124,9 +124,9 @@ void KeyingOperation::update_memory_buffer_partial(MemoryBuffer *output, it.out[0] = 1.0f; } else { - const float saturation = get_pixel_saturation(pixel_color, m_screenBalance, primary_channel); + const float saturation = get_pixel_saturation(pixel_color, screenBalance_, primary_channel); const float screen_saturation = get_pixel_saturation( - screen_color, m_screenBalance, primary_channel); + screen_color, screenBalance_, primary_channel); if (saturation < 0) { /* Means main channel of pixel is different from screen, diff --git a/source/blender/compositor/operations/COM_KeyingOperation.h b/source/blender/compositor/operations/COM_KeyingOperation.h index 89674e64701..3ad18085f6b 100644 --- a/source/blender/compositor/operations/COM_KeyingOperation.h +++ b/source/blender/compositor/operations/COM_KeyingOperation.h @@ -31,10 +31,10 @@ namespace blender::compositor { */ class KeyingOperation : public MultiThreadedOperation { protected: - SocketReader *m_pixelReader; - SocketReader *m_screenReader; + SocketReader *pixelReader_; + SocketReader *screenReader_; - float m_screenBalance; + float screenBalance_; public: KeyingOperation(); @@ -44,7 +44,7 @@ class KeyingOperation : public MultiThreadedOperation { void setScreenBalance(float value) { - m_screenBalance = value; + screenBalance_ = value; } void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; diff --git a/source/blender/compositor/operations/COM_KeyingScreenOperation.cc b/source/blender/compositor/operations/COM_KeyingScreenOperation.cc index 646450eb970..8f14b5415b5 100644 --- a/source/blender/compositor/operations/COM_KeyingScreenOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingScreenOperation.cc @@ -29,31 +29,31 @@ namespace blender::compositor { KeyingScreenOperation::KeyingScreenOperation() { this->addOutputSocket(DataType::Color); - m_movieClip = nullptr; - m_framenumber = 0; - m_trackingObject[0] = 0; + movieClip_ = nullptr; + framenumber_ = 0; + trackingObject_[0] = 0; flags.complex = true; - m_cachedTriangulation = nullptr; + cachedTriangulation_ = nullptr; } void KeyingScreenOperation::initExecution() { initMutex(); if (execution_model_ == eExecutionModel::FullFrame) { - BLI_assert(m_cachedTriangulation == nullptr); - if (m_movieClip) { - m_cachedTriangulation = buildVoronoiTriangulation(); + BLI_assert(cachedTriangulation_ == nullptr); + if (movieClip_) { + cachedTriangulation_ = buildVoronoiTriangulation(); } } else { - m_cachedTriangulation = nullptr; + cachedTriangulation_ = nullptr; } } void KeyingScreenOperation::deinitExecution() { - if (m_cachedTriangulation) { - TriangulationData *triangulation = m_cachedTriangulation; + if (cachedTriangulation_) { + TriangulationData *triangulation = cachedTriangulation_; if (triangulation->triangulated_points) { MEM_freeN(triangulation->triangulated_points); @@ -67,9 +67,9 @@ void KeyingScreenOperation::deinitExecution() MEM_freeN(triangulation->triangles_AABB); } - MEM_freeN(m_cachedTriangulation); + MEM_freeN(cachedTriangulation_); - m_cachedTriangulation = nullptr; + cachedTriangulation_ = nullptr; } } @@ -77,7 +77,7 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri { MovieClipUser user = {0}; TriangulationData *triangulation; - MovieTracking *tracking = &m_movieClip->tracking; + MovieTracking *tracking = &movieClip_->tracking; MovieTrackingTrack *track; VoronoiSite *sites, *site; ImBuf *ibuf; @@ -87,10 +87,10 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri int i; int width = this->getWidth(); int height = this->getHeight(); - int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(m_movieClip, m_framenumber); + int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, framenumber_); - if (m_trackingObject[0]) { - MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, m_trackingObject); + if (trackingObject_[0]) { + MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, trackingObject_); if (!object) { return nullptr; @@ -126,7 +126,7 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri } BKE_movieclip_user_set_frame(&user, clip_frame); - ibuf = BKE_movieclip_get_ibuf(m_movieClip, &user); + ibuf = BKE_movieclip_get_ibuf(movieClip_, &user); if (!ibuf) { return nullptr; @@ -237,7 +237,7 @@ KeyingScreenOperation::TileData *KeyingScreenOperation::triangulate(const rcti * int chunk_size = 20; int i; - triangulation = m_cachedTriangulation; + triangulation = cachedTriangulation_; if (!triangulation) { return nullptr; @@ -271,14 +271,14 @@ KeyingScreenOperation::TileData *KeyingScreenOperation::triangulate(const rcti * void *KeyingScreenOperation::initializeTileData(rcti *rect) { - if (m_movieClip == nullptr) { + if (movieClip_ == nullptr) { return nullptr; } - if (!m_cachedTriangulation) { + if (!cachedTriangulation_) { lockMutex(); - if (m_cachedTriangulation == nullptr) { - m_cachedTriangulation = buildVoronoiTriangulation(); + if (cachedTriangulation_ == nullptr) { + cachedTriangulation_ = buildVoronoiTriangulation(); } unlockMutex(); } @@ -301,13 +301,13 @@ void KeyingScreenOperation::determine_canvas(const rcti &preferred_area, rcti &r { r_area = COM_AREA_NONE; - if (m_movieClip) { + if (movieClip_) { MovieClipUser user = {0}; int width, height; - int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(m_movieClip, m_framenumber); + int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, framenumber_); BKE_movieclip_user_set_frame(&user, clip_frame); - BKE_movieclip_get_size(m_movieClip, &user, &width, &height); + BKE_movieclip_get_size(movieClip_, &user, &width, &height); r_area = preferred_area; r_area.xmax = r_area.xmin + width; r_area.ymax = r_area.ymin + height; @@ -321,8 +321,8 @@ void KeyingScreenOperation::executePixel(float output[4], int x, int y, void *da output[2] = 0.0f; output[3] = 1.0f; - if (m_movieClip && data) { - TriangulationData *triangulation = m_cachedTriangulation; + if (movieClip_ && data) { + TriangulationData *triangulation = cachedTriangulation_; TileData *tile_data = (TileData *)data; int i; float co[2] = {(float)x, (float)y}; @@ -356,7 +356,7 @@ void KeyingScreenOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - if (m_movieClip == nullptr) { + if (movieClip_ == nullptr) { output->fill(area, COM_COLOR_BLACK); return; } @@ -366,7 +366,7 @@ void KeyingScreenOperation::update_memory_buffer_partial(MemoryBuffer *output, const int *triangles = tri_area->triangles; const int num_triangles = tri_area->triangles_total; - const TriangulationData *triangulation = m_cachedTriangulation; + const TriangulationData *triangulation = cachedTriangulation_; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { copy_v4_v4(it.out, COM_COLOR_BLACK); diff --git a/source/blender/compositor/operations/COM_KeyingScreenOperation.h b/source/blender/compositor/operations/COM_KeyingScreenOperation.h index 32299c8f241..a828513d9fa 100644 --- a/source/blender/compositor/operations/COM_KeyingScreenOperation.h +++ b/source/blender/compositor/operations/COM_KeyingScreenOperation.h @@ -49,10 +49,10 @@ class KeyingScreenOperation : public MultiThreadedOperation { int triangles_total; } TileData; - MovieClip *m_movieClip; - int m_framenumber; - TriangulationData *m_cachedTriangulation; - char m_trackingObject[64]; + MovieClip *movieClip_; + int framenumber_; + TriangulationData *cachedTriangulation_; + char trackingObject_[64]; /** * Determine the output resolution. The resolution is retrieved from the Renderer @@ -72,15 +72,15 @@ class KeyingScreenOperation : public MultiThreadedOperation { void setMovieClip(MovieClip *clip) { - m_movieClip = clip; + movieClip_ = clip; } void setTrackingObject(const char *object) { - BLI_strncpy(m_trackingObject, object, sizeof(m_trackingObject)); + BLI_strncpy(trackingObject_, object, sizeof(trackingObject_)); } void setFramenumber(int framenumber) { - m_framenumber = framenumber; + framenumber_ = framenumber; } void executePixel(float output[4], int x, int y, void *data) override; diff --git a/source/blender/compositor/operations/COM_LuminanceMatteOperation.cc b/source/blender/compositor/operations/COM_LuminanceMatteOperation.cc index 97a615bdd1e..d266cbd00f5 100644 --- a/source/blender/compositor/operations/COM_LuminanceMatteOperation.cc +++ b/source/blender/compositor/operations/COM_LuminanceMatteOperation.cc @@ -27,18 +27,18 @@ LuminanceMatteOperation::LuminanceMatteOperation() addInputSocket(DataType::Color); addOutputSocket(DataType::Value); - m_inputImageProgram = nullptr; + inputImageProgram_ = nullptr; flags.can_be_constant = true; } void LuminanceMatteOperation::initExecution() { - m_inputImageProgram = this->getInputSocketReader(0); + inputImageProgram_ = this->getInputSocketReader(0); } void LuminanceMatteOperation::deinitExecution() { - m_inputImageProgram = nullptr; + inputImageProgram_ = nullptr; } void LuminanceMatteOperation::executePixelSampled(float output[4], @@ -47,10 +47,10 @@ void LuminanceMatteOperation::executePixelSampled(float output[4], PixelSampler sampler) { float inColor[4]; - m_inputImageProgram->readSampled(inColor, x, y, sampler); + inputImageProgram_->readSampled(inColor, x, y, sampler); - const float high = m_settings->t1; - const float low = m_settings->t2; + const float high = settings_->t1; + const float low = settings_->t2; const float luminance = IMB_colormanagement_get_luminance(inColor); float alpha; @@ -91,8 +91,8 @@ void LuminanceMatteOperation::update_memory_buffer_partial(MemoryBuffer *output, */ /* Test range. */ - const float high = m_settings->t1; - const float low = m_settings->t2; + const float high = settings_->t1; + const float low = settings_->t2; float alpha; if (luminance > high) { alpha = 1.0f; diff --git a/source/blender/compositor/operations/COM_LuminanceMatteOperation.h b/source/blender/compositor/operations/COM_LuminanceMatteOperation.h index 53618a4a107..6262d1999bc 100644 --- a/source/blender/compositor/operations/COM_LuminanceMatteOperation.h +++ b/source/blender/compositor/operations/COM_LuminanceMatteOperation.h @@ -28,8 +28,8 @@ namespace blender::compositor { */ class LuminanceMatteOperation : public MultiThreadedOperation { private: - NodeChroma *m_settings; - SocketReader *m_inputImageProgram; + NodeChroma *settings_; + SocketReader *inputImageProgram_; public: /** @@ -47,7 +47,7 @@ class LuminanceMatteOperation : public MultiThreadedOperation { void setSettings(NodeChroma *nodeChroma) { - m_settings = nodeChroma; + settings_ = nodeChroma; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_MapRangeOperation.cc b/source/blender/compositor/operations/COM_MapRangeOperation.cc index cdf41290a0a..0fcdbd1fd99 100644 --- a/source/blender/compositor/operations/COM_MapRangeOperation.cc +++ b/source/blender/compositor/operations/COM_MapRangeOperation.cc @@ -28,18 +28,18 @@ MapRangeOperation::MapRangeOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_inputOperation = nullptr; - m_useClamp = false; + inputOperation_ = nullptr; + useClamp_ = false; flags.can_be_constant = true; } void MapRangeOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); - m_sourceMinOperation = this->getInputSocketReader(1); - m_sourceMaxOperation = this->getInputSocketReader(2); - m_destMinOperation = this->getInputSocketReader(3); - m_destMaxOperation = this->getInputSocketReader(4); + inputOperation_ = this->getInputSocketReader(0); + sourceMinOperation_ = this->getInputSocketReader(1); + sourceMaxOperation_ = this->getInputSocketReader(2); + destMinOperation_ = this->getInputSocketReader(3); + destMaxOperation_ = this->getInputSocketReader(4); } /* The code below assumes all data is inside range +- this, and that input buffer is single channel @@ -56,11 +56,11 @@ void MapRangeOperation::executePixelSampled(float output[4], float source_min, source_max; float dest_min, dest_max; - m_inputOperation->readSampled(inputs, x, y, sampler); - m_sourceMinOperation->readSampled(inputs + 1, x, y, sampler); - m_sourceMaxOperation->readSampled(inputs + 2, x, y, sampler); - m_destMinOperation->readSampled(inputs + 3, x, y, sampler); - m_destMaxOperation->readSampled(inputs + 4, x, y, sampler); + inputOperation_->readSampled(inputs, x, y, sampler); + sourceMinOperation_->readSampled(inputs + 1, x, y, sampler); + sourceMaxOperation_->readSampled(inputs + 2, x, y, sampler); + destMinOperation_->readSampled(inputs + 3, x, y, sampler); + destMaxOperation_->readSampled(inputs + 4, x, y, sampler); value = inputs[0]; source_min = inputs[1]; @@ -84,7 +84,7 @@ void MapRangeOperation::executePixelSampled(float output[4], value = dest_min; } - if (m_useClamp) { + if (useClamp_) { if (dest_max > dest_min) { CLAMP(value, dest_min, dest_max); } @@ -98,11 +98,11 @@ void MapRangeOperation::executePixelSampled(float output[4], void MapRangeOperation::deinitExecution() { - m_inputOperation = nullptr; - m_sourceMinOperation = nullptr; - m_sourceMaxOperation = nullptr; - m_destMinOperation = nullptr; - m_destMaxOperation = nullptr; + inputOperation_ = nullptr; + sourceMinOperation_ = nullptr; + sourceMaxOperation_ = nullptr; + destMinOperation_ = nullptr; + destMaxOperation_ = nullptr; } void MapRangeOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -131,7 +131,7 @@ void MapRangeOperation::update_memory_buffer_partial(MemoryBuffer *output, value = dest_min; } - if (m_useClamp) { + if (useClamp_) { if (dest_max > dest_min) { CLAMP(value, dest_min, dest_max); } diff --git a/source/blender/compositor/operations/COM_MapRangeOperation.h b/source/blender/compositor/operations/COM_MapRangeOperation.h index b061eb687c1..f5c42d19079 100644 --- a/source/blender/compositor/operations/COM_MapRangeOperation.h +++ b/source/blender/compositor/operations/COM_MapRangeOperation.h @@ -32,13 +32,13 @@ class MapRangeOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputOperation; - SocketReader *m_sourceMinOperation; - SocketReader *m_sourceMaxOperation; - SocketReader *m_destMinOperation; - SocketReader *m_destMaxOperation; + SocketReader *inputOperation_; + SocketReader *sourceMinOperation_; + SocketReader *sourceMaxOperation_; + SocketReader *destMinOperation_; + SocketReader *destMaxOperation_; - bool m_useClamp; + bool useClamp_; public: /** @@ -66,7 +66,7 @@ class MapRangeOperation : public MultiThreadedOperation { */ void setUseClamp(bool value) { - m_useClamp = value; + useClamp_ = value; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_MapUVOperation.cc b/source/blender/compositor/operations/COM_MapUVOperation.cc index 83f4be133ed..a5140c30fed 100644 --- a/source/blender/compositor/operations/COM_MapUVOperation.cc +++ b/source/blender/compositor/operations/COM_MapUVOperation.cc @@ -25,12 +25,12 @@ MapUVOperation::MapUVOperation() this->addInputSocket(DataType::Color, ResizeMode::Align); this->addInputSocket(DataType::Vector); this->addOutputSocket(DataType::Color); - m_alpha = 0.0f; + alpha_ = 0.0f; this->flags.complex = true; set_canvas_input_index(UV_INPUT_INDEX); - m_inputUVProgram = nullptr; - m_inputColorProgram = nullptr; + inputUVProgram_ = nullptr; + inputColorProgram_ = nullptr; } void MapUVOperation::init_data() @@ -46,11 +46,11 @@ void MapUVOperation::init_data() void MapUVOperation::initExecution() { - m_inputColorProgram = this->getInputSocketReader(0); - m_inputUVProgram = this->getInputSocketReader(1); + inputColorProgram_ = this->getInputSocketReader(0); + inputUVProgram_ = this->getInputSocketReader(1); if (execution_model_ == eExecutionModel::Tiled) { uv_input_read_fn_ = [=](float x, float y, float *out) { - m_inputUVProgram->readSampled(out, x, y, PixelSampler::Bilinear); + inputUVProgram_->readSampled(out, x, y, PixelSampler::Bilinear); }; } } @@ -70,17 +70,17 @@ void MapUVOperation::executePixelSampled(float output[4], } /* EWA filtering */ - m_inputColorProgram->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); + inputColorProgram_->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); /* UV to alpha threshold */ - const float threshold = m_alpha * 0.05f; + const float threshold = alpha_ * 0.05f; /* XXX alpha threshold is used to fade out pixels on boundaries with invalid derivatives. * this calculation is not very well defined, should be looked into if it becomes a problem ... */ float du = len_v2(deriv[0]); float dv = len_v2(deriv[1]); - float factor = 1.0f - threshold * (du / m_inputColorProgram->getWidth() + - dv / m_inputColorProgram->getHeight()); + float factor = 1.0f - threshold * (du / inputColorProgram_->getWidth() + + dv / inputColorProgram_->getHeight()); if (factor < 0.0f) { alpha = 0.0f; } @@ -164,8 +164,8 @@ void MapUVOperation::pixelTransform(const float xy[2], void MapUVOperation::deinitExecution() { - m_inputUVProgram = nullptr; - m_inputColorProgram = nullptr; + inputUVProgram_ = nullptr; + inputColorProgram_ = nullptr; } bool MapUVOperation::determineDependingAreaOfInterest(rcti *input, @@ -246,7 +246,7 @@ void MapUVOperation::update_memory_buffer_partial(MemoryBuffer *output, input_image->read_elem_filtered(uv[0], uv[1], deriv[0], deriv[1], it.out); /* UV to alpha threshold. */ - const float threshold = m_alpha * 0.05f; + const float threshold = alpha_ * 0.05f; /* XXX alpha threshold is used to fade out pixels on boundaries with invalid derivatives. * this calculation is not very well defined, should be looked into if it becomes a problem ... */ diff --git a/source/blender/compositor/operations/COM_MapUVOperation.h b/source/blender/compositor/operations/COM_MapUVOperation.h index 612caab21ad..7025e02e069 100644 --- a/source/blender/compositor/operations/COM_MapUVOperation.h +++ b/source/blender/compositor/operations/COM_MapUVOperation.h @@ -29,15 +29,15 @@ class MapUVOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputUVProgram; - SocketReader *m_inputColorProgram; + SocketReader *inputUVProgram_; + SocketReader *inputColorProgram_; int uv_width_; int uv_height_; int image_width_; int image_height_; - float m_alpha; + float alpha_; std::function<void(float x, float y, float *out)> uv_input_read_fn_; @@ -72,7 +72,7 @@ class MapUVOperation : public MultiThreadedOperation { void setAlpha(float alpha) { - m_alpha = alpha; + alpha_ = alpha; } void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; diff --git a/source/blender/compositor/operations/COM_MapValueOperation.cc b/source/blender/compositor/operations/COM_MapValueOperation.cc index 5351f7ac7e4..0f4175c3d3d 100644 --- a/source/blender/compositor/operations/COM_MapValueOperation.cc +++ b/source/blender/compositor/operations/COM_MapValueOperation.cc @@ -24,13 +24,13 @@ MapValueOperation::MapValueOperation() { this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_inputOperation = nullptr; + inputOperation_ = nullptr; flags.can_be_constant = true; } void MapValueOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); } void MapValueOperation::executePixelSampled(float output[4], @@ -39,8 +39,8 @@ void MapValueOperation::executePixelSampled(float output[4], PixelSampler sampler) { float src[4]; - m_inputOperation->readSampled(src, x, y, sampler); - TexMapping *texmap = m_settings; + inputOperation_->readSampled(src, x, y, sampler); + TexMapping *texmap = settings_; float value = (src[0] + texmap->loc[0]) * texmap->size[0]; if (texmap->flag & TEXMAP_CLIP_MIN) { if (value < texmap->min[0]) { @@ -58,7 +58,7 @@ void MapValueOperation::executePixelSampled(float output[4], void MapValueOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void MapValueOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -67,7 +67,7 @@ void MapValueOperation::update_memory_buffer_partial(MemoryBuffer *output, { for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const float input = *it.in(0); - TexMapping *texmap = m_settings; + TexMapping *texmap = settings_; float value = (input + texmap->loc[0]) * texmap->size[0]; if (texmap->flag & TEXMAP_CLIP_MIN) { if (value < texmap->min[0]) { diff --git a/source/blender/compositor/operations/COM_MapValueOperation.h b/source/blender/compositor/operations/COM_MapValueOperation.h index 75761681f12..38cb75869d5 100644 --- a/source/blender/compositor/operations/COM_MapValueOperation.h +++ b/source/blender/compositor/operations/COM_MapValueOperation.h @@ -32,8 +32,8 @@ class MapValueOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputOperation; - TexMapping *m_settings; + SocketReader *inputOperation_; + TexMapping *settings_; public: /** @@ -61,7 +61,7 @@ class MapValueOperation : public MultiThreadedOperation { */ void setSettings(TexMapping *settings) { - m_settings = settings; + settings_ = settings; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_MaskOperation.cc b/source/blender/compositor/operations/COM_MaskOperation.cc index aa7b693554f..d02d23445b6 100644 --- a/source/blender/compositor/operations/COM_MaskOperation.cc +++ b/source/blender/compositor/operations/COM_MaskOperation.cc @@ -26,34 +26,34 @@ namespace blender::compositor { MaskOperation::MaskOperation() { this->addOutputSocket(DataType::Value); - m_mask = nullptr; - m_maskWidth = 0; - m_maskHeight = 0; - m_maskWidthInv = 0.0f; - m_maskHeightInv = 0.0f; - m_frame_shutter = 0.0f; - m_frame_number = 0; - m_rasterMaskHandleTot = 1; - memset(m_rasterMaskHandles, 0, sizeof(m_rasterMaskHandles)); + mask_ = nullptr; + maskWidth_ = 0; + maskHeight_ = 0; + maskWidthInv_ = 0.0f; + maskHeightInv_ = 0.0f; + frame_shutter_ = 0.0f; + frame_number_ = 0; + rasterMaskHandleTot_ = 1; + memset(rasterMaskHandles_, 0, sizeof(rasterMaskHandles_)); } void MaskOperation::initExecution() { - if (m_mask && m_rasterMaskHandles[0] == nullptr) { - if (m_rasterMaskHandleTot == 1) { - m_rasterMaskHandles[0] = BKE_maskrasterize_handle_new(); + if (mask_ && rasterMaskHandles_[0] == nullptr) { + if (rasterMaskHandleTot_ == 1) { + rasterMaskHandles_[0] = BKE_maskrasterize_handle_new(); BKE_maskrasterize_handle_init( - m_rasterMaskHandles[0], m_mask, m_maskWidth, m_maskHeight, true, true, m_do_feather); + rasterMaskHandles_[0], mask_, maskWidth_, maskHeight_, true, true, do_feather_); } else { /* make a throw away copy of the mask */ - const float frame = (float)m_frame_number - m_frame_shutter; - const float frame_step = (m_frame_shutter * 2.0f) / m_rasterMaskHandleTot; + const float frame = (float)frame_number_ - frame_shutter_; + const float frame_step = (frame_shutter_ * 2.0f) / rasterMaskHandleTot_; float frame_iter = frame; Mask *mask_temp = (Mask *)BKE_id_copy_ex( - nullptr, &m_mask->id, nullptr, LIB_ID_COPY_LOCALIZE | LIB_ID_COPY_NO_ANIMDATA); + nullptr, &mask_->id, nullptr, LIB_ID_COPY_LOCALIZE | LIB_ID_COPY_NO_ANIMDATA); /* trick so we can get unkeyed edits to display */ { @@ -62,24 +62,19 @@ void MaskOperation::initExecution() for (masklay = (MaskLayer *)mask_temp->masklayers.first; masklay; masklay = masklay->next) { - masklay_shape = BKE_mask_layer_shape_verify_frame(masklay, m_frame_number); + masklay_shape = BKE_mask_layer_shape_verify_frame(masklay, frame_number_); BKE_mask_layer_shape_from_mask(masklay, masklay_shape); } } - for (unsigned int i = 0; i < m_rasterMaskHandleTot; i++) { - m_rasterMaskHandles[i] = BKE_maskrasterize_handle_new(); + for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) { + rasterMaskHandles_[i] = BKE_maskrasterize_handle_new(); /* re-eval frame info */ BKE_mask_evaluate(mask_temp, frame_iter, true); - BKE_maskrasterize_handle_init(m_rasterMaskHandles[i], - mask_temp, - m_maskWidth, - m_maskHeight, - true, - true, - m_do_feather); + BKE_maskrasterize_handle_init( + rasterMaskHandles_[i], mask_temp, maskWidth_, maskHeight_, true, true, do_feather_); frame_iter += frame_step; } @@ -91,23 +86,23 @@ void MaskOperation::initExecution() void MaskOperation::deinitExecution() { - for (unsigned int i = 0; i < m_rasterMaskHandleTot; i++) { - if (m_rasterMaskHandles[i]) { - BKE_maskrasterize_handle_free(m_rasterMaskHandles[i]); - m_rasterMaskHandles[i] = nullptr; + for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) { + if (rasterMaskHandles_[i]) { + BKE_maskrasterize_handle_free(rasterMaskHandles_[i]); + rasterMaskHandles_[i] = nullptr; } } } void MaskOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { - if (m_maskWidth == 0 || m_maskHeight == 0) { + if (maskWidth_ == 0 || maskHeight_ == 0) { r_area = COM_AREA_NONE; } else { r_area = preferred_area; - r_area.xmax = r_area.xmin + m_maskWidth; - r_area.ymax = r_area.ymin + m_maskHeight; + r_area.xmax = r_area.xmin + maskWidth_; + r_area.ymax = r_area.ymin + maskHeight_; } } @@ -117,13 +112,13 @@ void MaskOperation::executePixelSampled(float output[4], PixelSampler /*sampler*/) { const float xy[2] = { - (x * m_maskWidthInv) + m_mask_px_ofs[0], - (y * m_maskHeightInv) + m_mask_px_ofs[1], + (x * maskWidthInv_) + mask_px_ofs_[0], + (y * maskHeightInv_) + mask_px_ofs_[1], }; - if (m_rasterMaskHandleTot == 1) { - if (m_rasterMaskHandles[0]) { - output[0] = BKE_maskrasterize_handle_sample(m_rasterMaskHandles[0], xy); + if (rasterMaskHandleTot_ == 1) { + if (rasterMaskHandles_[0]) { + output[0] = BKE_maskrasterize_handle_sample(rasterMaskHandles_[0], xy); } else { output[0] = 0.0f; @@ -133,14 +128,14 @@ void MaskOperation::executePixelSampled(float output[4], /* In case loop below fails. */ output[0] = 0.0f; - for (unsigned int i = 0; i < m_rasterMaskHandleTot; i++) { - if (m_rasterMaskHandles[i]) { - output[0] += BKE_maskrasterize_handle_sample(m_rasterMaskHandles[i], xy); + for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) { + if (rasterMaskHandles_[i]) { + output[0] += BKE_maskrasterize_handle_sample(rasterMaskHandles_[i], xy); } } /* until we get better falloff */ - output[0] /= m_rasterMaskHandleTot; + output[0] /= rasterMaskHandleTot_; } } @@ -156,23 +151,23 @@ void MaskOperation::update_memory_buffer_partial(MemoryBuffer *output, float xy[2]; for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { - xy[0] = it.x * m_maskWidthInv + m_mask_px_ofs[0]; - xy[1] = it.y * m_maskHeightInv + m_mask_px_ofs[1]; + xy[0] = it.x * maskWidthInv_ + mask_px_ofs_[0]; + xy[1] = it.y * maskHeightInv_ + mask_px_ofs_[1]; *it.out = 0.0f; for (MaskRasterHandle *handle : handles) { *it.out += BKE_maskrasterize_handle_sample(handle, xy); } /* Until we get better falloff. */ - *it.out /= m_rasterMaskHandleTot; + *it.out /= rasterMaskHandleTot_; } } Vector<MaskRasterHandle *> MaskOperation::get_non_null_handles() const { Vector<MaskRasterHandle *> handles; - for (int i = 0; i < m_rasterMaskHandleTot; i++) { - MaskRasterHandle *handle = m_rasterMaskHandles[i]; + for (int i = 0; i < rasterMaskHandleTot_; i++) { + MaskRasterHandle *handle = rasterMaskHandles_[i]; if (handle == nullptr) { continue; } diff --git a/source/blender/compositor/operations/COM_MaskOperation.h b/source/blender/compositor/operations/COM_MaskOperation.h index 8ad3044b6cd..e8f386242b4 100644 --- a/source/blender/compositor/operations/COM_MaskOperation.h +++ b/source/blender/compositor/operations/COM_MaskOperation.h @@ -33,23 +33,23 @@ namespace blender::compositor { */ class MaskOperation : public MultiThreadedOperation { protected: - Mask *m_mask; + Mask *mask_; /* NOTE: these are used more like aspect, * but they _do_ impact on mask detail */ - int m_maskWidth; - int m_maskHeight; - float m_maskWidthInv; /* `1 / m_maskWidth` */ - float m_maskHeightInv; /* `1 / m_maskHeight` */ - float m_mask_px_ofs[2]; + int maskWidth_; + int maskHeight_; + float maskWidthInv_; /* `1 / maskWidth_` */ + float maskHeightInv_; /* `1 / maskHeight_` */ + float mask_px_ofs_[2]; - float m_frame_shutter; - int m_frame_number; + float frame_shutter_; + int frame_number_; - bool m_do_feather; + bool do_feather_; - struct MaskRasterHandle *m_rasterMaskHandles[CMP_NODE_MASK_MBLUR_SAMPLES_MAX]; - unsigned int m_rasterMaskHandleTot; + struct MaskRasterHandle *rasterMaskHandles_[CMP_NODE_MASK_MBLUR_SAMPLES_MAX]; + unsigned int rasterMaskHandleTot_; /** * Determine the output resolution. The resolution is retrieved from the Renderer @@ -64,36 +64,36 @@ class MaskOperation : public MultiThreadedOperation { void setMask(Mask *mask) { - m_mask = mask; + mask_ = mask; } void setMaskWidth(int width) { - m_maskWidth = width; - m_maskWidthInv = 1.0f / (float)width; - m_mask_px_ofs[0] = m_maskWidthInv * 0.5f; + maskWidth_ = width; + maskWidthInv_ = 1.0f / (float)width; + mask_px_ofs_[0] = maskWidthInv_ * 0.5f; } void setMaskHeight(int height) { - m_maskHeight = height; - m_maskHeightInv = 1.0f / (float)height; - m_mask_px_ofs[1] = m_maskHeightInv * 0.5f; + maskHeight_ = height; + maskHeightInv_ = 1.0f / (float)height; + mask_px_ofs_[1] = maskHeightInv_ * 0.5f; } void setFramenumber(int frame_number) { - m_frame_number = frame_number; + frame_number_ = frame_number; } void setFeather(bool feather) { - m_do_feather = feather; + do_feather_ = feather; } void setMotionBlurSamples(int samples) { - m_rasterMaskHandleTot = MIN2(MAX2(1, samples), CMP_NODE_MASK_MBLUR_SAMPLES_MAX); + rasterMaskHandleTot_ = MIN2(MAX2(1, samples), CMP_NODE_MASK_MBLUR_SAMPLES_MAX); } void setMotionBlurShutter(float shutter) { - m_frame_shutter = shutter; + frame_shutter_ = shutter; } void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.cc b/source/blender/compositor/operations/COM_MathBaseOperation.cc index a16ecfc7327..30b6e14a324 100644 --- a/source/blender/compositor/operations/COM_MathBaseOperation.cc +++ b/source/blender/compositor/operations/COM_MathBaseOperation.cc @@ -28,25 +28,25 @@ MathBaseOperation::MathBaseOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_inputValue1Operation = nullptr; - m_inputValue2Operation = nullptr; - m_inputValue3Operation = nullptr; - m_useClamp = false; + inputValue1Operation_ = nullptr; + inputValue2Operation_ = nullptr; + inputValue3Operation_ = nullptr; + useClamp_ = false; this->flags.can_be_constant = true; } void MathBaseOperation::initExecution() { - m_inputValue1Operation = this->getInputSocketReader(0); - m_inputValue2Operation = this->getInputSocketReader(1); - m_inputValue3Operation = this->getInputSocketReader(2); + inputValue1Operation_ = this->getInputSocketReader(0); + inputValue2Operation_ = this->getInputSocketReader(1); + inputValue3Operation_ = this->getInputSocketReader(2); } void MathBaseOperation::deinitExecution() { - m_inputValue1Operation = nullptr; - m_inputValue2Operation = nullptr; - m_inputValue3Operation = nullptr; + inputValue1Operation_ = nullptr; + inputValue2Operation_ = nullptr; + inputValue3Operation_ = nullptr; } void MathBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -66,7 +66,7 @@ void MathBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_are void MathBaseOperation::clampIfNeeded(float *color) { - if (m_useClamp) { + if (useClamp_) { CLAMP(color[0], 0.0f, 1.0f); } } @@ -84,8 +84,8 @@ void MathAddOperation::executePixelSampled(float output[4], float x, float y, Pi float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = inputValue1[0] + inputValue2[0]; @@ -100,8 +100,8 @@ void MathSubtractOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = inputValue1[0] - inputValue2[0]; @@ -116,8 +116,8 @@ void MathMultiplyOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = inputValue1[0] * inputValue2[0]; @@ -132,8 +132,8 @@ void MathDivideOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); if (inputValue2[0] == 0) { /* We don't want to divide by zero. */ output[0] = 0.0; @@ -161,8 +161,8 @@ void MathSineOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = sin(inputValue1[0]); @@ -185,8 +185,8 @@ void MathCosineOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = cos(inputValue1[0]); @@ -209,8 +209,8 @@ void MathTangentOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = tan(inputValue1[0]); @@ -233,8 +233,8 @@ void MathHyperbolicSineOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = sinh(inputValue1[0]); @@ -257,8 +257,8 @@ void MathHyperbolicCosineOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = cosh(inputValue1[0]); @@ -281,8 +281,8 @@ void MathHyperbolicTangentOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = tanh(inputValue1[0]); @@ -305,8 +305,8 @@ void MathArcSineOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); if (inputValue1[0] <= 1 && inputValue1[0] >= -1) { output[0] = asin(inputValue1[0]); @@ -334,8 +334,8 @@ void MathArcCosineOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); if (inputValue1[0] <= 1 && inputValue1[0] >= -1) { output[0] = acos(inputValue1[0]); @@ -363,8 +363,8 @@ void MathArcTangentOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = atan(inputValue1[0]); @@ -387,8 +387,8 @@ void MathPowerOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); if (inputValue1[0] >= 0) { output[0] = pow(inputValue1[0], inputValue2[0]); @@ -438,8 +438,8 @@ void MathLogarithmOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); if (inputValue1[0] > 0 && inputValue2[0] > 0) { output[0] = log(inputValue1[0]) / log(inputValue2[0]); @@ -474,8 +474,8 @@ void MathMinimumOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = MIN2(inputValue1[0], inputValue2[0]); @@ -498,8 +498,8 @@ void MathMaximumOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = MAX2(inputValue1[0], inputValue2[0]); @@ -522,8 +522,8 @@ void MathRoundOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = round(inputValue1[0]); @@ -546,8 +546,8 @@ void MathLessThanOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = inputValue1[0] < inputValue2[0] ? 1.0f : 0.0f; @@ -562,8 +562,8 @@ void MathGreaterThanOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = inputValue1[0] > inputValue2[0] ? 1.0f : 0.0f; @@ -578,8 +578,8 @@ void MathModuloOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); if (inputValue2[0] == 0) { output[0] = 0.0; @@ -607,7 +607,7 @@ void MathAbsoluteOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = fabs(inputValue1[0]); @@ -629,7 +629,7 @@ void MathRadiansOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = DEG2RADF(inputValue1[0]); @@ -651,7 +651,7 @@ void MathDegreesOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = RAD2DEGF(inputValue1[0]); @@ -674,8 +674,8 @@ void MathArcTan2Operation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = atan2(inputValue1[0], inputValue2[0]); @@ -697,7 +697,7 @@ void MathFloorOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = floor(inputValue1[0]); @@ -719,7 +719,7 @@ void MathCeilOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = ceil(inputValue1[0]); @@ -741,7 +741,7 @@ void MathFractOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = inputValue1[0] - floor(inputValue1[0]); @@ -763,7 +763,7 @@ void MathSqrtOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); if (inputValue1[0] > 0) { output[0] = sqrt(inputValue1[0]); @@ -790,7 +790,7 @@ void MathInverseSqrtOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); if (inputValue1[0] > 0) { output[0] = 1.0f / sqrt(inputValue1[0]); @@ -817,7 +817,7 @@ void MathSignOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = compatible_signf(inputValue1[0]); @@ -839,7 +839,7 @@ void MathExponentOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = expf(inputValue1[0]); @@ -861,7 +861,7 @@ void MathTruncOperation::executePixelSampled(float output[4], { float inputValue1[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); output[0] = (inputValue1[0] >= 0.0f) ? floor(inputValue1[0]) : ceil(inputValue1[0]); @@ -885,8 +885,8 @@ void MathSnapOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); if (inputValue1[0] == 0 || inputValue2[0] == 0) { /* We don't want to divide by zero. */ output[0] = 0.0f; @@ -922,9 +922,9 @@ void MathWrapOperation::executePixelSampled(float output[4], float inputValue2[4]; float inputValue3[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); - m_inputValue3Operation->readSampled(inputValue3, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + inputValue3Operation_->readSampled(inputValue3, x, y, sampler); output[0] = wrapf(inputValue1[0], inputValue2[0], inputValue3[0]); @@ -947,8 +947,8 @@ void MathPingpongOperation::executePixelSampled(float output[4], float inputValue1[4]; float inputValue2[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); output[0] = pingpongf(inputValue1[0], inputValue2[0]); @@ -972,9 +972,9 @@ void MathCompareOperation::executePixelSampled(float output[4], float inputValue2[4]; float inputValue3[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); - m_inputValue3Operation->readSampled(inputValue3, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + inputValue3Operation_->readSampled(inputValue3, x, y, sampler); output[0] = (fabsf(inputValue1[0] - inputValue2[0]) <= MAX2(inputValue3[0], 1e-5f)) ? 1.0f : 0.0f; @@ -999,9 +999,9 @@ void MathMultiplyAddOperation::executePixelSampled(float output[4], float inputValue2[4]; float inputValue3[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); - m_inputValue3Operation->readSampled(inputValue3, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + inputValue3Operation_->readSampled(inputValue3, x, y, sampler); output[0] = inputValue1[0] * inputValue2[0] + inputValue3[0]; @@ -1025,9 +1025,9 @@ void MathSmoothMinOperation::executePixelSampled(float output[4], float inputValue2[4]; float inputValue3[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); - m_inputValue3Operation->readSampled(inputValue3, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + inputValue3Operation_->readSampled(inputValue3, x, y, sampler); output[0] = smoothminf(inputValue1[0], inputValue2[0], inputValue3[0]); @@ -1051,9 +1051,9 @@ void MathSmoothMaxOperation::executePixelSampled(float output[4], float inputValue2[4]; float inputValue3[4]; - m_inputValue1Operation->readSampled(inputValue1, x, y, sampler); - m_inputValue2Operation->readSampled(inputValue2, x, y, sampler); - m_inputValue3Operation->readSampled(inputValue3, x, y, sampler); + inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + inputValue3Operation_->readSampled(inputValue3, x, y, sampler); output[0] = -smoothminf(-inputValue1[0], -inputValue2[0], inputValue3[0]); diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.h b/source/blender/compositor/operations/COM_MathBaseOperation.h index 1424a7a9769..fcb735720b2 100644 --- a/source/blender/compositor/operations/COM_MathBaseOperation.h +++ b/source/blender/compositor/operations/COM_MathBaseOperation.h @@ -31,11 +31,11 @@ class MathBaseOperation : public MultiThreadedOperation { /** * Prefetched reference to the inputProgram */ - SocketReader *m_inputValue1Operation; - SocketReader *m_inputValue2Operation; - SocketReader *m_inputValue3Operation; + SocketReader *inputValue1Operation_; + SocketReader *inputValue2Operation_; + SocketReader *inputValue3Operation_; - bool m_useClamp; + bool useClamp_; protected: /** @@ -48,7 +48,7 @@ class MathBaseOperation : public MultiThreadedOperation { float clamp_when_enabled(float value) { - if (m_useClamp) { + if (useClamp_) { return CLAMPIS(value, 0.0f, 1.0f); } return value; @@ -56,7 +56,7 @@ class MathBaseOperation : public MultiThreadedOperation { void clamp_when_enabled(float *out) { - if (m_useClamp) { + if (useClamp_) { CLAMP(*out, 0.0f, 1.0f); } } @@ -79,7 +79,7 @@ class MathBaseOperation : public MultiThreadedOperation { void setUseClamp(bool value) { - m_useClamp = value; + useClamp_ = value; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_MixOperation.cc b/source/blender/compositor/operations/COM_MixOperation.cc index d7a8d0c0e8e..216dbc3a701 100644 --- a/source/blender/compositor/operations/COM_MixOperation.cc +++ b/source/blender/compositor/operations/COM_MixOperation.cc @@ -28,9 +28,9 @@ MixBaseOperation::MixBaseOperation() this->addInputSocket(DataType::Color); this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_inputValueOperation = nullptr; - m_inputColor1Operation = nullptr; - m_inputColor2Operation = nullptr; + inputValueOperation_ = nullptr; + inputColor1Operation_ = nullptr; + inputColor2Operation_ = nullptr; this->setUseValueAlphaMultiply(false); this->setUseClamp(false); flags.can_be_constant = true; @@ -38,9 +38,9 @@ MixBaseOperation::MixBaseOperation() void MixBaseOperation::initExecution() { - m_inputValueOperation = this->getInputSocketReader(0); - m_inputColor1Operation = this->getInputSocketReader(1); - m_inputColor2Operation = this->getInputSocketReader(2); + inputValueOperation_ = this->getInputSocketReader(0); + inputColor1Operation_ = this->getInputSocketReader(1); + inputColor2Operation_ = this->getInputSocketReader(2); } void MixBaseOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) @@ -49,9 +49,9 @@ void MixBaseOperation::executePixelSampled(float output[4], float x, float y, Pi float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -89,9 +89,9 @@ void MixBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_area void MixBaseOperation::deinitExecution() { - m_inputValueOperation = nullptr; - m_inputColor1Operation = nullptr; - m_inputColor2Operation = nullptr; + inputValueOperation_ = nullptr; + inputColor1Operation_ = nullptr; + inputColor2Operation_ = nullptr; } void MixBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -141,9 +141,9 @@ void MixAddOperation::executePixelSampled(float output[4], float x, float y, Pix float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -186,9 +186,9 @@ void MixBlendOperation::executePixelSampled(float output[4], float inputValue[4]; float value; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -233,9 +233,9 @@ void MixColorBurnOperation::executePixelSampled(float output[4], float inputValue[4]; float tmp; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -352,9 +352,9 @@ void MixColorOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -422,9 +422,9 @@ void MixDarkenOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -468,9 +468,9 @@ void MixDifferenceOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -514,9 +514,9 @@ void MixDivideOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -595,9 +595,9 @@ void MixDodgeOperation::executePixelSampled(float output[4], float inputValue[4]; float tmp; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -736,9 +736,9 @@ void MixGlareOperation::executePixelSampled(float output[4], float inputValue[4]; float value, input_weight, glare_weight; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); value = inputValue[0]; /* Linear interpolation between 3 cases: * value=-1:output=input value=0:output=input+glare value=1:output=glare @@ -794,9 +794,9 @@ void MixHueOperation::executePixelSampled(float output[4], float x, float y, Pix float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -864,9 +864,9 @@ void MixLightenOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -934,9 +934,9 @@ void MixLinearLightOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -1010,9 +1010,9 @@ void MixMultiplyOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -1057,9 +1057,9 @@ void MixOverlayOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -1136,9 +1136,9 @@ void MixSaturationOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -1200,9 +1200,9 @@ void MixScreenOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -1248,9 +1248,9 @@ void MixSoftLightOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -1317,9 +1317,9 @@ void MixSubtractOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { @@ -1361,9 +1361,9 @@ void MixValueOperation::executePixelSampled(float output[4], float inputColor2[4]; float inputValue[4]; - m_inputValueOperation->readSampled(inputValue, x, y, sampler); - m_inputColor1Operation->readSampled(inputColor1, x, y, sampler); - m_inputColor2Operation->readSampled(inputColor2, x, y, sampler); + inputValueOperation_->readSampled(inputValue, x, y, sampler); + inputColor1Operation_->readSampled(inputColor1, x, y, sampler); + inputColor2Operation_->readSampled(inputColor2, x, y, sampler); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { diff --git a/source/blender/compositor/operations/COM_MixOperation.h b/source/blender/compositor/operations/COM_MixOperation.h index 5d96aa4f5d7..0efc98617a6 100644 --- a/source/blender/compositor/operations/COM_MixOperation.h +++ b/source/blender/compositor/operations/COM_MixOperation.h @@ -53,15 +53,15 @@ class MixBaseOperation : public MultiThreadedOperation { /** * Prefetched reference to the inputProgram */ - SocketReader *m_inputValueOperation; - SocketReader *m_inputColor1Operation; - SocketReader *m_inputColor2Operation; - bool m_valueAlphaMultiply; - bool m_useClamp; + SocketReader *inputValueOperation_; + SocketReader *inputColor1Operation_; + SocketReader *inputColor2Operation_; + bool valueAlphaMultiply_; + bool useClamp_; inline void clampIfNeeded(float color[4]) { - if (m_useClamp) { + if (useClamp_) { clamp_v4(color, 0.0f, 1.0f); } } @@ -91,15 +91,15 @@ class MixBaseOperation : public MultiThreadedOperation { void setUseValueAlphaMultiply(const bool value) { - m_valueAlphaMultiply = value; + valueAlphaMultiply_ = value; } inline bool useValueAlphaMultiply() { - return m_valueAlphaMultiply; + return valueAlphaMultiply_; } void setUseClamp(bool value) { - m_useClamp = value; + useClamp_ = value; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cc b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cc index e62c126812f..c43a552f1ce 100644 --- a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cc +++ b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cc @@ -26,9 +26,9 @@ namespace blender::compositor { MovieClipAttributeOperation::MovieClipAttributeOperation() { this->addOutputSocket(DataType::Value); - m_framenumber = 0; - m_attribute = MCA_X; - m_invert = false; + framenumber_ = 0; + attribute_ = MCA_X; + invert_ = false; needs_canvas_to_get_constant_ = true; is_value_calculated_ = false; stabilization_resolution_socket_ = nullptr; @@ -45,7 +45,7 @@ void MovieClipAttributeOperation::calc_value() { BLI_assert(this->get_flags().is_canvas_set); is_value_calculated_ = true; - if (m_clip == nullptr) { + if (clip_ == nullptr) { return; } float loc[2], scale, angle; @@ -53,38 +53,38 @@ void MovieClipAttributeOperation::calc_value() loc[1] = 0.0f; scale = 1.0f; angle = 0.0f; - int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(m_clip, m_framenumber); + int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip_, framenumber_); NodeOperation &stabilization_operation = stabilization_resolution_socket_ ? stabilization_resolution_socket_->getLink()->getOperation() : *this; - BKE_tracking_stabilization_data_get(m_clip, + BKE_tracking_stabilization_data_get(clip_, clip_framenr, stabilization_operation.getWidth(), stabilization_operation.getHeight(), loc, &scale, &angle); - switch (m_attribute) { + switch (attribute_) { case MCA_SCALE: - m_value = scale; + value_ = scale; break; case MCA_ANGLE: - m_value = angle; + value_ = angle; break; case MCA_X: - m_value = loc[0]; + value_ = loc[0]; break; case MCA_Y: - m_value = loc[1]; + value_ = loc[1]; break; } - if (m_invert) { - if (m_attribute != MCA_SCALE) { - m_value = -m_value; + if (invert_) { + if (attribute_ != MCA_SCALE) { + value_ = -value_; } else { - m_value = 1.0f / m_value; + value_ = 1.0f / value_; } } } @@ -94,7 +94,7 @@ void MovieClipAttributeOperation::executePixelSampled(float output[4], float /*y*/, PixelSampler /*sampler*/) { - output[0] = m_value; + output[0] = value_; } void MovieClipAttributeOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -107,7 +107,7 @@ const float *MovieClipAttributeOperation::get_constant_elem() if (!is_value_calculated_) { calc_value(); } - return &m_value; + return &value_; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h index 640d578abb0..2df2b199107 100644 --- a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h +++ b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h @@ -36,11 +36,11 @@ typedef enum MovieClipAttribute { */ class MovieClipAttributeOperation : public ConstantOperation { private: - MovieClip *m_clip; - float m_value; - int m_framenumber; - bool m_invert; - MovieClipAttribute m_attribute; + MovieClip *clip_; + float value_; + int framenumber_; + bool invert_; + MovieClipAttribute attribute_; bool is_value_calculated_; NodeOperationInput *stabilization_resolution_socket_; @@ -62,19 +62,19 @@ class MovieClipAttributeOperation : public ConstantOperation { void setMovieClip(MovieClip *clip) { - m_clip = clip; + clip_ = clip; } void setFramenumber(int framenumber) { - m_framenumber = framenumber; + framenumber_ = framenumber; } void setAttribute(MovieClipAttribute attribute) { - m_attribute = attribute; + attribute_ = attribute; } void setInvert(bool invert) { - m_invert = invert; + invert_ = invert; } /** diff --git a/source/blender/compositor/operations/COM_MovieClipOperation.cc b/source/blender/compositor/operations/COM_MovieClipOperation.cc index aac263142d7..2803c707371 100644 --- a/source/blender/compositor/operations/COM_MovieClipOperation.cc +++ b/source/blender/compositor/operations/COM_MovieClipOperation.cc @@ -27,30 +27,30 @@ namespace blender::compositor { MovieClipBaseOperation::MovieClipBaseOperation() { - m_movieClip = nullptr; - m_movieClipBuffer = nullptr; - m_movieClipUser = nullptr; - m_movieClipwidth = 0; - m_movieClipheight = 0; - m_framenumber = 0; + movieClip_ = nullptr; + movieClipBuffer_ = nullptr; + movieClipUser_ = nullptr; + movieClipwidth_ = 0; + movieClipheight_ = 0; + framenumber_ = 0; } void MovieClipBaseOperation::initExecution() { - if (m_movieClip) { - BKE_movieclip_user_set_frame(m_movieClipUser, m_framenumber); + if (movieClip_) { + BKE_movieclip_user_set_frame(movieClipUser_, framenumber_); ImBuf *ibuf; - if (m_cacheFrame) { - ibuf = BKE_movieclip_get_ibuf(m_movieClip, m_movieClipUser); + if (cacheFrame_) { + ibuf = BKE_movieclip_get_ibuf(movieClip_, movieClipUser_); } else { ibuf = BKE_movieclip_get_ibuf_flag( - m_movieClip, m_movieClipUser, m_movieClip->flag, MOVIECLIP_CACHE_SKIP); + movieClip_, movieClipUser_, movieClip_->flag, MOVIECLIP_CACHE_SKIP); } if (ibuf) { - m_movieClipBuffer = ibuf; + movieClipBuffer_ = ibuf; if (ibuf->rect_float == nullptr || ibuf->userflags & IB_RECT_INVALID) { IMB_float_from_rect(ibuf); ibuf->userflags &= ~IB_RECT_INVALID; @@ -61,19 +61,19 @@ void MovieClipBaseOperation::initExecution() void MovieClipBaseOperation::deinitExecution() { - if (m_movieClipBuffer) { - IMB_freeImBuf(m_movieClipBuffer); + if (movieClipBuffer_) { + IMB_freeImBuf(movieClipBuffer_); - m_movieClipBuffer = nullptr; + movieClipBuffer_ = nullptr; } } void MovieClipBaseOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area) { r_area = COM_AREA_NONE; - if (m_movieClip) { + if (movieClip_) { int width, height; - BKE_movieclip_get_size(m_movieClip, m_movieClipUser, &width, &height); + BKE_movieclip_get_size(movieClip_, movieClipUser_, &width, &height); BLI_rcti_init(&r_area, 0, width, 0, height); } } @@ -83,7 +83,7 @@ void MovieClipBaseOperation::executePixelSampled(float output[4], float y, PixelSampler sampler) { - ImBuf *ibuf = m_movieClipBuffer; + ImBuf *ibuf = movieClipBuffer_; if (ibuf == nullptr) { zero_v4(output); @@ -111,8 +111,8 @@ void MovieClipBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - if (m_movieClipBuffer) { - output->copy_from(m_movieClipBuffer, area); + if (movieClipBuffer_) { + output->copy_from(movieClipBuffer_, area); } else { output->fill(area, COM_COLOR_TRANSPARENT); @@ -143,8 +143,8 @@ void MovieClipAlphaOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - if (m_movieClipBuffer) { - output->copy_from(m_movieClipBuffer, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0); + if (movieClipBuffer_) { + output->copy_from(movieClipBuffer_, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0); } else { output->fill(area, COM_VALUE_ZERO); diff --git a/source/blender/compositor/operations/COM_MovieClipOperation.h b/source/blender/compositor/operations/COM_MovieClipOperation.h index a319c2116b7..58cebba45d7 100644 --- a/source/blender/compositor/operations/COM_MovieClipOperation.h +++ b/source/blender/compositor/operations/COM_MovieClipOperation.h @@ -30,13 +30,13 @@ namespace blender::compositor { */ class MovieClipBaseOperation : public MultiThreadedOperation { protected: - MovieClip *m_movieClip; - MovieClipUser *m_movieClipUser; - ImBuf *m_movieClipBuffer; - int m_movieClipheight; - int m_movieClipwidth; - int m_framenumber; - bool m_cacheFrame; + MovieClip *movieClip_; + MovieClipUser *movieClipUser_; + ImBuf *movieClipBuffer_; + int movieClipheight_; + int movieClipwidth_; + int framenumber_; + bool cacheFrame_; /** * Determine the output resolution. The resolution is retrieved from the Renderer @@ -50,20 +50,20 @@ class MovieClipBaseOperation : public MultiThreadedOperation { void deinitExecution() override; void setMovieClip(MovieClip *image) { - m_movieClip = image; + movieClip_ = image; } void setMovieClipUser(MovieClipUser *imageuser) { - m_movieClipUser = imageuser; + movieClipUser_ = imageuser; } void setCacheFrame(bool value) { - m_cacheFrame = value; + cacheFrame_ = value; } void setFramenumber(int framenumber) { - m_framenumber = framenumber; + framenumber_ = framenumber; } void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; diff --git a/source/blender/compositor/operations/COM_MovieDistortionOperation.cc b/source/blender/compositor/operations/COM_MovieDistortionOperation.cc index ec17c2d030f..0cb0742dbee 100644 --- a/source/blender/compositor/operations/COM_MovieDistortionOperation.cc +++ b/source/blender/compositor/operations/COM_MovieDistortionOperation.cc @@ -27,20 +27,20 @@ MovieDistortionOperation::MovieDistortionOperation(bool distortion) this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); this->set_canvas_input_index(0); - m_inputOperation = nullptr; - m_movieClip = nullptr; - m_apply = distortion; + inputOperation_ = nullptr; + movieClip_ = nullptr; + apply_ = distortion; } void MovieDistortionOperation::init_data() { - if (m_movieClip) { - MovieTracking *tracking = &m_movieClip->tracking; + if (movieClip_) { + MovieTracking *tracking = &movieClip_->tracking; MovieClipUser clipUser = {0}; int calibration_width, calibration_height; - BKE_movieclip_user_set_frame(&clipUser, m_framenumber); - BKE_movieclip_get_size(m_movieClip, &clipUser, &calibration_width, &calibration_height); + BKE_movieclip_user_set_frame(&clipUser, framenumber_); + BKE_movieclip_get_size(movieClip_, &clipUser, &calibration_width, &calibration_height); float delta[2]; rcti full_frame; @@ -48,42 +48,41 @@ void MovieDistortionOperation::init_data() full_frame.xmax = this->getWidth(); full_frame.ymax = this->getHeight(); BKE_tracking_max_distortion_delta_across_bound( - tracking, this->getWidth(), this->getHeight(), &full_frame, !m_apply, delta); + tracking, this->getWidth(), this->getHeight(), &full_frame, !apply_, delta); /* 5 is just in case we didn't hit real max of distortion in * BKE_tracking_max_undistortion_delta_across_bound */ - m_margin[0] = delta[0] + 5; - m_margin[1] = delta[1] + 5; + margin_[0] = delta[0] + 5; + margin_[1] = delta[1] + 5; - m_calibration_width = calibration_width; - m_calibration_height = calibration_height; - m_pixel_aspect = tracking->camera.pixel_aspect; + calibration_width_ = calibration_width; + calibration_height_ = calibration_height; + pixel_aspect_ = tracking->camera.pixel_aspect; } else { - m_margin[0] = m_margin[1] = 0; + margin_[0] = margin_[1] = 0; } } void MovieDistortionOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); - if (m_movieClip) { - MovieTracking *tracking = &m_movieClip->tracking; - m_distortion = BKE_tracking_distortion_new( - tracking, m_calibration_width, m_calibration_height); + inputOperation_ = this->getInputSocketReader(0); + if (movieClip_) { + MovieTracking *tracking = &movieClip_->tracking; + distortion_ = BKE_tracking_distortion_new(tracking, calibration_width_, calibration_height_); } else { - m_distortion = nullptr; + distortion_ = nullptr; } } void MovieDistortionOperation::deinitExecution() { - m_inputOperation = nullptr; - m_movieClip = nullptr; - if (m_distortion != nullptr) { - BKE_tracking_distortion_free(m_distortion); + inputOperation_ = nullptr; + movieClip_ = nullptr; + if (distortion_ != nullptr) { + BKE_tracking_distortion_free(distortion_); } } @@ -92,33 +91,33 @@ void MovieDistortionOperation::executePixelSampled(float output[4], float y, PixelSampler /*sampler*/) { - if (m_distortion != nullptr) { + if (distortion_ != nullptr) { /* float overscan = 0.0f; */ - const float pixel_aspect = m_pixel_aspect; + const float pixel_aspect = pixel_aspect_; const float w = (float)this->getWidth() /* / (1 + overscan) */; const float h = (float)this->getHeight() /* / (1 + overscan) */; - const float aspx = w / (float)m_calibration_width; - const float aspy = h / (float)m_calibration_height; + const float aspx = w / (float)calibration_width_; + const float aspy = h / (float)calibration_height_; float in[2]; float out[2]; in[0] = (x /* - 0.5 * overscan * w */) / aspx; in[1] = (y /* - 0.5 * overscan * h */) / aspy / pixel_aspect; - if (m_apply) { - BKE_tracking_distortion_undistort_v2(m_distortion, in, out); + if (apply_) { + BKE_tracking_distortion_undistort_v2(distortion_, in, out); } else { - BKE_tracking_distortion_distort_v2(m_distortion, in, out); + BKE_tracking_distortion_distort_v2(distortion_, in, out); } float u = out[0] * aspx /* + 0.5 * overscan * w */, v = (out[1] * aspy /* + 0.5 * overscan * h */) * pixel_aspect; - m_inputOperation->readSampled(output, u, v, PixelSampler::Bilinear); + inputOperation_->readSampled(output, u, v, PixelSampler::Bilinear); } else { - m_inputOperation->readSampled(output, x, y, PixelSampler::Bilinear); + inputOperation_->readSampled(output, x, y, PixelSampler::Bilinear); } } @@ -127,10 +126,10 @@ bool MovieDistortionOperation::determineDependingAreaOfInterest(rcti *input, rcti *output) { rcti newInput; - newInput.xmin = input->xmin - m_margin[0]; - newInput.ymin = input->ymin - m_margin[1]; - newInput.xmax = input->xmax + m_margin[0]; - newInput.ymax = input->ymax + m_margin[1]; + newInput.xmin = input->xmin - margin_[0]; + newInput.ymin = input->ymin - margin_[1]; + newInput.xmax = input->xmax + margin_[0]; + newInput.ymax = input->ymax + margin_[1]; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -140,10 +139,10 @@ void MovieDistortionOperation::get_area_of_interest(const int input_idx, { BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - r_input_area.xmin = output_area.xmin - m_margin[0]; - r_input_area.ymin = output_area.ymin - m_margin[1]; - r_input_area.xmax = output_area.xmax + m_margin[0]; - r_input_area.ymax = output_area.ymax + m_margin[1]; + r_input_area.xmin = output_area.xmin - margin_[0]; + r_input_area.ymin = output_area.ymin - margin_[1]; + r_input_area.xmax = output_area.xmax + margin_[0]; + r_input_area.ymax = output_area.ymax + margin_[1]; } void MovieDistortionOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -151,28 +150,28 @@ void MovieDistortionOperation::update_memory_buffer_partial(MemoryBuffer *output Span<MemoryBuffer *> inputs) { const MemoryBuffer *input_img = inputs[0]; - if (m_distortion == nullptr) { + if (distortion_ == nullptr) { output->copy_from(input_img, area); return; } /* `float overscan = 0.0f;` */ - const float pixel_aspect = m_pixel_aspect; + const float pixel_aspect = pixel_aspect_; const float w = (float)this->getWidth() /* `/ (1 + overscan)` */; const float h = (float)this->getHeight() /* `/ (1 + overscan)` */; - const float aspx = w / (float)m_calibration_width; - const float aspy = h / (float)m_calibration_height; + const float aspx = w / (float)calibration_width_; + const float aspy = h / (float)calibration_height_; float xy[2]; float distorted_xy[2]; for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { xy[0] = (it.x /* `- 0.5 * overscan * w` */) / aspx; xy[1] = (it.y /* `- 0.5 * overscan * h` */) / aspy / pixel_aspect; - if (m_apply) { - BKE_tracking_distortion_undistort_v2(m_distortion, xy, distorted_xy); + if (apply_) { + BKE_tracking_distortion_undistort_v2(distortion_, xy, distorted_xy); } else { - BKE_tracking_distortion_distort_v2(m_distortion, xy, distorted_xy); + BKE_tracking_distortion_distort_v2(distortion_, xy, distorted_xy); } const float u = distorted_xy[0] * aspx /* `+ 0.5 * overscan * w` */; diff --git a/source/blender/compositor/operations/COM_MovieDistortionOperation.h b/source/blender/compositor/operations/COM_MovieDistortionOperation.h index a3630504442..3e728962bc3 100644 --- a/source/blender/compositor/operations/COM_MovieDistortionOperation.h +++ b/source/blender/compositor/operations/COM_MovieDistortionOperation.h @@ -28,17 +28,17 @@ namespace blender::compositor { class MovieDistortionOperation : public MultiThreadedOperation { private: - SocketReader *m_inputOperation; - MovieClip *m_movieClip; - int m_margin[2]; + SocketReader *inputOperation_; + MovieClip *movieClip_; + int margin_[2]; protected: - bool m_apply; - int m_framenumber; + bool apply_; + int framenumber_; - struct MovieDistortion *m_distortion; - int m_calibration_width, m_calibration_height; - float m_pixel_aspect; + struct MovieDistortion *distortion_; + int calibration_width_, calibration_height_; + float pixel_aspect_; public: MovieDistortionOperation(bool distortion); @@ -50,11 +50,11 @@ class MovieDistortionOperation : public MultiThreadedOperation { void setMovieClip(MovieClip *clip) { - m_movieClip = clip; + movieClip_ = clip; } void setFramenumber(int framenumber) { - m_framenumber = framenumber; + framenumber_ = framenumber; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.cc b/source/blender/compositor/operations/COM_MultilayerImageOperation.cc index 20cea6ad659..0209ea0e18c 100644 --- a/source/blender/compositor/operations/COM_MultilayerImageOperation.cc +++ b/source/blender/compositor/operations/COM_MultilayerImageOperation.cc @@ -26,27 +26,27 @@ MultilayerBaseOperation::MultilayerBaseOperation(RenderLayer *render_layer, RenderPass *render_pass, int view) { - m_passId = BLI_findindex(&render_layer->passes, render_pass); - m_view = view; - m_renderLayer = render_layer; - m_renderPass = render_pass; + passId_ = BLI_findindex(&render_layer->passes, render_pass); + view_ = view; + renderLayer_ = render_layer; + renderPass_ = render_pass; } ImBuf *MultilayerBaseOperation::getImBuf() { /* temporarily changes the view to get the right ImBuf */ - int view = m_imageUser->view; + int view = imageUser_->view; - m_imageUser->view = m_view; - m_imageUser->pass = m_passId; + imageUser_->view = view_; + imageUser_->pass = passId_; - if (BKE_image_multilayer_index(m_image->rr, m_imageUser)) { + if (BKE_image_multilayer_index(image_->rr, imageUser_)) { ImBuf *ibuf = BaseImageOperation::getImBuf(); - m_imageUser->view = view; + imageUser_->view = view; return ibuf; } - m_imageUser->view = view; + imageUser_->view = view; return nullptr; } @@ -54,17 +54,17 @@ void MultilayerBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - output->copy_from(m_buffer, area); + output->copy_from(buffer_, area); } std::unique_ptr<MetaData> MultilayerColorOperation::getMetaData() { - BLI_assert(m_buffer); + BLI_assert(buffer_); MetaDataExtractCallbackData callback_data = {nullptr}; - RenderResult *render_result = m_image->rr; + RenderResult *render_result = image_->rr; if (render_result && render_result->stamp_data) { - RenderLayer *render_layer = m_renderLayer; - RenderPass *render_pass = m_renderPass; + RenderLayer *render_layer = renderLayer_; + RenderPass *render_pass = renderPass_; std::string full_layer_name = std::string(render_layer->name, BLI_strnlen(render_layer->name, sizeof(render_layer->name))) + @@ -88,20 +88,20 @@ void MultilayerColorOperation::executePixelSampled(float output[4], float y, PixelSampler sampler) { - if (m_imageFloatBuffer == nullptr) { + if (imageFloatBuffer_ == nullptr) { zero_v4(output); } else { - if (m_numberOfChannels == 4) { + if (numberOfChannels_ == 4) { switch (sampler) { case PixelSampler::Nearest: - nearest_interpolation_color(m_buffer, nullptr, output, x, y); + nearest_interpolation_color(buffer_, nullptr, output, x, y); break; case PixelSampler::Bilinear: - bilinear_interpolation_color(m_buffer, nullptr, output, x, y); + bilinear_interpolation_color(buffer_, nullptr, output, x, y); break; case PixelSampler::Bicubic: - bicubic_interpolation_color(m_buffer, nullptr, output, x, y); + bicubic_interpolation_color(buffer_, nullptr, output, x, y); break; } } @@ -114,7 +114,7 @@ void MultilayerColorOperation::executePixelSampled(float output[4], } else { int offset = (yi * this->getWidth() + xi) * 3; - copy_v3_v3(output, &m_imageFloatBuffer[offset]); + copy_v3_v3(output, &imageFloatBuffer_[offset]); } } } @@ -125,7 +125,7 @@ void MultilayerValueOperation::executePixelSampled(float output[4], float y, PixelSampler /*sampler*/) { - if (m_imageFloatBuffer == nullptr) { + if (imageFloatBuffer_ == nullptr) { output[0] = 0.0f; } else { @@ -136,7 +136,7 @@ void MultilayerValueOperation::executePixelSampled(float output[4], output[0] = 0.0f; } else { - float result = m_imageFloatBuffer[yi * this->getWidth() + xi]; + float result = imageFloatBuffer_[yi * this->getWidth() + xi]; output[0] = result; } } @@ -147,7 +147,7 @@ void MultilayerVectorOperation::executePixelSampled(float output[4], float y, PixelSampler /*sampler*/) { - if (m_imageFloatBuffer == nullptr) { + if (imageFloatBuffer_ == nullptr) { output[0] = 0.0f; } else { @@ -159,7 +159,7 @@ void MultilayerVectorOperation::executePixelSampled(float output[4], } else { int offset = (yi * this->getWidth() + xi) * 3; - copy_v3_v3(output, &m_imageFloatBuffer[offset]); + copy_v3_v3(output, &imageFloatBuffer_[offset]); } } } diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.h b/source/blender/compositor/operations/COM_MultilayerImageOperation.h index a682ca1941c..77805decc1f 100644 --- a/source/blender/compositor/operations/COM_MultilayerImageOperation.h +++ b/source/blender/compositor/operations/COM_MultilayerImageOperation.h @@ -24,12 +24,12 @@ namespace blender::compositor { class MultilayerBaseOperation : public BaseImageOperation { private: - int m_passId; - int m_view; + int passId_; + int view_; protected: - RenderLayer *m_renderLayer; - RenderPass *m_renderPass; + RenderLayer *renderLayer_; + RenderPass *renderPass_; ImBuf *getImBuf() override; public: diff --git a/source/blender/compositor/operations/COM_NormalizeOperation.cc b/source/blender/compositor/operations/COM_NormalizeOperation.cc index f3388397a79..0c2dc309ede 100644 --- a/source/blender/compositor/operations/COM_NormalizeOperation.cc +++ b/source/blender/compositor/operations/COM_NormalizeOperation.cc @@ -24,14 +24,14 @@ NormalizeOperation::NormalizeOperation() { this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Value); - m_imageReader = nullptr; - m_cachedInstance = nullptr; + imageReader_ = nullptr; + cachedInstance_ = nullptr; this->flags.complex = true; flags.can_be_constant = true; } void NormalizeOperation::initExecution() { - m_imageReader = this->getInputSocketReader(0); + imageReader_ = this->getInputSocketReader(0); NodeOperation::initMutex(); } @@ -40,7 +40,7 @@ void NormalizeOperation::executePixel(float output[4], int x, int y, void *data) /* using generic two floats struct to store `x: min`, `y: multiply` */ NodeTwoFloats *minmult = (NodeTwoFloats *)data; - m_imageReader->read(output, x, y, nullptr); + imageReader_->read(output, x, y, nullptr); output[0] = (output[0] - minmult->x) * minmult->y; @@ -55,9 +55,9 @@ void NormalizeOperation::executePixel(float output[4], int x, int y, void *data) void NormalizeOperation::deinitExecution() { - m_imageReader = nullptr; - delete m_cachedInstance; - m_cachedInstance = nullptr; + imageReader_ = nullptr; + delete cachedInstance_; + cachedInstance_ = nullptr; NodeOperation::deinitMutex(); } @@ -66,7 +66,7 @@ bool NormalizeOperation::determineDependingAreaOfInterest(rcti * /*input*/, rcti *output) { rcti imageInput; - if (m_cachedInstance) { + if (cachedInstance_) { return false; } @@ -89,8 +89,8 @@ bool NormalizeOperation::determineDependingAreaOfInterest(rcti * /*input*/, void *NormalizeOperation::initializeTileData(rcti *rect) { lockMutex(); - if (m_cachedInstance == nullptr) { - MemoryBuffer *tile = (MemoryBuffer *)m_imageReader->initializeTileData(rect); + if (cachedInstance_ == nullptr) { + MemoryBuffer *tile = (MemoryBuffer *)imageReader_->initializeTileData(rect); /* using generic two floats struct to store `x: min`, `y: multiply`. */ NodeTwoFloats *minmult = new NodeTwoFloats(); @@ -117,11 +117,11 @@ void *NormalizeOperation::initializeTileData(rcti *rect) /* The rare case of flat buffer would cause a divide by 0 */ minmult->y = ((maxv != minv) ? 1.0f / (maxv - minv) : 0.0f); - m_cachedInstance = minmult; + cachedInstance_ = minmult; } unlockMutex(); - return m_cachedInstance; + return cachedInstance_; } void NormalizeOperation::deinitializeTileData(rcti * /*rect*/, void * /*data*/) @@ -140,7 +140,7 @@ void NormalizeOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(outpu const rcti &UNUSED(area), Span<MemoryBuffer *> inputs) { - if (m_cachedInstance == nullptr) { + if (cachedInstance_ == nullptr) { MemoryBuffer *input = inputs[0]; /* Using generic two floats struct to store `x: min`, `y: multiply`. */ @@ -162,7 +162,7 @@ void NormalizeOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(outpu /* The case of a flat buffer would cause a divide by 0. */ minmult->y = ((maxv != minv) ? 1.0f / (maxv - minv) : 0.0f); - m_cachedInstance = minmult; + cachedInstance_ = minmult; } } @@ -170,7 +170,7 @@ void NormalizeOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - NodeTwoFloats *minmult = m_cachedInstance; + NodeTwoFloats *minmult = cachedInstance_; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const float input_value = *it.in(0); diff --git a/source/blender/compositor/operations/COM_NormalizeOperation.h b/source/blender/compositor/operations/COM_NormalizeOperation.h index 7af2aad8a88..450155c319a 100644 --- a/source/blender/compositor/operations/COM_NormalizeOperation.h +++ b/source/blender/compositor/operations/COM_NormalizeOperation.h @@ -32,13 +32,13 @@ class NormalizeOperation : public MultiThreadedOperation { /** * \brief Cached reference to the reader */ - SocketReader *m_imageReader; + SocketReader *imageReader_; /** * \brief temporarily cache of the execution storage * it stores `x->min` and `y->multiply`. */ - NodeTwoFloats *m_cachedInstance; + NodeTwoFloats *cachedInstance_; public: NormalizeOperation(); diff --git a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cc b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cc index 1a49d83af54..e652a0be3e6 100644 --- a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cc +++ b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cc @@ -56,26 +56,26 @@ void *OutputOpenExrSingleLayerMultiViewOperation::get_handle(const char *filenam exrhandle = IMB_exr_get_handle_name(filename); - if (!BKE_scene_multiview_is_render_view_first(m_rd, m_viewName)) { + if (!BKE_scene_multiview_is_render_view_first(rd_, viewName_)) { return exrhandle; } IMB_exr_clear_channels(exrhandle); - for (srv = (SceneRenderView *)m_rd->views.first; srv; srv = srv->next) { - if (BKE_scene_multiview_is_render_view_active(m_rd, srv) == false) { + for (srv = (SceneRenderView *)rd_->views.first; srv; srv = srv->next) { + if (BKE_scene_multiview_is_render_view_active(rd_, srv) == false) { continue; } IMB_exr_add_view(exrhandle, srv->name); - add_exr_channels(exrhandle, nullptr, m_datatype, srv->name, width, false, nullptr); + add_exr_channels(exrhandle, nullptr, datatype_, srv->name, width, false, nullptr); } BLI_make_existing_file(filename); /* prepare the file with all the channels */ - if (!IMB_exr_begin_write(exrhandle, filename, width, height, m_format->exr_codec, nullptr)) { + if (!IMB_exr_begin_write(exrhandle, filename, width, height, format_->exr_codec, nullptr)) { printf("Error Writing Singlelayer Multiview Openexr\n"); IMB_exr_close(exrhandle); } @@ -97,33 +97,33 @@ void OutputOpenExrSingleLayerMultiViewOperation::deinitExecution() char filename[FILE_MAX]; BKE_image_path_from_imtype(filename, - m_path, + path_, BKE_main_blendfile_path_from_global(), - m_rd->cfra, + rd_->cfra, R_IMF_IMTYPE_OPENEXR, - (m_rd->scemode & R_EXTENSION) != 0, + (rd_->scemode & R_EXTENSION) != 0, true, nullptr); exrhandle = this->get_handle(filename); add_exr_channels(exrhandle, nullptr, - m_datatype, - m_viewName, + datatype_, + viewName_, width, - m_format->depth == R_IMF_CHAN_DEPTH_16, - m_outputBuffer); + format_->depth == R_IMF_CHAN_DEPTH_16, + outputBuffer_); /* memory can only be freed after we write all views to the file */ - m_outputBuffer = nullptr; - m_imageInput = nullptr; + outputBuffer_ = nullptr; + imageInput_ = nullptr; /* ready to close the file */ - if (BKE_scene_multiview_is_render_view_last(m_rd, m_viewName)) { + if (BKE_scene_multiview_is_render_view_last(rd_, viewName_)) { IMB_exr_write_channels(exrhandle); /* free buffer memory for all the views */ - free_exr_channels(exrhandle, m_rd, nullptr, m_datatype); + free_exr_channels(exrhandle, rd_, nullptr, datatype_); /* remove exr handle and data */ IMB_exr_close(exrhandle); @@ -158,28 +158,28 @@ void *OutputOpenExrMultiLayerMultiViewOperation::get_handle(const char *filename /* get a new global handle */ exrhandle = IMB_exr_get_handle_name(filename); - if (!BKE_scene_multiview_is_render_view_first(m_rd, m_viewName)) { + if (!BKE_scene_multiview_is_render_view_first(rd_, viewName_)) { return exrhandle; } IMB_exr_clear_channels(exrhandle); /* check renderdata for amount of views */ - for (srv = (SceneRenderView *)m_rd->views.first; srv; srv = srv->next) { + for (srv = (SceneRenderView *)rd_->views.first; srv; srv = srv->next) { - if (BKE_scene_multiview_is_render_view_active(m_rd, srv) == false) { + if (BKE_scene_multiview_is_render_view_active(rd_, srv) == false) { continue; } IMB_exr_add_view(exrhandle, srv->name); - for (unsigned int i = 0; i < m_layers.size(); i++) { + for (unsigned int i = 0; i < layers_.size(); i++) { add_exr_channels(exrhandle, - m_layers[i].name, - m_layers[i].datatype, + layers_[i].name, + layers_[i].datatype, srv->name, width, - m_exr_half_float, + exr_half_float_, nullptr); } } @@ -188,7 +188,7 @@ void *OutputOpenExrMultiLayerMultiViewOperation::get_handle(const char *filename /* prepare the file with all the channels for the header */ StampData *stamp_data = createStampData(); - if (!IMB_exr_begin_write(exrhandle, filename, width, height, m_exr_codec, stamp_data)) { + if (!IMB_exr_begin_write(exrhandle, filename, width, height, exr_codec_, stamp_data)) { printf("Error Writing Multilayer Multiview Openexr\n"); IMB_exr_close(exrhandle); BKE_stamp_data_free(stamp_data); @@ -212,39 +212,39 @@ void OutputOpenExrMultiLayerMultiViewOperation::deinitExecution() char filename[FILE_MAX]; BKE_image_path_from_imtype(filename, - m_path, + path_, BKE_main_blendfile_path_from_global(), - m_rd->cfra, + rd_->cfra, R_IMF_IMTYPE_MULTILAYER, - (m_rd->scemode & R_EXTENSION) != 0, + (rd_->scemode & R_EXTENSION) != 0, true, nullptr); exrhandle = this->get_handle(filename); - for (unsigned int i = 0; i < m_layers.size(); i++) { + for (unsigned int i = 0; i < layers_.size(); i++) { add_exr_channels(exrhandle, - m_layers[i].name, - m_layers[i].datatype, - m_viewName, + layers_[i].name, + layers_[i].datatype, + viewName_, width, - m_exr_half_float, - m_layers[i].outputBuffer); + exr_half_float_, + layers_[i].outputBuffer); } - for (unsigned int i = 0; i < m_layers.size(); i++) { + for (unsigned int i = 0; i < layers_.size(); i++) { /* memory can only be freed after we write all views to the file */ - m_layers[i].outputBuffer = nullptr; - m_layers[i].imageInput = nullptr; + layers_[i].outputBuffer = nullptr; + layers_[i].imageInput = nullptr; } /* ready to close the file */ - if (BKE_scene_multiview_is_render_view_last(m_rd, m_viewName)) { + if (BKE_scene_multiview_is_render_view_last(rd_, viewName_)) { IMB_exr_write_channels(exrhandle); /* free buffer memory for all the views */ - for (unsigned int i = 0; i < m_layers.size(); i++) { - free_exr_channels(exrhandle, m_rd, m_layers[i].name, m_layers[i].datatype); + for (unsigned int i = 0; i < layers_.size(); i++) { + free_exr_channels(exrhandle, rd_, layers_[i].name, layers_[i].datatype); } IMB_exr_close(exrhandle); @@ -267,8 +267,8 @@ OutputStereoOperation::OutputStereoOperation(const RenderData *rd, : OutputSingleLayerOperation( rd, tree, datatype, format, path, viewSettings, displaySettings, viewName, saveAsRender) { - BLI_strncpy(m_name, name, sizeof(m_name)); - m_channels = get_datatype_size(datatype); + BLI_strncpy(name_, name, sizeof(name_)); + channels_ = get_datatype_size(datatype); } void *OutputStereoOperation::get_handle(const char *filename) @@ -283,7 +283,7 @@ void *OutputStereoOperation::get_handle(const char *filename) exrhandle = IMB_exr_get_handle_name(filename); - if (!BKE_scene_multiview_is_render_view_first(m_rd, m_viewName)) { + if (!BKE_scene_multiview_is_render_view_first(rd_, viewName_)) { return exrhandle; } @@ -306,24 +306,24 @@ void OutputStereoOperation::deinitExecution() if (width != 0 && height != 0) { void *exrhandle; - exrhandle = this->get_handle(m_path); - float *buf = m_outputBuffer; + exrhandle = this->get_handle(path_); + float *buf = outputBuffer_; /* populate single EXR channel with view data */ IMB_exr_add_channel(exrhandle, nullptr, - m_name, - m_viewName, + name_, + viewName_, 1, - m_channels * width * height, + channels_ * width * height, buf, - m_format->depth == R_IMF_CHAN_DEPTH_16); + format_->depth == R_IMF_CHAN_DEPTH_16); - m_imageInput = nullptr; - m_outputBuffer = nullptr; + imageInput_ = nullptr; + outputBuffer_ = nullptr; /* create stereo ibuf */ - if (BKE_scene_multiview_is_render_view_last(m_rd, m_viewName)) { + if (BKE_scene_multiview_is_render_view_last(rd_, viewName_)) { ImBuf *ibuf[3] = {nullptr}; const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME}; char filename[FILE_MAX]; @@ -331,33 +331,33 @@ void OutputStereoOperation::deinitExecution() /* get rectf from EXR */ for (i = 0; i < 2; i++) { - float *rectf = IMB_exr_channel_rect(exrhandle, nullptr, m_name, names[i]); - ibuf[i] = IMB_allocImBuf(width, height, m_format->planes, 0); + float *rectf = IMB_exr_channel_rect(exrhandle, nullptr, name_, names[i]); + ibuf[i] = IMB_allocImBuf(width, height, format_->planes, 0); - ibuf[i]->channels = m_channels; + ibuf[i]->channels = channels_; ibuf[i]->rect_float = rectf; ibuf[i]->mall |= IB_rectfloat; - ibuf[i]->dither = m_rd->dither_intensity; + ibuf[i]->dither = rd_->dither_intensity; /* do colormanagement in the individual views, so it doesn't need to do in the stereo */ IMB_colormanagement_imbuf_for_write( - ibuf[i], true, false, m_viewSettings, m_displaySettings, m_format); + ibuf[i], true, false, viewSettings_, displaySettings_, format_); IMB_prepare_write_ImBuf(IMB_isfloat(ibuf[i]), ibuf[i]); } /* create stereo buffer */ - ibuf[2] = IMB_stereo3d_ImBuf(m_format, ibuf[0], ibuf[1]); + ibuf[2] = IMB_stereo3d_ImBuf(format_, ibuf[0], ibuf[1]); BKE_image_path_from_imformat(filename, - m_path, + path_, BKE_main_blendfile_path_from_global(), - m_rd->cfra, - m_format, - (m_rd->scemode & R_EXTENSION) != 0, + rd_->cfra, + format_, + (rd_->scemode & R_EXTENSION) != 0, true, nullptr); - BKE_imbuf_write(ibuf[2], filename, m_format); + BKE_imbuf_write(ibuf[2], filename, format_); /* imbuf knows which rects are not part of ibuf */ for (i = 0; i < 3; i++) { diff --git a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h index 6230a6f306b..a6e76e6190e 100644 --- a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h +++ b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h @@ -65,8 +65,8 @@ class OutputOpenExrMultiLayerMultiViewOperation : public OutputOpenExrMultiLayer class OutputStereoOperation : public OutputSingleLayerOperation { private: - char m_name[FILE_MAX]; - size_t m_channels; + char name_[FILE_MAX]; + size_t channels_; public: OutputStereoOperation(const RenderData *rd, diff --git a/source/blender/compositor/operations/COM_OutputFileOperation.cc b/source/blender/compositor/operations/COM_OutputFileOperation.cc index 92eeb0b600b..6a5ddd969b4 100644 --- a/source/blender/compositor/operations/COM_OutputFileOperation.cc +++ b/source/blender/compositor/operations/COM_OutputFileOperation.cc @@ -213,64 +213,64 @@ OutputSingleLayerOperation::OutputSingleLayerOperation( const char *viewName, const bool saveAsRender) { - m_rd = rd; - m_tree = tree; + rd_ = rd; + tree_ = tree; this->addInputSocket(datatype); - m_outputBuffer = nullptr; - m_datatype = datatype; - m_imageInput = nullptr; + outputBuffer_ = nullptr; + datatype_ = datatype; + imageInput_ = nullptr; - m_format = format; - BLI_strncpy(m_path, path, sizeof(m_path)); + format_ = format; + BLI_strncpy(path_, path, sizeof(path_)); - m_viewSettings = viewSettings; - m_displaySettings = displaySettings; - m_viewName = viewName; - m_saveAsRender = saveAsRender; + viewSettings_ = viewSettings; + displaySettings_ = displaySettings; + viewName_ = viewName; + saveAsRender_ = saveAsRender; } void OutputSingleLayerOperation::initExecution() { - m_imageInput = getInputSocketReader(0); - m_outputBuffer = init_buffer(this->getWidth(), this->getHeight(), m_datatype); + imageInput_ = getInputSocketReader(0); + outputBuffer_ = init_buffer(this->getWidth(), this->getHeight(), datatype_); } void OutputSingleLayerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) { - write_buffer_rect(rect, m_tree, m_imageInput, m_outputBuffer, this->getWidth(), m_datatype); + write_buffer_rect(rect, tree_, imageInput_, outputBuffer_, this->getWidth(), datatype_); } void OutputSingleLayerOperation::deinitExecution() { if (this->getWidth() * this->getHeight() != 0) { - int size = get_datatype_size(m_datatype); - ImBuf *ibuf = IMB_allocImBuf(this->getWidth(), this->getHeight(), m_format->planes, 0); + int size = get_datatype_size(datatype_); + ImBuf *ibuf = IMB_allocImBuf(this->getWidth(), this->getHeight(), format_->planes, 0); char filename[FILE_MAX]; const char *suffix; ibuf->channels = size; - ibuf->rect_float = m_outputBuffer; + ibuf->rect_float = outputBuffer_; ibuf->mall |= IB_rectfloat; - ibuf->dither = m_rd->dither_intensity; + ibuf->dither = rd_->dither_intensity; IMB_colormanagement_imbuf_for_write( - ibuf, m_saveAsRender, false, m_viewSettings, m_displaySettings, m_format); + ibuf, saveAsRender_, false, viewSettings_, displaySettings_, format_); - suffix = BKE_scene_multiview_view_suffix_get(m_rd, m_viewName); + suffix = BKE_scene_multiview_view_suffix_get(rd_, viewName_); BKE_image_path_from_imformat(filename, - m_path, + path_, BKE_main_blendfile_path_from_global(), - m_rd->cfra, - m_format, - (m_rd->scemode & R_EXTENSION) != 0, + rd_->cfra, + format_, + (rd_->scemode & R_EXTENSION) != 0, true, suffix); - if (0 == BKE_imbuf_write(ibuf, filename, m_format)) { + if (0 == BKE_imbuf_write(ibuf, filename, format_)) { printf("Cannot save Node File Output to %s\n", filename); } else { @@ -279,20 +279,20 @@ void OutputSingleLayerOperation::deinitExecution() IMB_freeImBuf(ibuf); } - m_outputBuffer = nullptr; - m_imageInput = nullptr; + outputBuffer_ = nullptr; + imageInput_ = nullptr; } void OutputSingleLayerOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output), const rcti &area, Span<MemoryBuffer *> inputs) { - if (!m_outputBuffer) { + if (!outputBuffer_) { return; } MemoryBuffer output_buf( - m_outputBuffer, COM_data_type_num_channels(m_datatype), this->getWidth(), this->getHeight()); + outputBuffer_, COM_data_type_num_channels(datatype_), this->getWidth(), this->getHeight()); const MemoryBuffer *input_image = inputs[0]; output_buf.copy_from(input_image, area); } @@ -318,14 +318,14 @@ OutputOpenExrMultiLayerOperation::OutputOpenExrMultiLayerOperation(const Scene * bool exr_half_float, const char *viewName) { - m_scene = scene; - m_rd = rd; - m_tree = tree; - - BLI_strncpy(m_path, path, sizeof(m_path)); - m_exr_codec = exr_codec; - m_exr_half_float = exr_half_float; - m_viewName = viewName; + scene_ = scene; + rd_ = rd; + tree_ = tree; + + BLI_strncpy(path_, path, sizeof(path_)); + exr_codec_ = exr_codec; + exr_half_float_ = exr_half_float; + viewName_ = viewName; this->set_canvas_input_index(RESOLUTION_INPUT_ANY); } @@ -334,7 +334,7 @@ void OutputOpenExrMultiLayerOperation::add_layer(const char *name, bool use_layer) { this->addInputSocket(datatype); - m_layers.append(OutputOpenExrLayer(name, datatype, use_layer)); + layers_.append(OutputOpenExrLayer(name, datatype, use_layer)); } StampData *OutputOpenExrMultiLayerOperation::createStampData() const @@ -342,9 +342,9 @@ StampData *OutputOpenExrMultiLayerOperation::createStampData() const /* StampData API doesn't provide functions to modify an instance without having a RenderResult. */ RenderResult render_result; - StampData *stamp_data = BKE_stamp_info_from_scene_static(m_scene); + StampData *stamp_data = BKE_stamp_info_from_scene_static(scene_); render_result.stamp_data = stamp_data; - for (const OutputOpenExrLayer &layer : m_layers) { + for (const OutputOpenExrLayer &layer : layers_) { /* Skip unconnected sockets. */ if (layer.imageInput == nullptr) { continue; @@ -363,23 +363,23 @@ StampData *OutputOpenExrMultiLayerOperation::createStampData() const void OutputOpenExrMultiLayerOperation::initExecution() { - for (unsigned int i = 0; i < m_layers.size(); i++) { - if (m_layers[i].use_layer) { + for (unsigned int i = 0; i < layers_.size(); i++) { + if (layers_[i].use_layer) { SocketReader *reader = getInputSocketReader(i); - m_layers[i].imageInput = reader; - m_layers[i].outputBuffer = init_buffer( - this->getWidth(), this->getHeight(), m_layers[i].datatype); + layers_[i].imageInput = reader; + layers_[i].outputBuffer = init_buffer( + this->getWidth(), this->getHeight(), layers_[i].datatype); } } } void OutputOpenExrMultiLayerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) { - for (unsigned int i = 0; i < m_layers.size(); i++) { - OutputOpenExrLayer &layer = m_layers[i]; + for (unsigned int i = 0; i < layers_.size(); i++) { + OutputOpenExrLayer &layer = layers_[i]; if (layer.imageInput) { write_buffer_rect( - rect, m_tree, layer.imageInput, layer.outputBuffer, this->getWidth(), layer.datatype); + rect, tree_, layer.imageInput, layer.outputBuffer, this->getWidth(), layer.datatype); } } } @@ -393,35 +393,35 @@ void OutputOpenExrMultiLayerOperation::deinitExecution() const char *suffix; void *exrhandle = IMB_exr_get_handle(); - suffix = BKE_scene_multiview_view_suffix_get(m_rd, m_viewName); + suffix = BKE_scene_multiview_view_suffix_get(rd_, viewName_); BKE_image_path_from_imtype(filename, - m_path, + path_, BKE_main_blendfile_path_from_global(), - m_rd->cfra, + rd_->cfra, R_IMF_IMTYPE_MULTILAYER, - (m_rd->scemode & R_EXTENSION) != 0, + (rd_->scemode & R_EXTENSION) != 0, true, suffix); BLI_make_existing_file(filename); - for (unsigned int i = 0; i < m_layers.size(); i++) { - OutputOpenExrLayer &layer = m_layers[i]; + for (unsigned int i = 0; i < layers_.size(); i++) { + OutputOpenExrLayer &layer = layers_[i]; if (!layer.imageInput) { continue; /* skip unconnected sockets */ } add_exr_channels(exrhandle, - m_layers[i].name, - m_layers[i].datatype, + layers_[i].name, + layers_[i].datatype, "", width, - m_exr_half_float, - m_layers[i].outputBuffer); + exr_half_float_, + layers_[i].outputBuffer); } /* when the filename has no permissions, this can fail */ StampData *stamp_data = createStampData(); - if (IMB_exr_begin_write(exrhandle, filename, width, height, m_exr_codec, stamp_data)) { + if (IMB_exr_begin_write(exrhandle, filename, width, height, exr_codec_, stamp_data)) { IMB_exr_write_channels(exrhandle); } else { @@ -431,13 +431,13 @@ void OutputOpenExrMultiLayerOperation::deinitExecution() } IMB_exr_close(exrhandle); - for (unsigned int i = 0; i < m_layers.size(); i++) { - if (m_layers[i].outputBuffer) { - MEM_freeN(m_layers[i].outputBuffer); - m_layers[i].outputBuffer = nullptr; + for (unsigned int i = 0; i < layers_.size(); i++) { + if (layers_[i].outputBuffer) { + MEM_freeN(layers_[i].outputBuffer); + layers_[i].outputBuffer = nullptr; } - m_layers[i].imageInput = nullptr; + layers_[i].imageInput = nullptr; } BKE_stamp_data_free(stamp_data); } @@ -448,8 +448,8 @@ void OutputOpenExrMultiLayerOperation::update_memory_buffer_partial(MemoryBuffer Span<MemoryBuffer *> inputs) { const MemoryBuffer *input_image = inputs[0]; - for (int i = 0; i < m_layers.size(); i++) { - OutputOpenExrLayer &layer = m_layers[i]; + for (int i = 0; i < layers_.size(); i++) { + OutputOpenExrLayer &layer = layers_[i]; if (layer.outputBuffer) { MemoryBuffer output_buf(layer.outputBuffer, COM_data_type_num_channels(layer.datatype), diff --git a/source/blender/compositor/operations/COM_OutputFileOperation.h b/source/blender/compositor/operations/COM_OutputFileOperation.h index 057cee0c43e..e862b964431 100644 --- a/source/blender/compositor/operations/COM_OutputFileOperation.h +++ b/source/blender/compositor/operations/COM_OutputFileOperation.h @@ -32,21 +32,21 @@ namespace blender::compositor { /* Writes the image to a single-layer file. */ class OutputSingleLayerOperation : public MultiThreadedOperation { protected: - const RenderData *m_rd; - const bNodeTree *m_tree; + const RenderData *rd_; + const bNodeTree *tree_; - ImageFormatData *m_format; - char m_path[FILE_MAX]; + ImageFormatData *format_; + char path_[FILE_MAX]; - float *m_outputBuffer; - DataType m_datatype; - SocketReader *m_imageInput; + float *outputBuffer_; + DataType datatype_; + SocketReader *imageInput_; - const ColorManagedViewSettings *m_viewSettings; - const ColorManagedDisplaySettings *m_displaySettings; + const ColorManagedViewSettings *viewSettings_; + const ColorManagedDisplaySettings *displaySettings_; - const char *m_viewName; - bool m_saveAsRender; + const char *viewName_; + bool saveAsRender_; public: OutputSingleLayerOperation(const RenderData *rd, @@ -92,15 +92,15 @@ struct OutputOpenExrLayer { /* Writes inputs into OpenEXR multilayer channels. */ class OutputOpenExrMultiLayerOperation : public MultiThreadedOperation { protected: - const Scene *m_scene; - const RenderData *m_rd; - const bNodeTree *m_tree; - - char m_path[FILE_MAX]; - char m_exr_codec; - bool m_exr_half_float; - Vector<OutputOpenExrLayer> m_layers; - const char *m_viewName; + const Scene *scene_; + const RenderData *rd_; + const bNodeTree *tree_; + + char path_[FILE_MAX]; + char exr_codec_; + bool exr_half_float_; + Vector<OutputOpenExrLayer> layers_; + const char *viewName_; StampData *createStampData() const; diff --git a/source/blender/compositor/operations/COM_PixelateOperation.cc b/source/blender/compositor/operations/COM_PixelateOperation.cc index b9a18756550..0d6e906a4c3 100644 --- a/source/blender/compositor/operations/COM_PixelateOperation.cc +++ b/source/blender/compositor/operations/COM_PixelateOperation.cc @@ -25,17 +25,17 @@ PixelateOperation::PixelateOperation(DataType datatype) this->addInputSocket(datatype); this->addOutputSocket(datatype); this->set_canvas_input_index(0); - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void PixelateOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); } void PixelateOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void PixelateOperation::executePixelSampled(float output[4], @@ -45,7 +45,7 @@ void PixelateOperation::executePixelSampled(float output[4], { float nx = round(x); float ny = round(y); - m_inputOperation->readSampled(output, nx, ny, sampler); + inputOperation_->readSampled(output, nx, ny, sampler); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_PixelateOperation.h b/source/blender/compositor/operations/COM_PixelateOperation.h index e8b272853da..f8155e54f75 100644 --- a/source/blender/compositor/operations/COM_PixelateOperation.h +++ b/source/blender/compositor/operations/COM_PixelateOperation.h @@ -34,7 +34,7 @@ class PixelateOperation : public NodeOperation { /** * \brief cached reference to the input operation */ - SocketReader *m_inputOperation; + SocketReader *inputOperation_; public: /** diff --git a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cc b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cc index 92733186979..fbaab16efc2 100644 --- a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cc +++ b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cc @@ -134,7 +134,7 @@ static void read_input_corners(NodeOperation *op, const int first_input_idx, flo /* ******** PlaneCornerPinMaskOperation ******** */ -PlaneCornerPinMaskOperation::PlaneCornerPinMaskOperation() : m_corners_ready(false) +PlaneCornerPinMaskOperation::PlaneCornerPinMaskOperation() : corners_ready_(false) { addInputSocket(DataType::Vector); addInputSocket(DataType::Vector); @@ -182,7 +182,7 @@ void *PlaneCornerPinMaskOperation::initializeTileData(rcti *rect) * we don't have a nice generic system for that yet */ lockMutex(); - if (!m_corners_ready) { + if (!corners_ready_) { SocketReader *readers[4] = { getInputSocketReader(0), getInputSocketReader(1), @@ -193,7 +193,7 @@ void *PlaneCornerPinMaskOperation::initializeTileData(rcti *rect) readCornersFromSockets(rect, readers, corners); calculateCorners(corners, true, 0); - m_corners_ready = true; + corners_ready_ = true; } unlockMutex(); @@ -219,7 +219,7 @@ void PlaneCornerPinMaskOperation::get_area_of_interest(const int UNUSED(input_id /* ******** PlaneCornerPinWarpImageOperation ******** */ -PlaneCornerPinWarpImageOperation::PlaneCornerPinWarpImageOperation() : m_corners_ready(false) +PlaneCornerPinWarpImageOperation::PlaneCornerPinWarpImageOperation() : corners_ready_(false) { addInputSocket(DataType::Vector); addInputSocket(DataType::Vector); @@ -259,7 +259,7 @@ void *PlaneCornerPinWarpImageOperation::initializeTileData(rcti *rect) * we don't have a nice generic system for that yet */ lockMutex(); - if (!m_corners_ready) { + if (!corners_ready_) { /* corner sockets start at index 1 */ SocketReader *readers[4] = { getInputSocketReader(1), @@ -271,7 +271,7 @@ void *PlaneCornerPinWarpImageOperation::initializeTileData(rcti *rect) readCornersFromSockets(rect, readers, corners); calculateCorners(corners, true, 0); - m_corners_ready = true; + corners_ready_ = true; } unlockMutex(); diff --git a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.h b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.h index 7b3917923d2..211dcee5132 100644 --- a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.h +++ b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.h @@ -32,7 +32,7 @@ namespace blender::compositor { class PlaneCornerPinMaskOperation : public PlaneDistortMaskOperation { private: /* TODO(manzanilla): to be removed with tiled implementation. */ - bool m_corners_ready; + bool corners_ready_; public: PlaneCornerPinMaskOperation(); @@ -50,7 +50,7 @@ class PlaneCornerPinMaskOperation : public PlaneDistortMaskOperation { class PlaneCornerPinWarpImageOperation : public PlaneDistortWarpImageOperation { private: - bool m_corners_ready; + bool corners_ready_; public: PlaneCornerPinWarpImageOperation(); diff --git a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cc b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cc index 9bed0ca14cb..8cfa8715cc2 100644 --- a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cc +++ b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cc @@ -25,7 +25,7 @@ namespace blender::compositor { PlaneDistortBaseOperation::PlaneDistortBaseOperation() - : m_motion_blur_samples(1), m_motion_blur_shutter(0.5f) + : motion_blur_samples_(1), motion_blur_shutter_(0.5f) { } @@ -33,8 +33,8 @@ void PlaneDistortBaseOperation::calculateCorners(const float corners[4][2], bool normalized, int sample) { - BLI_assert(sample < m_motion_blur_samples); - MotionSample *sample_data = &m_samples[sample]; + BLI_assert(sample < motion_blur_samples_); + MotionSample *sample_data = &samples_[sample]; if (normalized) { for (int i = 0; i < 4; i++) { sample_data->frameSpaceCorners[i][0] = corners[i][0] * this->getWidth(); @@ -68,7 +68,7 @@ PlaneDistortWarpImageOperation::PlaneDistortWarpImageOperation() : PlaneDistortB { this->addInputSocket(DataType::Color, ResizeMode::Align); this->addOutputSocket(DataType::Color); - m_pixelReader = nullptr; + pixelReader_ = nullptr; this->flags.complex = true; } @@ -83,19 +83,19 @@ void PlaneDistortWarpImageOperation::calculateCorners(const float corners[4][2], const int height = image->getHeight(); float frame_corners[4][2] = { {0.0f, 0.0f}, {(float)width, 0.0f}, {(float)width, (float)height}, {0.0f, (float)height}}; - MotionSample *sample_data = &m_samples[sample]; + MotionSample *sample_data = &samples_[sample]; BKE_tracking_homography_between_two_quads( sample_data->frameSpaceCorners, frame_corners, sample_data->perspectiveMatrix); } void PlaneDistortWarpImageOperation::initExecution() { - m_pixelReader = this->getInputSocketReader(0); + pixelReader_ = this->getInputSocketReader(0); } void PlaneDistortWarpImageOperation::deinitExecution() { - m_pixelReader = nullptr; + pixelReader_ = nullptr; } void PlaneDistortWarpImageOperation::executePixelSampled(float output[4], @@ -105,19 +105,19 @@ void PlaneDistortWarpImageOperation::executePixelSampled(float output[4], { float uv[2]; float deriv[2][2]; - if (m_motion_blur_samples == 1) { - warpCoord(x, y, m_samples[0].perspectiveMatrix, uv, deriv); - m_pixelReader->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); + if (motion_blur_samples_ == 1) { + warpCoord(x, y, samples_[0].perspectiveMatrix, uv, deriv); + pixelReader_->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); } else { zero_v4(output); - for (int sample = 0; sample < m_motion_blur_samples; sample++) { + for (int sample = 0; sample < motion_blur_samples_; sample++) { float color[4]; - warpCoord(x, y, m_samples[sample].perspectiveMatrix, uv, deriv); - m_pixelReader->readFiltered(color, uv[0], uv[1], deriv[0], deriv[1]); + warpCoord(x, y, samples_[sample].perspectiveMatrix, uv, deriv); + pixelReader_->readFiltered(color, uv[0], uv[1], deriv[0], deriv[1]); add_v4_v4(output, color); } - mul_v4_fl(output, 1.0f / (float)m_motion_blur_samples); + mul_v4_fl(output, 1.0f / (float)motion_blur_samples_); } } @@ -129,22 +129,22 @@ void PlaneDistortWarpImageOperation::update_memory_buffer_partial(MemoryBuffer * float uv[2]; float deriv[2][2]; BuffersIterator<float> it = output->iterate_with({}, area); - if (m_motion_blur_samples == 1) { + if (motion_blur_samples_ == 1) { for (; !it.is_end(); ++it) { - warpCoord(it.x, it.y, m_samples[0].perspectiveMatrix, uv, deriv); + warpCoord(it.x, it.y, samples_[0].perspectiveMatrix, uv, deriv); input_img->read_elem_filtered(uv[0], uv[1], deriv[0], deriv[1], it.out); } } else { for (; !it.is_end(); ++it) { zero_v4(it.out); - for (const int sample : IndexRange(m_motion_blur_samples)) { + for (const int sample : IndexRange(motion_blur_samples_)) { float color[4]; - warpCoord(it.x, it.y, m_samples[sample].perspectiveMatrix, uv, deriv); + warpCoord(it.x, it.y, samples_[sample].perspectiveMatrix, uv, deriv); input_img->read_elem_filtered(uv[0], uv[1], deriv[0], deriv[1], color); add_v4_v4(it.out, color); } - mul_v4_fl(it.out, 1.0f / (float)m_motion_blur_samples); + mul_v4_fl(it.out, 1.0f / (float)motion_blur_samples_); } } } @@ -155,10 +155,10 @@ bool PlaneDistortWarpImageOperation::determineDependingAreaOfInterest( float min[2], max[2]; INIT_MINMAX2(min, max); - for (int sample = 0; sample < m_motion_blur_samples; sample++) { + for (int sample = 0; sample < motion_blur_samples_; sample++) { float UVs[4][2]; float deriv[2][2]; - MotionSample *sample_data = &m_samples[sample]; + MotionSample *sample_data = &samples_[sample]; /* TODO(sergey): figure out proper way to do this. */ warpCoord(input->xmin - 2, input->ymin - 2, sample_data->perspectiveMatrix, UVs[0], deriv); warpCoord(input->xmax + 2, input->ymin - 2, sample_data->perspectiveMatrix, UVs[1], deriv); @@ -196,10 +196,10 @@ void PlaneDistortWarpImageOperation::get_area_of_interest(const int input_idx, #if 0 float min[2], max[2]; INIT_MINMAX2(min, max); - for (int sample = 0; sample < m_motion_blur_samples; sample++) { + for (int sample = 0; sample < motion_blur_samples_; sample++) { float UVs[4][2]; float deriv[2][2]; - MotionSample *sample_data = &m_samples[sample]; + MotionSample *sample_data = &samples_[sample]; /* TODO(sergey): figure out proper way to do this. */ warpCoord( output_area.xmin - 2, output_area.ymin - 2, sample_data->perspectiveMatrix, UVs[0], deriv); @@ -228,12 +228,12 @@ PlaneDistortMaskOperation::PlaneDistortMaskOperation() : PlaneDistortBaseOperati addOutputSocket(DataType::Value); /* Currently hardcoded to 8 samples. */ - m_osa = 8; + osa_ = 8; } void PlaneDistortMaskOperation::initExecution() { - BLI_jitter_init(m_jitter, m_osa); + BLI_jitter_init(jitter_, osa_); } void PlaneDistortMaskOperation::executePixelSampled(float output[4], @@ -243,11 +243,11 @@ void PlaneDistortMaskOperation::executePixelSampled(float output[4], { float point[2]; int inside_counter = 0; - if (m_motion_blur_samples == 1) { - MotionSample *sample_data = &m_samples[0]; - for (int sample = 0; sample < m_osa; sample++) { - point[0] = x + m_jitter[sample][0]; - point[1] = y + m_jitter[sample][1]; + if (motion_blur_samples_ == 1) { + MotionSample *sample_data = &samples_[0]; + for (int sample = 0; sample < osa_; sample++) { + point[0] = x + jitter_[sample][0]; + point[1] = y + jitter_[sample][1]; if (isect_point_tri_v2(point, sample_data->frameSpaceCorners[0], sample_data->frameSpaceCorners[1], @@ -259,14 +259,14 @@ void PlaneDistortMaskOperation::executePixelSampled(float output[4], inside_counter++; } } - output[0] = (float)inside_counter / m_osa; + output[0] = (float)inside_counter / osa_; } else { - for (int motion_sample = 0; motion_sample < m_motion_blur_samples; motion_sample++) { - MotionSample *sample_data = &m_samples[motion_sample]; - for (int osa_sample = 0; osa_sample < m_osa; osa_sample++) { - point[0] = x + m_jitter[osa_sample][0]; - point[1] = y + m_jitter[osa_sample][1]; + for (int motion_sample = 0; motion_sample < motion_blur_samples_; motion_sample++) { + MotionSample *sample_data = &samples_[motion_sample]; + for (int osa_sample = 0; osa_sample < osa_; osa_sample++) { + point[0] = x + jitter_[osa_sample][0]; + point[1] = y + jitter_[osa_sample][1]; if (isect_point_tri_v2(point, sample_data->frameSpaceCorners[0], sample_data->frameSpaceCorners[1], @@ -279,7 +279,7 @@ void PlaneDistortMaskOperation::executePixelSampled(float output[4], } } } - output[0] = (float)inside_counter / (m_osa * m_motion_blur_samples); + output[0] = (float)inside_counter / (osa_ * motion_blur_samples_); } } @@ -289,11 +289,11 @@ void PlaneDistortMaskOperation::update_memory_buffer_partial(MemoryBuffer *outpu { for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { int inside_count = 0; - for (const int motion_sample : IndexRange(m_motion_blur_samples)) { - MotionSample &sample = m_samples[motion_sample]; + for (const int motion_sample : IndexRange(motion_blur_samples_)) { + MotionSample &sample = samples_[motion_sample]; inside_count += get_jitter_samples_inside_count(it.x, it.y, sample); } - *it.out = (float)inside_count / (m_osa * m_motion_blur_samples); + *it.out = (float)inside_count / (osa_ * motion_blur_samples_); } } @@ -303,9 +303,9 @@ int PlaneDistortMaskOperation::get_jitter_samples_inside_count(int x, { float point[2]; int inside_count = 0; - for (int sample = 0; sample < m_osa; sample++) { - point[0] = x + m_jitter[sample][0]; - point[1] = y + m_jitter[sample][1]; + for (int sample = 0; sample < osa_; sample++) { + point[0] = x + jitter_[sample][0]; + point[1] = y + jitter_[sample][1]; if (isect_point_tri_v2(point, sample_data.frameSpaceCorners[0], sample_data.frameSpaceCorners[1], diff --git a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h index 7b863d562ab..e9880624ebf 100644 --- a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h +++ b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h @@ -38,9 +38,9 @@ class PlaneDistortBaseOperation : public MultiThreadedOperation { float frameSpaceCorners[4][2]; /* Corners coordinates in pixel space. */ float perspectiveMatrix[3][3]; }; - MotionSample m_samples[PLANE_DISTORT_MAX_SAMPLES]; - int m_motion_blur_samples; - float m_motion_blur_shutter; + MotionSample samples_[PLANE_DISTORT_MAX_SAMPLES]; + int motion_blur_samples_; + float motion_blur_shutter_; public: PlaneDistortBaseOperation(); @@ -48,11 +48,11 @@ class PlaneDistortBaseOperation : public MultiThreadedOperation { void setMotionBlurSamples(int samples) { BLI_assert(samples <= PLANE_DISTORT_MAX_SAMPLES); - m_motion_blur_samples = samples; + motion_blur_samples_ = samples; } void setMotionBlurShutter(float shutter) { - m_motion_blur_shutter = shutter; + motion_blur_shutter_ = shutter; } virtual void calculateCorners(const float corners[4][2], bool normalized, int sample); @@ -63,7 +63,7 @@ class PlaneDistortBaseOperation : public MultiThreadedOperation { class PlaneDistortWarpImageOperation : public PlaneDistortBaseOperation { protected: - SocketReader *m_pixelReader; + SocketReader *pixelReader_; public: PlaneDistortWarpImageOperation(); @@ -87,8 +87,8 @@ class PlaneDistortWarpImageOperation : public PlaneDistortBaseOperation { class PlaneDistortMaskOperation : public PlaneDistortBaseOperation { protected: - int m_osa; - float m_jitter[32][2]; + int osa_; + float jitter_[32][2]; public: PlaneDistortMaskOperation(); diff --git a/source/blender/compositor/operations/COM_PlaneTrackOperation.cc b/source/blender/compositor/operations/COM_PlaneTrackOperation.cc index 64e31cc01e2..1f40556a935 100644 --- a/source/blender/compositor/operations/COM_PlaneTrackOperation.cc +++ b/source/blender/compositor/operations/COM_PlaneTrackOperation.cc @@ -27,25 +27,25 @@ namespace blender::compositor { PlaneTrackCommon::PlaneTrackCommon() { - m_movieClip = nullptr; - m_framenumber = 0; - m_trackingObjectName[0] = '\0'; - m_planeTrackName[0] = '\0'; + movieClip_ = nullptr; + framenumber_ = 0; + trackingObjectName_[0] = '\0'; + planeTrackName_[0] = '\0'; } void PlaneTrackCommon::read_and_calculate_corners(PlaneDistortBaseOperation *distort_op) { float corners[4][2]; - if (distort_op->m_motion_blur_samples == 1) { - readCornersFromTrack(corners, m_framenumber); + if (distort_op->motion_blur_samples_ == 1) { + readCornersFromTrack(corners, framenumber_); distort_op->calculateCorners(corners, true, 0); } else { - const float frame = (float)m_framenumber - distort_op->m_motion_blur_shutter; - const float frame_step = (distort_op->m_motion_blur_shutter * 2.0f) / - distort_op->m_motion_blur_samples; + const float frame = (float)framenumber_ - distort_op->motion_blur_shutter_; + const float frame_step = (distort_op->motion_blur_shutter_ * 2.0f) / + distort_op->motion_blur_samples_; float frame_iter = frame; - for (int sample = 0; sample < distort_op->m_motion_blur_samples; sample++) { + for (int sample = 0; sample < distort_op->motion_blur_samples_; sample++) { readCornersFromTrack(corners, frame_iter); distort_op->calculateCorners(corners, true, sample); frame_iter += frame_step; @@ -58,18 +58,18 @@ void PlaneTrackCommon::readCornersFromTrack(float corners[4][2], float frame) MovieTracking *tracking; MovieTrackingObject *object; - if (!m_movieClip) { + if (!movieClip_) { return; } - tracking = &m_movieClip->tracking; + tracking = &movieClip_->tracking; - object = BKE_tracking_object_get_named(tracking, m_trackingObjectName); + object = BKE_tracking_object_get_named(tracking, trackingObjectName_); if (object) { MovieTrackingPlaneTrack *plane_track; - plane_track = BKE_tracking_plane_track_get_named(tracking, object, m_planeTrackName); + plane_track = BKE_tracking_plane_track_get_named(tracking, object, planeTrackName_); if (plane_track) { - float clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(m_movieClip, frame); + float clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, frame); BKE_tracking_plane_marker_get_subframe_corners(plane_track, clip_framenr, corners); } } @@ -78,11 +78,11 @@ void PlaneTrackCommon::readCornersFromTrack(float corners[4][2], float frame) void PlaneTrackCommon::determine_canvas(const rcti &preferred_area, rcti &r_area) { r_area = COM_AREA_NONE; - if (m_movieClip) { + if (movieClip_) { int width, height; MovieClipUser user = {0}; - BKE_movieclip_user_set_frame(&user, m_framenumber); - BKE_movieclip_get_size(m_movieClip, &user, &width, &height); + BKE_movieclip_user_set_frame(&user, framenumber_); + BKE_movieclip_get_size(movieClip_, &user, &width, &height); r_area = preferred_area; r_area.xmax = r_area.xmin + width; r_area.ymax = r_area.ymin + height; diff --git a/source/blender/compositor/operations/COM_PlaneTrackOperation.h b/source/blender/compositor/operations/COM_PlaneTrackOperation.h index 1890195d14a..d3dbd092024 100644 --- a/source/blender/compositor/operations/COM_PlaneTrackOperation.h +++ b/source/blender/compositor/operations/COM_PlaneTrackOperation.h @@ -32,10 +32,10 @@ namespace blender::compositor { class PlaneTrackCommon { protected: - MovieClip *m_movieClip; - int m_framenumber; - char m_trackingObjectName[64]; - char m_planeTrackName[64]; + MovieClip *movieClip_; + int framenumber_; + char trackingObjectName_[64]; + char planeTrackName_[64]; /* NOTE: this class is not an operation itself (to prevent virtual inheritance issues) * implementation classes must make wrappers to use these methods, see below. @@ -48,19 +48,19 @@ class PlaneTrackCommon { void setMovieClip(MovieClip *clip) { - m_movieClip = clip; + movieClip_ = clip; } void setTrackingObject(char *object) { - BLI_strncpy(m_trackingObjectName, object, sizeof(m_trackingObjectName)); + BLI_strncpy(trackingObjectName_, object, sizeof(trackingObjectName_)); } void setPlaneTrackName(char *plane_track) { - BLI_strncpy(m_planeTrackName, plane_track, sizeof(m_planeTrackName)); + BLI_strncpy(planeTrackName_, plane_track, sizeof(planeTrackName_)); } void setFramenumber(int framenumber) { - m_framenumber = framenumber; + framenumber_ = framenumber; } private: diff --git a/source/blender/compositor/operations/COM_PosterizeOperation.cc b/source/blender/compositor/operations/COM_PosterizeOperation.cc index dd1c5cae1bb..44a86f1d9de 100644 --- a/source/blender/compositor/operations/COM_PosterizeOperation.cc +++ b/source/blender/compositor/operations/COM_PosterizeOperation.cc @@ -25,15 +25,15 @@ PosterizeOperation::PosterizeOperation() this->addInputSocket(DataType::Color); this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputProgram = nullptr; - m_inputStepsProgram = nullptr; + inputProgram_ = nullptr; + inputStepsProgram_ = nullptr; flags.can_be_constant = true; } void PosterizeOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); - m_inputStepsProgram = this->getInputSocketReader(1); + inputProgram_ = this->getInputSocketReader(0); + inputStepsProgram_ = this->getInputSocketReader(1); } void PosterizeOperation::executePixelSampled(float output[4], @@ -44,8 +44,8 @@ void PosterizeOperation::executePixelSampled(float output[4], float inputValue[4]; float inputSteps[4]; - m_inputProgram->readSampled(inputValue, x, y, sampler); - m_inputStepsProgram->readSampled(inputSteps, x, y, sampler); + inputProgram_->readSampled(inputValue, x, y, sampler); + inputStepsProgram_->readSampled(inputSteps, x, y, sampler); CLAMP(inputSteps[0], 2.0f, 1024.0f); const float steps_inv = 1.0f / inputSteps[0]; @@ -75,8 +75,8 @@ void PosterizeOperation::update_memory_buffer_partial(MemoryBuffer *output, void PosterizeOperation::deinitExecution() { - m_inputProgram = nullptr; - m_inputStepsProgram = nullptr; + inputProgram_ = nullptr; + inputStepsProgram_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_PosterizeOperation.h b/source/blender/compositor/operations/COM_PosterizeOperation.h index c625cbb83c6..58ce599c6fe 100644 --- a/source/blender/compositor/operations/COM_PosterizeOperation.h +++ b/source/blender/compositor/operations/COM_PosterizeOperation.h @@ -27,8 +27,8 @@ class PosterizeOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; - SocketReader *m_inputStepsProgram; + SocketReader *inputProgram_; + SocketReader *inputStepsProgram_; public: PosterizeOperation(); diff --git a/source/blender/compositor/operations/COM_PreviewOperation.cc b/source/blender/compositor/operations/COM_PreviewOperation.cc index 707706a9d07..960cfda9ec0 100644 --- a/source/blender/compositor/operations/COM_PreviewOperation.cc +++ b/source/blender/compositor/operations/COM_PreviewOperation.cc @@ -30,14 +30,14 @@ PreviewOperation::PreviewOperation(const ColorManagedViewSettings *viewSettings, { this->addInputSocket(DataType::Color, ResizeMode::Align); - m_preview = nullptr; - m_outputBuffer = nullptr; - m_input = nullptr; - m_divider = 1.0f; - m_viewSettings = viewSettings; - m_displaySettings = displaySettings; - m_defaultWidth = defaultWidth; - m_defaultHeight = defaultHeight; + preview_ = nullptr; + outputBuffer_ = nullptr; + input_ = nullptr; + divider_ = 1.0f; + viewSettings_ = viewSettings; + displaySettings_ = displaySettings; + defaultWidth_ = defaultWidth; + defaultHeight_ = defaultHeight; flags.use_viewer_border = true; flags.is_preview_operation = true; } @@ -47,34 +47,34 @@ void PreviewOperation::verifyPreview(bNodeInstanceHash *previews, bNodeInstanceK /* Size (0, 0) ensures the preview rect is not allocated in advance, * this is set later in initExecution once the resolution is determined. */ - m_preview = BKE_node_preview_verify(previews, key, 0, 0, true); + preview_ = BKE_node_preview_verify(previews, key, 0, 0, true); } void PreviewOperation::initExecution() { - m_input = getInputSocketReader(0); + input_ = getInputSocketReader(0); - if (this->getWidth() == (unsigned int)m_preview->xsize && - this->getHeight() == (unsigned int)m_preview->ysize) { - m_outputBuffer = m_preview->rect; + if (this->getWidth() == (unsigned int)preview_->xsize && + this->getHeight() == (unsigned int)preview_->ysize) { + outputBuffer_ = preview_->rect; } - if (m_outputBuffer == nullptr) { - m_outputBuffer = (unsigned char *)MEM_callocN( + if (outputBuffer_ == nullptr) { + outputBuffer_ = (unsigned char *)MEM_callocN( sizeof(unsigned char) * 4 * getWidth() * getHeight(), "PreviewOperation"); - if (m_preview->rect) { - MEM_freeN(m_preview->rect); + if (preview_->rect) { + MEM_freeN(preview_->rect); } - m_preview->xsize = getWidth(); - m_preview->ysize = getHeight(); - m_preview->rect = m_outputBuffer; + preview_->xsize = getWidth(); + preview_->ysize = getHeight(); + preview_->rect = outputBuffer_; } } void PreviewOperation::deinitExecution() { - m_outputBuffer = nullptr; - m_input = nullptr; + outputBuffer_ = nullptr; + input_ = nullptr; } void PreviewOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) @@ -83,21 +83,21 @@ void PreviewOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) float color[4]; struct ColormanageProcessor *cm_processor; - cm_processor = IMB_colormanagement_display_processor_new(m_viewSettings, m_displaySettings); + cm_processor = IMB_colormanagement_display_processor_new(viewSettings_, displaySettings_); for (int y = rect->ymin; y < rect->ymax; y++) { offset = (y * getWidth() + rect->xmin) * 4; for (int x = rect->xmin; x < rect->xmax; x++) { - float rx = floor(x / m_divider); - float ry = floor(y / m_divider); + float rx = floor(x / divider_); + float ry = floor(y / divider_); color[0] = 0.0f; color[1] = 0.0f; color[2] = 0.0f; color[3] = 1.0f; - m_input->readSampled(color, rx, ry, PixelSampler::Nearest); + input_->readSampled(color, rx, ry, PixelSampler::Nearest); IMB_colormanagement_processor_apply_v4(cm_processor, color); - rgba_float_to_uchar(m_outputBuffer + offset, color); + rgba_float_to_uchar(outputBuffer_ + offset, color); offset += 4; } } @@ -110,10 +110,10 @@ bool PreviewOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - newInput.xmin = input->xmin / m_divider; - newInput.xmax = input->xmax / m_divider; - newInput.ymin = input->ymin / m_divider; - newInput.ymax = input->ymax / m_divider; + newInput.xmin = input->xmin / divider_; + newInput.xmax = input->xmax / divider_; + newInput.ymin = input->ymin / divider_; + newInput.ymax = input->ymax / divider_; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -121,9 +121,9 @@ void PreviewOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti { /* Use default preview resolution as preferred ensuring it has size so that * generated inputs (which don't have resolution on their own) are displayed */ - BLI_assert(m_defaultWidth > 0 && m_defaultHeight > 0); + BLI_assert(defaultWidth_ > 0 && defaultHeight_ > 0); rcti local_preferred; - BLI_rcti_init(&local_preferred, 0, m_defaultWidth, 0, m_defaultHeight); + BLI_rcti_init(&local_preferred, 0, defaultWidth_, 0, defaultHeight_); NodeOperation::determine_canvas(local_preferred, r_area); /* If resolution is 0 there are two possible scenarios: @@ -137,17 +137,17 @@ void PreviewOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti */ int width = BLI_rcti_size_x(&r_area); int height = BLI_rcti_size_y(&r_area); - m_divider = 0.0f; + divider_ = 0.0f; if (width > 0 && height > 0) { if (width > height) { - m_divider = (float)COM_PREVIEW_SIZE / (width); + divider_ = (float)COM_PREVIEW_SIZE / (width); } else { - m_divider = (float)COM_PREVIEW_SIZE / (height); + divider_ = (float)COM_PREVIEW_SIZE / (height); } } - width = width * m_divider; - height = height * m_divider; + width = width * divider_; + height = height * divider_; BLI_rcti_init(&r_area, r_area.xmin, r_area.xmin + width, r_area.ymin, r_area.ymin + height); } @@ -164,10 +164,10 @@ void PreviewOperation::get_area_of_interest(const int input_idx, BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - r_input_area.xmin = output_area.xmin / m_divider; - r_input_area.xmax = output_area.xmax / m_divider; - r_input_area.ymin = output_area.ymin / m_divider; - r_input_area.ymax = output_area.ymax / m_divider; + r_input_area.xmin = output_area.xmin / divider_; + r_input_area.xmax = output_area.xmax / divider_; + r_input_area.ymin = output_area.ymin / divider_; + r_input_area.ymax = output_area.ymax / divider_; } void PreviewOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output), @@ -176,16 +176,16 @@ void PreviewOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output) { MemoryBuffer *input = inputs[0]; struct ColormanageProcessor *cm_processor = IMB_colormanagement_display_processor_new( - m_viewSettings, m_displaySettings); + viewSettings_, displaySettings_); rcti buffer_area; BLI_rcti_init(&buffer_area, 0, this->getWidth(), 0, this->getHeight()); BuffersIteratorBuilder<uchar> it_builder( - m_outputBuffer, buffer_area, area, COM_data_type_num_channels(DataType::Color)); + outputBuffer_, buffer_area, area, COM_data_type_num_channels(DataType::Color)); for (BuffersIterator<uchar> it = it_builder.build(); !it.is_end(); ++it) { - const float rx = it.x / m_divider; - const float ry = it.y / m_divider; + const float rx = it.x / divider_; + const float ry = it.y / divider_; float color[4]; input->read_elem_checked(rx, ry, color); diff --git a/source/blender/compositor/operations/COM_PreviewOperation.h b/source/blender/compositor/operations/COM_PreviewOperation.h index 4bd0f07d882..1df8815d62b 100644 --- a/source/blender/compositor/operations/COM_PreviewOperation.h +++ b/source/blender/compositor/operations/COM_PreviewOperation.h @@ -28,19 +28,19 @@ namespace blender::compositor { class PreviewOperation : public MultiThreadedOperation { protected: - unsigned char *m_outputBuffer; + unsigned char *outputBuffer_; /** * \brief holds reference to the SDNA bNode, where this nodes will render the preview image for */ - bNodePreview *m_preview; - SocketReader *m_input; - float m_divider; - unsigned int m_defaultWidth; - unsigned int m_defaultHeight; + bNodePreview *preview_; + SocketReader *input_; + float divider_; + unsigned int defaultWidth_; + unsigned int defaultHeight_; - const ColorManagedViewSettings *m_viewSettings; - const ColorManagedDisplaySettings *m_displaySettings; + const ColorManagedViewSettings *viewSettings_; + const ColorManagedDisplaySettings *displaySettings_; public: PreviewOperation(const ColorManagedViewSettings *viewSettings, diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc index d2d5581deb2..8e6aa7e8db8 100644 --- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc +++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc @@ -27,9 +27,9 @@ ProjectorLensDistortionOperation::ProjectorLensDistortionOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_inputProgram = nullptr; - m_dispersionAvailable = false; - m_dispersion = 0.0f; + inputProgram_ = nullptr; + dispersionAvailable_ = false; + dispersion_ = 0.0f; } void ProjectorLensDistortionOperation::init_data() @@ -37,23 +37,23 @@ void ProjectorLensDistortionOperation::init_data() if (execution_model_ == eExecutionModel::FullFrame) { NodeOperation *dispersion_input = get_input_operation(1); if (dispersion_input->get_flags().is_constant_operation) { - m_dispersion = static_cast<ConstantOperation *>(dispersion_input)->get_constant_elem()[0]; + dispersion_ = static_cast<ConstantOperation *>(dispersion_input)->get_constant_elem()[0]; } - m_kr = 0.25f * max_ff(min_ff(m_dispersion, 1.0f), 0.0f); - m_kr2 = m_kr * 20; + kr_ = 0.25f * max_ff(min_ff(dispersion_, 1.0f), 0.0f); + kr2_ = kr_ * 20; } } void ProjectorLensDistortionOperation::initExecution() { this->initMutex(); - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void *ProjectorLensDistortionOperation::initializeTileData(rcti * /*rect*/) { updateDispersion(); - void *buffer = m_inputProgram->initializeTileData(nullptr); + void *buffer = inputProgram_->initializeTileData(nullptr); return buffer; } @@ -65,11 +65,11 @@ void ProjectorLensDistortionOperation::executePixel(float output[4], int x, int const float v = (y + 0.5f) / height; const float u = (x + 0.5f) / width; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - inputBuffer->readBilinear(inputValue, (u * width + m_kr2) - 0.5f, v * height - 0.5f); + inputBuffer->readBilinear(inputValue, (u * width + kr2_) - 0.5f, v * height - 0.5f); output[0] = inputValue[0]; inputBuffer->read(inputValue, x, y); output[1] = inputValue[1]; - inputBuffer->readBilinear(inputValue, (u * width - m_kr2) - 0.5f, v * height - 0.5f); + inputBuffer->readBilinear(inputValue, (u * width - kr2_) - 0.5f, v * height - 0.5f); output[2] = inputValue[2]; output[3] = 1.0f; } @@ -77,18 +77,18 @@ void ProjectorLensDistortionOperation::executePixel(float output[4], int x, int void ProjectorLensDistortionOperation::deinitExecution() { this->deinitMutex(); - m_inputProgram = nullptr; + inputProgram_ = nullptr; } bool ProjectorLensDistortionOperation::determineDependingAreaOfInterest( rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newInput; - if (m_dispersionAvailable) { + if (dispersionAvailable_) { newInput.ymax = input->ymax; newInput.ymin = input->ymin; - newInput.xmin = input->xmin - m_kr2 - 2; - newInput.xmax = input->xmax + m_kr2 + 2; + newInput.xmin = input->xmin - kr2_ - 2; + newInput.xmax = input->xmax + kr2_ + 2; } else { rcti dispInput; @@ -112,17 +112,17 @@ bool ProjectorLensDistortionOperation::determineDependingAreaOfInterest( /* TODO(manzanilla): to be removed with tiled implementation. */ void ProjectorLensDistortionOperation::updateDispersion() { - if (m_dispersionAvailable) { + if (dispersionAvailable_) { return; } this->lockMutex(); - if (!m_dispersionAvailable) { + if (!dispersionAvailable_) { float result[4]; this->getInputSocketReader(1)->readSampled(result, 1, 1, PixelSampler::Nearest); - m_dispersion = result[0]; - m_kr = 0.25f * max_ff(min_ff(m_dispersion, 1.0f), 0.0f); - m_kr2 = m_kr * 20; - m_dispersionAvailable = true; + dispersion_ = result[0]; + kr_ = 0.25f * max_ff(min_ff(dispersion_, 1.0f), 0.0f); + kr2_ = kr_ * 20; + dispersionAvailable_ = true; } this->unlockMutex(); } @@ -156,8 +156,8 @@ void ProjectorLensDistortionOperation::get_area_of_interest(const int input_idx, r_input_area.ymax = output_area.ymax; r_input_area.ymin = output_area.ymin; - r_input_area.xmin = output_area.xmin - m_kr2 - 2; - r_input_area.xmax = output_area.xmax + m_kr2 + 2; + r_input_area.xmin = output_area.xmin - kr2_ - 2; + r_input_area.xmax = output_area.xmax + kr2_ + 2; } void ProjectorLensDistortionOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -171,11 +171,11 @@ void ProjectorLensDistortionOperation::update_memory_buffer_partial(MemoryBuffer for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { const float v = (it.y + 0.5f) / height; const float u = (it.x + 0.5f) / width; - input_image->read_elem_bilinear((u * width + m_kr2) - 0.5f, v * height - 0.5f, color); + input_image->read_elem_bilinear((u * width + kr2_) - 0.5f, v * height - 0.5f, color); it.out[0] = color[0]; input_image->read_elem(it.x, it.y, color); it.out[1] = color[1]; - input_image->read_elem_bilinear((u * width - m_kr2) - 0.5f, v * height - 0.5f, color); + input_image->read_elem_bilinear((u * width - kr2_) - 0.5f, v * height - 0.5f, color); it.out[2] = color[2]; it.out[3] = 1.0f; } diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h index b42fa3a361c..af9b216db07 100644 --- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h +++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h @@ -28,13 +28,13 @@ class ProjectorLensDistortionOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; - float m_dispersion; + float dispersion_; /* TODO(manzanilla): to be removed with tiled implementation. */ - bool m_dispersionAvailable; + bool dispersionAvailable_; - float m_kr, m_kr2; + float kr_, kr2_; public: ProjectorLensDistortionOperation(); diff --git a/source/blender/compositor/operations/COM_QualityStepHelper.cc b/source/blender/compositor/operations/COM_QualityStepHelper.cc index 77d5afa93e0..a45c7ab552c 100644 --- a/source/blender/compositor/operations/COM_QualityStepHelper.cc +++ b/source/blender/compositor/operations/COM_QualityStepHelper.cc @@ -22,45 +22,45 @@ namespace blender::compositor { QualityStepHelper::QualityStepHelper() { - m_quality = eCompositorQuality::High; - m_step = 1; - m_offsetadd = 4; + quality_ = eCompositorQuality::High; + step_ = 1; + offsetadd_ = 4; } void QualityStepHelper::initExecution(QualityHelper helper) { switch (helper) { case COM_QH_INCREASE: - switch (m_quality) { + switch (quality_) { case eCompositorQuality::High: default: - m_step = 1; - m_offsetadd = 1; + step_ = 1; + offsetadd_ = 1; break; case eCompositorQuality::Medium: - m_step = 2; - m_offsetadd = 2; + step_ = 2; + offsetadd_ = 2; break; case eCompositorQuality::Low: - m_step = 3; - m_offsetadd = 3; + step_ = 3; + offsetadd_ = 3; break; } break; case COM_QH_MULTIPLY: - switch (m_quality) { + switch (quality_) { case eCompositorQuality::High: default: - m_step = 1; - m_offsetadd = 4; + step_ = 1; + offsetadd_ = 4; break; case eCompositorQuality::Medium: - m_step = 2; - m_offsetadd = 8; + step_ = 2; + offsetadd_ = 8; break; case eCompositorQuality::Low: - m_step = 4; - m_offsetadd = 16; + step_ = 4; + offsetadd_ = 16; break; } break; diff --git a/source/blender/compositor/operations/COM_QualityStepHelper.h b/source/blender/compositor/operations/COM_QualityStepHelper.h index 08ebf33cdeb..5c59f4d2a37 100644 --- a/source/blender/compositor/operations/COM_QualityStepHelper.h +++ b/source/blender/compositor/operations/COM_QualityStepHelper.h @@ -29,9 +29,9 @@ typedef enum QualityHelper { class QualityStepHelper { private: - eCompositorQuality m_quality; - int m_step; - int m_offsetadd; + eCompositorQuality quality_; + int step_; + int offsetadd_; protected: /** @@ -41,11 +41,11 @@ class QualityStepHelper { inline int getStep() const { - return m_step; + return step_; } inline int getOffsetAdd() const { - return m_offsetadd; + return offsetadd_; } public: @@ -53,7 +53,7 @@ class QualityStepHelper { void setQuality(eCompositorQuality quality) { - m_quality = quality; + quality_ = quality; } }; diff --git a/source/blender/compositor/operations/COM_ReadBufferOperation.cc b/source/blender/compositor/operations/COM_ReadBufferOperation.cc index 4e542488eb0..9fe800021e7 100644 --- a/source/blender/compositor/operations/COM_ReadBufferOperation.cc +++ b/source/blender/compositor/operations/COM_ReadBufferOperation.cc @@ -26,32 +26,32 @@ namespace blender::compositor { ReadBufferOperation::ReadBufferOperation(DataType datatype) { this->addOutputSocket(datatype); - m_single_value = false; - m_offset = 0; - m_buffer = nullptr; + single_value_ = false; + offset_ = 0; + buffer_ = nullptr; flags.is_read_buffer_operation = true; } void *ReadBufferOperation::initializeTileData(rcti * /*rect*/) { - return m_buffer; + return buffer_; } void ReadBufferOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { - if (m_memoryProxy != nullptr) { - WriteBufferOperation *operation = m_memoryProxy->getWriteBufferOperation(); + if (memoryProxy_ != nullptr) { + WriteBufferOperation *operation = memoryProxy_->getWriteBufferOperation(); operation->determine_canvas(preferred_area, r_area); operation->set_canvas(r_area); /** \todo may not occur! But does with blur node. */ - if (m_memoryProxy->getExecutor()) { + if (memoryProxy_->getExecutor()) { uint resolution[2] = {static_cast<uint>(BLI_rcti_size_x(&r_area)), static_cast<uint>(BLI_rcti_size_y(&r_area))}; - m_memoryProxy->getExecutor()->setResolution(resolution); + memoryProxy_->getExecutor()->setResolution(resolution); } - m_single_value = operation->isSingleValue(); + single_value_ = operation->isSingleValue(); } } void ReadBufferOperation::executePixelSampled(float output[4], @@ -59,21 +59,21 @@ void ReadBufferOperation::executePixelSampled(float output[4], float y, PixelSampler sampler) { - if (m_single_value) { + if (single_value_) { /* write buffer has a single value stored at (0,0) */ - m_buffer->read(output, 0, 0); + buffer_->read(output, 0, 0); } else { switch (sampler) { case PixelSampler::Nearest: - m_buffer->read(output, x, y); + buffer_->read(output, x, y); break; case PixelSampler::Bilinear: default: - m_buffer->readBilinear(output, x, y); + buffer_->readBilinear(output, x, y); break; case PixelSampler::Bicubic: - m_buffer->readBilinear(output, x, y); + buffer_->readBilinear(output, x, y); break; } } @@ -86,29 +86,29 @@ void ReadBufferOperation::executePixelExtend(float output[4], MemoryBufferExtend extend_x, MemoryBufferExtend extend_y) { - if (m_single_value) { + if (single_value_) { /* write buffer has a single value stored at (0,0) */ - m_buffer->read(output, 0, 0); + buffer_->read(output, 0, 0); } else if (sampler == PixelSampler::Nearest) { - m_buffer->read(output, x, y, extend_x, extend_y); + buffer_->read(output, x, y, extend_x, extend_y); } else { - m_buffer->readBilinear(output, x, y, extend_x, extend_y); + buffer_->readBilinear(output, x, y, extend_x, extend_y); } } void ReadBufferOperation::executePixelFiltered( float output[4], float x, float y, float dx[2], float dy[2]) { - if (m_single_value) { + if (single_value_) { /* write buffer has a single value stored at (0,0) */ - m_buffer->read(output, 0, 0); + buffer_->read(output, 0, 0); } else { const float uv[2] = {x, y}; const float deriv[2][2] = {{dx[0], dx[1]}, {dy[0], dy[1]}}; - m_buffer->readEWA(output, uv, deriv); + buffer_->readEWA(output, uv, deriv); } } @@ -125,8 +125,8 @@ bool ReadBufferOperation::determineDependingAreaOfInterest(rcti *input, void ReadBufferOperation::readResolutionFromWriteBuffer() { - if (m_memoryProxy != nullptr) { - WriteBufferOperation *operation = m_memoryProxy->getWriteBufferOperation(); + if (memoryProxy_ != nullptr) { + WriteBufferOperation *operation = memoryProxy_->getWriteBufferOperation(); this->setWidth(operation->getWidth()); this->setHeight(operation->getHeight()); } @@ -134,7 +134,7 @@ void ReadBufferOperation::readResolutionFromWriteBuffer() void ReadBufferOperation::updateMemoryBuffer() { - m_buffer = this->getMemoryProxy()->getBuffer(); + buffer_ = this->getMemoryProxy()->getBuffer(); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ReadBufferOperation.h b/source/blender/compositor/operations/COM_ReadBufferOperation.h index d4a8fe19761..f4504e11f48 100644 --- a/source/blender/compositor/operations/COM_ReadBufferOperation.h +++ b/source/blender/compositor/operations/COM_ReadBufferOperation.h @@ -26,21 +26,21 @@ namespace blender::compositor { class ReadBufferOperation : public NodeOperation { private: - MemoryProxy *m_memoryProxy; - bool m_single_value; /* single value stored in buffer, copied from associated write operation */ - unsigned int m_offset; - MemoryBuffer *m_buffer; + MemoryProxy *memoryProxy_; + bool single_value_; /* single value stored in buffer, copied from associated write operation */ + unsigned int offset_; + MemoryBuffer *buffer_; public: ReadBufferOperation(DataType datatype); void setMemoryProxy(MemoryProxy *memoryProxy) { - m_memoryProxy = memoryProxy; + memoryProxy_ = memoryProxy; } MemoryProxy *getMemoryProxy() const { - return m_memoryProxy; + return memoryProxy_; } void determine_canvas(const rcti &preferred_area, rcti &r_area) override; @@ -56,18 +56,18 @@ class ReadBufferOperation : public NodeOperation { void executePixelFiltered(float output[4], float x, float y, float dx[2], float dy[2]) override; void setOffset(unsigned int offset) { - m_offset = offset; + offset_ = offset; } unsigned int getOffset() const { - return m_offset; + return offset_; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) override; MemoryBuffer *getInputMemoryBuffer(MemoryBuffer **memoryBuffers) override { - return memoryBuffers[m_offset]; + return memoryBuffers[offset_]; } void readResolutionFromWriteBuffer(); void updateMemoryBuffer(); diff --git a/source/blender/compositor/operations/COM_RenderLayersProg.cc b/source/blender/compositor/operations/COM_RenderLayersProg.cc index 1291c85b4ad..02a278899bb 100644 --- a/source/blender/compositor/operations/COM_RenderLayersProg.cc +++ b/source/blender/compositor/operations/COM_RenderLayersProg.cc @@ -25,12 +25,12 @@ namespace blender::compositor { /* ******** Render Layers Base Prog ******** */ RenderLayersProg::RenderLayersProg(const char *passName, DataType type, int elementsize) - : m_passName(passName) + : passName_(passName) { this->setScene(nullptr); - m_inputBuffer = nullptr; - m_elementsize = elementsize; - m_rd = nullptr; + inputBuffer_ = nullptr; + elementsize_ = elementsize; + rd_ = nullptr; layer_buffer_ = nullptr; this->addOutputSocket(type); @@ -52,9 +52,9 @@ void RenderLayersProg::initExecution() RenderLayer *rl = RE_GetRenderLayer(rr, view_layer->name); if (rl) { - m_inputBuffer = RE_RenderLayerGetPass(rl, m_passName.c_str(), m_viewName); - if (m_inputBuffer) { - layer_buffer_ = new MemoryBuffer(m_inputBuffer, m_elementsize, getWidth(), getHeight()); + inputBuffer_ = RE_RenderLayerGetPass(rl, passName_.c_str(), viewName_); + if (inputBuffer_) { + layer_buffer_ = new MemoryBuffer(inputBuffer_, elementsize_, getWidth(), getHeight()); } } } @@ -72,10 +72,10 @@ void RenderLayersProg::doInterpolation(float output[4], float x, float y, PixelS int ix = x, iy = y; if (ix < 0 || iy < 0 || ix >= width || iy >= height) { - if (m_elementsize == 1) { + if (elementsize_ == 1) { output[0] = 0.0f; } - else if (m_elementsize == 3) { + else if (elementsize_ == 3) { zero_v3(output); } else { @@ -86,26 +86,26 @@ void RenderLayersProg::doInterpolation(float output[4], float x, float y, PixelS switch (sampler) { case PixelSampler::Nearest: { - offset = (iy * width + ix) * m_elementsize; + offset = (iy * width + ix) * elementsize_; - if (m_elementsize == 1) { - output[0] = m_inputBuffer[offset]; + if (elementsize_ == 1) { + output[0] = inputBuffer_[offset]; } - else if (m_elementsize == 3) { - copy_v3_v3(output, &m_inputBuffer[offset]); + else if (elementsize_ == 3) { + copy_v3_v3(output, &inputBuffer_[offset]); } else { - copy_v4_v4(output, &m_inputBuffer[offset]); + copy_v4_v4(output, &inputBuffer_[offset]); } break; } case PixelSampler::Bilinear: - BLI_bilinear_interpolation_fl(m_inputBuffer, output, width, height, m_elementsize, x, y); + BLI_bilinear_interpolation_fl(inputBuffer_, output, width, height, elementsize_, x, y); break; case PixelSampler::Bicubic: - BLI_bicubic_interpolation_fl(m_inputBuffer, output, width, height, m_elementsize, x, y); + BLI_bicubic_interpolation_fl(inputBuffer_, output, width, height, elementsize_, x, y); break; } } @@ -113,7 +113,7 @@ void RenderLayersProg::doInterpolation(float output[4], float x, float y, PixelS void RenderLayersProg::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) { #if 0 - const RenderData *rd = m_rd; + const RenderData *rd = rd_; int dx = 0, dy = 0; @@ -135,7 +135,7 @@ void RenderLayersProg::executePixelSampled(float output[4], float x, float y, Pi #ifndef NDEBUG { const DataType data_type = this->getOutputSocket()->getDataType(); - int actual_element_size = m_elementsize; + int actual_element_size = elementsize_; int expected_element_size; if (data_type == DataType::Value) { expected_element_size = 1; @@ -154,8 +154,8 @@ void RenderLayersProg::executePixelSampled(float output[4], float x, float y, Pi } #endif - if (m_inputBuffer == nullptr) { - int elemsize = m_elementsize; + if (inputBuffer_ == nullptr) { + int elemsize = elementsize_; if (elemsize == 1) { output[0] = 0.0f; } @@ -174,7 +174,7 @@ void RenderLayersProg::executePixelSampled(float output[4], float x, float y, Pi void RenderLayersProg::deinitExecution() { - m_inputBuffer = nullptr; + inputBuffer_ = nullptr; if (layer_buffer_) { delete layer_buffer_; layer_buffer_ = nullptr; @@ -225,7 +225,7 @@ std::unique_ptr<MetaData> RenderLayersProg::getMetaData() std::string full_layer_name = std::string( view_layer->name, BLI_strnlen(view_layer->name, sizeof(view_layer->name))) + - "." + m_passName; + "." + passName_; blender::StringRef cryptomatte_layer_name = blender::bke::cryptomatte::BKE_cryptomatte_extract_layer_name(full_layer_name); callback_data.setCryptomatteKeys(cryptomatte_layer_name); @@ -249,13 +249,13 @@ void RenderLayersProg::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs)) { - BLI_assert(output->get_num_channels() >= m_elementsize); + BLI_assert(output->get_num_channels() >= elementsize_); if (layer_buffer_) { - output->copy_from(layer_buffer_, area, 0, m_elementsize, 0); + output->copy_from(layer_buffer_, area, 0, elementsize_, 0); } else { - std::unique_ptr<float[]> zero_elem = std::make_unique<float[]>(m_elementsize); - output->fill(area, 0, zero_elem.get(), m_elementsize); + std::unique_ptr<float[]> zero_elem = std::make_unique<float[]>(elementsize_); + output->fill(area, 0, zero_elem.get(), elementsize_); } } @@ -280,7 +280,7 @@ void RenderLayersAOOperation::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> UNUSED(inputs)) { BLI_assert(output->get_num_channels() == COM_DATA_TYPE_COLOR_CHANNELS); - BLI_assert(m_elementsize == COM_DATA_TYPE_COLOR_CHANNELS); + BLI_assert(elementsize_ == COM_DATA_TYPE_COLOR_CHANNELS); if (layer_buffer_) { output->copy_from(layer_buffer_, area, 0, COM_DATA_TYPE_VECTOR_CHANNELS, 0); } @@ -313,7 +313,7 @@ void RenderLayersAlphaProg::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> UNUSED(inputs)) { BLI_assert(output->get_num_channels() == COM_DATA_TYPE_VALUE_CHANNELS); - BLI_assert(m_elementsize == COM_DATA_TYPE_COLOR_CHANNELS); + BLI_assert(elementsize_ == COM_DATA_TYPE_COLOR_CHANNELS); if (layer_buffer_) { output->copy_from(layer_buffer_, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0); } @@ -347,7 +347,7 @@ void RenderLayersDepthProg::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> UNUSED(inputs)) { BLI_assert(output->get_num_channels() == COM_DATA_TYPE_VALUE_CHANNELS); - BLI_assert(m_elementsize == COM_DATA_TYPE_VALUE_CHANNELS); + BLI_assert(elementsize_ == COM_DATA_TYPE_VALUE_CHANNELS); if (layer_buffer_) { output->copy_from(layer_buffer_, area); } diff --git a/source/blender/compositor/operations/COM_RenderLayersProg.h b/source/blender/compositor/operations/COM_RenderLayersProg.h index 0be21d8aad7..14fc3babe32 100644 --- a/source/blender/compositor/operations/COM_RenderLayersProg.h +++ b/source/blender/compositor/operations/COM_RenderLayersProg.h @@ -38,17 +38,17 @@ class RenderLayersProg : public MultiThreadedOperation { /** * Reference to the scene object. */ - Scene *m_scene; + Scene *scene_; /** * layerId of the layer where this operation needs to get its data from */ - short m_layerId; + short layerId_; /** * viewName of the view to use (unless another view is specified by the node */ - const char *m_viewName; + const char *viewName_; const MemoryBuffer *layer_buffer_; @@ -56,19 +56,19 @@ class RenderLayersProg : public MultiThreadedOperation { * Cached instance to the float buffer inside the layer. * TODO: To be removed with tiled implementation. */ - float *m_inputBuffer; + float *inputBuffer_; /** * Render-pass where this operation needs to get its data from. */ - std::string m_passName; + std::string passName_; - int m_elementsize; + int elementsize_; /** * \brief render data used for active rendering */ - const RenderData *m_rd; + const RenderData *rd_; /** * Determine the output resolution. The resolution is retrieved from the Renderer @@ -80,7 +80,7 @@ class RenderLayersProg : public MultiThreadedOperation { */ inline float *getInputBuffer() { - return m_inputBuffer; + return inputBuffer_; } void doInterpolation(float output[4], float x, float y, PixelSampler sampler); @@ -97,31 +97,31 @@ class RenderLayersProg : public MultiThreadedOperation { */ void setScene(Scene *scene) { - m_scene = scene; + scene_ = scene; } Scene *getScene() const { - return m_scene; + return scene_; } void setRenderData(const RenderData *rd) { - m_rd = rd; + rd_ = rd; } void setLayerId(short layerId) { - m_layerId = layerId; + layerId_ = layerId; } short getLayerId() const { - return m_layerId; + return layerId_; } void setViewName(const char *viewName) { - m_viewName = viewName; + viewName_ = viewName; } const char *getViewName() { - return m_viewName; + return viewName_; } void initExecution() override; void deinitExecution() override; diff --git a/source/blender/compositor/operations/COM_RotateOperation.cc b/source/blender/compositor/operations/COM_RotateOperation.cc index e32005d3c8d..9cef80c14b9 100644 --- a/source/blender/compositor/operations/COM_RotateOperation.cc +++ b/source/blender/compositor/operations/COM_RotateOperation.cc @@ -26,10 +26,10 @@ RotateOperation::RotateOperation() this->addInputSocket(DataType::Value, ResizeMode::None); this->addOutputSocket(DataType::Color); this->set_canvas_input_index(0); - m_imageSocket = nullptr; - m_degreeSocket = nullptr; - m_doDegree2RadConversion = false; - m_isDegreeSet = false; + imageSocket_ = nullptr; + degreeSocket_ = nullptr; + doDegree2RadConversion_ = false; + isDegreeSet_ = false; sampler_ = PixelSampler::Bilinear; } @@ -127,29 +127,29 @@ void RotateOperation::get_rotation_canvas(const rcti &input_canvas, void RotateOperation::init_data() { if (execution_model_ == eExecutionModel::Tiled) { - get_rotation_center(get_canvas(), m_centerX, m_centerY); + get_rotation_center(get_canvas(), centerX_, centerY_); } } void RotateOperation::initExecution() { - m_imageSocket = this->getInputSocketReader(0); - m_degreeSocket = this->getInputSocketReader(1); + imageSocket_ = this->getInputSocketReader(0); + degreeSocket_ = this->getInputSocketReader(1); } void RotateOperation::deinitExecution() { - m_imageSocket = nullptr; - m_degreeSocket = nullptr; + imageSocket_ = nullptr; + degreeSocket_ = nullptr; } inline void RotateOperation::ensureDegree() { - if (!m_isDegreeSet) { + if (!isDegreeSet_) { float degree[4]; switch (execution_model_) { case eExecutionModel::Tiled: - m_degreeSocket->readSampled(degree, 0, 0, PixelSampler::Nearest); + degreeSocket_->readSampled(degree, 0, 0, PixelSampler::Nearest); break; case eExecutionModel::FullFrame: degree[0] = get_input_operation(DEGREE_INPUT_INDEX)->get_constant_value_default(0.0f); @@ -157,27 +157,27 @@ inline void RotateOperation::ensureDegree() } double rad; - if (m_doDegree2RadConversion) { + if (doDegree2RadConversion_) { rad = DEG2RAD((double)degree[0]); } else { rad = degree[0]; } - m_cosine = cos(rad); - m_sine = sin(rad); + cosine_ = cos(rad); + sine_ = sin(rad); - m_isDegreeSet = true; + isDegreeSet_ = true; } } void RotateOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) { ensureDegree(); - const float dy = y - m_centerY; - const float dx = x - m_centerX; - const float nx = m_centerX + (m_cosine * dx + m_sine * dy); - const float ny = m_centerY + (-m_sine * dx + m_cosine * dy); - m_imageSocket->readSampled(output, nx, ny, sampler); + const float dy = y - centerY_; + const float dx = x - centerX_; + const float nx = centerX_ + (cosine_ * dx + sine_ * dy); + const float ny = centerY_ + (-sine_ * dx + cosine_ * dy); + imageSocket_->readSampled(output, nx, ny, sampler); } bool RotateOperation::determineDependingAreaOfInterest(rcti *input, @@ -187,19 +187,19 @@ bool RotateOperation::determineDependingAreaOfInterest(rcti *input, ensureDegree(); rcti newInput; - const float dxmin = input->xmin - m_centerX; - const float dymin = input->ymin - m_centerY; - const float dxmax = input->xmax - m_centerX; - const float dymax = input->ymax - m_centerY; - - const float x1 = m_centerX + (m_cosine * dxmin + m_sine * dymin); - const float x2 = m_centerX + (m_cosine * dxmax + m_sine * dymin); - const float x3 = m_centerX + (m_cosine * dxmin + m_sine * dymax); - const float x4 = m_centerX + (m_cosine * dxmax + m_sine * dymax); - const float y1 = m_centerY + (-m_sine * dxmin + m_cosine * dymin); - const float y2 = m_centerY + (-m_sine * dxmax + m_cosine * dymin); - const float y3 = m_centerY + (-m_sine * dxmin + m_cosine * dymax); - const float y4 = m_centerY + (-m_sine * dxmax + m_cosine * dymax); + const float dxmin = input->xmin - centerX_; + const float dymin = input->ymin - centerY_; + const float dxmax = input->xmax - centerX_; + const float dymax = input->ymax - centerY_; + + const float x1 = centerX_ + (cosine_ * dxmin + sine_ * dymin); + const float x2 = centerX_ + (cosine_ * dxmax + sine_ * dymin); + const float x3 = centerX_ + (cosine_ * dxmin + sine_ * dymax); + const float x4 = centerX_ + (cosine_ * dxmax + sine_ * dymax); + const float y1 = centerY_ + (-sine_ * dxmin + cosine_ * dymin); + const float y2 = centerY_ + (-sine_ * dxmax + cosine_ * dymin); + const float y3 = centerY_ + (-sine_ * dxmin + cosine_ * dymax); + const float y4 = centerY_ + (-sine_ * dxmax + cosine_ * dymax); const float minx = MIN2(x1, MIN2(x2, MIN2(x3, x4))); const float maxx = MAX2(x1, MAX2(x2, MAX2(x3, x4))); const float miny = MIN2(y1, MIN2(y2, MIN2(y3, y4))); @@ -229,7 +229,7 @@ void RotateOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) ensureDegree(); - get_rotation_canvas(input_canvas, m_sine, m_cosine, r_area); + get_rotation_canvas(input_canvas, sine_, cosine_, r_area); } } @@ -246,7 +246,7 @@ void RotateOperation::get_area_of_interest(const int input_idx, const rcti &input_image_canvas = get_input_operation(IMAGE_INPUT_INDEX)->get_canvas(); get_rotation_area_of_interest( - input_image_canvas, this->get_canvas(), m_sine, m_cosine, output_area, r_input_area); + input_image_canvas, this->get_canvas(), sine_, cosine_, output_area, r_input_area); expand_area_for_sampler(r_input_area, sampler_); } @@ -266,7 +266,7 @@ void RotateOperation::update_memory_buffer_partial(MemoryBuffer *output, for (BuffersIterator<float> it = output->iterate_with({}, area); !it.is_end(); ++it) { float x = rotate_offset_x + it.x + canvas_.xmin; float y = rotate_offset_y + it.y + canvas_.ymin; - rotate_coords(x, y, center_x, center_y, m_sine, m_cosine); + rotate_coords(x, y, center_x, center_y, sine_, cosine_); input_img->read_elem_sampled(x - canvas_.xmin, y - canvas_.ymin, sampler_, it.out); } } diff --git a/source/blender/compositor/operations/COM_RotateOperation.h b/source/blender/compositor/operations/COM_RotateOperation.h index 314e0f6076f..d99c914bed7 100644 --- a/source/blender/compositor/operations/COM_RotateOperation.h +++ b/source/blender/compositor/operations/COM_RotateOperation.h @@ -27,16 +27,16 @@ class RotateOperation : public MultiThreadedOperation { constexpr static int IMAGE_INPUT_INDEX = 0; constexpr static int DEGREE_INPUT_INDEX = 1; - SocketReader *m_imageSocket; - SocketReader *m_degreeSocket; + SocketReader *imageSocket_; + SocketReader *degreeSocket_; /* TODO(manzanilla): to be removed with tiled implementation. */ - float m_centerX; - float m_centerY; + float centerX_; + float centerY_; - float m_cosine; - float m_sine; - bool m_doDegree2RadConversion; - bool m_isDegreeSet; + float cosine_; + float sine_; + bool doDegree2RadConversion_; + bool isDegreeSet_; PixelSampler sampler_; public: @@ -89,7 +89,7 @@ class RotateOperation : public MultiThreadedOperation { void setDoDegree2RadConversion(bool abool) { - m_doDegree2RadConversion = abool; + doDegree2RadConversion_ = abool; } void set_sampler(PixelSampler sampler) diff --git a/source/blender/compositor/operations/COM_SMAAOperation.cc b/source/blender/compositor/operations/COM_SMAAOperation.cc index eb5db8d1698..40af7389d7f 100644 --- a/source/blender/compositor/operations/COM_SMAAOperation.cc +++ b/source/blender/compositor/operations/COM_SMAAOperation.cc @@ -171,34 +171,34 @@ SMAAEdgeDetectionOperation::SMAAEdgeDetectionOperation() this->addInputSocket(DataType::Value); /* Depth, material ID, etc. TODO: currently unused. */ this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_imageReader = nullptr; - m_valueReader = nullptr; + imageReader_ = nullptr; + valueReader_ = nullptr; this->setThreshold(CMP_DEFAULT_SMAA_THRESHOLD); this->setLocalContrastAdaptationFactor(CMP_DEFAULT_SMAA_CONTRAST_LIMIT); } void SMAAEdgeDetectionOperation::initExecution() { - m_imageReader = this->getInputSocketReader(0); - m_valueReader = this->getInputSocketReader(1); + imageReader_ = this->getInputSocketReader(0); + valueReader_ = this->getInputSocketReader(1); } void SMAAEdgeDetectionOperation::deinitExecution() { - m_imageReader = nullptr; - m_valueReader = nullptr; + imageReader_ = nullptr; + valueReader_ = nullptr; } void SMAAEdgeDetectionOperation::setThreshold(float threshold) { /* UI values are between 0 and 1 for simplicity but algorithm expects values between 0 and 0.5 */ - m_threshold = scalenorm(0, 0.5, threshold); + threshold_ = scalenorm(0, 0.5, threshold); } void SMAAEdgeDetectionOperation::setLocalContrastAdaptationFactor(float factor) { /* UI values are between 0 and 1 for simplicity but algorithm expects values between 1 and 10 */ - m_contrast_limit = scalenorm(1, 10, factor); + contrast_limit_ = scalenorm(1, 10, factor); } bool SMAAEdgeDetectionOperation::determineDependingAreaOfInterest( @@ -228,18 +228,18 @@ void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, voi float color[4]; /* Calculate luma deltas: */ - sample(m_imageReader, x, y, color); + sample(imageReader_, x, y, color); float L = IMB_colormanagement_get_luminance(color); - sample(m_imageReader, x - 1, y, color); + sample(imageReader_, x - 1, y, color); float Lleft = IMB_colormanagement_get_luminance(color); - sample(m_imageReader, x, y - 1, color); + sample(imageReader_, x, y - 1, color); float Ltop = IMB_colormanagement_get_luminance(color); float Dleft = fabsf(L - Lleft); float Dtop = fabsf(L - Ltop); /* We do the usual threshold: */ - output[0] = (x > 0 && Dleft >= m_threshold) ? 1.0f : 0.0f; - output[1] = (y > 0 && Dtop >= m_threshold) ? 1.0f : 0.0f; + output[0] = (x > 0 && Dleft >= threshold_) ? 1.0f : 0.0f; + output[1] = (y > 0 && Dtop >= threshold_) ? 1.0f : 0.0f; output[2] = 0.0f; output[3] = 1.0f; @@ -249,9 +249,9 @@ void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, voi } /* Calculate right and bottom deltas: */ - sample(m_imageReader, x + 1, y, color); + sample(imageReader_, x + 1, y, color); float Lright = IMB_colormanagement_get_luminance(color); - sample(m_imageReader, x, y + 1, color); + sample(imageReader_, x, y + 1, color); float Lbottom = IMB_colormanagement_get_luminance(color); float Dright = fabsf(L - Lright); float Dbottom = fabsf(L - Lbottom); @@ -260,15 +260,15 @@ void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, voi float maxDelta = fmaxf(fmaxf(Dleft, Dright), fmaxf(Dtop, Dbottom)); /* Calculate luma used for both left and top edges: */ - sample(m_imageReader, x - 1, y - 1, color); + sample(imageReader_, x - 1, y - 1, color); float Llefttop = IMB_colormanagement_get_luminance(color); /* Left edge */ if (output[0] != 0.0f) { /* Calculate deltas around the left pixel: */ - sample(m_imageReader, x - 2, y, color); + sample(imageReader_, x - 2, y, color); float Lleftleft = IMB_colormanagement_get_luminance(color); - sample(m_imageReader, x - 1, y + 1, color); + sample(imageReader_, x - 1, y + 1, color); float Lleftbottom = IMB_colormanagement_get_luminance(color); float Dleftleft = fabsf(Lleft - Lleftleft); float Dlefttop = fabsf(Lleft - Llefttop); @@ -278,7 +278,7 @@ void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, voi maxDelta = fmaxf(maxDelta, fmaxf(Dleftleft, fmaxf(Dlefttop, Dleftbottom))); /* Local contrast adaptation: */ - if (maxDelta > m_contrast_limit * Dleft) { + if (maxDelta > contrast_limit_ * Dleft) { output[0] = 0.0f; } } @@ -286,9 +286,9 @@ void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, voi /* Top edge */ if (output[1] != 0.0f) { /* Calculate top-top delta: */ - sample(m_imageReader, x, y - 2, color); + sample(imageReader_, x, y - 2, color); float Ltoptop = IMB_colormanagement_get_luminance(color); - sample(m_imageReader, x + 1, y - 1, color); + sample(imageReader_, x + 1, y - 1, color); float Ltopright = IMB_colormanagement_get_luminance(color); float Dtoptop = fabsf(Ltop - Ltoptop); float Dtopleft = fabsf(Ltop - Llefttop); @@ -298,7 +298,7 @@ void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, voi maxDelta = fmaxf(maxDelta, fmaxf(Dtoptop, fmaxf(Dtopleft, Dtopright))); /* Local contrast adaptation: */ - if (maxDelta > m_contrast_limit * Dtop) { + if (maxDelta > contrast_limit_ * Dtop) { output[1] = 0.0f; } } @@ -325,8 +325,8 @@ void SMAAEdgeDetectionOperation::update_memory_buffer_partial(MemoryBuffer *outp const float Dtop = fabsf(L - Ltop); /* We do the usual threshold: */ - it.out[0] = (x > 0 && Dleft >= m_threshold) ? 1.0f : 0.0f; - it.out[1] = (y > 0 && Dtop >= m_threshold) ? 1.0f : 0.0f; + it.out[0] = (x > 0 && Dleft >= threshold_) ? 1.0f : 0.0f; + it.out[1] = (y > 0 && Dtop >= threshold_) ? 1.0f : 0.0f; it.out[2] = 0.0f; it.out[3] = 1.0f; @@ -365,7 +365,7 @@ void SMAAEdgeDetectionOperation::update_memory_buffer_partial(MemoryBuffer *outp maxDelta = fmaxf(maxDelta, fmaxf(Dleftleft, fmaxf(Dlefttop, Dleftbottom))); /* Local contrast adaptation: */ - if (maxDelta > m_contrast_limit * Dleft) { + if (maxDelta > contrast_limit_ * Dleft) { it.out[0] = 0.0f; } } @@ -385,7 +385,7 @@ void SMAAEdgeDetectionOperation::update_memory_buffer_partial(MemoryBuffer *outp maxDelta = fmaxf(maxDelta, fmaxf(Dtoptop, fmaxf(Dtopleft, Dtopright))); /* Local contrast adaptation: */ - if (maxDelta > m_contrast_limit * Dtop) { + if (maxDelta > contrast_limit_ * Dtop) { it.out[1] = 0.0f; } } @@ -401,7 +401,7 @@ SMAABlendingWeightCalculationOperation::SMAABlendingWeightCalculationOperation() this->addInputSocket(DataType::Color); /* edges */ this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_imageReader = nullptr; + imageReader_ = nullptr; this->setCornerRounding(CMP_DEFAULT_SMAA_CORNER_ROUNDING); } @@ -412,16 +412,16 @@ void *SMAABlendingWeightCalculationOperation::initializeTileData(rcti *rect) void SMAABlendingWeightCalculationOperation::initExecution() { - m_imageReader = this->getInputSocketReader(0); + imageReader_ = this->getInputSocketReader(0); if (execution_model_ == eExecutionModel::Tiled) { - sample_image_fn_ = [=](int x, int y, float *out) { sample(m_imageReader, x, y, out); }; + sample_image_fn_ = [=](int x, int y, float *out) { sample(imageReader_, x, y, out); }; } } void SMAABlendingWeightCalculationOperation::setCornerRounding(float rounding) { /* UI values are between 0 and 1 for simplicity but algorithm expects values between 0 and 100 */ - m_corner_rounding = static_cast<int>(scalenorm(0, 100, rounding)); + corner_rounding_ = static_cast<int>(scalenorm(0, 100, rounding)); } void SMAABlendingWeightCalculationOperation::executePixel(float output[4], @@ -432,7 +432,7 @@ void SMAABlendingWeightCalculationOperation::executePixel(float output[4], float edges[4], c[4]; zero_v4(output); - sample(m_imageReader, x, y, edges); + sample(imageReader_, x, y, edges); /* Edge at north */ if (edges[1] > 0.0f) { @@ -453,19 +453,19 @@ void SMAABlendingWeightCalculationOperation::executePixel(float output[4], /* Fetch the left and right crossing edges: */ int e1 = 0, e2 = 0; - sample(m_imageReader, left, y - 1, c); + sample(imageReader_, left, y - 1, c); if (c[0] > 0.0) { e1 += 1; } - sample(m_imageReader, left, y, c); + sample(imageReader_, left, y, c); if (c[0] > 0.0) { e1 += 2; } - sample(m_imageReader, right + 1, y - 1, c); + sample(imageReader_, right + 1, y - 1, c); if (c[0] > 0.0) { e2 += 1; } - sample(m_imageReader, right + 1, y, c); + sample(imageReader_, right + 1, y, c); if (c[0] > 0.0) { e2 += 2; } @@ -475,7 +475,7 @@ void SMAABlendingWeightCalculationOperation::executePixel(float output[4], area(d1, d2, e1, e2, output); /* R, G */ /* Fix corners: */ - if (m_corner_rounding) { + if (corner_rounding_) { detectHorizontalCornerPattern(output, left, right, y, d1, d2); } } @@ -494,19 +494,19 @@ void SMAABlendingWeightCalculationOperation::executePixel(float output[4], /* Fetch the top and bottom crossing edges: */ int e1 = 0, e2 = 0; - sample(m_imageReader, x - 1, top, c); + sample(imageReader_, x - 1, top, c); if (c[1] > 0.0) { e1 += 1; } - sample(m_imageReader, x, top, c); + sample(imageReader_, x, top, c); if (c[1] > 0.0) { e1 += 2; } - sample(m_imageReader, x - 1, bottom + 1, c); + sample(imageReader_, x - 1, bottom + 1, c); if (c[1] > 0.0) { e2 += 1; } - sample(m_imageReader, x, bottom + 1, c); + sample(imageReader_, x, bottom + 1, c); if (c[1] > 0.0) { e2 += 2; } @@ -515,7 +515,7 @@ void SMAABlendingWeightCalculationOperation::executePixel(float output[4], area(d1, d2, e1, e2, output + 2); /* B, A */ /* Fix corners: */ - if (m_corner_rounding) { + if (corner_rounding_) { detectVerticalCornerPattern(output + 2, x, top, bottom, d1, d2); } } @@ -581,7 +581,7 @@ void SMAABlendingWeightCalculationOperation::update_memory_buffer_partial( area(d1, d2, e1, e2, it.out); /* R, G */ /* Fix corners: */ - if (m_corner_rounding) { + if (corner_rounding_) { detectHorizontalCornerPattern(it.out, left, right, y, d1, d2); } } @@ -621,7 +621,7 @@ void SMAABlendingWeightCalculationOperation::update_memory_buffer_partial( area(d1, d2, e1, e2, it.out + 2); /* B, A */ /* Fix corners: */ - if (m_corner_rounding) { + if (corner_rounding_) { detectVerticalCornerPattern(it.out + 2, x, top, bottom, d1, d2); } } @@ -630,7 +630,7 @@ void SMAABlendingWeightCalculationOperation::update_memory_buffer_partial( void SMAABlendingWeightCalculationOperation::deinitExecution() { - m_imageReader = nullptr; + imageReader_ = nullptr; } bool SMAABlendingWeightCalculationOperation::determineDependingAreaOfInterest( @@ -947,7 +947,7 @@ void SMAABlendingWeightCalculationOperation::detectHorizontalCornerPattern( float weights[2], int left, int right, int y, int d1, int d2) { float factor[2] = {1.0f, 1.0f}; - float rounding = m_corner_rounding / 100.0f; + float rounding = corner_rounding_ / 100.0f; float e[4]; /* Reduce blending for pixels in the center of a line. */ @@ -976,7 +976,7 @@ void SMAABlendingWeightCalculationOperation::detectVerticalCornerPattern( float weights[2], int x, int top, int bottom, int d1, int d2) { float factor[2] = {1.0f, 1.0f}; - float rounding = m_corner_rounding / 100.0f; + float rounding = corner_rounding_ / 100.0f; float e[4]; /* Reduce blending for pixels in the center of a line. */ @@ -1011,8 +1011,8 @@ SMAANeighborhoodBlendingOperation::SMAANeighborhoodBlendingOperation() this->addInputSocket(DataType::Color); /* blend */ this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_image1Reader = nullptr; - m_image2Reader = nullptr; + image1Reader_ = nullptr; + image2Reader_ = nullptr; } void *SMAANeighborhoodBlendingOperation::initializeTileData(rcti *rect) @@ -1022,8 +1022,8 @@ void *SMAANeighborhoodBlendingOperation::initializeTileData(rcti *rect) void SMAANeighborhoodBlendingOperation::initExecution() { - m_image1Reader = this->getInputSocketReader(0); - m_image2Reader = this->getInputSocketReader(1); + image1Reader_ = this->getInputSocketReader(0); + image2Reader_ = this->getInputSocketReader(1); } void SMAANeighborhoodBlendingOperation::executePixel(float output[4], @@ -1034,16 +1034,16 @@ void SMAANeighborhoodBlendingOperation::executePixel(float output[4], float w[4]; /* Fetch the blending weights for current pixel: */ - sample(m_image2Reader, x, y, w); + sample(image2Reader_, x, y, w); float left = w[2], top = w[0]; - sample(m_image2Reader, x + 1, y, w); + sample(image2Reader_, x + 1, y, w); float right = w[3]; - sample(m_image2Reader, x, y + 1, w); + sample(image2Reader_, x, y + 1, w); float bottom = w[1]; /* Is there any blending weight with a value greater than 0.0? */ if (right + bottom + left + top < 1e-5f) { - sample(m_image1Reader, x, y, output); + sample(image1Reader_, x, y, output); return; } @@ -1067,8 +1067,8 @@ void SMAANeighborhoodBlendingOperation::executePixel(float output[4], } /* We exploit bilinear filtering to mix current pixel with the chosen neighbor: */ - samplefunc(m_image1Reader, x, y, offset1, color1); - samplefunc(m_image1Reader, x, y, offset2, color2); + samplefunc(image1Reader_, x, y, offset1, color1); + samplefunc(image1Reader_, x, y, offset2, color2); mul_v4_v4fl(output, color1, weight1); madd_v4_v4fl(output, color2, weight2); @@ -1129,8 +1129,8 @@ void SMAANeighborhoodBlendingOperation::update_memory_buffer_partial(MemoryBuffe void SMAANeighborhoodBlendingOperation::deinitExecution() { - m_image1Reader = nullptr; - m_image2Reader = nullptr; + image1Reader_ = nullptr; + image2Reader_ = nullptr; } bool SMAANeighborhoodBlendingOperation::determineDependingAreaOfInterest( diff --git a/source/blender/compositor/operations/COM_SMAAOperation.h b/source/blender/compositor/operations/COM_SMAAOperation.h index 91b9299ee43..d4c9e128dca 100644 --- a/source/blender/compositor/operations/COM_SMAAOperation.h +++ b/source/blender/compositor/operations/COM_SMAAOperation.h @@ -29,11 +29,11 @@ namespace blender::compositor { class SMAAEdgeDetectionOperation : public MultiThreadedOperation { protected: - SocketReader *m_imageReader; - SocketReader *m_valueReader; + SocketReader *imageReader_; + SocketReader *valueReader_; - float m_threshold; - float m_contrast_limit; + float threshold_; + float contrast_limit_; public: SMAAEdgeDetectionOperation(); @@ -72,9 +72,9 @@ class SMAAEdgeDetectionOperation : public MultiThreadedOperation { class SMAABlendingWeightCalculationOperation : public MultiThreadedOperation { private: - SocketReader *m_imageReader; + SocketReader *imageReader_; std::function<void(int x, int y, float *out)> sample_image_fn_; - int m_corner_rounding; + int corner_rounding_; public: SMAABlendingWeightCalculationOperation(); @@ -132,8 +132,8 @@ class SMAABlendingWeightCalculationOperation : public MultiThreadedOperation { class SMAANeighborhoodBlendingOperation : public MultiThreadedOperation { private: - SocketReader *m_image1Reader; - SocketReader *m_image2Reader; + SocketReader *image1Reader_; + SocketReader *image2Reader_; public: SMAANeighborhoodBlendingOperation(); diff --git a/source/blender/compositor/operations/COM_ScaleOperation.cc b/source/blender/compositor/operations/COM_ScaleOperation.cc index 5d0f9a2ad5e..82878c1276f 100644 --- a/source/blender/compositor/operations/COM_ScaleOperation.cc +++ b/source/blender/compositor/operations/COM_ScaleOperation.cc @@ -31,11 +31,11 @@ namespace blender::compositor { BaseScaleOperation::BaseScaleOperation() { #ifdef USE_FORCE_BILINEAR - m_sampler = (int)PixelSampler::Bilinear; + sampler_ = (int)PixelSampler::Bilinear; #else - m_sampler = -1; + sampler_ = -1; #endif - m_variable_size = false; + variable_size_ = false; } void BaseScaleOperation::set_scale_canvas_max_size(Size2f size) @@ -53,9 +53,9 @@ ScaleOperation::ScaleOperation(DataType data_type) : BaseScaleOperation() this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); this->addOutputSocket(data_type); - m_inputOperation = nullptr; - m_inputXOperation = nullptr; - m_inputYOperation = nullptr; + inputOperation_ = nullptr; + inputXOperation_ = nullptr; + inputYOperation_ = nullptr; } float ScaleOperation::get_constant_scale(const int input_op_idx, const float factor) @@ -118,16 +118,16 @@ void ScaleOperation::init_data() void ScaleOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); - m_inputXOperation = this->getInputSocketReader(1); - m_inputYOperation = this->getInputSocketReader(2); + inputOperation_ = this->getInputSocketReader(0); + inputXOperation_ = this->getInputSocketReader(1); + inputYOperation_ = this->getInputSocketReader(2); } void ScaleOperation::deinitExecution() { - m_inputOperation = nullptr; - m_inputXOperation = nullptr; - m_inputYOperation = nullptr; + inputOperation_ = nullptr; + inputXOperation_ = nullptr; + inputYOperation_ = nullptr; } void ScaleOperation::get_scale_offset(const rcti &input_canvas, @@ -176,7 +176,7 @@ void ScaleOperation::get_area_of_interest(const int input_idx, get_scale_area_of_interest( image_op->get_canvas(), this->get_canvas(), scale_x, scale_y, output_area, r_input_area); - expand_area_for_sampler(r_input_area, (PixelSampler)m_sampler); + expand_area_for_sampler(r_input_area, (PixelSampler)sampler_); } void ScaleOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -207,7 +207,7 @@ void ScaleOperation::update_memory_buffer_partial(MemoryBuffer *output, from_scale_offset_y + canvas_.ymin + it.y, scale_center_y, rel_scale_y); input_image->read_elem_sampled( - scaled_x - canvas_.xmin, scaled_y - canvas_.ymin, (PixelSampler)m_sampler, it.out); + scaled_x - canvas_.xmin, scaled_y - canvas_.ymin, (PixelSampler)sampler_, it.out); } } @@ -268,15 +268,15 @@ void ScaleRelativeOperation::executePixelSampled(float output[4], float scaleX[4]; float scaleY[4]; - m_inputXOperation->readSampled(scaleX, x, y, effective_sampler); - m_inputYOperation->readSampled(scaleY, x, y, effective_sampler); + inputXOperation_->readSampled(scaleX, x, y, effective_sampler); + inputYOperation_->readSampled(scaleY, x, y, effective_sampler); const float scx = scaleX[0]; const float scy = scaleY[0]; float nx = this->canvas_center_x_ + (x - this->canvas_center_x_) / scx; float ny = this->canvas_center_y_ + (y - this->canvas_center_y_) / scy; - m_inputOperation->readSampled(output, nx, ny, effective_sampler); + inputOperation_->readSampled(output, nx, ny, effective_sampler); } bool ScaleRelativeOperation::determineDependingAreaOfInterest(rcti *input, @@ -284,12 +284,12 @@ bool ScaleRelativeOperation::determineDependingAreaOfInterest(rcti *input, rcti *output) { rcti newInput; - if (!m_variable_size) { + if (!variable_size_) { float scaleX[4]; float scaleY[4]; - m_inputXOperation->readSampled(scaleX, 0, 0, PixelSampler::Nearest); - m_inputYOperation->readSampled(scaleY, 0, 0, PixelSampler::Nearest); + inputXOperation_->readSampled(scaleX, 0, 0, PixelSampler::Nearest); + inputYOperation_->readSampled(scaleY, 0, 0, PixelSampler::Nearest); const float scx = scaleX[0]; const float scy = scaleY[0]; @@ -318,8 +318,8 @@ void ScaleAbsoluteOperation::executePixelSampled(float output[4], float scaleX[4]; float scaleY[4]; - m_inputXOperation->readSampled(scaleX, x, y, effective_sampler); - m_inputYOperation->readSampled(scaleY, x, y, effective_sampler); + inputXOperation_->readSampled(scaleX, x, y, effective_sampler); + inputYOperation_->readSampled(scaleY, x, y, effective_sampler); const float scx = scaleX[0]; /* Target absolute scale. */ const float scy = scaleY[0]; /* Target absolute scale. */ @@ -333,7 +333,7 @@ void ScaleAbsoluteOperation::executePixelSampled(float output[4], float nx = this->canvas_center_x_ + (x - this->canvas_center_x_) / relativeXScale; float ny = this->canvas_center_y_ + (y - this->canvas_center_y_) / relativeYScale; - m_inputOperation->readSampled(output, nx, ny, effective_sampler); + inputOperation_->readSampled(output, nx, ny, effective_sampler); } bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, @@ -341,12 +341,12 @@ bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, rcti *output) { rcti newInput; - if (!m_variable_size) { + if (!variable_size_) { float scaleX[4]; float scaleY[4]; - m_inputXOperation->readSampled(scaleX, 0, 0, PixelSampler::Nearest); - m_inputYOperation->readSampled(scaleY, 0, 0, PixelSampler::Nearest); + inputXOperation_->readSampled(scaleX, 0, 0, PixelSampler::Nearest); + inputYOperation_->readSampled(scaleY, 0, 0, PixelSampler::Nearest); const float scx = scaleX[0]; const float scy = scaleY[0]; @@ -380,78 +380,78 @@ ScaleFixedSizeOperation::ScaleFixedSizeOperation() : BaseScaleOperation() this->addInputSocket(DataType::Color, ResizeMode::None); this->addOutputSocket(DataType::Color); this->set_canvas_input_index(0); - m_inputOperation = nullptr; - m_is_offset = false; + inputOperation_ = nullptr; + is_offset_ = false; } void ScaleFixedSizeOperation::init_data(const rcti &input_canvas) { const int input_width = BLI_rcti_size_x(&input_canvas); const int input_height = BLI_rcti_size_y(&input_canvas); - m_relX = input_width / (float)m_newWidth; - m_relY = input_height / (float)m_newHeight; + relX_ = input_width / (float)newWidth_; + relY_ = input_height / (float)newHeight_; /* *** all the options below are for a fairly special case - camera framing *** */ - if (m_offsetX != 0.0f || m_offsetY != 0.0f) { - m_is_offset = true; + if (offsetX_ != 0.0f || offsetY_ != 0.0f) { + is_offset_ = true; - if (m_newWidth > m_newHeight) { - m_offsetX *= m_newWidth; - m_offsetY *= m_newWidth; + if (newWidth_ > newHeight_) { + offsetX_ *= newWidth_; + offsetY_ *= newWidth_; } else { - m_offsetX *= m_newHeight; - m_offsetY *= m_newHeight; + offsetX_ *= newHeight_; + offsetY_ *= newHeight_; } } - if (m_is_aspect) { + if (is_aspect_) { /* apply aspect from clip */ const float w_src = input_width; const float h_src = input_height; /* destination aspect is already applied from the camera frame */ - const float w_dst = m_newWidth; - const float h_dst = m_newHeight; + const float w_dst = newWidth_; + const float h_dst = newHeight_; const float asp_src = w_src / h_src; const float asp_dst = w_dst / h_dst; if (fabsf(asp_src - asp_dst) >= FLT_EPSILON) { - if ((asp_src > asp_dst) == (m_is_crop == true)) { + if ((asp_src > asp_dst) == (is_crop_ == true)) { /* fit X */ const float div = asp_src / asp_dst; - m_relX /= div; - m_offsetX += ((w_src - (w_src * div)) / (w_src / w_dst)) / 2.0f; - if (m_is_crop && execution_model_ == eExecutionModel::FullFrame) { - int fit_width = m_newWidth * div; + relX_ /= div; + offsetX_ += ((w_src - (w_src * div)) / (w_src / w_dst)) / 2.0f; + if (is_crop_ && execution_model_ == eExecutionModel::FullFrame) { + int fit_width = newWidth_ * div; if (fit_width > max_scale_canvas_size_.x) { fit_width = max_scale_canvas_size_.x; } - const int added_width = fit_width - m_newWidth; - m_newWidth += added_width; - m_offsetX += added_width / 2.0f; + const int added_width = fit_width - newWidth_; + newWidth_ += added_width; + offsetX_ += added_width / 2.0f; } } else { /* fit Y */ const float div = asp_dst / asp_src; - m_relY /= div; - m_offsetY += ((h_src - (h_src * div)) / (h_src / h_dst)) / 2.0f; - if (m_is_crop && execution_model_ == eExecutionModel::FullFrame) { - int fit_height = m_newHeight * div; + relY_ /= div; + offsetY_ += ((h_src - (h_src * div)) / (h_src / h_dst)) / 2.0f; + if (is_crop_ && execution_model_ == eExecutionModel::FullFrame) { + int fit_height = newHeight_ * div; if (fit_height > max_scale_canvas_size_.y) { fit_height = max_scale_canvas_size_.y; } - const int added_height = fit_height - m_newHeight; - m_newHeight += added_height; - m_offsetY += added_height / 2.0f; + const int added_height = fit_height - newHeight_; + newHeight_ += added_height; + offsetY_ += added_height / 2.0f; } } - m_is_offset = true; + is_offset_ = true; } } /* *** end framing options *** */ @@ -459,12 +459,12 @@ void ScaleFixedSizeOperation::init_data(const rcti &input_canvas) void ScaleFixedSizeOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); + inputOperation_ = this->getInputSocketReader(0); } void ScaleFixedSizeOperation::deinitExecution() { - m_inputOperation = nullptr; + inputOperation_ = nullptr; } void ScaleFixedSizeOperation::executePixelSampled(float output[4], @@ -474,13 +474,13 @@ void ScaleFixedSizeOperation::executePixelSampled(float output[4], { PixelSampler effective_sampler = getEffectiveSampler(sampler); - if (m_is_offset) { - float nx = ((x - m_offsetX) * m_relX); - float ny = ((y - m_offsetY) * m_relY); - m_inputOperation->readSampled(output, nx, ny, effective_sampler); + if (is_offset_) { + float nx = ((x - offsetX_) * relX_); + float ny = ((y - offsetY_) * relY_); + inputOperation_->readSampled(output, nx, ny, effective_sampler); } else { - m_inputOperation->readSampled(output, x * m_relX, y * m_relY, effective_sampler); + inputOperation_->readSampled(output, x * relX_, y * relY_, effective_sampler); } } @@ -490,10 +490,10 @@ bool ScaleFixedSizeOperation::determineDependingAreaOfInterest(rcti *input, { rcti newInput; - newInput.xmax = (input->xmax - m_offsetX) * m_relX + 1; - newInput.xmin = (input->xmin - m_offsetX) * m_relX; - newInput.ymax = (input->ymax - m_offsetY) * m_relY + 1; - newInput.ymin = (input->ymin - m_offsetY) * m_relY; + newInput.xmax = (input->xmax - offsetX_) * relX_ + 1; + newInput.xmin = (input->xmin - offsetX_) * relX_; + newInput.ymax = (input->ymax - offsetY_) * relY_ + 1; + newInput.ymin = (input->ymin - offsetY_) * relY_; return BaseScaleOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -501,22 +501,22 @@ bool ScaleFixedSizeOperation::determineDependingAreaOfInterest(rcti *input, void ScaleFixedSizeOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { rcti local_preferred = preferred_area; - local_preferred.xmax = local_preferred.xmin + m_newWidth; - local_preferred.ymax = local_preferred.ymin + m_newHeight; + local_preferred.xmax = local_preferred.xmin + newWidth_; + local_preferred.ymax = local_preferred.ymin + newHeight_; rcti input_canvas; const bool input_determined = getInputSocket(0)->determine_canvas(local_preferred, input_canvas); if (input_determined) { init_data(input_canvas); r_area = input_canvas; if (execution_model_ == eExecutionModel::FullFrame) { - r_area.xmin /= m_relX; - r_area.ymin /= m_relY; - r_area.xmin += m_offsetX; - r_area.ymin += m_offsetY; + r_area.xmin /= relX_; + r_area.ymin /= relY_; + r_area.xmin += offsetX_; + r_area.ymin += offsetY_; } - r_area.xmax = r_area.xmin + m_newWidth; - r_area.ymax = r_area.ymin + m_newHeight; + r_area.xmax = r_area.xmin + newWidth_; + r_area.ymax = r_area.ymin + newHeight_; } } @@ -527,11 +527,11 @@ void ScaleFixedSizeOperation::get_area_of_interest(const int input_idx, BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - r_input_area.xmax = ceilf((output_area.xmax - m_offsetX) * m_relX); - r_input_area.xmin = floorf((output_area.xmin - m_offsetX) * m_relX); - r_input_area.ymax = ceilf((output_area.ymax - m_offsetY) * m_relY); - r_input_area.ymin = floorf((output_area.ymin - m_offsetY) * m_relY); - expand_area_for_sampler(r_input_area, (PixelSampler)m_sampler); + r_input_area.xmax = ceilf((output_area.xmax - offsetX_) * relX_); + r_input_area.xmin = floorf((output_area.xmin - offsetX_) * relX_); + r_input_area.ymax = ceilf((output_area.ymax - offsetY_) * relY_); + r_input_area.ymin = floorf((output_area.ymin - offsetY_) * relY_); + expand_area_for_sampler(r_input_area, (PixelSampler)sampler_); } void ScaleFixedSizeOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -539,19 +539,19 @@ void ScaleFixedSizeOperation::update_memory_buffer_partial(MemoryBuffer *output, Span<MemoryBuffer *> inputs) { const MemoryBuffer *input_img = inputs[0]; - PixelSampler sampler = (PixelSampler)m_sampler; + PixelSampler sampler = (PixelSampler)sampler_; BuffersIterator<float> it = output->iterate_with({}, area); - if (m_is_offset) { + if (is_offset_) { for (; !it.is_end(); ++it) { - const float nx = (canvas_.xmin + it.x - m_offsetX) * m_relX; - const float ny = (canvas_.ymin + it.y - m_offsetY) * m_relY; + const float nx = (canvas_.xmin + it.x - offsetX_) * relX_; + const float ny = (canvas_.ymin + it.y - offsetY_) * relY_; input_img->read_elem_sampled(nx - canvas_.xmin, ny - canvas_.ymin, sampler, it.out); } } else { for (; !it.is_end(); ++it) { - input_img->read_elem_sampled((canvas_.xmin + it.x) * m_relX - canvas_.xmin, - (canvas_.ymin + it.y) * m_relY - canvas_.ymin, + input_img->read_elem_sampled((canvas_.xmin + it.x) * relX_ - canvas_.xmin, + (canvas_.ymin + it.y) * relY_ - canvas_.ymin, sampler, it.out); } diff --git a/source/blender/compositor/operations/COM_ScaleOperation.h b/source/blender/compositor/operations/COM_ScaleOperation.h index 4ba17e2ba20..868a17bc394 100644 --- a/source/blender/compositor/operations/COM_ScaleOperation.h +++ b/source/blender/compositor/operations/COM_ScaleOperation.h @@ -29,11 +29,11 @@ class BaseScaleOperation : public MultiThreadedOperation { public: void setSampler(PixelSampler sampler) { - m_sampler = (int)sampler; + sampler_ = (int)sampler; } void setVariableSize(bool variable_size) { - m_variable_size = variable_size; + variable_size_ = variable_size; }; void set_scale_canvas_max_size(Size2f size); @@ -43,13 +43,13 @@ class BaseScaleOperation : public MultiThreadedOperation { PixelSampler getEffectiveSampler(PixelSampler sampler) { - return (m_sampler == -1) ? sampler : (PixelSampler)m_sampler; + return (sampler_ == -1) ? sampler : (PixelSampler)sampler_; } Size2f max_scale_canvas_size_ = {DEFAULT_MAX_SCALE_CANVAS_SIZE, DEFAULT_MAX_SCALE_CANVAS_SIZE}; - int m_sampler; + int sampler_; /* TODO(manzanilla): to be removed with tiled implementation. */ - bool m_variable_size; + bool variable_size_; }; class ScaleOperation : public BaseScaleOperation { @@ -61,9 +61,9 @@ class ScaleOperation : public BaseScaleOperation { static constexpr int X_INPUT_INDEX = 1; static constexpr int Y_INPUT_INDEX = 2; - SocketReader *m_inputOperation; - SocketReader *m_inputXOperation; - SocketReader *m_inputYOperation; + SocketReader *inputOperation_; + SocketReader *inputXOperation_; + SocketReader *inputYOperation_; float canvas_center_x_; float canvas_center_y_; @@ -157,20 +157,20 @@ class ScaleAbsoluteOperation : public ScaleOperation { }; class ScaleFixedSizeOperation : public BaseScaleOperation { - SocketReader *m_inputOperation; - int m_newWidth; - int m_newHeight; - float m_relX; - float m_relY; + SocketReader *inputOperation_; + int newWidth_; + int newHeight_; + float relX_; + float relY_; /* center is only used for aspect correction */ - float m_offsetX; - float m_offsetY; - bool m_is_aspect; - bool m_is_crop; + float offsetX_; + float offsetY_; + bool is_aspect_; + bool is_crop_; /* set from other properties on initialization, * check if we need to apply offset */ - bool m_is_offset; + bool is_offset_; public: ScaleFixedSizeOperation(); @@ -184,24 +184,24 @@ class ScaleFixedSizeOperation : public BaseScaleOperation { void deinitExecution() override; void setNewWidth(int width) { - m_newWidth = width; + newWidth_ = width; } void setNewHeight(int height) { - m_newHeight = height; + newHeight_ = height; } void setIsAspect(bool is_aspect) { - m_is_aspect = is_aspect; + is_aspect_ = is_aspect; } void setIsCrop(bool is_crop) { - m_is_crop = is_crop; + is_crop_ = is_crop; } void setOffset(float x, float y) { - m_offsetX = x; - m_offsetY = y; + offsetX_ = x; + offsetY_ = y; } void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; diff --git a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cc b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cc index ec2fc1aab65..3892d76874c 100644 --- a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cc +++ b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cc @@ -33,49 +33,49 @@ ScreenLensDistortionOperation::ScreenLensDistortionOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_inputProgram = nullptr; - m_distortion = 0.0f; - m_dispersion = 0.0f; - m_distortion_const = false; - m_dispersion_const = false; - m_variables_ready = false; + inputProgram_ = nullptr; + distortion_ = 0.0f; + dispersion_ = 0.0f; + distortion_const_ = false; + dispersion_const_ = false; + variables_ready_ = false; } void ScreenLensDistortionOperation::setDistortion(float distortion) { - m_distortion = distortion; - m_distortion_const = true; + distortion_ = distortion; + distortion_const_ = true; } void ScreenLensDistortionOperation::setDispersion(float dispersion) { - m_dispersion = dispersion; - m_dispersion_const = true; + dispersion_ = dispersion; + dispersion_const_ = true; } void ScreenLensDistortionOperation::init_data() { - m_cx = 0.5f * (float)getWidth(); - m_cy = 0.5f * (float)getHeight(); + cx_ = 0.5f * (float)getWidth(); + cy_ = 0.5f * (float)getHeight(); switch (execution_model_) { case eExecutionModel::FullFrame: { NodeOperation *distortion_op = get_input_operation(1); NodeOperation *dispersion_op = get_input_operation(2); - if (!m_distortion_const && distortion_op->get_flags().is_constant_operation) { - m_distortion = static_cast<ConstantOperation *>(distortion_op)->get_constant_elem()[0]; + if (!distortion_const_ && distortion_op->get_flags().is_constant_operation) { + distortion_ = static_cast<ConstantOperation *>(distortion_op)->get_constant_elem()[0]; } - if (!m_dispersion_const && distortion_op->get_flags().is_constant_operation) { - m_dispersion = static_cast<ConstantOperation *>(dispersion_op)->get_constant_elem()[0]; + if (!dispersion_const_ && distortion_op->get_flags().is_constant_operation) { + dispersion_ = static_cast<ConstantOperation *>(dispersion_op)->get_constant_elem()[0]; } - updateVariables(m_distortion, m_dispersion); + updateVariables(distortion_, dispersion_); break; } case eExecutionModel::Tiled: { /* If both are constant, init variables once. */ - if (m_distortion_const && m_dispersion_const) { - updateVariables(m_distortion, m_dispersion); - m_variables_ready = true; + if (distortion_const_ && dispersion_const_) { + updateVariables(distortion_, dispersion_); + variables_ready_ = true; } break; } @@ -84,38 +84,38 @@ void ScreenLensDistortionOperation::init_data() void ScreenLensDistortionOperation::initExecution() { - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); this->initMutex(); uint rng_seed = (uint)(PIL_check_seconds_timer_i() & UINT_MAX); - rng_seed ^= (uint)POINTER_AS_INT(m_inputProgram); - m_rng = BLI_rng_new(rng_seed); + rng_seed ^= (uint)POINTER_AS_INT(inputProgram_); + rng_ = BLI_rng_new(rng_seed); } void *ScreenLensDistortionOperation::initializeTileData(rcti * /*rect*/) { - void *buffer = m_inputProgram->initializeTileData(nullptr); + void *buffer = inputProgram_->initializeTileData(nullptr); /* get distortion/dispersion values once, by reading inputs at (0,0) * XXX this assumes invariable values (no image inputs), * we don't have a nice generic system for that yet */ - if (!m_variables_ready) { + if (!variables_ready_) { this->lockMutex(); - if (!m_distortion_const) { + if (!distortion_const_) { float result[4]; getInputSocketReader(1)->readSampled(result, 0, 0, PixelSampler::Nearest); - m_distortion = result[0]; + distortion_ = result[0]; } - if (!m_dispersion_const) { + if (!dispersion_const_) { float result[4]; getInputSocketReader(2)->readSampled(result, 0, 0, PixelSampler::Nearest); - m_dispersion = result[0]; + dispersion_ = result[0]; } - updateVariables(m_distortion, m_dispersion); - m_variables_ready = true; + updateVariables(distortion_, dispersion_); + variables_ready_ = true; this->unlockMutex(); } @@ -125,8 +125,8 @@ void *ScreenLensDistortionOperation::initializeTileData(rcti * /*rect*/) void ScreenLensDistortionOperation::get_uv(const float xy[2], float uv[2]) const { - uv[0] = m_sc * ((xy[0] + 0.5f) - m_cx) / m_cx; - uv[1] = m_sc * ((xy[1] + 0.5f) - m_cy) / m_cy; + uv[0] = sc_ * ((xy[0] + 0.5f) - cx_) / cx_; + uv[1] = sc_ * ((xy[1] + 0.5f) - cy_) / cy_; } void ScreenLensDistortionOperation::distort_uv(const float uv[2], float t, float xy[2]) const @@ -162,14 +162,14 @@ void ScreenLensDistortionOperation::accumulate(const MemoryBuffer *buffer, float color[4]; float dsf = len_v2v2(delta[a], delta[b]) + 1.0f; - int ds = m_jitter ? (dsf < 4.0f ? 2 : (int)sqrtf(dsf)) : (int)dsf; + int ds = jitter_ ? (dsf < 4.0f ? 2 : (int)sqrtf(dsf)) : (int)dsf; float sd = 1.0f / (float)ds; - float k4 = m_k4[a]; - float dk4 = m_dk4[a]; + float k4 = k4_[a]; + float dk4 = dk4_[a]; for (float z = 0; z < ds; z++) { - float tz = (z + (m_jitter ? BLI_rng_get_float(m_rng) : 0.5f)) * sd; + float tz = (z + (jitter_ ? BLI_rng_get_float(rng_) : 0.5f)) * sd; float t = 1.0f - (k4 + tz * dk4) * r_sq; float xy[2]; @@ -202,9 +202,9 @@ void ScreenLensDistortionOperation::executePixel(float output[4], int x, int y, float delta[3][2]; float sum[4] = {0, 0, 0, 0}; - bool valid_r = get_delta(uv_dot, m_k4[0], uv, delta[0]); - bool valid_g = get_delta(uv_dot, m_k4[1], uv, delta[1]); - bool valid_b = get_delta(uv_dot, m_k4[2], uv, delta[2]); + bool valid_r = get_delta(uv_dot, k4_[0], uv, delta[0]); + bool valid_g = get_delta(uv_dot, k4_[1], uv, delta[1]); + bool valid_b = get_delta(uv_dot, k4_[2], uv, delta[2]); if (valid_r && valid_g && valid_b) { accumulate(buffer, 0, 1, uv_dot, uv, delta, sum, count); @@ -231,8 +231,8 @@ void ScreenLensDistortionOperation::executePixel(float output[4], int x, int y, void ScreenLensDistortionOperation::deinitExecution() { this->deinitMutex(); - m_inputProgram = nullptr; - BLI_rng_free(m_rng); + inputProgram_ = nullptr; + BLI_rng_free(rng_); } void ScreenLensDistortionOperation::determineUV(float result[6], float x, float y) const @@ -245,9 +245,9 @@ void ScreenLensDistortionOperation::determineUV(float result[6], float x, float copy_v2_v2(result + 0, xy); copy_v2_v2(result + 2, xy); copy_v2_v2(result + 4, xy); - get_delta(uv_dot, m_k4[0], uv, result + 0); - get_delta(uv_dot, m_k4[1], uv, result + 2); - get_delta(uv_dot, m_k4[2], uv, result + 4); + get_delta(uv_dot, k4_[0], uv, result + 0); + get_delta(uv_dot, k4_[1], uv, result + 2); + get_delta(uv_dot, k4_[2], uv, result + 4); } bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( @@ -293,7 +293,7 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( BLI_rcti_init_minmax(&newInput); - if (m_dispersion_const && m_distortion_const) { + if (dispersion_const_ && distortion_const_) { /* update from fixed distortion/dispersion */ # define UPDATE_INPUT(x, y) \ { \ @@ -315,7 +315,7 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( } else { /* use maximum dispersion 1.0 if not const */ - float dispersion = m_dispersion_const ? m_dispersion : 1.0f; + float dispersion = dispersion_const_ ? dispersion_ : 1.0f; # define UPDATE_INPUT(x, y, distortion) \ { \ @@ -329,12 +329,12 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( } \ (void)0 - if (m_distortion_const) { + if (distortion_const_) { /* update from fixed distortion */ - UPDATE_INPUT(input->xmin, input->xmax, m_distortion); - UPDATE_INPUT(input->xmin, input->ymax, m_distortion); - UPDATE_INPUT(input->xmax, input->ymax, m_distortion); - UPDATE_INPUT(input->xmax, input->ymin, m_distortion); + UPDATE_INPUT(input->xmin, input->xmax, distortion_); + UPDATE_INPUT(input->xmin, input->ymax, distortion_); + UPDATE_INPUT(input->xmax, input->ymax, distortion_); + UPDATE_INPUT(input->xmax, input->ymin, distortion_); } else { /* update from min/max distortion (-1..1) */ @@ -367,18 +367,18 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( void ScreenLensDistortionOperation::updateVariables(float distortion, float dispersion) { - m_k[1] = max_ff(min_ff(distortion, 1.0f), -0.999f); + k_[1] = max_ff(min_ff(distortion, 1.0f), -0.999f); /* Smaller dispersion range for somewhat more control. */ float d = 0.25f * max_ff(min_ff(dispersion, 1.0f), 0.0f); - m_k[0] = max_ff(min_ff((m_k[1] + d), 1.0f), -0.999f); - m_k[2] = max_ff(min_ff((m_k[1] - d), 1.0f), -0.999f); - m_maxk = max_fff(m_k[0], m_k[1], m_k[2]); - m_sc = (m_fit && (m_maxk > 0.0f)) ? (1.0f / (1.0f + 2.0f * m_maxk)) : (1.0f / (1.0f + m_maxk)); - m_dk4[0] = 4.0f * (m_k[1] - m_k[0]); - m_dk4[1] = 4.0f * (m_k[2] - m_k[1]); - m_dk4[2] = 0.0f; /* unused */ - - mul_v3_v3fl(m_k4, m_k, 4.0f); + k_[0] = max_ff(min_ff((k_[1] + d), 1.0f), -0.999f); + k_[2] = max_ff(min_ff((k_[1] - d), 1.0f), -0.999f); + maxk_ = max_fff(k_[0], k_[1], k_[2]); + sc_ = (fit_ && (maxk_ > 0.0f)) ? (1.0f / (1.0f + 2.0f * maxk_)) : (1.0f / (1.0f + maxk_)); + dk4_[0] = 4.0f * (k_[1] - k_[0]); + dk4_[1] = 4.0f * (k_[2] - k_[1]); + dk4_[2] = 0.0f; /* unused */ + + mul_v3_v3fl(k4_, k_, 4.0f); } void ScreenLensDistortionOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -422,7 +422,7 @@ void ScreenLensDistortionOperation::get_area_of_interest(const int input_idx, BLI_rcti_init_minmax(&newInput); - if (m_dispersion_const && m_distortion_const) { + if (dispersion_const_ && distortion_const_) { /* update from fixed distortion/dispersion */ # define UPDATE_INPUT(x, y) \ { \ @@ -444,7 +444,7 @@ void ScreenLensDistortionOperation::get_area_of_interest(const int input_idx, } else { /* use maximum dispersion 1.0 if not const */ - float dispersion = m_dispersion_const ? m_dispersion : 1.0f; + float dispersion = dispersion_const_ ? dispersion_ : 1.0f; # define UPDATE_INPUT(x, y, distortion) \ { \ @@ -458,12 +458,12 @@ void ScreenLensDistortionOperation::get_area_of_interest(const int input_idx, } \ (void)0 - if (m_distortion_const) { + if (distortion_const_) { /* update from fixed distortion */ - UPDATE_INPUT(input->xmin, input->xmax, m_distortion); - UPDATE_INPUT(input->xmin, input->ymax, m_distortion); - UPDATE_INPUT(input->xmax, input->ymax, m_distortion); - UPDATE_INPUT(input->xmax, input->ymin, m_distortion); + UPDATE_INPUT(input->xmin, input->xmax, distortion_); + UPDATE_INPUT(input->xmin, input->ymax, distortion_); + UPDATE_INPUT(input->xmax, input->ymax, distortion_); + UPDATE_INPUT(input->xmax, input->ymin, distortion_); } else { /* update from min/max distortion (-1..1) */ @@ -506,9 +506,9 @@ void ScreenLensDistortionOperation::update_memory_buffer_partial(MemoryBuffer *o const float uv_dot = len_squared_v2(uv); float delta[3][2]; - const bool valid_r = get_delta(uv_dot, m_k4[0], uv, delta[0]); - const bool valid_g = get_delta(uv_dot, m_k4[1], uv, delta[1]); - const bool valid_b = get_delta(uv_dot, m_k4[2], uv, delta[2]); + const bool valid_r = get_delta(uv_dot, k4_[0], uv, delta[0]); + const bool valid_g = get_delta(uv_dot, k4_[1], uv, delta[1]); + const bool valid_b = get_delta(uv_dot, k4_[2], uv, delta[2]); if (!(valid_r && valid_g && valid_b)) { zero_v4(it.out); continue; diff --git a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h index 93681b2f934..8962ee09290 100644 --- a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h +++ b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h @@ -30,22 +30,22 @@ class ScreenLensDistortionOperation : public MultiThreadedOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; - struct RNG *m_rng; - - bool m_fit; - bool m_jitter; - - float m_dispersion; - float m_distortion; - bool m_dispersion_const; - bool m_distortion_const; - bool m_variables_ready; - float m_k[3]; - float m_k4[3]; - float m_dk4[3]; - float m_maxk; - float m_sc, m_cx, m_cy; + SocketReader *inputProgram_; + struct RNG *rng_; + + bool fit_; + bool jitter_; + + float dispersion_; + float distortion_; + bool dispersion_const_; + bool distortion_const_; + bool variables_ready_; + float k_[3]; + float k4_[3]; + float dk4_[3]; + float maxk_; + float sc_, cx_, cy_; public: ScreenLensDistortionOperation(); @@ -70,11 +70,11 @@ class ScreenLensDistortionOperation : public MultiThreadedOperation { void setFit(bool fit) { - m_fit = fit; + fit_ = fit; } void setJitter(bool jitter) { - m_jitter = jitter; + jitter_ = jitter; } /** Set constant distortion value */ diff --git a/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.cc b/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.cc index da930186901..2f11e1dbb18 100644 --- a/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.cc +++ b/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.cc @@ -26,15 +26,15 @@ SetAlphaMultiplyOperation::SetAlphaMultiplyOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputColor = nullptr; - m_inputAlpha = nullptr; + inputColor_ = nullptr; + inputAlpha_ = nullptr; this->flags.can_be_constant = true; } void SetAlphaMultiplyOperation::initExecution() { - m_inputColor = getInputSocketReader(0); - m_inputAlpha = getInputSocketReader(1); + inputColor_ = getInputSocketReader(0); + inputAlpha_ = getInputSocketReader(1); } void SetAlphaMultiplyOperation::executePixelSampled(float output[4], @@ -45,16 +45,16 @@ void SetAlphaMultiplyOperation::executePixelSampled(float output[4], float color_input[4]; float alpha_input[4]; - m_inputColor->readSampled(color_input, x, y, sampler); - m_inputAlpha->readSampled(alpha_input, x, y, sampler); + inputColor_->readSampled(color_input, x, y, sampler); + inputAlpha_->readSampled(alpha_input, x, y, sampler); mul_v4_v4fl(output, color_input, alpha_input[0]); } void SetAlphaMultiplyOperation::deinitExecution() { - m_inputColor = nullptr; - m_inputAlpha = nullptr; + inputColor_ = nullptr; + inputAlpha_ = nullptr; } void SetAlphaMultiplyOperation::update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.h b/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.h index 44885318901..77f61e976e1 100644 --- a/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.h +++ b/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.h @@ -29,8 +29,8 @@ namespace blender::compositor { */ class SetAlphaMultiplyOperation : public MultiThreadedOperation { private: - SocketReader *m_inputColor; - SocketReader *m_inputAlpha; + SocketReader *inputColor_; + SocketReader *inputAlpha_; public: SetAlphaMultiplyOperation(); diff --git a/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.cc b/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.cc index 5abb490d698..09539d2fe57 100644 --- a/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.cc +++ b/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.cc @@ -26,15 +26,15 @@ SetAlphaReplaceOperation::SetAlphaReplaceOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_inputColor = nullptr; - m_inputAlpha = nullptr; + inputColor_ = nullptr; + inputAlpha_ = nullptr; this->flags.can_be_constant = true; } void SetAlphaReplaceOperation::initExecution() { - m_inputColor = getInputSocketReader(0); - m_inputAlpha = getInputSocketReader(1); + inputColor_ = getInputSocketReader(0); + inputAlpha_ = getInputSocketReader(1); } void SetAlphaReplaceOperation::executePixelSampled(float output[4], @@ -44,15 +44,15 @@ void SetAlphaReplaceOperation::executePixelSampled(float output[4], { float alpha_input[4]; - m_inputColor->readSampled(output, x, y, sampler); - m_inputAlpha->readSampled(alpha_input, x, y, sampler); + inputColor_->readSampled(output, x, y, sampler); + inputAlpha_->readSampled(alpha_input, x, y, sampler); output[3] = alpha_input[0]; } void SetAlphaReplaceOperation::deinitExecution() { - m_inputColor = nullptr; - m_inputAlpha = nullptr; + inputColor_ = nullptr; + inputAlpha_ = nullptr; } void SetAlphaReplaceOperation::update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.h b/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.h index 2c2d4cddf5b..9c295eec3bd 100644 --- a/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.h +++ b/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.h @@ -28,8 +28,8 @@ namespace blender::compositor { */ class SetAlphaReplaceOperation : public MultiThreadedOperation { private: - SocketReader *m_inputColor; - SocketReader *m_inputAlpha; + SocketReader *inputColor_; + SocketReader *inputAlpha_; public: /** diff --git a/source/blender/compositor/operations/COM_SetColorOperation.cc b/source/blender/compositor/operations/COM_SetColorOperation.cc index 25969821931..8700ba7496b 100644 --- a/source/blender/compositor/operations/COM_SetColorOperation.cc +++ b/source/blender/compositor/operations/COM_SetColorOperation.cc @@ -31,7 +31,7 @@ void SetColorOperation::executePixelSampled(float output[4], float /*y*/, PixelSampler /*sampler*/) { - copy_v4_v4(output, m_color); + copy_v4_v4(output, color_); } void SetColorOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) diff --git a/source/blender/compositor/operations/COM_SetColorOperation.h b/source/blender/compositor/operations/COM_SetColorOperation.h index b529d245091..ad30c1d820d 100644 --- a/source/blender/compositor/operations/COM_SetColorOperation.h +++ b/source/blender/compositor/operations/COM_SetColorOperation.h @@ -28,7 +28,7 @@ namespace blender::compositor { */ class SetColorOperation : public ConstantOperation { private: - float m_color[4]; + float color_[4]; public: /** @@ -38,44 +38,44 @@ class SetColorOperation : public ConstantOperation { const float *get_constant_elem() override { - return m_color; + return color_; } float getChannel1() { - return m_color[0]; + return color_[0]; } void setChannel1(float value) { - m_color[0] = value; + color_[0] = value; } float getChannel2() { - return m_color[1]; + return color_[1]; } void setChannel2(float value) { - m_color[1] = value; + color_[1] = value; } float getChannel3() { - return m_color[2]; + return color_[2]; } void setChannel3(float value) { - m_color[2] = value; + color_[2] = value; } float getChannel4() { - return m_color[3]; + return color_[3]; } void setChannel4(const float value) { - m_color[3] = value; + color_[3] = value; } void setChannels(const float value[4]) { - copy_v4_v4(m_color, value); + copy_v4_v4(color_, value); } /** diff --git a/source/blender/compositor/operations/COM_SetSamplerOperation.cc b/source/blender/compositor/operations/COM_SetSamplerOperation.cc index eb7eedb2bd5..7919b885556 100644 --- a/source/blender/compositor/operations/COM_SetSamplerOperation.cc +++ b/source/blender/compositor/operations/COM_SetSamplerOperation.cc @@ -28,11 +28,11 @@ SetSamplerOperation::SetSamplerOperation() void SetSamplerOperation::initExecution() { - m_reader = this->getInputSocketReader(0); + reader_ = this->getInputSocketReader(0); } void SetSamplerOperation::deinitExecution() { - m_reader = nullptr; + reader_ = nullptr; } void SetSamplerOperation::executePixelSampled(float output[4], @@ -40,7 +40,7 @@ void SetSamplerOperation::executePixelSampled(float output[4], float y, PixelSampler /*sampler*/) { - m_reader->readSampled(output, x, y, m_sampler); + reader_->readSampled(output, x, y, sampler_); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_SetSamplerOperation.h b/source/blender/compositor/operations/COM_SetSamplerOperation.h index 0b6c1f2ccff..87b232cbfa7 100644 --- a/source/blender/compositor/operations/COM_SetSamplerOperation.h +++ b/source/blender/compositor/operations/COM_SetSamplerOperation.h @@ -28,8 +28,8 @@ namespace blender::compositor { */ class SetSamplerOperation : public NodeOperation { private: - PixelSampler m_sampler; - SocketReader *m_reader; + PixelSampler sampler_; + SocketReader *reader_; public: /** @@ -39,7 +39,7 @@ class SetSamplerOperation : public NodeOperation { void setSampler(PixelSampler sampler) { - m_sampler = sampler; + sampler_ = sampler; } /** diff --git a/source/blender/compositor/operations/COM_SetValueOperation.cc b/source/blender/compositor/operations/COM_SetValueOperation.cc index 4db0963f45b..b5e2f50338f 100644 --- a/source/blender/compositor/operations/COM_SetValueOperation.cc +++ b/source/blender/compositor/operations/COM_SetValueOperation.cc @@ -31,7 +31,7 @@ void SetValueOperation::executePixelSampled(float output[4], float /*y*/, PixelSampler /*sampler*/) { - output[0] = m_value; + output[0] = value_; } void SetValueOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) diff --git a/source/blender/compositor/operations/COM_SetValueOperation.h b/source/blender/compositor/operations/COM_SetValueOperation.h index 25f5e806eaf..bf914d2f918 100644 --- a/source/blender/compositor/operations/COM_SetValueOperation.h +++ b/source/blender/compositor/operations/COM_SetValueOperation.h @@ -28,7 +28,7 @@ namespace blender::compositor { */ class SetValueOperation : public ConstantOperation { private: - float m_value; + float value_; public: /** @@ -38,16 +38,16 @@ class SetValueOperation : public ConstantOperation { const float *get_constant_elem() override { - return &m_value; + return &value_; } float getValue() { - return m_value; + return value_; } void setValue(float value) { - m_value = value; + value_ = value; } /** diff --git a/source/blender/compositor/operations/COM_SplitOperation.cc b/source/blender/compositor/operations/COM_SplitOperation.cc index 794934a741a..99db558343d 100644 --- a/source/blender/compositor/operations/COM_SplitOperation.cc +++ b/source/blender/compositor/operations/COM_SplitOperation.cc @@ -25,21 +25,21 @@ SplitOperation::SplitOperation() this->addInputSocket(DataType::Color); this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_image1Input = nullptr; - m_image2Input = nullptr; + image1Input_ = nullptr; + image2Input_ = nullptr; } void SplitOperation::initExecution() { /* When initializing the tree during initial load the width and height can be zero. */ - m_image1Input = getInputSocketReader(0); - m_image2Input = getInputSocketReader(1); + image1Input_ = getInputSocketReader(0); + image2Input_ = getInputSocketReader(1); } void SplitOperation::deinitExecution() { - m_image1Input = nullptr; - m_image2Input = nullptr; + image1Input_ = nullptr; + image2Input_ = nullptr; } void SplitOperation::executePixelSampled(float output[4], @@ -47,14 +47,14 @@ void SplitOperation::executePixelSampled(float output[4], float y, PixelSampler /*sampler*/) { - int perc = m_xSplit ? m_splitPercentage * this->getWidth() / 100.0f : - m_splitPercentage * this->getHeight() / 100.0f; - bool image1 = m_xSplit ? x > perc : y > perc; + int perc = xSplit_ ? splitPercentage_ * this->getWidth() / 100.0f : + splitPercentage_ * this->getHeight() / 100.0f; + bool image1 = xSplit_ ? x > perc : y > perc; if (image1) { - m_image1Input->readSampled(output, x, y, PixelSampler::Nearest); + image1Input_->readSampled(output, x, y, PixelSampler::Nearest); } else { - m_image2Input->readSampled(output, x, y, PixelSampler::Nearest); + image2Input_->readSampled(output, x, y, PixelSampler::Nearest); } } @@ -72,11 +72,11 @@ void SplitOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - const int percent = m_xSplit ? m_splitPercentage * this->getWidth() / 100.0f : - m_splitPercentage * this->getHeight() / 100.0f; + const int percent = xSplit_ ? splitPercentage_ * this->getWidth() / 100.0f : + splitPercentage_ * this->getHeight() / 100.0f; const size_t elem_bytes = COM_data_type_bytes_len(getOutputSocket()->getDataType()); for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { - const bool is_image1 = m_xSplit ? it.x > percent : it.y > percent; + const bool is_image1 = xSplit_ ? it.x > percent : it.y > percent; memcpy(it.out, it.in(is_image1 ? 0 : 1), elem_bytes); } } diff --git a/source/blender/compositor/operations/COM_SplitOperation.h b/source/blender/compositor/operations/COM_SplitOperation.h index ae4d83fd059..9f594793be5 100644 --- a/source/blender/compositor/operations/COM_SplitOperation.h +++ b/source/blender/compositor/operations/COM_SplitOperation.h @@ -24,11 +24,11 @@ namespace blender::compositor { class SplitOperation : public MultiThreadedOperation { private: - SocketReader *m_image1Input; - SocketReader *m_image2Input; + SocketReader *image1Input_; + SocketReader *image2Input_; - float m_splitPercentage; - bool m_xSplit; + float splitPercentage_; + bool xSplit_; public: SplitOperation(); @@ -38,11 +38,11 @@ class SplitOperation : public MultiThreadedOperation { void determine_canvas(const rcti &preferred_area, rcti &r_area) override; void setSplitPercentage(float splitPercentage) { - m_splitPercentage = splitPercentage; + splitPercentage_ = splitPercentage; } void setXSplit(bool xsplit) { - m_xSplit = xsplit; + xSplit_ = xsplit; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_SunBeamsOperation.cc b/source/blender/compositor/operations/COM_SunBeamsOperation.cc index b71350fd472..b055d0a7644 100644 --- a/source/blender/compositor/operations/COM_SunBeamsOperation.cc +++ b/source/blender/compositor/operations/COM_SunBeamsOperation.cc @@ -33,9 +33,9 @@ SunBeamsOperation::SunBeamsOperation() void SunBeamsOperation::calc_rays_common_data() { /* convert to pixels */ - m_source_px[0] = m_data.source[0] * this->getWidth(); - m_source_px[1] = m_data.source[1] * this->getHeight(); - m_ray_length_px = m_data.ray_length * MAX2(this->getWidth(), this->getHeight()); + source_px_[0] = data_.source[0] * this->getWidth(); + source_px_[1] = data_.source[1] * this->getHeight(); + ray_length_px_ = data_.ray_length * MAX2(this->getWidth(), this->getHeight()); } void SunBeamsOperation::initExecution() @@ -322,7 +322,7 @@ void SunBeamsOperation::executePixel(float output[4], int x, int y, void *data) { const float co[2] = {(float)x, (float)y}; - accumulate_line((MemoryBuffer *)data, output, co, m_source_px, 0.0f, m_ray_length_px); + accumulate_line((MemoryBuffer *)data, output, co, source_px_, 0.0f, ray_length_px_); } static void calc_ray_shift(rcti *rect, float x, float y, const float source[2], float ray_length) @@ -349,10 +349,10 @@ bool SunBeamsOperation::determineDependingAreaOfInterest(rcti *input, * and gives a rect that contains all possible accumulated pixels. */ rcti rect = *input; - calc_ray_shift(&rect, input->xmin, input->ymin, m_source_px, m_ray_length_px); - calc_ray_shift(&rect, input->xmin, input->ymax, m_source_px, m_ray_length_px); - calc_ray_shift(&rect, input->xmax, input->ymin, m_source_px, m_ray_length_px); - calc_ray_shift(&rect, input->xmax, input->ymax, m_source_px, m_ray_length_px); + calc_ray_shift(&rect, input->xmin, input->ymin, source_px_, ray_length_px_); + calc_ray_shift(&rect, input->xmin, input->ymax, source_px_, ray_length_px_); + calc_ray_shift(&rect, input->xmax, input->ymin, source_px_, ray_length_px_); + calc_ray_shift(&rect, input->xmax, input->ymax, source_px_, ray_length_px_); return NodeOperation::determineDependingAreaOfInterest(&rect, readOperation, output); } @@ -369,10 +369,10 @@ void SunBeamsOperation::get_area_of_interest(const int input_idx, /* Enlarges the rect by moving each corner toward the source. * This is the maximum distance that pixels can influence each other * and gives a rect that contains all possible accumulated pixels. */ - calc_ray_shift(&r_input_area, output_area.xmin, output_area.ymin, m_source_px, m_ray_length_px); - calc_ray_shift(&r_input_area, output_area.xmin, output_area.ymax, m_source_px, m_ray_length_px); - calc_ray_shift(&r_input_area, output_area.xmax, output_area.ymin, m_source_px, m_ray_length_px); - calc_ray_shift(&r_input_area, output_area.xmax, output_area.ymax, m_source_px, m_ray_length_px); + calc_ray_shift(&r_input_area, output_area.xmin, output_area.ymin, source_px_, ray_length_px_); + calc_ray_shift(&r_input_area, output_area.xmin, output_area.ymax, source_px_, ray_length_px_); + calc_ray_shift(&r_input_area, output_area.xmax, output_area.ymin, source_px_, ray_length_px_); + calc_ray_shift(&r_input_area, output_area.xmax, output_area.ymax, source_px_, ray_length_px_); } void SunBeamsOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -386,7 +386,7 @@ void SunBeamsOperation::update_memory_buffer_partial(MemoryBuffer *output, float *out_elem = output->get_elem(area.xmin, y); for (int x = area.xmin; x < area.xmax; x++) { coords[0] = x; - accumulate_line(input, out_elem, coords, m_source_px, 0.0f, m_ray_length_px); + accumulate_line(input, out_elem, coords, source_px_, 0.0f, ray_length_px_); out_elem += output->elem_stride; } } diff --git a/source/blender/compositor/operations/COM_SunBeamsOperation.h b/source/blender/compositor/operations/COM_SunBeamsOperation.h index 71fc04453fe..2a62be065a4 100644 --- a/source/blender/compositor/operations/COM_SunBeamsOperation.h +++ b/source/blender/compositor/operations/COM_SunBeamsOperation.h @@ -37,7 +37,7 @@ class SunBeamsOperation : public MultiThreadedOperation { void setData(const NodeSunBeams &data) { - m_data = data; + data_ = data; } void update_memory_buffer_partial(MemoryBuffer *output, @@ -49,10 +49,10 @@ class SunBeamsOperation : public MultiThreadedOperation { void calc_rays_common_data(); private: - NodeSunBeams m_data; + NodeSunBeams data_; - float m_source_px[2]; - float m_ray_length_px; + float source_px_[2]; + float ray_length_px_; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_TextureOperation.cc b/source/blender/compositor/operations/COM_TextureOperation.cc index 994379c35c1..7c18b8214de 100644 --- a/source/blender/compositor/operations/COM_TextureOperation.cc +++ b/source/blender/compositor/operations/COM_TextureOperation.cc @@ -28,12 +28,12 @@ TextureBaseOperation::TextureBaseOperation() { this->addInputSocket(DataType::Vector); // offset this->addInputSocket(DataType::Vector); // size - m_texture = nullptr; - m_inputSize = nullptr; - m_inputOffset = nullptr; - m_rd = nullptr; - m_pool = nullptr; - m_sceneColorManage = false; + texture_ = nullptr; + inputSize_ = nullptr; + inputOffset_ = nullptr; + rd_ = nullptr; + pool_ = nullptr; + sceneColorManage_ = false; flags.complex = true; } TextureOperation::TextureOperation() : TextureBaseOperation() @@ -47,23 +47,23 @@ TextureAlphaOperation::TextureAlphaOperation() : TextureBaseOperation() void TextureBaseOperation::initExecution() { - m_inputOffset = getInputSocketReader(0); - m_inputSize = getInputSocketReader(1); - m_pool = BKE_image_pool_new(); - if (m_texture != nullptr && m_texture->nodetree != nullptr && m_texture->use_nodes) { - ntreeTexBeginExecTree(m_texture->nodetree); + inputOffset_ = getInputSocketReader(0); + inputSize_ = getInputSocketReader(1); + pool_ = BKE_image_pool_new(); + if (texture_ != nullptr && texture_->nodetree != nullptr && texture_->use_nodes) { + ntreeTexBeginExecTree(texture_->nodetree); } NodeOperation::initExecution(); } void TextureBaseOperation::deinitExecution() { - m_inputSize = nullptr; - m_inputOffset = nullptr; - BKE_image_pool_free(m_pool); - m_pool = nullptr; - if (m_texture != nullptr && m_texture->use_nodes && m_texture->nodetree != nullptr && - m_texture->nodetree->execdata != nullptr) { - ntreeTexEndExecTree(m_texture->nodetree->execdata); + inputSize_ = nullptr; + inputOffset_ = nullptr; + BKE_image_pool_free(pool_); + pool_ = nullptr; + if (texture_ != nullptr && texture_->use_nodes && texture_->nodetree != nullptr && + texture_->nodetree->execdata != nullptr) { + ntreeTexEndExecTree(texture_->nodetree->execdata); } NodeOperation::deinitExecution(); } @@ -72,8 +72,8 @@ void TextureBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_ { r_area = preferred_area; if (BLI_rcti_is_empty(&preferred_area)) { - int width = m_rd->xsch * m_rd->size / 100; - int height = m_rd->ysch * m_rd->size / 100; + int width = rd_->xsch * rd_->size / 100; + int height = rd_->ysch * rd_->size / 100; r_area.xmax = preferred_area.xmin + width; r_area.ymax = preferred_area.ymin + height; } @@ -115,13 +115,13 @@ void TextureBaseOperation::executePixelSampled(float output[4], * interpolation and (b) in such configuration multitex() simply floor's the value * which often produces artifacts. */ - if (m_texture != nullptr && (m_texture->imaflag & TEX_INTERPOL) == 0) { + if (texture_ != nullptr && (texture_->imaflag & TEX_INTERPOL) == 0) { u += 0.5f / cx; v += 0.5f / cy; } - m_inputSize->readSampled(textureSize, x, y, sampler); - m_inputOffset->readSampled(textureOffset, x, y, sampler); + inputSize_->readSampled(textureSize, x, y, sampler); + inputOffset_->readSampled(textureOffset, x, y, sampler); vec[0] = textureSize[0] * (u + textureOffset[0]); vec[1] = textureSize[1] * (v + textureOffset[1]); @@ -129,7 +129,7 @@ void TextureBaseOperation::executePixelSampled(float output[4], const int thread_id = WorkScheduler::current_thread_id(); retval = multitex_ext( - m_texture, vec, nullptr, nullptr, 0, &texres, thread_id, m_pool, m_sceneColorManage, false); + texture_, vec, nullptr, nullptr, 0, &texres, thread_id, pool_, sceneColorManage_, false); output[3] = texres.talpha ? texres.ta : texres.tin; if (retval & TEX_RGB) { @@ -164,7 +164,7 @@ void TextureBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, * interpolation and (b) in such configuration multitex() simply floor's the value * which often produces artifacts. */ - if (m_texture != nullptr && (m_texture->imaflag & TEX_INTERPOL) == 0) { + if (texture_ != nullptr && (texture_->imaflag & TEX_INTERPOL) == 0) { u += 0.5f / center_x; v += 0.5f / center_y; } @@ -173,15 +173,15 @@ void TextureBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, vec[1] = tex_size[1] * (v + tex_offset[1]); vec[2] = tex_size[2] * tex_offset[2]; - const int retval = multitex_ext(m_texture, + const int retval = multitex_ext(texture_, vec, nullptr, nullptr, 0, &tex_result, thread_id, - m_pool, - m_sceneColorManage, + pool_, + sceneColorManage_, false); it.out[3] = tex_result.talpha ? tex_result.ta : tex_result.tin; diff --git a/source/blender/compositor/operations/COM_TextureOperation.h b/source/blender/compositor/operations/COM_TextureOperation.h index 2efb76e8c37..3916f82c77b 100644 --- a/source/blender/compositor/operations/COM_TextureOperation.h +++ b/source/blender/compositor/operations/COM_TextureOperation.h @@ -35,12 +35,12 @@ namespace blender::compositor { */ class TextureBaseOperation : public MultiThreadedOperation { private: - Tex *m_texture; - const RenderData *m_rd; - SocketReader *m_inputSize; - SocketReader *m_inputOffset; - struct ImagePool *m_pool; - bool m_sceneColorManage; + Tex *texture_; + const RenderData *rd_; + SocketReader *inputSize_; + SocketReader *inputOffset_; + struct ImagePool *pool_; + bool sceneColorManage_; protected: /** @@ -58,17 +58,17 @@ class TextureBaseOperation : public MultiThreadedOperation { void setTexture(Tex *texture) { - m_texture = texture; + texture_ = texture; } void initExecution() override; void deinitExecution() override; void setRenderData(const RenderData *rd) { - m_rd = rd; + rd_ = rd; } void setSceneColorManage(bool sceneColorManage) { - m_sceneColorManage = sceneColorManage; + sceneColorManage_ = sceneColorManage; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_TonemapOperation.cc b/source/blender/compositor/operations/COM_TonemapOperation.cc index 4d2a9a7f965..b9d67ec8be3 100644 --- a/source/blender/compositor/operations/COM_TonemapOperation.cc +++ b/source/blender/compositor/operations/COM_TonemapOperation.cc @@ -28,14 +28,14 @@ TonemapOperation::TonemapOperation() { this->addInputSocket(DataType::Color, ResizeMode::Align); this->addOutputSocket(DataType::Color); - m_imageReader = nullptr; - m_data = nullptr; - m_cachedInstance = nullptr; + imageReader_ = nullptr; + data_ = nullptr; + cachedInstance_ = nullptr; this->flags.complex = true; } void TonemapOperation::initExecution() { - m_imageReader = this->getInputSocketReader(0); + imageReader_ = this->getInputSocketReader(0); NodeOperation::initMutex(); } @@ -43,11 +43,11 @@ void TonemapOperation::executePixel(float output[4], int x, int y, void *data) { AvgLogLum *avg = (AvgLogLum *)data; - m_imageReader->read(output, x, y, nullptr); + imageReader_->read(output, x, y, nullptr); mul_v3_fl(output, avg->al); - float dr = output[0] + m_data->offset; - float dg = output[1] + m_data->offset; - float db = output[2] + m_data->offset; + float dr = output[0] + data_->offset; + float dg = output[1] + data_->offset; + float db = output[2] + data_->offset; output[0] /= ((dr == 0.0f) ? 1.0f : dr); output[1] /= ((dg == 0.0f) ? 1.0f : dg); output[2] /= ((db == 0.0f) ? 1.0f : db); @@ -61,13 +61,13 @@ void TonemapOperation::executePixel(float output[4], int x, int y, void *data) void PhotoreceptorTonemapOperation::executePixel(float output[4], int x, int y, void *data) { AvgLogLum *avg = (AvgLogLum *)data; - NodeTonemap *ntm = m_data; + NodeTonemap *ntm = data_; - const float f = expf(-m_data->f); + const float f = expf(-data_->f); const float m = (ntm->m > 0.0f) ? ntm->m : (0.3f + 0.7f * powf(avg->auto_key, 1.4f)); const float ic = 1.0f - ntm->c, ia = 1.0f - ntm->a; - m_imageReader->read(output, x, y, nullptr); + imageReader_->read(output, x, y, nullptr); const float L = IMB_colormanagement_get_luminance(output); float I_l = output[0] + ic * (L - output[0]); @@ -86,8 +86,8 @@ void PhotoreceptorTonemapOperation::executePixel(float output[4], int x, int y, void TonemapOperation::deinitExecution() { - m_imageReader = nullptr; - delete m_cachedInstance; + imageReader_ = nullptr; + delete cachedInstance_; NodeOperation::deinitMutex(); } @@ -111,8 +111,8 @@ bool TonemapOperation::determineDependingAreaOfInterest(rcti * /*input*/, void *TonemapOperation::initializeTileData(rcti *rect) { lockMutex(); - if (m_cachedInstance == nullptr) { - MemoryBuffer *tile = (MemoryBuffer *)m_imageReader->initializeTileData(rect); + if (cachedInstance_ == nullptr) { + MemoryBuffer *tile = (MemoryBuffer *)imageReader_->initializeTileData(rect); AvgLogLum *data = new AvgLogLum(); float *buffer = tile->getBuffer(); @@ -140,12 +140,12 @@ void *TonemapOperation::initializeTileData(rcti *rect) avl = lsum * sc; data->auto_key = (maxl > minl) ? ((maxl - avl) / (maxl - minl)) : 1.0f; float al = exp((double)avl); - data->al = (al == 0.0f) ? 0.0f : (m_data->key / al); - data->igm = (m_data->gamma == 0.0f) ? 1 : (1.0f / m_data->gamma); - m_cachedInstance = data; + data->al = (al == 0.0f) ? 0.0f : (data_->key / al); + data->igm = (data_->gamma == 0.0f) ? 1 : (1.0f / data_->gamma); + cachedInstance_ = data; } unlockMutex(); - return m_cachedInstance; + return cachedInstance_; } void TonemapOperation::deinitializeTileData(rcti * /*rect*/, void * /*data*/) @@ -189,7 +189,7 @@ void TonemapOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output) const rcti &UNUSED(area), Span<MemoryBuffer *> inputs) { - if (m_cachedInstance == nullptr) { + if (cachedInstance_ == nullptr) { Luminance lum = {0}; const MemoryBuffer *input = inputs[0]; exec_system_->execute_work<Luminance>( @@ -213,9 +213,9 @@ void TonemapOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output) const float avg_log = lum.log_sum / lum.num_pixels; avg->auto_key = (max_log > min_log) ? ((max_log - avg_log) / (max_log - min_log)) : 1.0f; const float al = exp((double)avg_log); - avg->al = (al == 0.0f) ? 0.0f : (m_data->key / al); - avg->igm = (m_data->gamma == 0.0f) ? 1 : (1.0f / m_data->gamma); - m_cachedInstance = avg; + avg->al = (al == 0.0f) ? 0.0f : (data_->key / al); + avg->igm = (data_->gamma == 0.0f) ? 1 : (1.0f / data_->gamma); + cachedInstance_ = avg; } } @@ -223,9 +223,9 @@ void TonemapOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - AvgLogLum *avg = m_cachedInstance; + AvgLogLum *avg = cachedInstance_; const float igm = avg->igm; - const float offset = m_data->offset; + const float offset = data_->offset; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { copy_v4_v4(it.out, it.in(0)); mul_v3_fl(it.out, avg->al); @@ -247,9 +247,9 @@ void PhotoreceptorTonemapOperation::update_memory_buffer_partial(MemoryBuffer *o const rcti &area, Span<MemoryBuffer *> inputs) { - AvgLogLum *avg = m_cachedInstance; - NodeTonemap *ntm = m_data; - const float f = expf(-m_data->f); + AvgLogLum *avg = cachedInstance_; + NodeTonemap *ntm = data_; + const float f = expf(-data_->f); const float m = (ntm->m > 0.0f) ? ntm->m : (0.3f + 0.7f * powf(avg->auto_key, 1.4f)); const float ic = 1.0f - ntm->c; const float ia = 1.0f - ntm->a; diff --git a/source/blender/compositor/operations/COM_TonemapOperation.h b/source/blender/compositor/operations/COM_TonemapOperation.h index 7fe496ba107..c04ee4fcbe9 100644 --- a/source/blender/compositor/operations/COM_TonemapOperation.h +++ b/source/blender/compositor/operations/COM_TonemapOperation.h @@ -44,17 +44,17 @@ class TonemapOperation : public MultiThreadedOperation { /** * \brief Cached reference to the reader */ - SocketReader *m_imageReader; + SocketReader *imageReader_; /** * \brief settings of the Tonemap */ - NodeTonemap *m_data; + NodeTonemap *data_; /** * \brief temporarily cache of the execution storage */ - AvgLogLum *m_cachedInstance; + AvgLogLum *cachedInstance_; public: TonemapOperation(); @@ -79,7 +79,7 @@ class TonemapOperation : public MultiThreadedOperation { void setData(NodeTonemap *data) { - m_data = data; + data_ = data; } bool determineDependingAreaOfInterest(rcti *input, diff --git a/source/blender/compositor/operations/COM_TrackPositionOperation.cc b/source/blender/compositor/operations/COM_TrackPositionOperation.cc index c424ece572d..d9e55011d16 100644 --- a/source/blender/compositor/operations/COM_TrackPositionOperation.cc +++ b/source/blender/compositor/operations/COM_TrackPositionOperation.cc @@ -27,14 +27,14 @@ namespace blender::compositor { TrackPositionOperation::TrackPositionOperation() { this->addOutputSocket(DataType::Value); - m_movieClip = nullptr; - m_framenumber = 0; - m_trackingObjectName[0] = 0; - m_trackName[0] = 0; - m_axis = 0; - m_position = CMP_TRACKPOS_ABSOLUTE; - m_relativeFrame = 0; - m_speed_output = false; + movieClip_ = nullptr; + framenumber_ = 0; + trackingObjectName_[0] = 0; + trackName_[0] = 0; + axis_ = 0; + position_ = CMP_TRACKPOS_ABSOLUTE; + relativeFrame_ = 0; + speed_output_ = false; flags.is_set_operation = true; is_track_position_calculated_ = false; } @@ -54,76 +54,76 @@ void TrackPositionOperation::calc_track_position() MovieTrackingObject *object; track_position_ = 0; - zero_v2(m_markerPos); - zero_v2(m_relativePos); + zero_v2(markerPos_); + zero_v2(relativePos_); - if (!m_movieClip) { + if (!movieClip_) { return; } - tracking = &m_movieClip->tracking; + tracking = &movieClip_->tracking; - BKE_movieclip_user_set_frame(&user, m_framenumber); - BKE_movieclip_get_size(m_movieClip, &user, &m_width, &m_height); + BKE_movieclip_user_set_frame(&user, framenumber_); + BKE_movieclip_get_size(movieClip_, &user, &width_, &height_); - object = BKE_tracking_object_get_named(tracking, m_trackingObjectName); + object = BKE_tracking_object_get_named(tracking, trackingObjectName_); if (object) { MovieTrackingTrack *track; - track = BKE_tracking_track_get_named(tracking, object, m_trackName); + track = BKE_tracking_track_get_named(tracking, object, trackName_); if (track) { MovieTrackingMarker *marker; - int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(m_movieClip, m_framenumber); + int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, framenumber_); marker = BKE_tracking_marker_get(track, clip_framenr); - copy_v2_v2(m_markerPos, marker->pos); + copy_v2_v2(markerPos_, marker->pos); - if (m_speed_output) { - int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(m_movieClip, - m_relativeFrame); + if (speed_output_) { + int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, + relativeFrame_); marker = BKE_tracking_marker_get_exact(track, relative_clip_framenr); if (marker != nullptr && (marker->flag & MARKER_DISABLED) == 0) { - copy_v2_v2(m_relativePos, marker->pos); + copy_v2_v2(relativePos_, marker->pos); } else { - copy_v2_v2(m_relativePos, m_markerPos); + copy_v2_v2(relativePos_, markerPos_); } - if (m_relativeFrame < m_framenumber) { - swap_v2_v2(m_relativePos, m_markerPos); + if (relativeFrame_ < framenumber_) { + swap_v2_v2(relativePos_, markerPos_); } } - else if (m_position == CMP_TRACKPOS_RELATIVE_START) { + else if (position_ == CMP_TRACKPOS_RELATIVE_START) { int i; for (i = 0; i < track->markersnr; i++) { marker = &track->markers[i]; if ((marker->flag & MARKER_DISABLED) == 0) { - copy_v2_v2(m_relativePos, marker->pos); + copy_v2_v2(relativePos_, marker->pos); break; } } } - else if (m_position == CMP_TRACKPOS_RELATIVE_FRAME) { - int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(m_movieClip, - m_relativeFrame); + else if (position_ == CMP_TRACKPOS_RELATIVE_FRAME) { + int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, + relativeFrame_); marker = BKE_tracking_marker_get(track, relative_clip_framenr); - copy_v2_v2(m_relativePos, marker->pos); + copy_v2_v2(relativePos_, marker->pos); } } } - track_position_ = m_markerPos[m_axis] - m_relativePos[m_axis]; - if (m_axis == 0) { - track_position_ *= m_width; + track_position_ = markerPos_[axis_] - relativePos_[axis_]; + if (axis_ == 0) { + track_position_ *= width_; } else { - track_position_ *= m_height; + track_position_ *= height_; } } @@ -132,13 +132,13 @@ void TrackPositionOperation::executePixelSampled(float output[4], float /*y*/, PixelSampler /*sampler*/) { - output[0] = m_markerPos[m_axis] - m_relativePos[m_axis]; + output[0] = markerPos_[axis_] - relativePos_[axis_]; - if (m_axis == 0) { - output[0] *= m_width; + if (axis_ == 0) { + output[0] *= width_; } else { - output[0] *= m_height; + output[0] *= height_; } } diff --git a/source/blender/compositor/operations/COM_TrackPositionOperation.h b/source/blender/compositor/operations/COM_TrackPositionOperation.h index 8fcbf6d31af..25e5a144228 100644 --- a/source/blender/compositor/operations/COM_TrackPositionOperation.h +++ b/source/blender/compositor/operations/COM_TrackPositionOperation.h @@ -35,18 +35,18 @@ namespace blender::compositor { */ class TrackPositionOperation : public ConstantOperation { protected: - MovieClip *m_movieClip; - int m_framenumber; - char m_trackingObjectName[64]; - char m_trackName[64]; - int m_axis; - int m_position; - int m_relativeFrame; - bool m_speed_output; - - int m_width, m_height; - float m_markerPos[2]; - float m_relativePos[2]; + MovieClip *movieClip_; + int framenumber_; + char trackingObjectName_[64]; + char trackName_[64]; + int axis_; + int position_; + int relativeFrame_; + bool speed_output_; + + int width_, height_; + float markerPos_[2]; + float relativePos_[2]; float track_position_; bool is_track_position_calculated_; @@ -60,35 +60,35 @@ class TrackPositionOperation : public ConstantOperation { void setMovieClip(MovieClip *clip) { - m_movieClip = clip; + movieClip_ = clip; } void setTrackingObject(char *object) { - BLI_strncpy(m_trackingObjectName, object, sizeof(m_trackingObjectName)); + BLI_strncpy(trackingObjectName_, object, sizeof(trackingObjectName_)); } void setTrackName(char *track) { - BLI_strncpy(m_trackName, track, sizeof(m_trackName)); + BLI_strncpy(trackName_, track, sizeof(trackName_)); } void setFramenumber(int framenumber) { - m_framenumber = framenumber; + framenumber_ = framenumber; } void setAxis(int value) { - m_axis = value; + axis_ = value; } void setPosition(int value) { - m_position = value; + position_ = value; } void setRelativeFrame(int value) { - m_relativeFrame = value; + relativeFrame_ = value; } void setSpeedOutput(bool speed_output) { - m_speed_output = speed_output; + speed_output_ = speed_output; } void initExecution() override; diff --git a/source/blender/compositor/operations/COM_TranslateOperation.cc b/source/blender/compositor/operations/COM_TranslateOperation.cc index 05fe267b174..1ec5029385e 100644 --- a/source/blender/compositor/operations/COM_TranslateOperation.cc +++ b/source/blender/compositor/operations/COM_TranslateOperation.cc @@ -30,28 +30,28 @@ TranslateOperation::TranslateOperation(DataType data_type, ResizeMode resize_mod this->addInputSocket(DataType::Value, ResizeMode::None); this->addOutputSocket(data_type); this->set_canvas_input_index(0); - m_inputOperation = nullptr; - m_inputXOperation = nullptr; - m_inputYOperation = nullptr; - m_isDeltaSet = false; - m_factorX = 1.0f; - m_factorY = 1.0f; + inputOperation_ = nullptr; + inputXOperation_ = nullptr; + inputYOperation_ = nullptr; + isDeltaSet_ = false; + factorX_ = 1.0f; + factorY_ = 1.0f; this->x_extend_mode_ = MemoryBufferExtend::Clip; this->y_extend_mode_ = MemoryBufferExtend::Clip; } void TranslateOperation::initExecution() { - m_inputOperation = this->getInputSocketReader(0); - m_inputXOperation = this->getInputSocketReader(1); - m_inputYOperation = this->getInputSocketReader(2); + inputOperation_ = this->getInputSocketReader(0); + inputXOperation_ = this->getInputSocketReader(1); + inputYOperation_ = this->getInputSocketReader(2); } void TranslateOperation::deinitExecution() { - m_inputOperation = nullptr; - m_inputXOperation = nullptr; - m_inputYOperation = nullptr; + inputOperation_ = nullptr; + inputXOperation_ = nullptr; + inputYOperation_ = nullptr; } void TranslateOperation::executePixelSampled(float output[4], @@ -64,7 +64,7 @@ void TranslateOperation::executePixelSampled(float output[4], float originalXPos = x - this->getDeltaX(); float originalYPos = y - this->getDeltaY(); - m_inputOperation->readSampled(output, originalXPos, originalYPos, PixelSampler::Bilinear); + inputOperation_->readSampled(output, originalXPos, originalYPos, PixelSampler::Bilinear); } bool TranslateOperation::determineDependingAreaOfInterest(rcti *input, @@ -85,8 +85,8 @@ bool TranslateOperation::determineDependingAreaOfInterest(rcti *input, void TranslateOperation::setFactorXY(float factorX, float factorY) { - m_factorX = factorX; - m_factorY = factorY; + factorX_ = factorX; + factorY_ = factorY; } void TranslateOperation::set_wrapping(int wrapping_type) diff --git a/source/blender/compositor/operations/COM_TranslateOperation.h b/source/blender/compositor/operations/COM_TranslateOperation.h index 734a19008d6..25251ff1d9e 100644 --- a/source/blender/compositor/operations/COM_TranslateOperation.h +++ b/source/blender/compositor/operations/COM_TranslateOperation.h @@ -30,14 +30,14 @@ class TranslateOperation : public MultiThreadedOperation { static constexpr int Y_INPUT_INDEX = 2; private: - SocketReader *m_inputOperation; - SocketReader *m_inputXOperation; - SocketReader *m_inputYOperation; - float m_deltaX; - float m_deltaY; - bool m_isDeltaSet; - float m_factorX; - float m_factorY; + SocketReader *inputOperation_; + SocketReader *inputXOperation_; + SocketReader *inputYOperation_; + float deltaX_; + float deltaY_; + bool isDeltaSet_; + float factorX_; + float factorY_; protected: MemoryBufferExtend x_extend_mode_; @@ -56,29 +56,29 @@ class TranslateOperation : public MultiThreadedOperation { float getDeltaX() { - return m_deltaX * m_factorX; + return deltaX_ * factorX_; } float getDeltaY() { - return m_deltaY * m_factorY; + return deltaY_ * factorY_; } inline void ensureDelta() { - if (!m_isDeltaSet) { + if (!isDeltaSet_) { if (execution_model_ == eExecutionModel::Tiled) { float tempDelta[4]; - m_inputXOperation->readSampled(tempDelta, 0, 0, PixelSampler::Nearest); - m_deltaX = tempDelta[0]; - m_inputYOperation->readSampled(tempDelta, 0, 0, PixelSampler::Nearest); - m_deltaY = tempDelta[0]; + inputXOperation_->readSampled(tempDelta, 0, 0, PixelSampler::Nearest); + deltaX_ = tempDelta[0]; + inputYOperation_->readSampled(tempDelta, 0, 0, PixelSampler::Nearest); + deltaY_ = tempDelta[0]; } else { - m_deltaX = get_input_operation(X_INPUT_INDEX)->get_constant_value_default(0.0f); - m_deltaY = get_input_operation(Y_INPUT_INDEX)->get_constant_value_default(0.0f); + deltaX_ = get_input_operation(X_INPUT_INDEX)->get_constant_value_default(0.0f); + deltaY_ = get_input_operation(Y_INPUT_INDEX)->get_constant_value_default(0.0f); } - m_isDeltaSet = true; + isDeltaSet_ = true; } } diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cc b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cc index 0afc315ae7e..a0013ae1061 100644 --- a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cc +++ b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cc @@ -34,24 +34,24 @@ VariableSizeBokehBlurOperation::VariableSizeBokehBlurOperation() flags.complex = true; flags.open_cl = true; - m_inputProgram = nullptr; - m_inputBokehProgram = nullptr; - m_inputSizeProgram = nullptr; - m_maxBlur = 32.0f; - m_threshold = 1.0f; - m_do_size_scale = false; + inputProgram_ = nullptr; + inputBokehProgram_ = nullptr; + inputSizeProgram_ = nullptr; + maxBlur_ = 32.0f; + threshold_ = 1.0f; + do_size_scale_ = false; #ifdef COM_DEFOCUS_SEARCH - m_inputSearchProgram = nullptr; + inputSearchProgram_ = nullptr; #endif } void VariableSizeBokehBlurOperation::initExecution() { - m_inputProgram = getInputSocketReader(0); - m_inputBokehProgram = getInputSocketReader(1); - m_inputSizeProgram = getInputSocketReader(2); + inputProgram_ = getInputSocketReader(0); + inputBokehProgram_ = getInputSocketReader(1); + inputSizeProgram_ = getInputSocketReader(2); #ifdef COM_DEFOCUS_SEARCH - m_inputSearchProgram = getInputSocketReader(3); + inputSearchProgram_ = getInputSocketReader(3); #endif QualityStepHelper::initExecution(COM_QH_INCREASE); } @@ -65,18 +65,18 @@ struct VariableSizeBokehBlurTileData { void *VariableSizeBokehBlurOperation::initializeTileData(rcti *rect) { VariableSizeBokehBlurTileData *data = new VariableSizeBokehBlurTileData(); - data->color = (MemoryBuffer *)m_inputProgram->initializeTileData(rect); - data->bokeh = (MemoryBuffer *)m_inputBokehProgram->initializeTileData(rect); - data->size = (MemoryBuffer *)m_inputSizeProgram->initializeTileData(rect); + data->color = (MemoryBuffer *)inputProgram_->initializeTileData(rect); + data->bokeh = (MemoryBuffer *)inputBokehProgram_->initializeTileData(rect); + data->size = (MemoryBuffer *)inputSizeProgram_->initializeTileData(rect); rcti rect2; - this->determineDependingAreaOfInterest(rect, (ReadBufferOperation *)m_inputSizeProgram, &rect2); + this->determineDependingAreaOfInterest(rect, (ReadBufferOperation *)inputSizeProgram_, &rect2); const float max_dim = MAX2(this->getWidth(), this->getHeight()); - const float scalar = m_do_size_scale ? (max_dim / 100.0f) : 1.0f; + const float scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; data->maxBlurScalar = (int)(data->size->get_max_value(rect2) * scalar); - CLAMP(data->maxBlurScalar, 1.0f, m_maxBlur); + CLAMP(data->maxBlurScalar, 1.0f, maxBlur_); return data; } @@ -101,7 +101,7 @@ void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, float color_accum[4]; const float max_dim = MAX2(getWidth(), getHeight()); - const float scalar = m_do_size_scale ? (max_dim / 100.0f) : 1.0f; + const float scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; int maxBlurScalar = tileData->maxBlurScalar; BLI_assert(inputBokehBuffer->getWidth() == COM_BLUR_BOKEH_PIXELS); @@ -109,10 +109,10 @@ void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, #ifdef COM_DEFOCUS_SEARCH float search[4]; - m_inputSearchProgram->read(search, - x / InverseSearchRadiusOperation::DIVIDER, - y / InverseSearchRadiusOperation::DIVIDER, - nullptr); + inputSearchProgram_->read(search, + x / InverseSearchRadiusOperation::DIVIDER, + y / InverseSearchRadiusOperation::DIVIDER, + nullptr); int minx = search[0]; int miny = search[1]; int maxx = search[2]; @@ -135,7 +135,7 @@ void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, const int addYStepValue = addXStepValue; const int addXStepColor = addXStepValue * COM_DATA_TYPE_COLOR_CHANNELS; - if (size_center > m_threshold) { + if (size_center > threshold_) { for (int ny = miny; ny < maxy; ny += addYStepValue) { float dy = ny - y; int offsetValueNy = ny * inputSizeBuffer->getWidth(); @@ -144,7 +144,7 @@ void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, for (int nx = minx; nx < maxx; nx += addXStepValue) { if (nx != x || ny != y) { float size = MIN2(inputSizeFloatBuffer[offsetValueNxNy] * scalar, size_center); - if (size > m_threshold) { + if (size > threshold_) { float dx = nx - x; if (size > fabsf(dx) && size > fabsf(dy)) { float uv[2] = { @@ -171,9 +171,9 @@ void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, output[3] = color_accum[3] / multiplier_accum[3]; /* blend in out values over the threshold, otherwise we get sharp, ugly transitions */ - if ((size_center > m_threshold) && (size_center < m_threshold * 2.0f)) { + if ((size_center > threshold_) && (size_center < threshold_ * 2.0f)) { /* factor from 0-1 */ - float fac = (size_center - m_threshold) / m_threshold; + float fac = (size_center - threshold_) / threshold_; interp_v4_v4v4(output, readColor, output, fac); } } @@ -190,21 +190,21 @@ void VariableSizeBokehBlurOperation::executeOpenCL(OpenCLDevice *device, cl_int step = this->getStep(); cl_int maxBlur; - cl_float threshold = m_threshold; + cl_float threshold = threshold_; - MemoryBuffer *sizeMemoryBuffer = m_inputSizeProgram->getInputMemoryBuffer(inputMemoryBuffers); + MemoryBuffer *sizeMemoryBuffer = inputSizeProgram_->getInputMemoryBuffer(inputMemoryBuffers); const float max_dim = MAX2(getWidth(), getHeight()); - cl_float scalar = m_do_size_scale ? (max_dim / 100.0f) : 1.0f; + cl_float scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; - maxBlur = (cl_int)min_ff(sizeMemoryBuffer->get_max_value() * scalar, (float)m_maxBlur); + maxBlur = (cl_int)min_ff(sizeMemoryBuffer->get_max_value() * scalar, (float)maxBlur_); device->COM_clAttachMemoryBufferToKernelParameter( - defocusKernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, m_inputProgram); + defocusKernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, inputProgram_); device->COM_clAttachMemoryBufferToKernelParameter( - defocusKernel, 1, -1, clMemToCleanUp, inputMemoryBuffers, m_inputBokehProgram); + defocusKernel, 1, -1, clMemToCleanUp, inputMemoryBuffers, inputBokehProgram_); device->COM_clAttachMemoryBufferToKernelParameter( - defocusKernel, 2, 4, clMemToCleanUp, inputMemoryBuffers, m_inputSizeProgram); + defocusKernel, 2, 4, clMemToCleanUp, inputMemoryBuffers, inputSizeProgram_); device->COM_clAttachOutputMemoryBufferToKernelParameter(defocusKernel, 3, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter(defocusKernel, 5, outputMemoryBuffer); clSetKernelArg(defocusKernel, 6, sizeof(cl_int), &step); @@ -218,11 +218,11 @@ void VariableSizeBokehBlurOperation::executeOpenCL(OpenCLDevice *device, void VariableSizeBokehBlurOperation::deinitExecution() { - m_inputProgram = nullptr; - m_inputBokehProgram = nullptr; - m_inputSizeProgram = nullptr; + inputProgram_ = nullptr; + inputBokehProgram_ = nullptr; + inputSizeProgram_ = nullptr; #ifdef COM_DEFOCUS_SEARCH - m_inputSearchProgram = nullptr; + inputSearchProgram_ = nullptr; #endif } @@ -233,8 +233,8 @@ bool VariableSizeBokehBlurOperation::determineDependingAreaOfInterest( rcti bokehInput; const float max_dim = MAX2(getWidth(), getHeight()); - const float scalar = m_do_size_scale ? (max_dim / 100.0f) : 1.0f; - int maxBlurScalar = m_maxBlur * scalar; + const float scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; + int maxBlurScalar = maxBlur_ * scalar; newInput.xmax = input->xmax + maxBlurScalar + 2; newInput.xmin = input->xmin - maxBlurScalar + 2; @@ -279,8 +279,8 @@ void VariableSizeBokehBlurOperation::get_area_of_interest(const int input_idx, case IMAGE_INPUT_INDEX: case SIZE_INPUT_INDEX: { const float max_dim = MAX2(getWidth(), getHeight()); - const float scalar = m_do_size_scale ? (max_dim / 100.0f) : 1.0f; - const int max_blur_scalar = m_maxBlur * scalar; + const float scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; + const int max_blur_scalar = maxBlur_ * scalar; r_input_area.xmax = output_area.xmax + max_blur_scalar + 2; r_input_area.xmin = output_area.xmin - max_blur_scalar - 2; r_input_area.ymax = output_area.ymax + max_blur_scalar + 2; @@ -389,7 +389,7 @@ void VariableSizeBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer * p.size_input = inputs[SIZE_INPUT_INDEX]; p.image_input = inputs[IMAGE_INPUT_INDEX]; p.step = QualityStepHelper::getStep(); - p.threshold = m_threshold; + p.threshold = threshold_; p.image_width = this->getWidth(); p.image_height = this->getHeight(); @@ -399,9 +399,9 @@ void VariableSizeBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer * const float max_size = p.size_input->get_max_value(scalar_area); const float max_dim = MAX2(this->getWidth(), this->getHeight()); - p.scalar = m_do_size_scale ? (max_dim / 100.0f) : 1.0f; + p.scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; p.max_blur_scalar = static_cast<int>(max_size * p.scalar); - CLAMP(p.max_blur_scalar, 1, m_maxBlur); + CLAMP(p.max_blur_scalar, 1, maxBlur_); for (BuffersIterator<float> it = output->iterate_with({p.image_input, p.size_input}, area); !it.is_end(); @@ -437,12 +437,12 @@ InverseSearchRadiusOperation::InverseSearchRadiusOperation() this->addInputSocket(DataType::Value, ResizeMode::Align); /* Radius. */ this->addOutputSocket(DataType::Color); this->flags.complex = true; - m_inputRadius = nullptr; + inputRadius_ = nullptr; } void InverseSearchRadiusOperation::initExecution() { - m_inputRadius = this->getInputSocketReader(0); + inputRadius_ = this->getInputSocketReader(0); } void *InverseSearchRadiusOperation::initializeTileData(rcti *rect) @@ -450,18 +450,18 @@ void *InverseSearchRadiusOperation::initializeTileData(rcti *rect) MemoryBuffer *data = new MemoryBuffer(DataType::Color, rect); float *buffer = data->getBuffer(); int x, y; - int width = m_inputRadius->getWidth(); - int height = m_inputRadius->getHeight(); + int width = inputRadius_->getWidth(); + int height = inputRadius_->getHeight(); float temp[4]; int offset = 0; for (y = rect->ymin; y < rect->ymax; y++) { for (x = rect->xmin; x < rect->xmax; x++) { int rx = x * DIVIDER; int ry = y * DIVIDER; - buffer[offset] = MAX2(rx - m_maxBlur, 0); - buffer[offset + 1] = MAX2(ry - m_maxBlur, 0); - buffer[offset + 2] = MIN2(rx + DIVIDER + m_maxBlur, width); - buffer[offset + 3] = MIN2(ry + DIVIDER + m_maxBlur, height); + buffer[offset] = MAX2(rx - maxBlur_, 0); + buffer[offset + 1] = MAX2(ry - maxBlur_, 0); + buffer[offset + 2] = MIN2(rx + DIVIDER + maxBlur_, width); + buffer[offset + 3] = MIN2(ry + DIVIDER + maxBlur_, height); offset += 4; } } @@ -476,7 +476,7 @@ void *InverseSearchRadiusOperation::initializeTileData(rcti *rect) for (int x2 = 0; x2 < DIVIDER; x2++) { for (int y2 = 0; y2 < DIVIDER; y2++) { - m_inputRadius->read(temp, rx + x2, ry + y2, PixelSampler::Nearest); + inputRadius_->read(temp, rx + x2, ry + y2, PixelSampler::Nearest); if (radius < temp[0]) { radius = temp[0]; maxx = x2; @@ -517,7 +517,7 @@ void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, void *data) void InverseSearchRadiusOperation::deinitExecution() { - m_inputRadius = nullptr; + inputRadius_ = nullptr; } void InverseSearchRadiusOperation::determineResolution(unsigned int resolution[2], @@ -532,10 +532,10 @@ bool InverseSearchRadiusOperation::determineDependingAreaOfInterest( rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newRect; - newRect.ymin = input->ymin * DIVIDER - m_maxBlur; - newRect.ymax = input->ymax * DIVIDER + m_maxBlur; - newRect.xmin = input->xmin * DIVIDER - m_maxBlur; - newRect.xmax = input->xmax * DIVIDER + m_maxBlur; + newRect.ymin = input->ymin * DIVIDER - maxBlur_; + newRect.ymax = input->ymax * DIVIDER + maxBlur_; + newRect.xmin = input->xmin * DIVIDER - maxBlur_; + newRect.xmax = input->xmax * DIVIDER + maxBlur_; return NodeOperation::determineDependingAreaOfInterest(&newRect, readOperation, output); } #endif diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h index 6819e64ce80..c32d10ae3b9 100644 --- a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h +++ b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h @@ -34,14 +34,14 @@ class VariableSizeBokehBlurOperation : public MultiThreadedOperation, public Qua static constexpr int DEFOCUS_INPUT_INDEX = 3; #endif - int m_maxBlur; - float m_threshold; - bool m_do_size_scale; /* scale size, matching 'BokehBlurNode' */ - SocketReader *m_inputProgram; - SocketReader *m_inputBokehProgram; - SocketReader *m_inputSizeProgram; + int maxBlur_; + float threshold_; + bool do_size_scale_; /* scale size, matching 'BokehBlurNode' */ + SocketReader *inputProgram_; + SocketReader *inputBokehProgram_; + SocketReader *inputSizeProgram_; #ifdef COM_DEFOCUS_SEARCH - SocketReader *m_inputSearchProgram; + SocketReader *inputSearchProgram_; #endif public: @@ -72,17 +72,17 @@ class VariableSizeBokehBlurOperation : public MultiThreadedOperation, public Qua void setMaxBlur(int maxRadius) { - m_maxBlur = maxRadius; + maxBlur_ = maxRadius; } void setThreshold(float threshold) { - m_threshold = threshold; + threshold_ = threshold; } void setDoScaleSize(bool scale_size) { - m_do_size_scale = scale_size; + do_size_scale_ = scale_size; } void executeOpenCL(OpenCLDevice *device, @@ -102,8 +102,8 @@ class VariableSizeBokehBlurOperation : public MultiThreadedOperation, public Qua #ifdef COM_DEFOCUS_SEARCH class InverseSearchRadiusOperation : public NodeOperation { private: - int m_maxBlur; - SocketReader *m_inputRadius; + int maxBlur_; + SocketReader *inputRadius_; public: static const int DIVIDER = 4; @@ -134,7 +134,7 @@ class InverseSearchRadiusOperation : public NodeOperation { void setMaxBlur(int maxRadius) { - m_maxBlur = maxRadius; + maxBlur_ = maxRadius; } }; #endif diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.cc b/source/blender/compositor/operations/COM_VectorBlurOperation.cc index acde0447596..6ebd8e27d76 100644 --- a/source/blender/compositor/operations/COM_VectorBlurOperation.cc +++ b/source/blender/compositor/operations/COM_VectorBlurOperation.cc @@ -46,21 +46,21 @@ VectorBlurOperation::VectorBlurOperation() this->addInputSocket(DataType::Value); /* ZBUF */ this->addInputSocket(DataType::Color); /* SPEED */ this->addOutputSocket(DataType::Color); - m_settings = nullptr; - m_cachedInstance = nullptr; - m_inputImageProgram = nullptr; - m_inputSpeedProgram = nullptr; - m_inputZProgram = nullptr; + settings_ = nullptr; + cachedInstance_ = nullptr; + inputImageProgram_ = nullptr; + inputSpeedProgram_ = nullptr; + inputZProgram_ = nullptr; flags.complex = true; flags.is_fullframe_operation = true; } void VectorBlurOperation::initExecution() { initMutex(); - m_inputImageProgram = getInputSocketReader(0); - m_inputZProgram = getInputSocketReader(1); - m_inputSpeedProgram = getInputSocketReader(2); - m_cachedInstance = nullptr; + inputImageProgram_ = getInputSocketReader(0); + inputZProgram_ = getInputSocketReader(1); + inputSpeedProgram_ = getInputSocketReader(2); + cachedInstance_ = nullptr; QualityStepHelper::initExecution(COM_QH_INCREASE); } @@ -74,38 +74,38 @@ void VectorBlurOperation::executePixel(float output[4], int x, int y, void *data void VectorBlurOperation::deinitExecution() { deinitMutex(); - m_inputImageProgram = nullptr; - m_inputSpeedProgram = nullptr; - m_inputZProgram = nullptr; - if (m_cachedInstance) { - MEM_freeN(m_cachedInstance); - m_cachedInstance = nullptr; + inputImageProgram_ = nullptr; + inputSpeedProgram_ = nullptr; + inputZProgram_ = nullptr; + if (cachedInstance_) { + MEM_freeN(cachedInstance_); + cachedInstance_ = nullptr; } } void *VectorBlurOperation::initializeTileData(rcti *rect) { - if (m_cachedInstance) { - return m_cachedInstance; + if (cachedInstance_) { + return cachedInstance_; } lockMutex(); - if (m_cachedInstance == nullptr) { - MemoryBuffer *tile = (MemoryBuffer *)m_inputImageProgram->initializeTileData(rect); - MemoryBuffer *speed = (MemoryBuffer *)m_inputSpeedProgram->initializeTileData(rect); - MemoryBuffer *z = (MemoryBuffer *)m_inputZProgram->initializeTileData(rect); + if (cachedInstance_ == nullptr) { + MemoryBuffer *tile = (MemoryBuffer *)inputImageProgram_->initializeTileData(rect); + MemoryBuffer *speed = (MemoryBuffer *)inputSpeedProgram_->initializeTileData(rect); + MemoryBuffer *z = (MemoryBuffer *)inputZProgram_->initializeTileData(rect); float *data = (float *)MEM_dupallocN(tile->getBuffer()); this->generateVectorBlur(data, tile, speed, z); - m_cachedInstance = data; + cachedInstance_ = data; } unlockMutex(); - return m_cachedInstance; + return cachedInstance_; } bool VectorBlurOperation::determineDependingAreaOfInterest(rcti * /*input*/, ReadBufferOperation *readOperation, rcti *output) { - if (m_cachedInstance == nullptr) { + if (cachedInstance_ == nullptr) { rcti newInput; newInput.xmax = this->getWidth(); newInput.xmin = 0; @@ -129,7 +129,7 @@ void VectorBlurOperation::update_memory_buffer(MemoryBuffer *output, Span<MemoryBuffer *> inputs) { /* TODO(manzanilla): once tiled implementation is removed, run multi-threaded where possible. */ - if (!m_cachedInstance) { + if (!cachedInstance_) { MemoryBuffer *image = inputs[IMAGE_INPUT_INDEX]; const bool is_image_inflated = image->is_a_single_elem(); image = is_image_inflated ? image->inflate() : image; @@ -142,8 +142,8 @@ void VectorBlurOperation::update_memory_buffer(MemoryBuffer *output, const bool is_z_inflated = z->is_a_single_elem(); z = is_z_inflated ? z->inflate() : z; - m_cachedInstance = (float *)MEM_dupallocN(image->getBuffer()); - this->generateVectorBlur(m_cachedInstance, image, speed, z); + cachedInstance_ = (float *)MEM_dupallocN(image->getBuffer()); + this->generateVectorBlur(cachedInstance_, image, speed, z); if (is_image_inflated) { delete image; @@ -155,7 +155,7 @@ void VectorBlurOperation::update_memory_buffer(MemoryBuffer *output, } const int num_channels = COM_data_type_num_channels(getOutputSocket()->getDataType()); - MemoryBuffer buf(m_cachedInstance, num_channels, this->getWidth(), this->getHeight()); + MemoryBuffer buf(cachedInstance_, num_channels, this->getWidth(), this->getHeight()); output->copy_from(&buf, area); } @@ -165,11 +165,11 @@ void VectorBlurOperation::generateVectorBlur(float *data, MemoryBuffer *inputZ) { NodeBlurData blurdata; - blurdata.samples = m_settings->samples / QualityStepHelper::getStep(); - blurdata.maxspeed = m_settings->maxspeed; - blurdata.minspeed = m_settings->minspeed; - blurdata.curved = m_settings->curved; - blurdata.fac = m_settings->fac; + blurdata.samples = settings_->samples / QualityStepHelper::getStep(); + blurdata.maxspeed = settings_->maxspeed; + blurdata.minspeed = settings_->minspeed; + blurdata.curved = settings_->curved; + blurdata.fac = settings_->fac; zbuf_accumulate_vecblur(&blurdata, this->getWidth(), this->getHeight(), diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.h b/source/blender/compositor/operations/COM_VectorBlurOperation.h index a6c619590e8..cb384283c79 100644 --- a/source/blender/compositor/operations/COM_VectorBlurOperation.h +++ b/source/blender/compositor/operations/COM_VectorBlurOperation.h @@ -33,16 +33,16 @@ class VectorBlurOperation : public NodeOperation, public QualityStepHelper { /** * \brief Cached reference to the inputProgram */ - SocketReader *m_inputImageProgram; - SocketReader *m_inputSpeedProgram; - SocketReader *m_inputZProgram; + SocketReader *inputImageProgram_; + SocketReader *inputSpeedProgram_; + SocketReader *inputZProgram_; /** * \brief settings of the glare node. */ - NodeBlurData *m_settings; + NodeBlurData *settings_; - float *m_cachedInstance; + float *cachedInstance_; public: VectorBlurOperation(); @@ -66,7 +66,7 @@ class VectorBlurOperation : public NodeOperation, public QualityStepHelper { void setVectorBlurSettings(NodeBlurData *settings) { - m_settings = settings; + settings_ = settings; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, diff --git a/source/blender/compositor/operations/COM_VectorCurveOperation.cc b/source/blender/compositor/operations/COM_VectorCurveOperation.cc index 2dd8f114038..ade0c5ee788 100644 --- a/source/blender/compositor/operations/COM_VectorCurveOperation.cc +++ b/source/blender/compositor/operations/COM_VectorCurveOperation.cc @@ -27,12 +27,12 @@ VectorCurveOperation::VectorCurveOperation() this->addInputSocket(DataType::Vector); this->addOutputSocket(DataType::Vector); - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void VectorCurveOperation::initExecution() { CurveBaseOperation::initExecution(); - m_inputProgram = this->getInputSocketReader(0); + inputProgram_ = this->getInputSocketReader(0); } void VectorCurveOperation::executePixelSampled(float output[4], @@ -42,22 +42,22 @@ void VectorCurveOperation::executePixelSampled(float output[4], { float input[4]; - m_inputProgram->readSampled(input, x, y, sampler); + inputProgram_->readSampled(input, x, y, sampler); - BKE_curvemapping_evaluate_premulRGBF(m_curveMapping, output, input); + BKE_curvemapping_evaluate_premulRGBF(curveMapping_, output, input); } void VectorCurveOperation::deinitExecution() { CurveBaseOperation::deinitExecution(); - m_inputProgram = nullptr; + inputProgram_ = nullptr; } void VectorCurveOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> inputs) { - CurveMapping *curve_map = m_curveMapping; + CurveMapping *curve_map = curveMapping_; for (BuffersIterator<float> it = output->iterate_with(inputs, area); !it.is_end(); ++it) { BKE_curvemapping_evaluate_premulRGBF(curve_map, it.out, it.in(0)); } diff --git a/source/blender/compositor/operations/COM_VectorCurveOperation.h b/source/blender/compositor/operations/COM_VectorCurveOperation.h index 27b3ad69e17..0f819628935 100644 --- a/source/blender/compositor/operations/COM_VectorCurveOperation.h +++ b/source/blender/compositor/operations/COM_VectorCurveOperation.h @@ -28,7 +28,7 @@ class VectorCurveOperation : public CurveBaseOperation { /** * Cached reference to the inputProgram */ - SocketReader *m_inputProgram; + SocketReader *inputProgram_; public: VectorCurveOperation(); diff --git a/source/blender/compositor/operations/COM_ViewerOperation.cc b/source/blender/compositor/operations/COM_ViewerOperation.cc index effda365d56..5360b118dee 100644 --- a/source/blender/compositor/operations/COM_ViewerOperation.cc +++ b/source/blender/compositor/operations/COM_ViewerOperation.cc @@ -33,23 +33,23 @@ ViewerOperation::ViewerOperation() { this->setImage(nullptr); this->setImageUser(nullptr); - m_outputBuffer = nullptr; - m_depthBuffer = nullptr; - m_active = false; - m_doDepthBuffer = false; - m_viewSettings = nullptr; - m_displaySettings = nullptr; - m_useAlphaInput = false; + outputBuffer_ = nullptr; + depthBuffer_ = nullptr; + active_ = false; + doDepthBuffer_ = false; + viewSettings_ = nullptr; + displaySettings_ = nullptr; + useAlphaInput_ = false; this->addInputSocket(DataType::Color); this->addInputSocket(DataType::Value); this->addInputSocket(DataType::Value); - m_imageInput = nullptr; - m_alphaInput = nullptr; - m_depthInput = nullptr; - m_rd = nullptr; - m_viewName = nullptr; + imageInput_ = nullptr; + alphaInput_ = nullptr; + depthInput_ = nullptr; + rd_ = nullptr; + viewName_ = nullptr; flags.use_viewer_border = true; flags.is_viewer_operation = true; } @@ -57,10 +57,10 @@ ViewerOperation::ViewerOperation() void ViewerOperation::initExecution() { /* When initializing the tree during initial load the width and height can be zero. */ - m_imageInput = getInputSocketReader(0); - m_alphaInput = getInputSocketReader(1); - m_depthInput = getInputSocketReader(2); - m_doDepthBuffer = (m_depthInput != nullptr); + imageInput_ = getInputSocketReader(0); + alphaInput_ = getInputSocketReader(1); + depthInput_ = getInputSocketReader(2); + doDepthBuffer_ = (depthInput_ != nullptr); if (isActiveViewerOutput() && !exec_system_->is_breaked()) { initImage(); @@ -69,16 +69,16 @@ void ViewerOperation::initExecution() void ViewerOperation::deinitExecution() { - m_imageInput = nullptr; - m_alphaInput = nullptr; - m_depthInput = nullptr; - m_outputBuffer = nullptr; + imageInput_ = nullptr; + alphaInput_ = nullptr; + depthInput_ = nullptr; + outputBuffer_ = nullptr; } void ViewerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) { - float *buffer = m_outputBuffer; - float *depthbuffer = m_depthBuffer; + float *buffer = outputBuffer_; + float *depthbuffer = depthBuffer_; if (!buffer) { return; } @@ -97,12 +97,12 @@ void ViewerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) for (y = y1; y < y2 && (!breaked); y++) { for (x = x1; x < x2; x++) { - m_imageInput->readSampled(&(buffer[offset4]), x, y, PixelSampler::Nearest); - if (m_useAlphaInput) { - m_alphaInput->readSampled(alpha, x, y, PixelSampler::Nearest); + imageInput_->readSampled(&(buffer[offset4]), x, y, PixelSampler::Nearest); + if (useAlphaInput_) { + alphaInput_->readSampled(alpha, x, y, PixelSampler::Nearest); buffer[offset4 + 3] = alpha[0]; } - m_depthInput->readSampled(depth, x, y, PixelSampler::Nearest); + depthInput_->readSampled(depth, x, y, PixelSampler::Nearest); depthbuffer[offset] = depth[0]; offset++; @@ -119,8 +119,8 @@ void ViewerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) void ViewerOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { - const int sceneRenderWidth = m_rd->xsch * m_rd->size / 100; - const int sceneRenderHeight = m_rd->ysch * m_rd->size / 100; + const int sceneRenderWidth = rd_->xsch * rd_->size / 100; + const int sceneRenderHeight = rd_->ysch * rd_->size / 100; rcti local_preferred = preferred_area; local_preferred.xmax = local_preferred.xmin + sceneRenderWidth; @@ -131,20 +131,20 @@ void ViewerOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) void ViewerOperation::initImage() { - Image *ima = m_image; - ImageUser iuser = *m_imageUser; + Image *ima = image_; + ImageUser iuser = *imageUser_; void *lock; ImBuf *ibuf; /* make sure the image has the correct number of views */ - if (ima && BKE_scene_multiview_is_render_view_first(m_rd, m_viewName)) { - BKE_image_ensure_viewer_views(m_rd, ima, m_imageUser); + if (ima && BKE_scene_multiview_is_render_view_first(rd_, viewName_)) { + BKE_image_ensure_viewer_views(rd_, ima, imageUser_); } BLI_thread_lock(LOCK_DRAW_IMAGE); /* local changes to the original ImageUser */ - iuser.multi_index = BKE_scene_multiview_view_id_get(m_rd, m_viewName); + iuser.multi_index = BKE_scene_multiview_view_id_get(rd_, viewName_); ibuf = BKE_image_acquire_ibuf(ima, &iuser, &lock); if (!ibuf) { @@ -179,21 +179,21 @@ void ViewerOperation::initImage() ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID; } - if (m_doDepthBuffer) { + if (doDepthBuffer_) { addzbuffloatImBuf(ibuf); } /* now we combine the input with ibuf */ - m_outputBuffer = ibuf->rect_float; + outputBuffer_ = ibuf->rect_float; /* needed for display buffer update */ - m_ibuf = ibuf; + ibuf_ = ibuf; - if (m_doDepthBuffer) { - m_depthBuffer = ibuf->zbuf_float; + if (doDepthBuffer_) { + depthBuffer_ = ibuf->zbuf_float; } - BKE_image_release_ibuf(m_image, m_ibuf, lock); + BKE_image_release_ibuf(image_, ibuf_, lock); BLI_thread_unlock(LOCK_DRAW_IMAGE); } @@ -204,20 +204,20 @@ void ViewerOperation::updateImage(const rcti *rect) return; } - float *buffer = m_outputBuffer; - IMB_partial_display_buffer_update(m_ibuf, + float *buffer = outputBuffer_; + IMB_partial_display_buffer_update(ibuf_, buffer, nullptr, display_width_, 0, 0, - m_viewSettings, - m_displaySettings, + viewSettings_, + displaySettings_, rect->xmin, rect->ymin, rect->xmax, rect->ymax); - m_image->gpuflag |= IMA_GPU_REFRESH; + image_->gpuflag |= IMA_GPU_REFRESH; this->updateDraw(); } @@ -234,25 +234,25 @@ void ViewerOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output), const rcti &area, Span<MemoryBuffer *> inputs) { - if (!m_outputBuffer) { + if (!outputBuffer_) { return; } const int offset_x = area.xmin + (canvas_.xmin > 0 ? canvas_.xmin * 2 : 0); const int offset_y = area.ymin + (canvas_.ymin > 0 ? canvas_.ymin * 2 : 0); MemoryBuffer output_buffer( - m_outputBuffer, COM_DATA_TYPE_COLOR_CHANNELS, display_width_, display_height_); + outputBuffer_, COM_DATA_TYPE_COLOR_CHANNELS, display_width_, display_height_); const MemoryBuffer *input_image = inputs[0]; output_buffer.copy_from(input_image, area, offset_x, offset_y); - if (m_useAlphaInput) { + if (useAlphaInput_) { const MemoryBuffer *input_alpha = inputs[1]; output_buffer.copy_from( input_alpha, area, 0, COM_DATA_TYPE_VALUE_CHANNELS, offset_x, offset_y, 3); } - if (m_depthBuffer) { + if (depthBuffer_) { MemoryBuffer depth_buffer( - m_depthBuffer, COM_DATA_TYPE_VALUE_CHANNELS, display_width_, display_height_); + depthBuffer_, COM_DATA_TYPE_VALUE_CHANNELS, display_width_, display_height_); const MemoryBuffer *input_depth = inputs[2]; depth_buffer.copy_from(input_depth, area, offset_x, offset_y); } @@ -274,15 +274,15 @@ void ViewerOperation::clear_display_buffer() } initImage(); - if (m_outputBuffer == nullptr) { + if (outputBuffer_ == nullptr) { return; } - size_t buf_bytes = (size_t)m_ibuf->y * m_ibuf->x * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float); + size_t buf_bytes = (size_t)ibuf_->y * ibuf_->x * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float); if (buf_bytes > 0) { - memset(m_outputBuffer, 0, buf_bytes); + memset(outputBuffer_, 0, buf_bytes); rcti display_area; - BLI_rcti_init(&display_area, 0, m_ibuf->x, 0, m_ibuf->y); + BLI_rcti_init(&display_area, 0, ibuf_->x, 0, ibuf_->y); updateImage(&display_area); } } diff --git a/source/blender/compositor/operations/COM_ViewerOperation.h b/source/blender/compositor/operations/COM_ViewerOperation.h index 137b7be53a9..9a812c8d87d 100644 --- a/source/blender/compositor/operations/COM_ViewerOperation.h +++ b/source/blender/compositor/operations/COM_ViewerOperation.h @@ -28,27 +28,27 @@ namespace blender::compositor { class ViewerOperation : public MultiThreadedOperation { private: /* TODO(manzanilla): To be removed together with tiled implementation. */ - float *m_outputBuffer; - float *m_depthBuffer; + float *outputBuffer_; + float *depthBuffer_; - Image *m_image; - ImageUser *m_imageUser; - bool m_active; - float m_centerX; - float m_centerY; - ChunkOrdering m_chunkOrder; - bool m_doDepthBuffer; - ImBuf *m_ibuf; - bool m_useAlphaInput; - const RenderData *m_rd; - const char *m_viewName; + Image *image_; + ImageUser *imageUser_; + bool active_; + float centerX_; + float centerY_; + ChunkOrdering chunkOrder_; + bool doDepthBuffer_; + ImBuf *ibuf_; + bool useAlphaInput_; + const RenderData *rd_; + const char *viewName_; - const ColorManagedViewSettings *m_viewSettings; - const ColorManagedDisplaySettings *m_displaySettings; + const ColorManagedViewSettings *viewSettings_; + const ColorManagedDisplaySettings *displaySettings_; - SocketReader *m_imageInput; - SocketReader *m_alphaInput; - SocketReader *m_depthInput; + SocketReader *imageInput_; + SocketReader *alphaInput_; + SocketReader *depthInput_; int display_width_; int display_height_; @@ -68,65 +68,65 @@ class ViewerOperation : public MultiThreadedOperation { } void setImage(Image *image) { - m_image = image; + image_ = image; } void setImageUser(ImageUser *imageUser) { - m_imageUser = imageUser; + imageUser_ = imageUser; } bool isActiveViewerOutput() const override { - return m_active; + return active_; } void setActive(bool active) { - m_active = active; + active_ = active; } void setCenterX(float centerX) { - m_centerX = centerX; + centerX_ = centerX; } void setCenterY(float centerY) { - m_centerY = centerY; + centerY_ = centerY; } void setChunkOrder(ChunkOrdering tileOrder) { - m_chunkOrder = tileOrder; + chunkOrder_ = tileOrder; } float getCenterX() const { - return m_centerX; + return centerX_; } float getCenterY() const { - return m_centerY; + return centerY_; } ChunkOrdering getChunkOrder() const { - return m_chunkOrder; + return chunkOrder_; } eCompositorPriority getRenderPriority() const override; void setUseAlphaInput(bool value) { - m_useAlphaInput = value; + useAlphaInput_ = value; } void setRenderData(const RenderData *rd) { - m_rd = rd; + rd_ = rd; } void setViewName(const char *viewName) { - m_viewName = viewName; + viewName_ = viewName; } void setViewSettings(const ColorManagedViewSettings *viewSettings) { - m_viewSettings = viewSettings; + viewSettings_ = viewSettings; } void setDisplaySettings(const ColorManagedDisplaySettings *displaySettings) { - m_displaySettings = displaySettings; + displaySettings_ = displaySettings; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_WrapOperation.cc b/source/blender/compositor/operations/COM_WrapOperation.cc index 7e49d7a7a79..be4798c605f 100644 --- a/source/blender/compositor/operations/COM_WrapOperation.cc +++ b/source/blender/compositor/operations/COM_WrapOperation.cc @@ -24,7 +24,7 @@ namespace blender::compositor { WrapOperation::WrapOperation(DataType datatype) : ReadBufferOperation(datatype) { - m_wrappingType = CMP_NODE_WRAP_NONE; + wrappingType_ = CMP_NODE_WRAP_NONE; } inline float WrapOperation::getWrappedOriginalXPos(float x) @@ -55,7 +55,7 @@ void WrapOperation::executePixelSampled(float output[4], float x, float y, Pixel nx = x; ny = y; MemoryBufferExtend extend_x = MemoryBufferExtend::Clip, extend_y = MemoryBufferExtend::Clip; - switch (m_wrappingType) { + switch (wrappingType_) { case CMP_NODE_WRAP_NONE: /* Intentionally empty, originalXPos and originalYPos have been set before. */ break; @@ -91,7 +91,7 @@ bool WrapOperation::determineDependingAreaOfInterest(rcti *input, newInput.ymin = input->ymin; newInput.ymax = input->ymax; - if (ELEM(m_wrappingType, CMP_NODE_WRAP_X, CMP_NODE_WRAP_XY)) { + if (ELEM(wrappingType_, CMP_NODE_WRAP_X, CMP_NODE_WRAP_XY)) { /* Wrap only on the x-axis if tile is wrapping. */ newInput.xmin = getWrappedOriginalXPos(input->xmin); newInput.xmax = roundf(getWrappedOriginalXPos(input->xmax)); @@ -100,7 +100,7 @@ bool WrapOperation::determineDependingAreaOfInterest(rcti *input, newInput.xmax = this->getWidth(); } } - if (ELEM(m_wrappingType, CMP_NODE_WRAP_Y, CMP_NODE_WRAP_XY)) { + if (ELEM(wrappingType_, CMP_NODE_WRAP_Y, CMP_NODE_WRAP_XY)) { /* Wrap only on the y-axis if tile is wrapping. */ newInput.ymin = getWrappedOriginalYPos(input->ymin); newInput.ymax = roundf(getWrappedOriginalYPos(input->ymax)); @@ -115,7 +115,7 @@ bool WrapOperation::determineDependingAreaOfInterest(rcti *input, void WrapOperation::setWrapping(int wrapping_type) { - m_wrappingType = wrapping_type; + wrappingType_ = wrapping_type; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_WrapOperation.h b/source/blender/compositor/operations/COM_WrapOperation.h index 6279129a550..15fc43cc65a 100644 --- a/source/blender/compositor/operations/COM_WrapOperation.h +++ b/source/blender/compositor/operations/COM_WrapOperation.h @@ -24,7 +24,7 @@ namespace blender::compositor { class WrapOperation : public ReadBufferOperation { private: - int m_wrappingType; + int wrappingType_; public: WrapOperation(DataType datatype); diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.cc b/source/blender/compositor/operations/COM_WriteBufferOperation.cc index ffc3788de12..26c1d71c9da 100644 --- a/source/blender/compositor/operations/COM_WriteBufferOperation.cc +++ b/source/blender/compositor/operations/COM_WriteBufferOperation.cc @@ -24,16 +24,16 @@ namespace blender::compositor { WriteBufferOperation::WriteBufferOperation(DataType datatype) { this->addInputSocket(datatype); - m_memoryProxy = new MemoryProxy(datatype); - m_memoryProxy->setWriteBufferOperation(this); - m_memoryProxy->setExecutor(nullptr); + memoryProxy_ = new MemoryProxy(datatype); + memoryProxy_->setWriteBufferOperation(this); + memoryProxy_->setExecutor(nullptr); flags.is_write_buffer_operation = true; } WriteBufferOperation::~WriteBufferOperation() { - if (m_memoryProxy) { - delete m_memoryProxy; - m_memoryProxy = nullptr; + if (memoryProxy_) { + delete memoryProxy_; + memoryProxy_ = nullptr; } } @@ -42,28 +42,28 @@ void WriteBufferOperation::executePixelSampled(float output[4], float y, PixelSampler sampler) { - m_input->readSampled(output, x, y, sampler); + input_->readSampled(output, x, y, sampler); } void WriteBufferOperation::initExecution() { - m_input = this->getInputOperation(0); - m_memoryProxy->allocate(this->getWidth(), this->getHeight()); + input_ = this->getInputOperation(0); + memoryProxy_->allocate(this->getWidth(), this->getHeight()); } void WriteBufferOperation::deinitExecution() { - m_input = nullptr; - m_memoryProxy->free(); + input_ = nullptr; + memoryProxy_->free(); } void WriteBufferOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) { - MemoryBuffer *memoryBuffer = m_memoryProxy->getBuffer(); + MemoryBuffer *memoryBuffer = memoryProxy_->getBuffer(); float *buffer = memoryBuffer->getBuffer(); const uint8_t num_channels = memoryBuffer->get_num_channels(); - if (m_input->get_flags().complex) { - void *data = m_input->initializeTileData(rect); + if (input_->get_flags().complex) { + void *data = input_->initializeTileData(rect); int x1 = rect->xmin; int y1 = rect->ymin; int x2 = rect->xmax; @@ -74,7 +74,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/ for (y = y1; y < y2 && (!breaked); y++) { int offset4 = (y * memoryBuffer->getWidth() + x1) * num_channels; for (x = x1; x < x2; x++) { - m_input->read(&(buffer[offset4]), x, y, data); + input_->read(&(buffer[offset4]), x, y, data); offset4 += num_channels; } if (isBraked()) { @@ -82,7 +82,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/ } } if (data) { - m_input->deinitializeTileData(rect, data); + input_->deinitializeTileData(rect, data); data = nullptr; } } @@ -98,7 +98,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/ for (y = y1; y < y2 && (!breaked); y++) { int offset4 = (y * memoryBuffer->getWidth() + x1) * num_channels; for (x = x1; x < x2; x++) { - m_input->readSampled(&(buffer[offset4]), x, y, PixelSampler::Nearest); + input_->readSampled(&(buffer[offset4]), x, y, PixelSampler::Nearest); offset4 += num_channels; } if (isBraked()) { @@ -147,12 +147,12 @@ void WriteBufferOperation::executeOpenCLRegion(OpenCLDevice *device, clMemToCleanUp->push_back(clOutputBuffer); std::list<cl_kernel> *clKernelsToCleanUp = new std::list<cl_kernel>(); - m_input->executeOpenCL(device, - outputBuffer, - clOutputBuffer, - inputMemoryBuffers, - clMemToCleanUp, - clKernelsToCleanUp); + input_->executeOpenCL(device, + outputBuffer, + clOutputBuffer, + inputMemoryBuffers, + clMemToCleanUp, + clKernelsToCleanUp); /* STEP 3 */ @@ -208,14 +208,14 @@ void WriteBufferOperation::determine_canvas(const rcti &preferred_area, rcti &r_ { NodeOperation::determine_canvas(preferred_area, r_area); /* make sure there is at least one pixel stored in case the input is a single value */ - m_single_value = false; + single_value_ = false; if (BLI_rcti_size_x(&r_area) == 0) { r_area.xmax += 1; - m_single_value = true; + single_value_ = true; } if (BLI_rcti_size_y(&r_area) == 0) { r_area.ymax += 1; - m_single_value = true; + single_value_ = true; } } diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.h b/source/blender/compositor/operations/COM_WriteBufferOperation.h index 4e6e81b7a7f..bd8a2876a42 100644 --- a/source/blender/compositor/operations/COM_WriteBufferOperation.h +++ b/source/blender/compositor/operations/COM_WriteBufferOperation.h @@ -31,21 +31,21 @@ class MemoryProxy; * \ingroup Operation */ class WriteBufferOperation : public NodeOperation { - MemoryProxy *m_memoryProxy; - bool m_single_value; /* single value stored in buffer */ - NodeOperation *m_input; + MemoryProxy *memoryProxy_; + bool single_value_; /* single value stored in buffer */ + NodeOperation *input_; public: WriteBufferOperation(DataType datatype); ~WriteBufferOperation(); MemoryProxy *getMemoryProxy() { - return m_memoryProxy; + return memoryProxy_; } void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; bool isSingleValue() const { - return m_single_value; + return single_value_; } void executeRegion(rcti *rect, unsigned int tileNumber) override; @@ -60,7 +60,7 @@ class WriteBufferOperation : public NodeOperation { void readResolutionFromInputSocket(); inline NodeOperation *getInput() { - return m_input; + return input_; } }; diff --git a/source/blender/compositor/operations/COM_ZCombineOperation.cc b/source/blender/compositor/operations/COM_ZCombineOperation.cc index ed77d05738d..3a0126a12d4 100644 --- a/source/blender/compositor/operations/COM_ZCombineOperation.cc +++ b/source/blender/compositor/operations/COM_ZCombineOperation.cc @@ -28,19 +28,19 @@ ZCombineOperation::ZCombineOperation() this->addInputSocket(DataType::Value); this->addOutputSocket(DataType::Color); - m_image1Reader = nullptr; - m_depth1Reader = nullptr; - m_image2Reader = nullptr; - m_depth2Reader = nullptr; + image1Reader_ = nullptr; + depth1Reader_ = nullptr; + image2Reader_ = nullptr; + depth2Reader_ = nullptr; this->flags.can_be_constant = true; } void ZCombineOperation::initExecution() { - m_image1Reader = this->getInputSocketReader(0); - m_depth1Reader = this->getInputSocketReader(1); - m_image2Reader = this->getInputSocketReader(2); - m_depth2Reader = this->getInputSocketReader(3); + image1Reader_ = this->getInputSocketReader(0); + depth1Reader_ = this->getInputSocketReader(1); + image2Reader_ = this->getInputSocketReader(2); + depth2Reader_ = this->getInputSocketReader(3); } void ZCombineOperation::executePixelSampled(float output[4], @@ -51,13 +51,13 @@ void ZCombineOperation::executePixelSampled(float output[4], float depth1[4]; float depth2[4]; - m_depth1Reader->readSampled(depth1, x, y, sampler); - m_depth2Reader->readSampled(depth2, x, y, sampler); + depth1Reader_->readSampled(depth1, x, y, sampler); + depth2Reader_->readSampled(depth2, x, y, sampler); if (depth1[0] < depth2[0]) { - m_image1Reader->readSampled(output, x, y, sampler); + image1Reader_->readSampled(output, x, y, sampler); } else { - m_image2Reader->readSampled(output, x, y, sampler); + image2Reader_->readSampled(output, x, y, sampler); } } @@ -83,15 +83,15 @@ void ZCombineAlphaOperation::executePixelSampled(float output[4], float color1[4]; float color2[4]; - m_depth1Reader->readSampled(depth1, x, y, sampler); - m_depth2Reader->readSampled(depth2, x, y, sampler); + depth1Reader_->readSampled(depth1, x, y, sampler); + depth2Reader_->readSampled(depth2, x, y, sampler); if (depth1[0] <= depth2[0]) { - m_image1Reader->readSampled(color1, x, y, sampler); - m_image2Reader->readSampled(color2, x, y, sampler); + image1Reader_->readSampled(color1, x, y, sampler); + image2Reader_->readSampled(color2, x, y, sampler); } else { - m_image1Reader->readSampled(color2, x, y, sampler); - m_image2Reader->readSampled(color1, x, y, sampler); + image1Reader_->readSampled(color2, x, y, sampler); + image2Reader_->readSampled(color1, x, y, sampler); } float fac = color1[3]; float ifac = 1.0f - fac; @@ -129,10 +129,10 @@ void ZCombineAlphaOperation::update_memory_buffer_partial(MemoryBuffer *output, void ZCombineOperation::deinitExecution() { - m_image1Reader = nullptr; - m_depth1Reader = nullptr; - m_image2Reader = nullptr; - m_depth2Reader = nullptr; + image1Reader_ = nullptr; + depth1Reader_ = nullptr; + image2Reader_ = nullptr; + depth2Reader_ = nullptr; } // MASK combine @@ -143,16 +143,16 @@ ZCombineMaskOperation::ZCombineMaskOperation() this->addInputSocket(DataType::Color); this->addOutputSocket(DataType::Color); - m_maskReader = nullptr; - m_image1Reader = nullptr; - m_image2Reader = nullptr; + maskReader_ = nullptr; + image1Reader_ = nullptr; + image2Reader_ = nullptr; } void ZCombineMaskOperation::initExecution() { - m_maskReader = this->getInputSocketReader(0); - m_image1Reader = this->getInputSocketReader(1); - m_image2Reader = this->getInputSocketReader(2); + maskReader_ = this->getInputSocketReader(0); + image1Reader_ = this->getInputSocketReader(1); + image2Reader_ = this->getInputSocketReader(2); } void ZCombineMaskOperation::executePixelSampled(float output[4], @@ -164,9 +164,9 @@ void ZCombineMaskOperation::executePixelSampled(float output[4], float color1[4]; float color2[4]; - m_maskReader->readSampled(mask, x, y, sampler); - m_image1Reader->readSampled(color1, x, y, sampler); - m_image2Reader->readSampled(color2, x, y, sampler); + maskReader_->readSampled(mask, x, y, sampler); + image1Reader_->readSampled(color1, x, y, sampler); + image2Reader_->readSampled(color2, x, y, sampler); interp_v4_v4v4(output, color1, color2, 1.0f - mask[0]); } @@ -192,9 +192,9 @@ void ZCombineMaskAlphaOperation::executePixelSampled(float output[4], float color1[4]; float color2[4]; - m_maskReader->readSampled(mask, x, y, sampler); - m_image1Reader->readSampled(color1, x, y, sampler); - m_image2Reader->readSampled(color2, x, y, sampler); + maskReader_->readSampled(mask, x, y, sampler); + image1Reader_->readSampled(color1, x, y, sampler); + image2Reader_->readSampled(color2, x, y, sampler); float fac = (1.0f - mask[0]) * (1.0f - color1[3]) + mask[0] * color2[3]; float mfac = 1.0f - fac; @@ -225,9 +225,9 @@ void ZCombineMaskAlphaOperation::update_memory_buffer_partial(MemoryBuffer *outp void ZCombineMaskOperation::deinitExecution() { - m_image1Reader = nullptr; - m_maskReader = nullptr; - m_image2Reader = nullptr; + image1Reader_ = nullptr; + maskReader_ = nullptr; + image2Reader_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ZCombineOperation.h b/source/blender/compositor/operations/COM_ZCombineOperation.h index acd60b6c866..612107e3c77 100644 --- a/source/blender/compositor/operations/COM_ZCombineOperation.h +++ b/source/blender/compositor/operations/COM_ZCombineOperation.h @@ -28,10 +28,10 @@ namespace blender::compositor { */ class ZCombineOperation : public MultiThreadedOperation { protected: - SocketReader *m_image1Reader; - SocketReader *m_depth1Reader; - SocketReader *m_image2Reader; - SocketReader *m_depth2Reader; + SocketReader *image1Reader_; + SocketReader *depth1Reader_; + SocketReader *image2Reader_; + SocketReader *depth2Reader_; public: /** @@ -62,9 +62,9 @@ class ZCombineAlphaOperation : public ZCombineOperation { class ZCombineMaskOperation : public MultiThreadedOperation { protected: - SocketReader *m_maskReader; - SocketReader *m_image1Reader; - SocketReader *m_image2Reader; + SocketReader *maskReader_; + SocketReader *image1Reader_; + SocketReader *image2Reader_; public: ZCombineMaskOperation(); |