From 1c42d4930a24d639b3aa561b9a8b4bbce05977e0 Mon Sep 17 00:00:00 2001 From: Manuel Castilla Date: Wed, 13 Oct 2021 23:01:15 +0200 Subject: Cleanup: convert camelCase naming to snake_case in Compositor To convert old code to the current convention and use a single code style. --- .../operations/COM_AlphaOverKeyOperation.cc | 36 +- .../operations/COM_AlphaOverKeyOperation.h | 2 +- .../operations/COM_AlphaOverMixedOperation.cc | 38 +- .../operations/COM_AlphaOverMixedOperation.h | 2 +- .../COM_AlphaOverPremultiplyOperation.cc | 36 +- .../operations/COM_AlphaOverPremultiplyOperation.h | 2 +- .../operations/COM_AntiAliasOperation.cc | 44 +- .../compositor/operations/COM_AntiAliasOperation.h | 16 +- .../operations/COM_BilateralBlurOperation.cc | 87 +- .../operations/COM_BilateralBlurOperation.h | 18 +- .../compositor/operations/COM_BlurBaseOperation.cc | 34 +- .../compositor/operations/COM_BlurBaseOperation.h | 18 +- .../operations/COM_BokehBlurOperation.cc | 224 ++--- .../compositor/operations/COM_BokehBlurOperation.h | 42 +- .../operations/COM_BokehImageOperation.cc | 133 +-- .../operations/COM_BokehImageOperation.h | 36 +- .../compositor/operations/COM_BoxMaskOperation.cc | 77 +- .../compositor/operations/COM_BoxMaskOperation.h | 22 +- .../operations/COM_BrightnessOperation.cc | 62 +- .../operations/COM_BrightnessOperation.h | 16 +- .../operations/COM_CalculateMeanOperation.cc | 57 +- .../operations/COM_CalculateMeanOperation.h | 20 +- .../COM_CalculateStandardDeviationOperation.cc | 34 +- .../COM_CalculateStandardDeviationOperation.h | 6 +- .../operations/COM_ChangeHSVOperation.cc | 58 +- .../compositor/operations/COM_ChangeHSVOperation.h | 14 +- .../operations/COM_ChannelMatteOperation.cc | 32 +- .../operations/COM_ChannelMatteOperation.h | 18 +- .../operations/COM_ChromaMatteOperation.cc | 64 +- .../operations/COM_ChromaMatteOperation.h | 14 +- .../operations/COM_ColorBalanceASCCDLOperation.cc | 50 +- .../operations/COM_ColorBalanceASCCDLOperation.h | 18 +- .../operations/COM_ColorBalanceLGGOperation.cc | 50 +- .../operations/COM_ColorBalanceLGGOperation.h | 18 +- .../operations/COM_ColorCorrectionOperation.cc | 126 +-- .../operations/COM_ColorCorrectionOperation.h | 32 +- .../operations/COM_ColorCurveOperation.cc | 112 +-- .../operations/COM_ColorCurveOperation.h | 32 +- .../operations/COM_ColorExposureOperation.cc | 46 +- .../operations/COM_ColorExposureOperation.h | 12 +- .../operations/COM_ColorMatteOperation.cc | 49 +- .../operations/COM_ColorMatteOperation.h | 14 +- .../operations/COM_ColorRampOperation.cc | 30 +- .../compositor/operations/COM_ColorRampOperation.h | 16 +- .../operations/COM_ColorSpillOperation.cc | 54 +- .../operations/COM_ColorSpillOperation.h | 28 +- .../operations/COM_CompositorOperation.cc | 116 +-- .../operations/COM_CompositorOperation.h | 48 +- .../compositor/operations/COM_ConstantOperation.h | 2 +- .../operations/COM_ConvertColorProfileOperation.cc | 27 +- .../operations/COM_ConvertColorProfileOperation.h | 24 +- .../COM_ConvertDepthToRadiusOperation.cc | 80 +- .../operations/COM_ConvertDepthToRadiusOperation.h | 38 +- .../compositor/operations/COM_ConvertOperation.cc | 365 ++++---- .../compositor/operations/COM_ConvertOperation.h | 64 +- .../COM_ConvolutionEdgeFilterOperation.cc | 38 +- .../COM_ConvolutionEdgeFilterOperation.h | 2 +- .../operations/COM_ConvolutionFilterOperation.cc | 88 +- .../operations/COM_ConvolutionFilterOperation.h | 20 +- .../compositor/operations/COM_CropOperation.cc | 62 +- .../compositor/operations/COM_CropOperation.h | 22 +- .../operations/COM_CryptomatteOperation.cc | 20 +- .../operations/COM_CryptomatteOperation.h | 8 +- .../operations/COM_CurveBaseOperation.cc | 28 +- .../compositor/operations/COM_CurveBaseOperation.h | 10 +- .../compositor/operations/COM_DenoiseOperation.cc | 97 ++- .../compositor/operations/COM_DenoiseOperation.h | 32 +- .../operations/COM_DespeckleOperation.cc | 88 +- .../compositor/operations/COM_DespeckleOperation.h | 24 +- .../operations/COM_DifferenceMatteOperation.cc | 48 +- .../operations/COM_DifferenceMatteOperation.h | 14 +- .../operations/COM_DilateErodeOperation.cc | 243 +++--- .../operations/COM_DilateErodeOperation.h | 94 +-- .../operations/COM_DirectionalBlurOperation.cc | 90 +- .../operations/COM_DirectionalBlurOperation.h | 28 +- .../compositor/operations/COM_DisplaceOperation.cc | 102 +-- .../compositor/operations/COM_DisplaceOperation.h | 18 +- .../operations/COM_DisplaceSimpleOperation.cc | 109 ++- .../operations/COM_DisplaceSimpleOperation.h | 22 +- .../operations/COM_DistanceRGBMatteOperation.cc | 50 +- .../operations/COM_DistanceRGBMatteOperation.h | 16 +- .../operations/COM_DistanceYCCMatteOperation.cc | 2 +- .../operations/COM_DistanceYCCMatteOperation.h | 2 +- .../operations/COM_DotproductOperation.cc | 26 +- .../operations/COM_DotproductOperation.h | 6 +- .../operations/COM_DoubleEdgeMaskOperation.cc | 189 +++-- .../operations/COM_DoubleEdgeMaskOperation.h | 36 +- .../operations/COM_EllipseMaskOperation.cc | 80 +- .../operations/COM_EllipseMaskOperation.h | 22 +- .../operations/COM_FastGaussianBlurOperation.cc | 126 +-- .../operations/COM_FastGaussianBlurOperation.h | 32 +- .../compositor/operations/COM_FlipOperation.cc | 76 +- .../compositor/operations/COM_FlipOperation.h | 22 +- .../operations/COM_GammaCorrectOperation.cc | 102 +-- .../operations/COM_GammaCorrectOperation.h | 20 +- .../compositor/operations/COM_GammaOperation.cc | 42 +- .../compositor/operations/COM_GammaOperation.h | 12 +- .../COM_GaussianAlphaBlurBaseOperation.cc | 10 +- .../COM_GaussianAlphaBlurBaseOperation.h | 8 +- .../operations/COM_GaussianAlphaXBlurOperation.cc | 82 +- .../operations/COM_GaussianAlphaXBlurOperation.h | 16 +- .../operations/COM_GaussianAlphaYBlurOperation.cc | 80 +- .../operations/COM_GaussianAlphaYBlurOperation.h | 16 +- .../operations/COM_GaussianBlurBaseOperation.cc | 10 +- .../operations/COM_GaussianBlurBaseOperation.h | 4 +- .../operations/COM_GaussianBokehBlurOperation.cc | 183 +++-- .../operations/COM_GaussianBokehBlurOperation.h | 32 +- .../operations/COM_GaussianXBlurOperation.cc | 123 +-- .../operations/COM_GaussianXBlurOperation.h | 30 +- .../operations/COM_GaussianYBlurOperation.cc | 127 +-- .../operations/COM_GaussianYBlurOperation.h | 30 +- .../operations/COM_GlareBaseOperation.cc | 54 +- .../compositor/operations/COM_GlareBaseOperation.h | 20 +- .../operations/COM_GlareFogGlowOperation.cc | 96 +-- .../operations/COM_GlareFogGlowOperation.h | 2 +- .../operations/COM_GlareGhostOperation.cc | 68 +- .../operations/COM_GlareGhostOperation.h | 2 +- .../operations/COM_GlareSimpleStarOperation.cc | 34 +- .../operations/COM_GlareSimpleStarOperation.h | 2 +- .../operations/COM_GlareStreaksOperation.cc | 32 +- .../operations/COM_GlareStreaksOperation.h | 2 +- .../operations/COM_GlareThresholdOperation.cc | 24 +- .../operations/COM_GlareThresholdOperation.h | 12 +- .../COM_HueSaturationValueCorrectOperation.cc | 40 +- .../COM_HueSaturationValueCorrectOperation.h | 10 +- .../compositor/operations/COM_IDMaskOperation.cc | 18 +- .../compositor/operations/COM_IDMaskOperation.h | 10 +- .../compositor/operations/COM_ImageOperation.cc | 80 +- .../compositor/operations/COM_ImageOperation.h | 38 +- .../compositor/operations/COM_InpaintOperation.cc | 69 +- .../compositor/operations/COM_InpaintOperation.h | 20 +- .../compositor/operations/COM_InvertOperation.cc | 51 +- .../compositor/operations/COM_InvertOperation.h | 16 +- .../operations/COM_KeyingBlurOperation.cc | 58 +- .../operations/COM_KeyingBlurOperation.h | 14 +- .../operations/COM_KeyingClipOperation.cc | 100 +-- .../operations/COM_KeyingClipOperation.h | 40 +- .../operations/COM_KeyingDespillOperation.cc | 62 +- .../operations/COM_KeyingDespillOperation.h | 22 +- .../compositor/operations/COM_KeyingOperation.cc | 49 +- .../compositor/operations/COM_KeyingOperation.h | 16 +- .../operations/COM_KeyingScreenOperation.cc | 80 +- .../operations/COM_KeyingScreenOperation.h | 28 +- .../operations/COM_LuminanceMatteOperation.cc | 32 +- .../operations/COM_LuminanceMatteOperation.h | 12 +- .../compositor/operations/COM_MapRangeOperation.cc | 62 +- .../compositor/operations/COM_MapRangeOperation.h | 24 +- .../compositor/operations/COM_MapUVOperation.cc | 88 +- .../compositor/operations/COM_MapUVOperation.h | 20 +- .../compositor/operations/COM_MapValueOperation.cc | 24 +- .../compositor/operations/COM_MapValueOperation.h | 12 +- .../compositor/operations/COM_MaskOperation.cc | 91 +- .../compositor/operations/COM_MaskOperation.h | 46 +- .../compositor/operations/COM_MathBaseOperation.cc | 835 +++++++++---------- .../compositor/operations/COM_MathBaseOperation.h | 104 +-- .../compositor/operations/COM_MixOperation.cc | 914 +++++++++++---------- .../compositor/operations/COM_MixOperation.h | 72 +- .../operations/COM_MovieClipAttributeOperation.cc | 18 +- .../operations/COM_MovieClipAttributeOperation.h | 12 +- .../operations/COM_MovieClipOperation.cc | 68 +- .../compositor/operations/COM_MovieClipOperation.h | 34 +- .../operations/COM_MovieDistortionOperation.cc | 75 +- .../operations/COM_MovieDistortionOperation.h | 22 +- .../operations/COM_MultilayerImageOperation.cc | 84 +- .../operations/COM_MultilayerImageOperation.h | 22 +- .../operations/COM_NormalizeOperation.cc | 76 +- .../compositor/operations/COM_NormalizeOperation.h | 20 +- .../compositor/operations/COM_OpenCLKernels.cl | 196 ++--- .../operations/COM_OutputFileMultiViewOperation.cc | 112 +-- .../operations/COM_OutputFileMultiViewOperation.h | 24 +- .../operations/COM_OutputFileOperation.cc | 180 ++-- .../operations/COM_OutputFileOperation.h | 56 +- .../compositor/operations/COM_PixelateOperation.cc | 26 +- .../compositor/operations/COM_PixelateOperation.h | 14 +- .../operations/COM_PlaneCornerPinOperation.cc | 107 +-- .../operations/COM_PlaneCornerPinOperation.h | 18 +- .../operations/COM_PlaneDistortCommonOperation.cc | 152 ++-- .../operations/COM_PlaneDistortCommonOperation.h | 30 +- .../operations/COM_PlaneTrackOperation.cc | 38 +- .../operations/COM_PlaneTrackOperation.h | 26 +- .../operations/COM_PosterizeOperation.cc | 50 +- .../compositor/operations/COM_PosterizeOperation.h | 12 +- .../compositor/operations/COM_PreviewOperation.cc | 90 +- .../compositor/operations/COM_PreviewOperation.h | 36 +- .../COM_ProjectorLensDistortionOperation.cc | 104 +-- .../COM_ProjectorLensDistortionOperation.h | 22 +- .../compositor/operations/COM_QualityStepHelper.cc | 2 +- .../compositor/operations/COM_QualityStepHelper.h | 8 +- .../operations/COM_ReadBufferOperation.cc | 64 +- .../operations/COM_ReadBufferOperation.h | 47 +- .../compositor/operations/COM_RenderLayersProg.cc | 117 +-- .../compositor/operations/COM_RenderLayersProg.h | 68 +- .../compositor/operations/COM_RotateOperation.cc | 111 +-- .../compositor/operations/COM_RotateOperation.h | 30 +- .../compositor/operations/COM_SMAAOperation.cc | 274 +++--- .../compositor/operations/COM_SMAAOperation.h | 74 +- .../compositor/operations/COM_ScaleOperation.cc | 303 +++---- .../compositor/operations/COM_ScaleOperation.h | 76 +- .../COM_ScreenLensDistortionOperation.cc | 168 ++-- .../operations/COM_ScreenLensDistortionOperation.h | 28 +- .../operations/COM_SetAlphaMultiplyOperation.cc | 34 +- .../operations/COM_SetAlphaMultiplyOperation.h | 10 +- .../operations/COM_SetAlphaReplaceOperation.cc | 34 +- .../operations/COM_SetAlphaReplaceOperation.h | 10 +- .../compositor/operations/COM_SetColorOperation.cc | 10 +- .../compositor/operations/COM_SetColorOperation.h | 20 +- .../operations/COM_SetSamplerOperation.cc | 20 +- .../operations/COM_SetSamplerOperation.h | 8 +- .../compositor/operations/COM_SetValueOperation.cc | 10 +- .../compositor/operations/COM_SetValueOperation.h | 6 +- .../operations/COM_SetVectorOperation.cc | 10 +- .../compositor/operations/COM_SetVectorOperation.h | 4 +- .../operations/COM_SocketProxyOperation.cc | 8 +- .../operations/COM_SocketProxyOperation.h | 2 +- .../compositor/operations/COM_SplitOperation.cc | 42 +- .../compositor/operations/COM_SplitOperation.h | 18 +- .../compositor/operations/COM_SunBeamsOperation.cc | 28 +- .../compositor/operations/COM_SunBeamsOperation.h | 14 +- .../compositor/operations/COM_TextureOperation.cc | 78 +- .../compositor/operations/COM_TextureOperation.h | 22 +- .../compositor/operations/COM_TonemapOperation.cc | 78 +- .../compositor/operations/COM_TonemapOperation.h | 24 +- .../operations/COM_TrackPositionOperation.cc | 62 +- .../operations/COM_TrackPositionOperation.h | 40 +- .../operations/COM_TransformOperation.cc | 22 +- .../operations/COM_TranslateOperation.cc | 86 +- .../compositor/operations/COM_TranslateOperation.h | 52 +- .../COM_VariableSizeBokehBlurOperation.cc | 345 ++++---- .../COM_VariableSizeBokehBlurOperation.h | 70 +- .../operations/COM_VectorBlurOperation.cc | 128 +-- .../operations/COM_VectorBlurOperation.h | 34 +- .../operations/COM_VectorCurveOperation.cc | 32 +- .../operations/COM_VectorCurveOperation.h | 10 +- .../compositor/operations/COM_ViewerOperation.cc | 146 ++-- .../compositor/operations/COM_ViewerOperation.h | 88 +- .../compositor/operations/COM_WrapOperation.cc | 81 +- .../compositor/operations/COM_WrapOperation.h | 18 +- .../operations/COM_WriteBufferOperation.cc | 146 ++-- .../operations/COM_WriteBufferOperation.h | 30 +- .../compositor/operations/COM_ZCombineOperation.cc | 108 +-- .../compositor/operations/COM_ZCombineOperation.h | 18 +- 241 files changed, 7160 insertions(+), 7077 deletions(-) (limited to 'source/blender/compositor/operations') diff --git a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cc b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cc index 2e494d1adf3..3c5053d8357 100644 --- a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cc +++ b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cc @@ -25,33 +25,33 @@ AlphaOverKeyOperation::AlphaOverKeyOperation() this->flags.can_be_constant = true; } -void AlphaOverKeyOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void AlphaOverKeyOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputOverColor[4]; + float input_color1[4]; + float input_over_color[4]; float value[4]; - inputValueOperation_->readSampled(value, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputOverColor, x, y, sampler); + input_value_operation_->read_sampled(value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_over_color, x, y, sampler); - if (inputOverColor[3] <= 0.0f) { - copy_v4_v4(output, inputColor1); + if (input_over_color[3] <= 0.0f) { + copy_v4_v4(output, input_color1); } - else if (value[0] == 1.0f && inputOverColor[3] >= 1.0f) { - copy_v4_v4(output, inputOverColor); + else if (value[0] == 1.0f && input_over_color[3] >= 1.0f) { + copy_v4_v4(output, input_over_color); } else { - float premul = value[0] * inputOverColor[3]; + float premul = value[0] * input_over_color[3]; float mul = 1.0f - premul; - output[0] = (mul * inputColor1[0]) + premul * inputOverColor[0]; - output[1] = (mul * inputColor1[1]) + premul * inputOverColor[1]; - output[2] = (mul * inputColor1[2]) + premul * inputOverColor[2]; - output[3] = (mul * inputColor1[3]) + value[0] * inputOverColor[3]; + output[0] = (mul * input_color1[0]) + premul * input_over_color[0]; + output[1] = (mul * input_color1[1]) + premul * input_over_color[1]; + output[2] = (mul * input_color1[2]) + premul * input_over_color[2]; + output[3] = (mul * input_color1[3]) + value[0] * input_over_color[3]; } } diff --git a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.h b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.h index 960fbc98fe9..cfcb655ceca 100644 --- a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.h +++ b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.h @@ -33,7 +33,7 @@ class AlphaOverKeyOperation : public MixBaseOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_row(PixelCursor &p) override; }; diff --git a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cc b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cc index 1df74ffac8e..102d031d9be 100644 --- a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cc +++ b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cc @@ -26,34 +26,34 @@ AlphaOverMixedOperation::AlphaOverMixedOperation() this->flags.can_be_constant = true; } -void AlphaOverMixedOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void AlphaOverMixedOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputOverColor[4]; + float input_color1[4]; + float input_over_color[4]; float value[4]; - inputValueOperation_->readSampled(value, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputOverColor, x, y, sampler); + input_value_operation_->read_sampled(value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_over_color, x, y, sampler); - if (inputOverColor[3] <= 0.0f) { - copy_v4_v4(output, inputColor1); + if (input_over_color[3] <= 0.0f) { + copy_v4_v4(output, input_color1); } - else if (value[0] == 1.0f && inputOverColor[3] >= 1.0f) { - copy_v4_v4(output, inputOverColor); + else if (value[0] == 1.0f && input_over_color[3] >= 1.0f) { + copy_v4_v4(output, input_over_color); } else { - float addfac = 1.0f - x_ + inputOverColor[3] * x_; + float addfac = 1.0f - x_ + input_over_color[3] * x_; float premul = value[0] * addfac; - float mul = 1.0f - value[0] * inputOverColor[3]; + float mul = 1.0f - value[0] * input_over_color[3]; - output[0] = (mul * inputColor1[0]) + premul * inputOverColor[0]; - output[1] = (mul * inputColor1[1]) + premul * inputOverColor[1]; - output[2] = (mul * inputColor1[2]) + premul * inputOverColor[2]; - output[3] = (mul * inputColor1[3]) + value[0] * inputOverColor[3]; + output[0] = (mul * input_color1[0]) + premul * input_over_color[0]; + output[1] = (mul * input_color1[1]) + premul * input_over_color[1]; + output[2] = (mul * input_color1[2]) + premul * input_over_color[2]; + output[3] = (mul * input_color1[3]) + value[0] * input_over_color[3]; } } diff --git a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h index 65967c03eb9..32ff77fdecd 100644 --- a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h +++ b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h @@ -39,7 +39,7 @@ class AlphaOverMixedOperation : public MixBaseOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void setX(float x) { diff --git a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cc b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cc index 5af992c8809..2d04c22533b 100644 --- a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cc +++ b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cc @@ -25,33 +25,33 @@ AlphaOverPremultiplyOperation::AlphaOverPremultiplyOperation() this->flags.can_be_constant = true; } -void AlphaOverPremultiplyOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void AlphaOverPremultiplyOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputOverColor[4]; + float input_color1[4]; + float input_over_color[4]; float value[4]; - inputValueOperation_->readSampled(value, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputOverColor, x, y, sampler); + input_value_operation_->read_sampled(value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_over_color, x, y, sampler); /* Zero alpha values should still permit an add of RGB data */ - if (inputOverColor[3] < 0.0f) { - copy_v4_v4(output, inputColor1); + if (input_over_color[3] < 0.0f) { + copy_v4_v4(output, input_color1); } - else if (value[0] == 1.0f && inputOverColor[3] >= 1.0f) { - copy_v4_v4(output, inputOverColor); + else if (value[0] == 1.0f && input_over_color[3] >= 1.0f) { + copy_v4_v4(output, input_over_color); } else { - float mul = 1.0f - value[0] * inputOverColor[3]; + float mul = 1.0f - value[0] * input_over_color[3]; - output[0] = (mul * inputColor1[0]) + value[0] * inputOverColor[0]; - output[1] = (mul * inputColor1[1]) + value[0] * inputOverColor[1]; - output[2] = (mul * inputColor1[2]) + value[0] * inputOverColor[2]; - output[3] = (mul * inputColor1[3]) + value[0] * inputOverColor[3]; + output[0] = (mul * input_color1[0]) + value[0] * input_over_color[0]; + output[1] = (mul * input_color1[1]) + value[0] * input_over_color[1]; + output[2] = (mul * input_color1[2]) + value[0] * input_over_color[2]; + output[3] = (mul * input_color1[3]) + value[0] * input_over_color[3]; } } diff --git a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h index 701bc07cc27..cc4cb615de8 100644 --- a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h +++ b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h @@ -33,7 +33,7 @@ class AlphaOverPremultiplyOperation : public MixBaseOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_row(PixelCursor &p) override; }; diff --git a/source/blender/compositor/operations/COM_AntiAliasOperation.cc b/source/blender/compositor/operations/COM_AntiAliasOperation.cc index 8a3b6f4df11..28fea7b406c 100644 --- a/source/blender/compositor/operations/COM_AntiAliasOperation.cc +++ b/source/blender/compositor/operations/COM_AntiAliasOperation.cc @@ -110,26 +110,26 @@ static int extrapolate9(float *E0, AntiAliasOperation::AntiAliasOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - valueReader_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + value_reader_ = nullptr; this->flags.complex = true; } -void AntiAliasOperation::initExecution() +void AntiAliasOperation::init_execution() { - valueReader_ = this->getInputSocketReader(0); + value_reader_ = this->get_input_socket_reader(0); } -void AntiAliasOperation::executePixel(float output[4], int x, int y, void *data) +void AntiAliasOperation::execute_pixel(float output[4], int x, int y, void *data) { MemoryBuffer *input_buffer = (MemoryBuffer *)data; - const int buffer_width = input_buffer->getWidth(), buffer_height = input_buffer->getHeight(); + const int buffer_width = input_buffer->get_width(), buffer_height = input_buffer->get_height(); if (y < 0 || y >= buffer_height || x < 0 || x >= buffer_width) { output[0] = 0.0f; } else { - const float *buffer = input_buffer->getBuffer(); + const float *buffer = input_buffer->get_buffer(); const float *row_curr = &buffer[y * buffer_width]; if (x == 0 || x == buffer_width - 1 || y == 0 || y == buffer_height - 1) { output[0] = row_curr[x]; @@ -173,27 +173,27 @@ void AntiAliasOperation::executePixel(float output[4], int x, int y, void *data) } } -void AntiAliasOperation::deinitExecution() +void AntiAliasOperation::deinit_execution() { - valueReader_ = nullptr; + value_reader_ = nullptr; } -bool AntiAliasOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool AntiAliasOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti imageInput; - NodeOperation *operation = getInputOperation(0); - imageInput.xmax = input->xmax + 1; - imageInput.xmin = input->xmin - 1; - imageInput.ymax = input->ymax + 1; - imageInput.ymin = input->ymin - 1; - return operation->determineDependingAreaOfInterest(&imageInput, readOperation, output); + rcti image_input; + NodeOperation *operation = get_input_operation(0); + image_input.xmax = input->xmax + 1; + image_input.xmin = input->xmin - 1; + image_input.ymax = input->ymax + 1; + image_input.ymin = input->ymin - 1; + return operation->determine_depending_area_of_interest(&image_input, read_operation, output); } -void *AntiAliasOperation::initializeTileData(rcti *rect) +void *AntiAliasOperation::initialize_tile_data(rcti *rect) { - return getInputOperation(0)->initializeTileData(rect); + return get_input_operation(0)->initialize_tile_data(rect); } void AntiAliasOperation::get_area_of_interest(const int input_idx, diff --git a/source/blender/compositor/operations/COM_AntiAliasOperation.h b/source/blender/compositor/operations/COM_AntiAliasOperation.h index 48ae03a1aaa..0a6a63bf57e 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 *valueReader_; + SocketReader *value_reader_; public: AntiAliasOperation(); @@ -41,22 +41,22 @@ class AntiAliasOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + void deinit_execution() override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; 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_BilateralBlurOperation.cc b/source/blender/compositor/operations/COM_BilateralBlurOperation.cc index 7368dcf0cad..5f7d2432f05 100644 --- a/source/blender/compositor/operations/COM_BilateralBlurOperation.cc +++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.cc @@ -22,65 +22,65 @@ namespace blender::compositor { BilateralBlurOperation::BilateralBlurOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); this->flags.complex = true; - inputColorProgram_ = nullptr; - inputDeterminatorProgram_ = nullptr; + input_color_program_ = nullptr; + input_determinator_program_ = nullptr; } -void BilateralBlurOperation::initExecution() +void BilateralBlurOperation::init_execution() { - inputColorProgram_ = getInputSocketReader(0); - inputDeterminatorProgram_ = getInputSocketReader(1); - QualityStepHelper::initExecution(COM_QH_INCREASE); + input_color_program_ = get_input_socket_reader(0); + input_determinator_program_ = get_input_socket_reader(1); + QualityStepHelper::init_execution(COM_QH_INCREASE); } -void BilateralBlurOperation::executePixel(float output[4], int x, int y, void *data) +void BilateralBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { /* Read the determinator color at x, y, * this will be used as the reference color for the determinator. */ - float determinatorReferenceColor[4]; + float determinator_reference_color[4]; float determinator[4]; - float tempColor[4]; - float blurColor[4]; - float blurDivider; + float temp_color[4]; + float blur_color[4]; + float blur_divider; 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; - inputDeterminatorProgram_->read(determinatorReferenceColor, x, y, data); + float delta_color; + input_determinator_program_->read(determinator_reference_color, x, y, data); - zero_v4(blurColor); - blurDivider = 0.0f; + zero_v4(blur_color); + blur_divider = 0.0f; /* TODO(sergey): This isn't really good bilateral filter, it should be * using gaussian bell for weights. Also sigma_color doesn't seem to be * used correct at all. */ - for (int yi = miny; yi < maxy; yi += QualityStepHelper::getStep()) { - for (int xi = minx; xi < maxx; xi += QualityStepHelper::getStep()) { + for (int yi = miny; yi < maxy; yi += QualityStepHelper::get_step()) { + for (int xi = minx; xi < maxx; xi += QualityStepHelper::get_step()) { /* Read determinator. */ - 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) { + input_determinator_program_->read(determinator, xi, yi, data); + delta_color = (fabsf(determinator_reference_color[0] - determinator[0]) + + fabsf(determinator_reference_color[1] - determinator[1]) + + /* Do not take the alpha channel into account. */ + fabsf(determinator_reference_color[2] - determinator[2])); + if (delta_color < sigmacolor) { /* Add this to the blur. */ - inputColorProgram_->read(tempColor, xi, yi, data); - add_v4_v4(blurColor, tempColor); - blurDivider += 1.0f; + input_color_program_->read(temp_color, xi, yi, data); + add_v4_v4(blur_color, temp_color); + blur_divider += 1.0f; } } } - if (blurDivider > 0.0f) { - mul_v4_v4fl(output, blurColor, 1.0f / blurDivider); + if (blur_divider > 0.0f) { + mul_v4_v4fl(output, blur_color, 1.0f / blur_divider); } else { output[0] = 0.0f; @@ -90,25 +90,24 @@ void BilateralBlurOperation::executePixel(float output[4], int x, int y, void *d } } -void BilateralBlurOperation::deinitExecution() +void BilateralBlurOperation::deinit_execution() { - inputColorProgram_ = nullptr; - inputDeterminatorProgram_ = nullptr; + input_color_program_ = nullptr; + input_determinator_program_ = nullptr; } -bool BilateralBlurOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool BilateralBlurOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; int add = ceil(space_) + 1; - newInput.xmax = input->xmax + (add); - newInput.xmin = input->xmin - (add); - newInput.ymax = input->ymax + (add); - newInput.ymin = input->ymin - (add); + new_input.xmax = input->xmax + (add); + new_input.xmin = input->xmin - (add); + new_input.ymax = input->ymax + (add); + new_input.ymin = input->ymin - (add); - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void BilateralBlurOperation::get_area_of_interest(const int UNUSED(input_idx), @@ -173,7 +172,7 @@ void BilateralBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, Span inputs) { PixelCursor p = {}; - p.step = QualityStepHelper::getStep(); + p.step = QualityStepHelper::get_step(); p.sigma_color = data_->sigma_color; p.input_color = inputs[0]; p.input_determinator = inputs[1]; diff --git a/source/blender/compositor/operations/COM_BilateralBlurOperation.h b/source/blender/compositor/operations/COM_BilateralBlurOperation.h index aa94df1e254..42df82a5296 100644 --- a/source/blender/compositor/operations/COM_BilateralBlurOperation.h +++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.h @@ -25,8 +25,8 @@ namespace blender::compositor { class BilateralBlurOperation : public MultiThreadedOperation, public QualityStepHelper { private: - SocketReader *inputColorProgram_; - SocketReader *inputDeterminatorProgram_; + SocketReader *input_color_program_; + SocketReader *input_determinator_program_; NodeBilateralBlurData *data_; float space_; @@ -36,23 +36,23 @@ class BilateralBlurOperation : public MultiThreadedOperation, public QualityStep /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void setData(NodeBilateralBlurData *data) + void set_data(NodeBilateralBlurData *data) { data_ = data; space_ = data->sigma_space + data->iter; diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.cc b/source/blender/compositor/operations/COM_BlurBaseOperation.cc index 3c43a16599b..15e2ce2d1e0 100644 --- a/source/blender/compositor/operations/COM_BlurBaseOperation.cc +++ b/source/blender/compositor/operations/COM_BlurBaseOperation.cc @@ -26,11 +26,11 @@ namespace blender::compositor { BlurBaseOperation::BlurBaseOperation(DataType data_type) { /* data_type is almost always DataType::Color except for alpha-blur */ - this->addInputSocket(data_type); - this->addInputSocket(DataType::Value); - this->addOutputSocket(data_type); + this->add_input_socket(data_type); + this->add_input_socket(DataType::Value); + this->add_output_socket(data_type); this->flags.complex = true; - inputProgram_ = nullptr; + input_program_ = nullptr; memset(&data_, 0, sizeof(NodeBlurData)); size_ = 1.0f; sizeavailable_ = false; @@ -41,11 +41,11 @@ BlurBaseOperation::BlurBaseOperation(DataType data_type) void BlurBaseOperation::init_data() { if (execution_model_ == eExecutionModel::FullFrame) { - updateSize(); + update_size(); } - data_.image_in_width = this->getWidth(); - data_.image_in_height = this->getHeight(); + data_.image_in_width = this->get_width(); + data_.image_in_height = this->get_height(); if (data_.relative) { int sizex, sizey; switch (data_.aspect) { @@ -66,12 +66,12 @@ void BlurBaseOperation::init_data() } } -void BlurBaseOperation::initExecution() +void BlurBaseOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); - inputSize_ = this->getInputSocketReader(1); + input_program_ = this->get_input_socket_reader(0); + input_size_ = this->get_input_socket_reader(1); - QualityStepHelper::initExecution(COM_QH_MULTIPLY); + QualityStepHelper::init_execution(COM_QH_MULTIPLY); } float *BlurBaseOperation::make_gausstab(float rad, int size) @@ -163,13 +163,13 @@ float *BlurBaseOperation::make_dist_fac_inverse(float rad, int size, int falloff return dist_fac_invert; } -void BlurBaseOperation::deinitExecution() +void BlurBaseOperation::deinit_execution() { - inputProgram_ = nullptr; - inputSize_ = nullptr; + input_program_ = nullptr; + input_size_ = nullptr; } -void BlurBaseOperation::setData(const NodeBlurData *data) +void BlurBaseOperation::set_data(const NodeBlurData *data) { memcpy(&data_, data, sizeof(NodeBlurData)); } @@ -185,7 +185,7 @@ int BlurBaseOperation::get_blur_size(eDimension dim) const return -1; } -void BlurBaseOperation::updateSize() +void BlurBaseOperation::update_size() { if (sizeavailable_ || use_variable_size_) { return; @@ -194,7 +194,7 @@ void BlurBaseOperation::updateSize() switch (execution_model_) { case eExecutionModel::Tiled: { float result[4]; - this->getInputSocketReader(1)->readSampled(result, 0, 0, PixelSampler::Nearest); + this->get_input_socket_reader(1)->read_sampled(result, 0, 0, PixelSampler::Nearest); size_ = result[0]; break; } diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.h b/source/blender/compositor/operations/COM_BlurBaseOperation.h index b1dad2e868f..ab378983100 100644 --- a/source/blender/compositor/operations/COM_BlurBaseOperation.h +++ b/source/blender/compositor/operations/COM_BlurBaseOperation.h @@ -43,13 +43,13 @@ class BlurBaseOperation : public MultiThreadedOperation, public QualityStepHelpe #endif float *make_dist_fac_inverse(float rad, int size, int falloff); - void updateSize(); + void update_size(); /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; - SocketReader *inputSize_; + SocketReader *input_program_; + SocketReader *input_size_; NodeBlurData data_; float size_; @@ -63,22 +63,22 @@ class BlurBaseOperation : public MultiThreadedOperation, public QualityStepHelpe /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setData(const NodeBlurData *data); + void set_data(const NodeBlurData *data); - void setSize(float size) + void set_size(float size) { size_ = size; sizeavailable_ = true; } - void setExtendBounds(bool extend_bounds) + void set_extend_bounds(bool extend_bounds) { extend_bounds_ = extend_bounds; } diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.cc b/source/blender/compositor/operations/COM_BokehBlurOperation.cc index d00a18baf7b..80e7390e02f 100644 --- a/source/blender/compositor/operations/COM_BokehBlurOperation.cc +++ b/source/blender/compositor/operations/COM_BokehBlurOperation.cc @@ -30,20 +30,20 @@ constexpr int SIZE_INPUT_INDEX = 3; BokehBlurOperation::BokehBlurOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color, ResizeMode::Align); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color, ResizeMode::Align); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); flags.complex = true; flags.open_cl = true; size_ = 1.0f; sizeavailable_ = false; - inputProgram_ = nullptr; - inputBokehProgram_ = nullptr; - inputBoundingBoxReader_ = nullptr; + input_program_ = nullptr; + input_bokeh_program_ = nullptr; + input_bounding_box_reader_ = nullptr; extend_bounds_ = false; } @@ -51,88 +51,88 @@ BokehBlurOperation::BokehBlurOperation() void BokehBlurOperation::init_data() { if (execution_model_ == eExecutionModel::FullFrame) { - updateSize(); + update_size(); } NodeOperation *bokeh = get_input_operation(BOKEH_INPUT_INDEX); - const int width = bokeh->getWidth(); - const int height = bokeh->getHeight(); + const int width = bokeh->get_width(); + const int height = bokeh->get_height(); const float dimension = MIN2(width, height); - bokehMidX_ = width / 2.0f; - bokehMidY_ = height / 2.0f; + bokeh_mid_x_ = width / 2.0f; + bokeh_mid_y_ = height / 2.0f; bokehDimension_ = dimension / 2.0f; } -void *BokehBlurOperation::initializeTileData(rcti * /*rect*/) +void *BokehBlurOperation::initialize_tile_data(rcti * /*rect*/) { - lockMutex(); + lock_mutex(); if (!sizeavailable_) { - updateSize(); + update_size(); } - void *buffer = getInputOperation(0)->initializeTileData(nullptr); - unlockMutex(); + void *buffer = get_input_operation(0)->initialize_tile_data(nullptr); + unlock_mutex(); return buffer; } -void BokehBlurOperation::initExecution() +void BokehBlurOperation::init_execution() { - initMutex(); + init_mutex(); - inputProgram_ = getInputSocketReader(0); - inputBokehProgram_ = getInputSocketReader(1); - inputBoundingBoxReader_ = getInputSocketReader(2); + input_program_ = get_input_socket_reader(0); + input_bokeh_program_ = get_input_socket_reader(1); + input_bounding_box_reader_ = get_input_socket_reader(2); - QualityStepHelper::initExecution(COM_QH_INCREASE); + QualityStepHelper::init_execution(COM_QH_INCREASE); } -void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data) +void BokehBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { float color_accum[4]; - float tempBoundingBox[4]; + float temp_bounding_box[4]; float bokeh[4]; - inputBoundingBoxReader_->readSampled(tempBoundingBox, x, y, PixelSampler::Nearest); - if (tempBoundingBox[0] > 0.0f) { + input_bounding_box_reader_->read_sampled(temp_bounding_box, x, y, PixelSampler::Nearest); + if (temp_bounding_box[0] > 0.0f) { float multiplier_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - const rcti &input_rect = inputBuffer->get_rect(); - float *buffer = inputBuffer->getBuffer(); - int bufferwidth = inputBuffer->getWidth(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + const rcti &input_rect = input_buffer->get_rect(); + float *buffer = input_buffer->get_buffer(); + int bufferwidth = input_buffer->get_width(); int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; - const float max_dim = MAX2(this->getWidth(), this->getHeight()); - int pixelSize = size_ * max_dim / 100.0f; + const float max_dim = MAX2(this->get_width(), this->get_height()); + int pixel_size = size_ * max_dim / 100.0f; zero_v4(color_accum); - if (pixelSize < 2) { - inputProgram_->readSampled(color_accum, x, y, PixelSampler::Nearest); + if (pixel_size < 2) { + input_program_->read_sampled(color_accum, x, y, PixelSampler::Nearest); multiplier_accum[0] = 1.0f; multiplier_accum[1] = 1.0f; multiplier_accum[2] = 1.0f; multiplier_accum[3] = 1.0f; } - int miny = y - pixelSize; - int maxy = y + pixelSize; - int minx = x - pixelSize; - int maxx = x + pixelSize; + int miny = y - pixel_size; + int maxy = y + pixel_size; + int minx = x - pixel_size; + int maxx = x + pixel_size; miny = MAX2(miny, input_rect.ymin); minx = MAX2(minx, input_rect.xmin); maxy = MIN2(maxy, input_rect.ymax); maxx = MIN2(maxx, input_rect.xmax); - int step = getStep(); - int offsetadd = getOffsetAdd() * COM_DATA_TYPE_COLOR_CHANNELS; + int step = get_step(); + int offsetadd = get_offset_add() * COM_DATA_TYPE_COLOR_CHANNELS; - float m = bokehDimension_ / pixelSize; + float m = bokehDimension_ / pixel_size; 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 = bokehMidX_ - (nx - x) * m; - float v = bokehMidY_ - (ny - y) * m; - inputBokehProgram_->readSampled(bokeh, u, v, PixelSampler::Nearest); + float u = bokeh_mid_x_ - (nx - x) * m; + float v = bokeh_mid_y_ - (ny - y) * m; + input_bokeh_program_->read_sampled(bokeh, u, v, PixelSampler::Nearest); madd_v4_v4v4(color_accum, bokeh, &buffer[bufferindex]); add_v4_v4(multiplier_accum, bokeh); bufferindex += offsetadd; @@ -144,100 +144,100 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data) output[3] = color_accum[3] * (1.0f / multiplier_accum[3]); } else { - inputProgram_->readSampled(output, x, y, PixelSampler::Nearest); + input_program_->read_sampled(output, x, y, PixelSampler::Nearest); } } -void BokehBlurOperation::deinitExecution() +void BokehBlurOperation::deinit_execution() { - deinitMutex(); - inputProgram_ = nullptr; - inputBokehProgram_ = nullptr; - inputBoundingBoxReader_ = nullptr; + deinit_mutex(); + input_program_ = nullptr; + input_bokeh_program_ = nullptr; + input_bounding_box_reader_ = nullptr; } -bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool BokehBlurOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; - rcti bokehInput; - const float max_dim = MAX2(this->getWidth(), this->getHeight()); + rcti new_input; + rcti bokeh_input; + const float max_dim = MAX2(this->get_width(), this->get_height()); 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); + new_input.xmax = input->xmax + (size_ * max_dim / 100.0f); + new_input.xmin = input->xmin - (size_ * max_dim / 100.0f); + new_input.ymax = input->ymax + (size_ * max_dim / 100.0f); + new_input.ymin = input->ymin - (size_ * max_dim / 100.0f); } else { - newInput.xmax = input->xmax + (10.0f * max_dim / 100.0f); - newInput.xmin = input->xmin - (10.0f * max_dim / 100.0f); - newInput.ymax = input->ymax + (10.0f * max_dim / 100.0f); - newInput.ymin = input->ymin - (10.0f * max_dim / 100.0f); + new_input.xmax = input->xmax + (10.0f * max_dim / 100.0f); + new_input.xmin = input->xmin - (10.0f * max_dim / 100.0f); + new_input.ymax = input->ymax + (10.0f * max_dim / 100.0f); + new_input.ymin = input->ymin - (10.0f * max_dim / 100.0f); } - NodeOperation *operation = getInputOperation(1); - bokehInput.xmax = operation->getWidth(); - bokehInput.xmin = 0; - bokehInput.ymax = operation->getHeight(); - bokehInput.ymin = 0; - if (operation->determineDependingAreaOfInterest(&bokehInput, readOperation, output)) { + NodeOperation *operation = get_input_operation(1); + bokeh_input.xmax = operation->get_width(); + bokeh_input.xmin = 0; + bokeh_input.ymax = operation->get_height(); + bokeh_input.ymin = 0; + if (operation->determine_depending_area_of_interest(&bokeh_input, read_operation, output)) { return true; } - operation = getInputOperation(0); - if (operation->determineDependingAreaOfInterest(&newInput, readOperation, output)) { + operation = get_input_operation(0); + if (operation->determine_depending_area_of_interest(&new_input, read_operation, output)) { return true; } - operation = getInputOperation(2); - if (operation->determineDependingAreaOfInterest(input, readOperation, output)) { + operation = get_input_operation(2); + if (operation->determine_depending_area_of_interest(input, read_operation, output)) { return true; } if (!sizeavailable_) { - rcti sizeInput; - sizeInput.xmin = 0; - sizeInput.ymin = 0; - sizeInput.xmax = 5; - sizeInput.ymax = 5; - operation = getInputOperation(3); - if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) { + rcti size_input; + size_input.xmin = 0; + size_input.ymin = 0; + size_input.xmax = 5; + size_input.ymax = 5; + operation = get_input_operation(3); + if (operation->determine_depending_area_of_interest(&size_input, read_operation, output)) { return true; } } return false; } -void BokehBlurOperation::executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list * /*clKernelsToCleanUp*/) +void BokehBlurOperation::execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list * /*cl_kernels_to_clean_up*/) { - cl_kernel kernel = device->COM_clCreateKernel("bokehBlurKernel", nullptr); + cl_kernel kernel = device->COM_cl_create_kernel("bokeh_blur_kernel", nullptr); if (!sizeavailable_) { - updateSize(); + update_size(); } - const float max_dim = MAX2(this->getWidth(), this->getHeight()); + const float max_dim = MAX2(this->get_width(), this->get_height()); cl_int radius = size_ * max_dim / 100.0f; - cl_int step = this->getStep(); - - device->COM_clAttachMemoryBufferToKernelParameter( - kernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, inputBoundingBoxReader_); - device->COM_clAttachMemoryBufferToKernelParameter( - kernel, 1, 4, clMemToCleanUp, inputMemoryBuffers, inputProgram_); - device->COM_clAttachMemoryBufferToKernelParameter( - kernel, 2, -1, clMemToCleanUp, inputMemoryBuffers, inputBokehProgram_); - device->COM_clAttachOutputMemoryBufferToKernelParameter(kernel, 3, clOutputBuffer); - device->COM_clAttachMemoryBufferOffsetToKernelParameter(kernel, 5, outputMemoryBuffer); + cl_int step = this->get_step(); + + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + kernel, 0, -1, cl_mem_to_clean_up, input_memory_buffers, input_bounding_box_reader_); + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + kernel, 1, 4, cl_mem_to_clean_up, input_memory_buffers, input_program_); + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + kernel, 2, -1, cl_mem_to_clean_up, input_memory_buffers, input_bokeh_program_); + device->COM_cl_attach_output_memory_buffer_to_kernel_parameter(kernel, 3, cl_output_buffer); + device->COM_cl_attach_memory_buffer_offset_to_kernel_parameter(kernel, 5, output_memory_buffer); clSetKernelArg(kernel, 6, sizeof(cl_int), &radius); clSetKernelArg(kernel, 7, sizeof(cl_int), &step); - device->COM_clAttachSizeToKernelParameter(kernel, 8, this); + device->COM_cl_attach_size_to_kernel_parameter(kernel, 8, this); - device->COM_clEnqueueRange(kernel, outputMemoryBuffer, 9, this); + device->COM_cl_enqueue_range(kernel, output_memory_buffer, 9, this); } -void BokehBlurOperation::updateSize() +void BokehBlurOperation::update_size() { if (sizeavailable_) { return; @@ -246,7 +246,7 @@ void BokehBlurOperation::updateSize() switch (execution_model_) { case eExecutionModel::Tiled: { float result[4]; - this->getInputSocketReader(3)->readSampled(result, 0, 0, PixelSampler::Nearest); + this->get_input_socket_reader(3)->read_sampled(result, 0, 0, PixelSampler::Nearest); size_ = result[0]; CLAMP(size_, 0.0f, 10.0f); break; @@ -298,7 +298,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 max_dim = MAX2(this->get_width(), this->get_height()); 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; @@ -307,7 +307,7 @@ void BokehBlurOperation::get_area_of_interest(const int input_idx, break; } case BOKEH_INPUT_INDEX: { - NodeOperation *bokeh_input = getInputOperation(BOKEH_INPUT_INDEX); + NodeOperation *bokeh_input = get_input_operation(BOKEH_INPUT_INDEX); r_input_area = bokeh_input->get_canvas(); break; } @@ -325,7 +325,7 @@ void BokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - const float max_dim = MAX2(this->getWidth(), this->getHeight()); + const float max_dim = MAX2(this->get_width(), this->get_height()); const int pixel_size = size_ * max_dim / 100.0f; const float m = bokehDimension_ / pixel_size; @@ -356,15 +356,15 @@ void BokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, const int maxy = MIN2(y + pixel_size, image_rect.ymax); const int minx = MAX2(x - pixel_size, image_rect.xmin); const int maxx = MIN2(x + pixel_size, image_rect.xmax); - const int step = getStep(); + const int step = get_step(); const int elem_stride = image_input->elem_stride * step; const int row_stride = image_input->row_stride * step; 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 = bokehMidY_ - (ny - y) * m; + const float v = bokeh_mid_y_ - (ny - y) * m; for (int nx = minx; nx < maxx; nx += step, color += elem_stride) { - const float u = bokehMidX_ - (nx - x) * m; + const float u = bokeh_mid_x_ - (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 0b70b7a714a..5f6a880f890 100644 --- a/source/blender/compositor/operations/COM_BokehBlurOperation.h +++ b/source/blender/compositor/operations/COM_BokehBlurOperation.h @@ -25,15 +25,15 @@ namespace blender::compositor { class BokehBlurOperation : public MultiThreadedOperation, public QualityStepHelper { private: - SocketReader *inputProgram_; - SocketReader *inputBokehProgram_; - SocketReader *inputBoundingBoxReader_; - void updateSize(); + SocketReader *input_program_; + SocketReader *input_bokeh_program_; + SocketReader *input_bounding_box_reader_; + void update_size(); float size_; bool sizeavailable_; - float bokehMidX_; - float bokehMidY_; + float bokeh_mid_x_; + float bokeh_mid_y_; float bokehDimension_; bool extend_bounds_; @@ -42,40 +42,40 @@ class BokehBlurOperation : public MultiThreadedOperation, public QualityStepHelp void init_data() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void setSize(float size) + void set_size(float size) { size_ = size; sizeavailable_ = true; } - void executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list *clKernelsToCleanUp) override; + void execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list *cl_kernels_to_clean_up) override; - void setExtendBounds(bool extend_bounds) + void set_extend_bounds(bool extend_bounds) { extend_bounds_ = extend_bounds; } diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.cc b/source/blender/compositor/operations/COM_BokehImageOperation.cc index 5389fa633b0..9e7c1162052 100644 --- a/source/blender/compositor/operations/COM_BokehImageOperation.cc +++ b/source/blender/compositor/operations/COM_BokehImageOperation.cc @@ -22,91 +22,91 @@ namespace blender::compositor { BokehImageOperation::BokehImageOperation() { - this->addOutputSocket(DataType::Color); - deleteData_ = false; + this->add_output_socket(DataType::Color); + delete_data_ = false; } -void BokehImageOperation::initExecution() +void BokehImageOperation::init_execution() { - 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); + center_[0] = get_width() / 2; + center_[1] = get_height() / 2; + inverse_rounding_ = 1.0f - data_->rounding; + circular_distance_ = get_width() / 2; + flap_rad_ = (float)(M_PI * 2) / data_->flaps; + flap_rad_add_ = data_->angle; + while (flap_rad_add_ < 0.0f) { + flap_rad_add_ += (float)(M_PI * 2.0); } - while (flapRadAdd_ > (float)M_PI) { - flapRadAdd_ -= (float)(M_PI * 2.0); + while (flap_rad_add_ > (float)M_PI) { + flap_rad_add_ -= (float)(M_PI * 2.0); } } -void BokehImageOperation::detemineStartPointOfFlap(float r[2], int flapNumber, float distance) +void BokehImageOperation::detemine_start_point_of_flap(float r[2], int flap_number, float distance) { - r[0] = sinf(flapRad_ * flapNumber + flapRadAdd_) * distance + center_[0]; - r[1] = cosf(flapRad_ * flapNumber + flapRadAdd_) * distance + center_[1]; + r[0] = sinf(flap_rad_ * flap_number + flap_rad_add_) * distance + center_[0]; + r[1] = cosf(flap_rad_ * flap_number + flap_rad_add_) * distance + center_[1]; } -float BokehImageOperation::isInsideBokeh(float distance, float x, float y) +float BokehImageOperation::is_inside_bokeh(float distance, float x, float y) { - float insideBokeh = 0.0f; + float inside_bokeh = 0.0f; const float deltaX = x - center_[0]; const float deltaY = y - center_[1]; - float closestPoint[2]; - float lineP1[2]; - float lineP2[2]; + float closest_point[2]; + float line_p1[2]; + float line_p2[2]; float point[2]; point[0] = x; point[1] = y; - const float distanceToCenter = len_v2v2(point, center_); + const float distance_to_center = len_v2v2(point, center_); const float bearing = (atan2f(deltaX, deltaY) + (float)(M_PI * 2.0)); - int flapNumber = (int)((bearing - flapRadAdd_) / flapRad_); + int flap_number = (int)((bearing - flap_rad_add_) / flap_rad_); - detemineStartPointOfFlap(lineP1, flapNumber, distance); - detemineStartPointOfFlap(lineP2, flapNumber + 1, distance); - closest_to_line_v2(closestPoint, point, lineP1, lineP2); + detemine_start_point_of_flap(line_p1, flap_number, distance); + detemine_start_point_of_flap(line_p2, flap_number + 1, distance); + closest_to_line_v2(closest_point, point, line_p1, line_p2); - const float distanceLineToCenter = len_v2v2(center_, closestPoint); - const float distanceRoundingToCenter = inverseRounding_ * distanceLineToCenter + - data_->rounding * distance; + const float distance_line_to_center = len_v2v2(center_, closest_point); + const float distance_rounding_to_center = inverse_rounding_ * distance_line_to_center + + data_->rounding * distance; - const float catadioptricDistanceToCenter = distanceRoundingToCenter * data_->catadioptric; - if (distanceRoundingToCenter >= distanceToCenter && - catadioptricDistanceToCenter <= distanceToCenter) { - if (distanceRoundingToCenter - distanceToCenter < 1.0f) { - insideBokeh = (distanceRoundingToCenter - distanceToCenter); + const float catadioptric_distance_to_center = distance_rounding_to_center * data_->catadioptric; + if (distance_rounding_to_center >= distance_to_center && + catadioptric_distance_to_center <= distance_to_center) { + if (distance_rounding_to_center - distance_to_center < 1.0f) { + inside_bokeh = (distance_rounding_to_center - distance_to_center); } else if (data_->catadioptric != 0.0f && - distanceToCenter - catadioptricDistanceToCenter < 1.0f) { - insideBokeh = (distanceToCenter - catadioptricDistanceToCenter); + distance_to_center - catadioptric_distance_to_center < 1.0f) { + inside_bokeh = (distance_to_center - catadioptric_distance_to_center); } else { - insideBokeh = 1.0f; + inside_bokeh = 1.0f; } } - return insideBokeh; + return inside_bokeh; } -void BokehImageOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void BokehImageOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { float shift = data_->lensshift; float shift2 = shift / 2.0f; - 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); + float distance = circular_distance_; + float inside_bokeh_max = is_inside_bokeh(distance, x, y); + float inside_bokeh_med = is_inside_bokeh(distance - fabsf(shift2 * distance), x, y); + float inside_bokeh_min = is_inside_bokeh(distance - fabsf(shift * distance), x, y); if (shift < 0) { - output[0] = insideBokehMax; - output[1] = insideBokehMed; - output[2] = insideBokehMin; + output[0] = inside_bokeh_max; + output[1] = inside_bokeh_med; + output[2] = inside_bokeh_min; } else { - output[0] = insideBokehMin; - output[1] = insideBokehMed; - output[2] = insideBokehMax; + output[0] = inside_bokeh_min; + output[1] = inside_bokeh_med; + output[2] = inside_bokeh_max; } - output[3] = (insideBokehMax + insideBokehMed + insideBokehMin) / 3.0f; + output[3] = (inside_bokeh_max + inside_bokeh_med + inside_bokeh_min) / 3.0f; } void BokehImageOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -115,28 +115,29 @@ void BokehImageOperation::update_memory_buffer_partial(MemoryBuffer *output, { const float shift = data_->lensshift; const float shift2 = shift / 2.0f; - const float distance = circularDistance_; + const float distance = circular_distance_; for (BuffersIterator 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); - const float insideBokehMin = isInsideBokeh(distance - fabsf(shift * distance), it.x, it.y); + const float inside_bokeh_max = is_inside_bokeh(distance, it.x, it.y); + const float inside_bokeh_med = is_inside_bokeh( + distance - fabsf(shift2 * distance), it.x, it.y); + const float inside_bokeh_min = is_inside_bokeh(distance - fabsf(shift * distance), it.x, it.y); if (shift < 0) { - it.out[0] = insideBokehMax; - it.out[1] = insideBokehMed; - it.out[2] = insideBokehMin; + it.out[0] = inside_bokeh_max; + it.out[1] = inside_bokeh_med; + it.out[2] = inside_bokeh_min; } else { - it.out[0] = insideBokehMin; - it.out[1] = insideBokehMed; - it.out[2] = insideBokehMax; + it.out[0] = inside_bokeh_min; + it.out[1] = inside_bokeh_med; + it.out[2] = inside_bokeh_max; } - it.out[3] = (insideBokehMax + insideBokehMed + insideBokehMin) / 3.0f; + it.out[3] = (inside_bokeh_max + inside_bokeh_med + inside_bokeh_min) / 3.0f; } } -void BokehImageOperation::deinitExecution() +void BokehImageOperation::deinit_execution() { - if (deleteData_) { + if (delete_data_) { 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 de1c05fe360..6c7818724b3 100644 --- a/source/blender/compositor/operations/COM_BokehImageOperation.h +++ b/source/blender/compositor/operations/COM_BokehImageOperation.h @@ -64,36 +64,36 @@ class BokehImageOperation : public MultiThreadedOperation { /** * \brief 1.0-rounding */ - float inverseRounding_; + float inverse_rounding_; /** * \brief distance of a full circle lens */ - float circularDistance_; + float circular_distance_; /** * \brief radius when the first flap starts */ - float flapRad_; + float flap_rad_; /** * \brief radians of a single flap */ - float flapRadAdd_; + float flap_rad_add_; /** * \brief should the data_ field by deleted when this operation is finished */ - bool deleteData_; + bool delete_data_; /** * \brief determine the coordinate of a flap corner. * * \param r: result in bokeh-image space are stored [x,y] - * \param flapNumber: the flap number to calculate + * \param flap_number: the flap number to calculate * \param distance: the lens distance is used to simulate lens shifts */ - void detemineStartPointOfFlap(float r[2], int flapNumber, float distance); + void detemine_start_point_of_flap(float r[2], int flap_number, float distance); /** * \brief Determine if a coordinate is inside the bokeh image @@ -104,7 +104,7 @@ class BokehImageOperation : public MultiThreadedOperation { * \param y: the y coordinate of the pixel to evaluate * \return float range 0..1 0 is completely outside */ - float isInsideBokeh(float distance, float x, float y); + float is_inside_bokeh(float distance, float x, float y); public: BokehImageOperation(); @@ -112,21 +112,21 @@ class BokehImageOperation : public MultiThreadedOperation { /** * \brief The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * \brief Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * \brief Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; /** * \brief determine the resolution of this operation. currently fixed at [COM_BLUR_BOKEH_PIXELS, - * COM_BLUR_BOKEH_PIXELS] \param resolution: \param preferredResolution: + * COM_BLUR_BOKEH_PIXELS] \param resolution: \param preferred_resolution: */ void determine_canvas(const rcti &preferred_area, rcti &r_area) override; @@ -134,21 +134,21 @@ class BokehImageOperation : public MultiThreadedOperation { * \brief set the node data * \param data: */ - void setData(NodeBokehImage *data) + void set_data(NodeBokehImage *data) { data_ = data; } /** - * \brief deleteDataOnFinish + * \brief delete_data_on_finish * * There are cases that the compositor uses this operation on its own (see defocus node) - * the deleteDataOnFinish must only be called when the data has been created by the compositor. - *It should not be called when the data has been created by the node-editor/user. + * the delete_data_on_finish must only be called when the data has been created by the + *compositor. It should not be called when the data has been created by the node-editor/user. */ - void deleteDataOnFinish() + void delete_data_on_finish() { - deleteData_ = true; + delete_data_ = 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 7263e6a1a59..adfe7fcd87a 100644 --- a/source/blender/compositor/operations/COM_BoxMaskOperation.cc +++ b/source/blender/compositor/operations/COM_BoxMaskOperation.cc @@ -22,66 +22,69 @@ namespace blender::compositor { BoxMaskOperation::BoxMaskOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - inputMask_ = nullptr; - inputValue_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + input_mask_ = nullptr; + input_value_ = nullptr; cosine_ = 0.0f; sine_ = 0.0f; } -void BoxMaskOperation::initExecution() +void BoxMaskOperation::init_execution() { - inputMask_ = this->getInputSocketReader(0); - inputValue_ = this->getInputSocketReader(1); + input_mask_ = this->get_input_socket_reader(0); + input_value_ = this->get_input_socket_reader(1); const double rad = (double)data_->rotation; cosine_ = cos(rad); sine_ = sin(rad); - aspectRatio_ = ((float)this->getWidth()) / this->getHeight(); + aspect_ratio_ = ((float)this->get_width()) / this->get_height(); } -void BoxMaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void BoxMaskOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputMask[4]; - float inputValue[4]; + float input_mask[4]; + float input_value[4]; - float rx = x / this->getWidth(); - float ry = y / this->getHeight(); + float rx = x / this->get_width(); + float ry = y / this->get_height(); - const float dy = (ry - data_->y) / aspectRatio_; + const float dy = (ry - data_->y) / aspect_ratio_; const float dx = rx - data_->x; rx = data_->x + (cosine_ * dx + sine_ * dy); ry = data_->y + (-sine_ * dx + cosine_ * dy); - inputMask_->readSampled(inputMask, x, y, sampler); - inputValue_->readSampled(inputValue, x, y, sampler); + input_mask_->read_sampled(input_mask, x, y, sampler); + input_value_->read_sampled(input_value, x, y, sampler); - 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); + float half_height = data_->height / 2.0f; + float half_width = data_->width / 2.0f; + bool inside = (rx > data_->x - half_width && rx < data_->x + half_width && + ry > data_->y - half_height && ry < data_->y + half_height); - switch (maskType_) { + switch (mask_type_) { case CMP_NODE_MASKTYPE_ADD: if (inside) { - output[0] = MAX2(inputMask[0], inputValue[0]); + output[0] = MAX2(input_mask[0], input_value[0]); } else { - output[0] = inputMask[0]; + output[0] = input_mask[0]; } break; case CMP_NODE_MASKTYPE_SUBTRACT: if (inside) { - output[0] = inputMask[0] - inputValue[0]; + output[0] = input_mask[0] - input_value[0]; CLAMP(output[0], 0, 1); } else { - output[0] = inputMask[0]; + output[0] = input_mask[0]; } break; case CMP_NODE_MASKTYPE_MULTIPLY: if (inside) { - output[0] = inputMask[0] * inputValue[0]; + output[0] = input_mask[0] * input_value[0]; } else { output[0] = 0; @@ -89,15 +92,15 @@ void BoxMaskOperation::executePixelSampled(float output[4], float x, float y, Pi break; case CMP_NODE_MASKTYPE_NOT: if (inside) { - if (inputMask[0] > 0.0f) { + if (input_mask[0] > 0.0f) { output[0] = 0; } else { - output[0] = inputValue[0]; + output[0] = input_value[0]; } } else { - output[0] = inputMask[0]; + output[0] = input_mask[0]; } break; } @@ -108,7 +111,7 @@ void BoxMaskOperation::update_memory_buffer_partial(MemoryBuffer *output, Span inputs) { MaskFunc mask_func; - switch (maskType_) { + switch (mask_type_) { 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]; @@ -141,13 +144,13 @@ void BoxMaskOperation::apply_mask(MemoryBuffer *output, Span inputs, MaskFunc mask_func) { - const float op_w = this->getWidth(); - const float op_h = this->getHeight(); + const float op_w = this->get_width(); + const float op_h = this->get_height(); const float half_w = data_->width / 2.0f; const float half_h = data_->height / 2.0f; for (BuffersIterator it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const float op_ry = it.y / op_h; - const float dy = (op_ry - data_->y) / aspectRatio_; + const float dy = (op_ry - data_->y) / aspect_ratio_; const float op_rx = it.x / op_w; const float dx = op_rx - data_->x; const float rx = data_->x + (cosine_ * dx + sine_ * dy); @@ -161,10 +164,10 @@ void BoxMaskOperation::apply_mask(MemoryBuffer *output, } } -void BoxMaskOperation::deinitExecution() +void BoxMaskOperation::deinit_execution() { - inputMask_ = nullptr; - inputValue_ = nullptr; + input_mask_ = nullptr; + input_value_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_BoxMaskOperation.h b/source/blender/compositor/operations/COM_BoxMaskOperation.h index 458cdf7ee16..4aee88556ee 100644 --- a/source/blender/compositor/operations/COM_BoxMaskOperation.h +++ b/source/blender/compositor/operations/COM_BoxMaskOperation.h @@ -27,15 +27,15 @@ class BoxMaskOperation : public MultiThreadedOperation { using MaskFunc = std::function; /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputMask_; - SocketReader *inputValue_; + SocketReader *input_mask_; + SocketReader *input_value_; float sine_; float cosine_; - float aspectRatio_; - int maskType_; + float aspect_ratio_; + int mask_type_; NodeBoxMask *data_; @@ -45,26 +45,26 @@ class BoxMaskOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setData(NodeBoxMask *data) + void set_data(NodeBoxMask *data) { data_ = data; } - void setMaskType(int maskType) + void set_mask_type(int mask_type) { - maskType_ = maskType; + mask_type_ = mask_type; } 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 77f30331767..a445bb122c2 100644 --- a/source/blender/compositor/operations/COM_BrightnessOperation.cc +++ b/source/blender/compositor/operations/COM_BrightnessOperation.cc @@ -22,41 +22,41 @@ namespace blender::compositor { BrightnessOperation::BrightnessOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); - inputProgram_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); + input_program_ = nullptr; use_premultiply_ = false; flags.can_be_constant = true; } -void BrightnessOperation::setUsePremultiply(bool use_premultiply) +void BrightnessOperation::set_use_premultiply(bool use_premultiply) { use_premultiply_ = use_premultiply; } -void BrightnessOperation::initExecution() +void BrightnessOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); - inputBrightnessProgram_ = this->getInputSocketReader(1); - inputContrastProgram_ = this->getInputSocketReader(2); + input_program_ = this->get_input_socket_reader(0); + input_brightness_program_ = this->get_input_socket_reader(1); + input_contrast_program_ = this->get_input_socket_reader(2); } -void BrightnessOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void BrightnessOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue[4]; + float input_value[4]; float a, b; - float inputBrightness[4]; - float inputContrast[4]; - 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]; + float input_brightness[4]; + float input_contrast[4]; + input_program_->read_sampled(input_value, x, y, sampler); + input_brightness_program_->read_sampled(input_brightness, x, y, sampler); + input_contrast_program_->read_sampled(input_contrast, x, y, sampler); + float brightness = input_brightness[0]; + float contrast = input_contrast[0]; brightness /= 100.0f; float delta = contrast / 200.0f; /* @@ -75,12 +75,12 @@ void BrightnessOperation::executePixelSampled(float output[4], b = a * brightness + delta; } if (use_premultiply_) { - premul_to_straight_v4(inputValue); + premul_to_straight_v4(input_value); } - output[0] = a * inputValue[0] + b; - output[1] = a * inputValue[1] + b; - output[2] = a * inputValue[2] + b; - output[3] = inputValue[3]; + output[0] = a * input_value[0] + b; + output[1] = a * input_value[1] + b; + output[2] = a * input_value[2] + b; + output[3] = input_value[3]; if (use_premultiply_) { straight_to_premul_v4(output); } @@ -130,11 +130,11 @@ void BrightnessOperation::update_memory_buffer_partial(MemoryBuffer *output, } } -void BrightnessOperation::deinitExecution() +void BrightnessOperation::deinit_execution() { - inputProgram_ = nullptr; - inputBrightnessProgram_ = nullptr; - inputContrastProgram_ = nullptr; + input_program_ = nullptr; + input_brightness_program_ = nullptr; + input_contrast_program_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_BrightnessOperation.h b/source/blender/compositor/operations/COM_BrightnessOperation.h index 0ecb8473319..003baa96613 100644 --- a/source/blender/compositor/operations/COM_BrightnessOperation.h +++ b/source/blender/compositor/operations/COM_BrightnessOperation.h @@ -25,11 +25,11 @@ namespace blender::compositor { class BrightnessOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; - SocketReader *inputBrightnessProgram_; - SocketReader *inputContrastProgram_; + SocketReader *input_program_; + SocketReader *input_brightness_program_; + SocketReader *input_contrast_program_; bool use_premultiply_; @@ -39,19 +39,19 @@ class BrightnessOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setUsePremultiply(bool use_premultiply); + void set_use_premultiply(bool use_premultiply); void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_CalculateMeanOperation.cc b/source/blender/compositor/operations/COM_CalculateMeanOperation.cc index ce2351cf759..f759ba5ccef 100644 --- a/source/blender/compositor/operations/COM_CalculateMeanOperation.cc +++ b/source/blender/compositor/operations/COM_CalculateMeanOperation.cc @@ -26,67 +26,66 @@ namespace blender::compositor { CalculateMeanOperation::CalculateMeanOperation() { - this->addInputSocket(DataType::Color, ResizeMode::Align); - this->addOutputSocket(DataType::Value); - imageReader_ = nullptr; + this->add_input_socket(DataType::Color, ResizeMode::Align); + this->add_output_socket(DataType::Value); + image_reader_ = nullptr; iscalculated_ = false; setting_ = 1; this->flags.complex = true; } -void CalculateMeanOperation::initExecution() +void CalculateMeanOperation::init_execution() { - imageReader_ = this->getInputSocketReader(0); + image_reader_ = this->get_input_socket_reader(0); iscalculated_ = false; - NodeOperation::initMutex(); + NodeOperation::init_mutex(); } -void CalculateMeanOperation::executePixel(float output[4], int /*x*/, int /*y*/, void * /*data*/) +void CalculateMeanOperation::execute_pixel(float output[4], int /*x*/, int /*y*/, void * /*data*/) { output[0] = result_; } -void CalculateMeanOperation::deinitExecution() +void CalculateMeanOperation::deinit_execution() { - imageReader_ = nullptr; - NodeOperation::deinitMutex(); + image_reader_ = nullptr; + NodeOperation::deinit_mutex(); } -bool CalculateMeanOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool CalculateMeanOperation::determine_depending_area_of_interest( + rcti * /*input*/, ReadBufferOperation *read_operation, rcti *output) { - rcti imageInput; + rcti image_input; if (iscalculated_) { return false; } - NodeOperation *operation = getInputOperation(0); - imageInput.xmax = operation->getWidth(); - imageInput.xmin = 0; - imageInput.ymax = operation->getHeight(); - imageInput.ymin = 0; - if (operation->determineDependingAreaOfInterest(&imageInput, readOperation, output)) { + NodeOperation *operation = get_input_operation(0); + image_input.xmax = operation->get_width(); + image_input.xmin = 0; + image_input.ymax = operation->get_height(); + image_input.ymin = 0; + if (operation->determine_depending_area_of_interest(&image_input, read_operation, output)) { return true; } return false; } -void *CalculateMeanOperation::initializeTileData(rcti *rect) +void *CalculateMeanOperation::initialize_tile_data(rcti *rect) { - lockMutex(); + lock_mutex(); if (!iscalculated_) { - MemoryBuffer *tile = (MemoryBuffer *)imageReader_->initializeTileData(rect); - calculateMean(tile); + MemoryBuffer *tile = (MemoryBuffer *)image_reader_->initialize_tile_data(rect); + calculate_mean(tile); iscalculated_ = true; } - unlockMutex(); + unlock_mutex(); return nullptr; } -void CalculateMeanOperation::calculateMean(MemoryBuffer *tile) +void CalculateMeanOperation::calculate_mean(MemoryBuffer *tile) { result_ = 0.0f; - float *buffer = tile->getBuffer(); - int size = tile->getWidth() * tile->getHeight(); + float *buffer = tile->get_buffer(); + int size = tile->get_width() * tile->get_height(); int pixels = 0; float sum = 0.0f; for (int i = 0, offset = 0; i < size; i++, offset += 4) { @@ -128,7 +127,7 @@ void CalculateMeanOperation::calculateMean(MemoryBuffer *tile) result_ = sum / pixels; } -void CalculateMeanOperation::setSetting(int setting) +void CalculateMeanOperation::set_setting(int setting) { setting_ = setting; switch (setting) { diff --git a/source/blender/compositor/operations/COM_CalculateMeanOperation.h b/source/blender/compositor/operations/COM_CalculateMeanOperation.h index a34bab45211..7c4fafb2f27 100644 --- a/source/blender/compositor/operations/COM_CalculateMeanOperation.h +++ b/source/blender/compositor/operations/COM_CalculateMeanOperation.h @@ -39,7 +39,7 @@ class CalculateMeanOperation : public MultiThreadedOperation { /** * \brief Cached reference to the reader */ - SocketReader *imageReader_; + SocketReader *image_reader_; bool iscalculated_; float result_; @@ -52,24 +52,24 @@ class CalculateMeanOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void setSetting(int setting); + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void set_setting(int setting); void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; @@ -82,7 +82,7 @@ class CalculateMeanOperation : public MultiThreadedOperation { Span inputs) override; protected: - void calculateMean(MemoryBuffer *tile); + void calculate_mean(MemoryBuffer *tile); float calc_mean(const MemoryBuffer *input); private: diff --git a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cc b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cc index 3c8d7f21801..06b3114845e 100644 --- a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cc +++ b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cc @@ -24,23 +24,23 @@ namespace blender::compositor { -void CalculateStandardDeviationOperation::executePixel(float output[4], - int /*x*/, - int /*y*/, - void * /*data*/) +void CalculateStandardDeviationOperation::execute_pixel(float output[4], + int /*x*/, + int /*y*/, + void * /*data*/) { - output[0] = standardDeviation_; + output[0] = standard_deviation_; } -void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect) +void *CalculateStandardDeviationOperation::initialize_tile_data(rcti *rect) { - lockMutex(); + lock_mutex(); if (!iscalculated_) { - MemoryBuffer *tile = (MemoryBuffer *)imageReader_->initializeTileData(rect); - CalculateMeanOperation::calculateMean(tile); - standardDeviation_ = 0.0f; - float *buffer = tile->getBuffer(); - int size = tile->getWidth() * tile->getHeight(); + MemoryBuffer *tile = (MemoryBuffer *)image_reader_->initialize_tile_data(rect); + CalculateMeanOperation::calculate_mean(tile); + standard_deviation_ = 0.0f; + float *buffer = tile->get_buffer(); + int size = tile->get_width() * tile->get_height(); int pixels = 0; float sum = 0.0f; float mean = result_; @@ -89,10 +89,10 @@ void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect) } } } - standardDeviation_ = sqrt(sum / (float)(pixels - 1)); + standard_deviation_ = sqrt(sum / (float)(pixels - 1)); iscalculated_ = true; } - unlockMutex(); + unlock_mutex(); return nullptr; } @@ -112,8 +112,8 @@ void CalculateStandardDeviationOperation::update_memory_buffer_started( join.sum += chunk.sum; join.num_pixels += chunk.num_pixels; }); - standardDeviation_ = total.num_pixels <= 1 ? 0.0f : - sqrt(total.sum / (float)(total.num_pixels - 1)); + standard_deviation_ = total.num_pixels <= 1 ? 0.0f : + sqrt(total.sum / (float)(total.num_pixels - 1)); iscalculated_ = true; } } @@ -121,7 +121,7 @@ void CalculateStandardDeviationOperation::update_memory_buffer_started( void CalculateStandardDeviationOperation::update_memory_buffer_partial( MemoryBuffer *output, const rcti &area, Span UNUSED(inputs)) { - output->fill(area, &standardDeviation_); + output->fill(area, &standard_deviation_); } using PixelsSum = CalculateMeanOperation::PixelsSum; diff --git a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h index 29d9c45c986..95b9eb21982 100644 --- a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h +++ b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h @@ -31,15 +31,15 @@ namespace blender::compositor { */ class CalculateStandardDeviationOperation : public CalculateMeanOperation { protected: - float standardDeviation_; + float standard_deviation_; public: /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; void update_memory_buffer_started(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.cc b/source/blender/compositor/operations/COM_ChangeHSVOperation.cc index 7e240a0b95a..b4effc087b1 100644 --- a/source/blender/compositor/operations/COM_ChangeHSVOperation.cc +++ b/source/blender/compositor/operations/COM_ChangeHSVOperation.cc @@ -22,54 +22,54 @@ namespace blender::compositor { ChangeHSVOperation::ChangeHSVOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); - inputOperation_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); + input_operation_ = nullptr; this->flags.can_be_constant = true; } -void ChangeHSVOperation::initExecution() +void ChangeHSVOperation::init_execution() { - inputOperation_ = getInputSocketReader(0); - hueOperation_ = getInputSocketReader(1); - saturationOperation_ = getInputSocketReader(2); - valueOperation_ = getInputSocketReader(3); + input_operation_ = get_input_socket_reader(0); + hue_operation_ = get_input_socket_reader(1); + saturation_operation_ = get_input_socket_reader(2); + value_operation_ = get_input_socket_reader(3); } -void ChangeHSVOperation::deinitExecution() +void ChangeHSVOperation::deinit_execution() { - inputOperation_ = nullptr; - hueOperation_ = nullptr; - saturationOperation_ = nullptr; - valueOperation_ = nullptr; + input_operation_ = nullptr; + hue_operation_ = nullptr; + saturation_operation_ = nullptr; + value_operation_ = nullptr; } -void ChangeHSVOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ChangeHSVOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; + float input_color1[4]; float hue[4], saturation[4], value[4]; - inputOperation_->readSampled(inputColor1, x, y, sampler); - hueOperation_->readSampled(hue, x, y, sampler); - saturationOperation_->readSampled(saturation, x, y, sampler); - valueOperation_->readSampled(value, x, y, sampler); + input_operation_->read_sampled(input_color1, x, y, sampler); + hue_operation_->read_sampled(hue, x, y, sampler); + saturation_operation_->read_sampled(saturation, x, y, sampler); + value_operation_->read_sampled(value, x, y, sampler); - output[0] = inputColor1[0] + (hue[0] - 0.5f); + output[0] = input_color1[0] + (hue[0] - 0.5f); if (output[0] > 1.0f) { output[0] -= 1.0f; } else if (output[0] < 0.0f) { output[0] += 1.0f; } - output[1] = inputColor1[1] * saturation[0]; - output[2] = inputColor1[2] * value[0]; - output[3] = inputColor1[3]; + output[1] = input_color1[1] * saturation[0]; + output[2] = input_color1[2] * value[0]; + output[3] = input_color1[3]; } void ChangeHSVOperation::update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.h b/source/blender/compositor/operations/COM_ChangeHSVOperation.h index 4b810a93816..35e606f63df 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 *inputOperation_; - SocketReader *hueOperation_; - SocketReader *saturationOperation_; - SocketReader *valueOperation_; + SocketReader *input_operation_; + SocketReader *hue_operation_; + SocketReader *saturation_operation_; + SocketReader *value_operation_; public: /** @@ -39,13 +39,13 @@ class ChangeHSVOperation : public MultiThreadedOperation { */ ChangeHSVOperation(); - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_ChannelMatteOperation.cc b/source/blender/compositor/operations/COM_ChannelMatteOperation.cc index cbc6d078ac1..0a6b8255c42 100644 --- a/source/blender/compositor/operations/COM_ChannelMatteOperation.cc +++ b/source/blender/compositor/operations/COM_ChannelMatteOperation.cc @@ -22,16 +22,16 @@ namespace blender::compositor { ChannelMatteOperation::ChannelMatteOperation() { - addInputSocket(DataType::Color); - addOutputSocket(DataType::Value); + add_input_socket(DataType::Color); + add_output_socket(DataType::Value); - inputImageProgram_ = nullptr; + input_image_program_ = nullptr; flags.can_be_constant = true; } -void ChannelMatteOperation::initExecution() +void ChannelMatteOperation::init_execution() { - inputImageProgram_ = this->getInputSocketReader(0); + input_image_program_ = this->get_input_socket_reader(0); limit_range_ = limit_max_ - limit_min_; @@ -77,34 +77,34 @@ void ChannelMatteOperation::initExecution() } } -void ChannelMatteOperation::deinitExecution() +void ChannelMatteOperation::deinit_execution() { - inputImageProgram_ = nullptr; + input_image_program_ = nullptr; } -void ChannelMatteOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ChannelMatteOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inColor[4]; + float in_color[4]; float alpha; const float limit_max = limit_max_; const float limit_min = limit_min_; const float limit_range = limit_range_; - inputImageProgram_->readSampled(inColor, x, y, sampler); + input_image_program_->read_sampled(in_color, x, y, sampler); /* matte operation */ - alpha = inColor[ids_[0]] - MAX2(inColor[ids_[1]], inColor[ids_[2]]); + alpha = in_color[ids_[0]] - MAX2(in_color[ids_[1]], in_color[ids_[2]]); /* flip because 0.0 is transparent, not 1.0 */ alpha = 1.0f - alpha; /* test range */ if (alpha > limit_max) { - alpha = inColor[3]; /* Whatever it was prior. */ + alpha = in_color[3]; /* Whatever it was prior. */ } else if (alpha < limit_min) { alpha = 0.0f; @@ -118,7 +118,7 @@ void ChannelMatteOperation::executePixelSampled(float output[4], */ /* Don't make something that was more transparent less transparent. */ - output[0] = MIN2(alpha, inColor[3]); + output[0] = MIN2(alpha, in_color[3]); } void ChannelMatteOperation::update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ChannelMatteOperation.h b/source/blender/compositor/operations/COM_ChannelMatteOperation.h index f7bf58b99c5..64b173885d5 100644 --- a/source/blender/compositor/operations/COM_ChannelMatteOperation.h +++ b/source/blender/compositor/operations/COM_ChannelMatteOperation.h @@ -28,7 +28,7 @@ namespace blender::compositor { */ class ChannelMatteOperation : public MultiThreadedOperation { private: - SocketReader *inputImageProgram_; + SocketReader *input_image_program_; /* int color_space_; */ /* node->custom1 */ /* UNUSED */ /* TODO ? */ int matte_channel_; /* node->custom2 */ @@ -58,17 +58,17 @@ class ChannelMatteOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setSettings(NodeChroma *nodeChroma, const int custom2) + void set_settings(NodeChroma *node_chroma, const int custom2) { - limit_max_ = nodeChroma->t1; - limit_min_ = nodeChroma->t2; - limit_method_ = nodeChroma->algorithm; - limit_channel_ = nodeChroma->channel; + limit_max_ = node_chroma->t1; + limit_min_ = node_chroma->t2; + limit_method_ = node_chroma->algorithm; + limit_channel_ = node_chroma->channel; matte_channel_ = custom2; } diff --git a/source/blender/compositor/operations/COM_ChromaMatteOperation.cc b/source/blender/compositor/operations/COM_ChromaMatteOperation.cc index 172460e9203..fceb0ea1c23 100644 --- a/source/blender/compositor/operations/COM_ChromaMatteOperation.cc +++ b/source/blender/compositor/operations/COM_ChromaMatteOperation.cc @@ -22,34 +22,34 @@ namespace blender::compositor { ChromaMatteOperation::ChromaMatteOperation() { - addInputSocket(DataType::Color); - addInputSocket(DataType::Color); - addOutputSocket(DataType::Value); + add_input_socket(DataType::Color); + add_input_socket(DataType::Color); + add_output_socket(DataType::Value); - inputImageProgram_ = nullptr; - inputKeyProgram_ = nullptr; + input_image_program_ = nullptr; + input_key_program_ = nullptr; flags.can_be_constant = true; } -void ChromaMatteOperation::initExecution() +void ChromaMatteOperation::init_execution() { - inputImageProgram_ = this->getInputSocketReader(0); - inputKeyProgram_ = this->getInputSocketReader(1); + input_image_program_ = this->get_input_socket_reader(0); + input_key_program_ = this->get_input_socket_reader(1); } -void ChromaMatteOperation::deinitExecution() +void ChromaMatteOperation::deinit_execution() { - inputImageProgram_ = nullptr; - inputKeyProgram_ = nullptr; + input_image_program_ = nullptr; + input_key_program_ = nullptr; } -void ChromaMatteOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ChromaMatteOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inKey[4]; - float inImage[4]; + float in_key[4]; + float in_image[4]; const float acceptance = settings_->t1; /* in radians */ const float cutoff = settings_->t2; /* in radians */ @@ -59,8 +59,8 @@ void ChromaMatteOperation::executePixelSampled(float output[4], float theta, beta; float kfg; - inputKeyProgram_->readSampled(inKey, x, y, sampler); - inputImageProgram_->readSampled(inImage, x, y, sampler); + input_key_program_->read_sampled(in_key, x, y, sampler); + input_image_program_->read_sampled(in_image, x, y, sampler); /* Store matte(alpha) value in [0] to go with * #COM_SetAlphaMultiplyOperation and the Value output. */ @@ -69,19 +69,19 @@ void ChromaMatteOperation::executePixelSampled(float output[4], /* Find theta, the angle that the color space should be rotated based on key. */ /* rescale to -1.0..1.0 */ - // inImage[0] = (inImage[0] * 2.0f) - 1.0f; // UNUSED - inImage[1] = (inImage[1] * 2.0f) - 1.0f; - inImage[2] = (inImage[2] * 2.0f) - 1.0f; + // in_image[0] = (in_image[0] * 2.0f) - 1.0f; // UNUSED + in_image[1] = (in_image[1] * 2.0f) - 1.0f; + in_image[2] = (in_image[2] * 2.0f) - 1.0f; - // inKey[0] = (inKey[0] * 2.0f) - 1.0f; // UNUSED - inKey[1] = (inKey[1] * 2.0f) - 1.0f; - inKey[2] = (inKey[2] * 2.0f) - 1.0f; + // in_key[0] = (in_key[0] * 2.0f) - 1.0f; // UNUSED + in_key[1] = (in_key[1] * 2.0f) - 1.0f; + in_key[2] = (in_key[2] * 2.0f) - 1.0f; - theta = atan2(inKey[2], inKey[1]); + theta = atan2(in_key[2], in_key[1]); /* Rotate the cb and cr into x/z space. */ - x_angle = inImage[1] * cosf(theta) + inImage[2] * sinf(theta); - z_angle = inImage[2] * cosf(theta) - inImage[1] * sinf(theta); + x_angle = in_image[1] * cosf(theta) + in_image[2] * sinf(theta); + z_angle = in_image[2] * cosf(theta) - in_image[1] * sinf(theta); /* If within the acceptance angle. */ /* If kfg is <0 then the pixel is outside of the key color. */ @@ -98,15 +98,15 @@ void ChromaMatteOperation::executePixelSampled(float output[4], } /* don't make something that was more transparent less transparent */ - if (alpha < inImage[3]) { + if (alpha < in_image[3]) { output[0] = alpha; } else { - output[0] = inImage[3]; + output[0] = in_image[3]; } } - else { /* Pixel is outside key color. */ - output[0] = inImage[3]; /* Make pixel just as transparent as it was before. */ + else { /* Pixel is outside key color. */ + output[0] = in_image[3]; /* Make pixel just as transparent as it was before. */ } } diff --git a/source/blender/compositor/operations/COM_ChromaMatteOperation.h b/source/blender/compositor/operations/COM_ChromaMatteOperation.h index 913d0f27107..954daef1be7 100644 --- a/source/blender/compositor/operations/COM_ChromaMatteOperation.h +++ b/source/blender/compositor/operations/COM_ChromaMatteOperation.h @@ -29,8 +29,8 @@ namespace blender::compositor { class ChromaMatteOperation : public MultiThreadedOperation { private: NodeChroma *settings_; - SocketReader *inputImageProgram_; - SocketReader *inputKeyProgram_; + SocketReader *input_image_program_; + SocketReader *input_key_program_; public: /** @@ -41,14 +41,14 @@ class ChromaMatteOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setSettings(NodeChroma *nodeChroma) + void set_settings(NodeChroma *node_chroma) { - settings_ = nodeChroma; + settings_ = node_chroma; } 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 b6253c07f12..e12138c1f00 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cc +++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cc @@ -34,43 +34,43 @@ inline float colorbalance_cdl(float in, float offset, float power, float slope) ColorBalanceASCCDLOperation::ColorBalanceASCCDLOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); - inputValueOperation_ = nullptr; - inputColorOperation_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); + input_value_operation_ = nullptr; + input_color_operation_ = nullptr; this->set_canvas_input_index(1); flags.can_be_constant = true; } -void ColorBalanceASCCDLOperation::initExecution() +void ColorBalanceASCCDLOperation::init_execution() { - inputValueOperation_ = this->getInputSocketReader(0); - inputColorOperation_ = this->getInputSocketReader(1); + input_value_operation_ = this->get_input_socket_reader(0); + input_color_operation_ = this->get_input_socket_reader(1); } -void ColorBalanceASCCDLOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ColorBalanceASCCDLOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; + float input_color[4]; float value[4]; - inputValueOperation_->readSampled(value, x, y, sampler); - inputColorOperation_->readSampled(inputColor, x, y, sampler); + input_value_operation_->read_sampled(value, x, y, sampler); + input_color_operation_->read_sampled(input_color, 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], offset_[0], power_[0], slope_[0]); - output[1] = mfac * inputColor[1] + - fac * colorbalance_cdl(inputColor[1], offset_[1], power_[1], slope_[1]); - output[2] = mfac * inputColor[2] + - fac * colorbalance_cdl(inputColor[2], offset_[2], power_[2], slope_[2]); - output[3] = inputColor[3]; + output[0] = mfac * input_color[0] + + fac * colorbalance_cdl(input_color[0], offset_[0], power_[0], slope_[0]); + output[1] = mfac * input_color[1] + + fac * colorbalance_cdl(input_color[1], offset_[1], power_[1], slope_[1]); + output[2] = mfac * input_color[2] + + fac * colorbalance_cdl(input_color[2], offset_[2], power_[2], slope_[2]); + output[3] = input_color[3]; } void ColorBalanceASCCDLOperation::update_memory_buffer_row(PixelCursor &p) @@ -90,10 +90,10 @@ void ColorBalanceASCCDLOperation::update_memory_buffer_row(PixelCursor &p) } } -void ColorBalanceASCCDLOperation::deinitExecution() +void ColorBalanceASCCDLOperation::deinit_execution() { - inputValueOperation_ = nullptr; - inputColorOperation_ = nullptr; + input_value_operation_ = nullptr; + input_color_operation_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h index 79c5cc1a047..64622e399d3 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h +++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h @@ -29,10 +29,10 @@ namespace blender::compositor { class ColorBalanceASCCDLOperation : public MultiThreadedRowOperation { protected: /** - * Prefetched reference to the inputProgram + * Prefetched reference to the input_program */ - SocketReader *inputValueOperation_; - SocketReader *inputColorOperation_; + SocketReader *input_value_operation_; + SocketReader *input_color_operation_; float offset_[3]; float power_[3]; @@ -47,27 +47,27 @@ class ColorBalanceASCCDLOperation : public MultiThreadedRowOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setOffset(float offset[3]) + void set_offset(float offset[3]) { copy_v3_v3(offset_, offset); } - void setPower(float power[3]) + void set_power(float power[3]) { copy_v3_v3(power_, power); } - void setSlope(float slope[3]) + void set_slope(float slope[3]) { copy_v3_v3(slope_, slope); } diff --git a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cc b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cc index d7c7368a214..d9af1b0a074 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cc +++ b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cc @@ -39,43 +39,43 @@ inline float colorbalance_lgg(float in, float lift_lgg, float gamma_inv, float g ColorBalanceLGGOperation::ColorBalanceLGGOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); - inputValueOperation_ = nullptr; - inputColorOperation_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); + input_value_operation_ = nullptr; + input_color_operation_ = nullptr; this->set_canvas_input_index(1); flags.can_be_constant = true; } -void ColorBalanceLGGOperation::initExecution() +void ColorBalanceLGGOperation::init_execution() { - inputValueOperation_ = this->getInputSocketReader(0); - inputColorOperation_ = this->getInputSocketReader(1); + input_value_operation_ = this->get_input_socket_reader(0); + input_color_operation_ = this->get_input_socket_reader(1); } -void ColorBalanceLGGOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ColorBalanceLGGOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; + float input_color[4]; float value[4]; - inputValueOperation_->readSampled(value, x, y, sampler); - inputColorOperation_->readSampled(inputColor, x, y, sampler); + input_value_operation_->read_sampled(value, x, y, sampler); + input_color_operation_->read_sampled(input_color, 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], lift_[0], gamma_inv_[0], gain_[0]); - output[1] = mfac * inputColor[1] + - fac * colorbalance_lgg(inputColor[1], lift_[1], gamma_inv_[1], gain_[1]); - output[2] = mfac * inputColor[2] + - fac * colorbalance_lgg(inputColor[2], lift_[2], gamma_inv_[2], gain_[2]); - output[3] = inputColor[3]; + output[0] = mfac * input_color[0] + + fac * colorbalance_lgg(input_color[0], lift_[0], gamma_inv_[0], gain_[0]); + output[1] = mfac * input_color[1] + + fac * colorbalance_lgg(input_color[1], lift_[1], gamma_inv_[1], gain_[1]); + output[2] = mfac * input_color[2] + + fac * colorbalance_lgg(input_color[2], lift_[2], gamma_inv_[2], gain_[2]); + output[3] = input_color[3]; } void ColorBalanceLGGOperation::update_memory_buffer_row(PixelCursor &p) @@ -95,10 +95,10 @@ void ColorBalanceLGGOperation::update_memory_buffer_row(PixelCursor &p) } } -void ColorBalanceLGGOperation::deinitExecution() +void ColorBalanceLGGOperation::deinit_execution() { - inputValueOperation_ = nullptr; - inputColorOperation_ = nullptr; + input_value_operation_ = nullptr; + input_color_operation_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h index 9393f635f9e..738669e71f9 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h +++ b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h @@ -29,10 +29,10 @@ namespace blender::compositor { class ColorBalanceLGGOperation : public MultiThreadedRowOperation { protected: /** - * Prefetched reference to the inputProgram + * Prefetched reference to the input_program */ - SocketReader *inputValueOperation_; - SocketReader *inputColorOperation_; + SocketReader *input_value_operation_; + SocketReader *input_color_operation_; float gain_[3]; float lift_[3]; @@ -47,27 +47,27 @@ class ColorBalanceLGGOperation : public MultiThreadedRowOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setGain(const float gain[3]) + void set_gain(const float gain[3]) { copy_v3_v3(gain_, gain); } - void setLift(const float lift[3]) + void set_lift(const float lift[3]) { copy_v3_v3(lift_, lift); } - void setGammaInv(const float gamma_inv[3]) + void set_gamma_inv(const float gamma_inv[3]) { copy_v3_v3(gamma_inv_, gamma_inv); } diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cc b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cc index 128c7c80ea9..538227d899b 100644 --- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cc +++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cc @@ -24,20 +24,20 @@ namespace blender::compositor { ColorCorrectionOperation::ColorCorrectionOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); - inputImage_ = nullptr; - inputMask_ = nullptr; - redChannelEnabled_ = true; - greenChannelEnabled_ = true; - blueChannelEnabled_ = true; + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); + input_image_ = nullptr; + input_mask_ = nullptr; + red_channel_enabled_ = true; + green_channel_enabled_ = true; + blue_channel_enabled_ = true; flags.can_be_constant = true; } -void ColorCorrectionOperation::initExecution() +void ColorCorrectionOperation::init_execution() { - inputImage_ = this->getInputSocketReader(0); - inputMask_ = this->getInputSocketReader(1); + input_image_ = this->get_input_socket_reader(0); + input_mask_ = this->get_input_socket_reader(1); } /* Calculate x^y if the function is defined. Otherwise return the given fallback value. */ @@ -49,17 +49,17 @@ BLI_INLINE float color_correct_powf_safe(const float x, const float y, const flo return powf(x, y); } -void ColorCorrectionOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ColorCorrectionOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputImageColor[4]; - float inputMask[4]; - inputImage_->readSampled(inputImageColor, x, y, sampler); - inputMask_->readSampled(inputMask, x, y, sampler); + float input_image_color[4]; + float input_mask[4]; + input_image_->read_sampled(input_image_color, x, y, sampler); + input_mask_->read_sampled(input_mask, x, y, sampler); - float level = (inputImageColor[0] + inputImageColor[1] + inputImageColor[2]) / 3.0f; + float level = (input_image_color[0] + input_image_color[1] + input_image_color[2]) / 3.0f; float contrast = data_->master.contrast; float saturation = data_->master.saturation; float gamma = data_->master.gamma; @@ -67,53 +67,53 @@ void ColorCorrectionOperation::executePixelSampled(float output[4], float lift = data_->master.lift; float r, g, b; - float value = inputMask[0]; + float value = input_mask[0]; value = MIN2(1.0f, value); const float mvalue = 1.0f - value; - float levelShadows = 0.0; - float levelMidtones = 0.0; - float levelHighlights = 0.0; + float level_shadows = 0.0; + float level_midtones = 0.0; + float level_highlights = 0.0; #define MARGIN 0.10f #define MARGIN_DIV (0.5f / MARGIN) if (level < data_->startmidtones - MARGIN) { - levelShadows = 1.0f; + level_shadows = 1.0f; } else if (level < data_->startmidtones + MARGIN) { - levelMidtones = ((level - data_->startmidtones) * MARGIN_DIV) + 0.5f; - levelShadows = 1.0f - levelMidtones; + level_midtones = ((level - data_->startmidtones) * MARGIN_DIV) + 0.5f; + level_shadows = 1.0f - level_midtones; } else if (level < data_->endmidtones - MARGIN) { - levelMidtones = 1.0f; + level_midtones = 1.0f; } else if (level < data_->endmidtones + MARGIN) { - levelHighlights = ((level - data_->endmidtones) * MARGIN_DIV) + 0.5f; - levelMidtones = 1.0f - levelHighlights; + level_highlights = ((level - data_->endmidtones) * MARGIN_DIV) + 0.5f; + level_midtones = 1.0f - level_highlights; } else { - levelHighlights = 1.0f; + level_highlights = 1.0f; } #undef MARGIN #undef MARGIN_DIV - 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); + 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); float invgamma = 1.0f / gamma; - float luma = IMB_colormanagement_get_luminance(inputImageColor); + float luma = IMB_colormanagement_get_luminance(input_image_color); - r = inputImageColor[0]; - g = inputImageColor[1]; - b = inputImageColor[2]; + r = input_image_color[0]; + g = input_image_color[1]; + b = input_image_color[2]; r = (luma + saturation * (r - luma)); g = (luma + saturation * (g - luma)); @@ -129,29 +129,29 @@ void ColorCorrectionOperation::executePixelSampled(float output[4], b = color_correct_powf_safe(b * gain + lift, invgamma, b); /* Mix with mask. */ - r = mvalue * inputImageColor[0] + value * r; - g = mvalue * inputImageColor[1] + value * g; - b = mvalue * inputImageColor[2] + value * b; + r = mvalue * input_image_color[0] + value * r; + g = mvalue * input_image_color[1] + value * g; + b = mvalue * input_image_color[2] + value * b; - if (redChannelEnabled_) { + if (red_channel_enabled_) { output[0] = r; } else { - output[0] = inputImageColor[0]; + output[0] = input_image_color[0]; } - if (greenChannelEnabled_) { + if (green_channel_enabled_) { output[1] = g; } else { - output[1] = inputImageColor[1]; + output[1] = input_image_color[1]; } - if (blueChannelEnabled_) { + if (blue_channel_enabled_) { output[2] = b; } else { - output[2] = inputImageColor[2]; + output[2] = input_image_color[2]; } - output[3] = inputImageColor[3]; + output[3] = input_image_color[3]; } void ColorCorrectionOperation::update_memory_buffer_row(PixelCursor &p) @@ -224,17 +224,17 @@ void ColorCorrectionOperation::update_memory_buffer_row(PixelCursor &p) 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[0] = red_channel_enabled_ ? r : in_color[0]; + p.out[1] = green_channel_enabled_ ? g : in_color[1]; + p.out[2] = blue_channel_enabled_ ? b : in_color[2]; p.out[3] = in_color[3]; } } -void ColorCorrectionOperation::deinitExecution() +void ColorCorrectionOperation::deinit_execution() { - inputImage_ = nullptr; - inputMask_ = nullptr; + input_image_ = nullptr; + input_mask_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.h b/source/blender/compositor/operations/COM_ColorCorrectionOperation.h index 157babd299b..b0d52507204 100644 --- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.h +++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.h @@ -25,15 +25,15 @@ namespace blender::compositor { class ColorCorrectionOperation : public MultiThreadedRowOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputImage_; - SocketReader *inputMask_; + SocketReader *input_image_; + SocketReader *input_mask_; NodeColorCorrection *data_; - bool redChannelEnabled_; - bool greenChannelEnabled_; - bool blueChannelEnabled_; + bool red_channel_enabled_; + bool green_channel_enabled_; + bool blue_channel_enabled_; public: ColorCorrectionOperation(); @@ -41,33 +41,33 @@ class ColorCorrectionOperation : public MultiThreadedRowOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setData(NodeColorCorrection *data) + void set_data(NodeColorCorrection *data) { data_ = data; } - void setRedChannelEnabled(bool enabled) + void set_red_channel_enabled(bool enabled) { - redChannelEnabled_ = enabled; + red_channel_enabled_ = enabled; } - void setGreenChannelEnabled(bool enabled) + void set_green_channel_enabled(bool enabled) { - greenChannelEnabled_ = enabled; + green_channel_enabled_ = enabled; } - void setBlueChannelEnabled(bool enabled) + void set_blue_channel_enabled(bool enabled) { - blueChannelEnabled_ = enabled; + blue_channel_enabled_ = 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 b88989ad224..7cfa1c09298 100644 --- a/source/blender/compositor/operations/COM_ColorCurveOperation.cc +++ b/source/blender/compositor/operations/COM_ColorCurveOperation.cc @@ -24,36 +24,36 @@ namespace blender::compositor { ColorCurveOperation::ColorCurveOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); - inputFacProgram_ = nullptr; - inputImageProgram_ = nullptr; - inputBlackProgram_ = nullptr; - inputWhiteProgram_ = nullptr; + input_fac_program_ = nullptr; + input_image_program_ = nullptr; + input_black_program_ = nullptr; + input_white_program_ = nullptr; this->set_canvas_input_index(1); } -void ColorCurveOperation::initExecution() +void ColorCurveOperation::init_execution() { - CurveBaseOperation::initExecution(); - inputFacProgram_ = this->getInputSocketReader(0); - inputImageProgram_ = this->getInputSocketReader(1); - inputBlackProgram_ = this->getInputSocketReader(2); - inputWhiteProgram_ = this->getInputSocketReader(3); + CurveBaseOperation::init_execution(); + input_fac_program_ = this->get_input_socket_reader(0); + input_image_program_ = this->get_input_socket_reader(1); + input_black_program_ = this->get_input_socket_reader(2); + input_white_program_ = this->get_input_socket_reader(3); - BKE_curvemapping_premultiply(curveMapping_, 0); + BKE_curvemapping_premultiply(curve_mapping_, 0); } -void ColorCurveOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ColorCurveOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - CurveMapping *cumap = curveMapping_; + CurveMapping *cumap = curve_mapping_; float fac[4]; float image[4]; @@ -63,15 +63,15 @@ void ColorCurveOperation::executePixelSampled(float output[4], float white[4]; float bwmul[3]; - inputBlackProgram_->readSampled(black, x, y, sampler); - inputWhiteProgram_->readSampled(white, x, y, sampler); + input_black_program_->read_sampled(black, x, y, sampler); + input_white_program_->read_sampled(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); - inputFacProgram_->readSampled(fac, x, y, sampler); - inputImageProgram_->readSampled(image, x, y, sampler); + input_fac_program_->read_sampled(fac, x, y, sampler); + input_image_program_->read_sampled(image, x, y, sampler); if (*fac >= 1.0f) { BKE_curvemapping_evaluate_premulRGBF_ex(cumap, output, image, black, bwmul); @@ -87,20 +87,20 @@ void ColorCurveOperation::executePixelSampled(float output[4], output[3] = image[3]; } -void ColorCurveOperation::deinitExecution() +void ColorCurveOperation::deinit_execution() { - CurveBaseOperation::deinitExecution(); - inputFacProgram_ = nullptr; - inputImageProgram_ = nullptr; - inputBlackProgram_ = nullptr; - inputWhiteProgram_ = nullptr; + CurveBaseOperation::deinit_execution(); + input_fac_program_ = nullptr; + input_image_program_ = nullptr; + input_black_program_ = nullptr; + input_white_program_ = nullptr; } void ColorCurveOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - CurveMapping *cumap = curveMapping_; + CurveMapping *cumap = curve_mapping_; float bwmul[3]; for (BuffersIterator it = output->iterate_with(inputs, area); !it.is_end(); ++it) { /* Local versions of `cumap->black` and `cumap->white`. */ @@ -130,63 +130,63 @@ void ColorCurveOperation::update_memory_buffer_partial(MemoryBuffer *output, ConstantLevelColorCurveOperation::ConstantLevelColorCurveOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); - inputFacProgram_ = nullptr; - inputImageProgram_ = nullptr; + input_fac_program_ = nullptr; + input_image_program_ = nullptr; this->set_canvas_input_index(1); } -void ConstantLevelColorCurveOperation::initExecution() +void ConstantLevelColorCurveOperation::init_execution() { - CurveBaseOperation::initExecution(); - inputFacProgram_ = this->getInputSocketReader(0); - inputImageProgram_ = this->getInputSocketReader(1); + CurveBaseOperation::init_execution(); + input_fac_program_ = this->get_input_socket_reader(0); + input_image_program_ = this->get_input_socket_reader(1); - BKE_curvemapping_premultiply(curveMapping_, 0); + BKE_curvemapping_premultiply(curve_mapping_, 0); - BKE_curvemapping_set_black_white(curveMapping_, black_, white_); + BKE_curvemapping_set_black_white(curve_mapping_, black_, white_); } -void ConstantLevelColorCurveOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConstantLevelColorCurveOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float fac[4]; float image[4]; - inputFacProgram_->readSampled(fac, x, y, sampler); - inputImageProgram_->readSampled(image, x, y, sampler); + input_fac_program_->read_sampled(fac, x, y, sampler); + input_image_program_->read_sampled(image, x, y, sampler); if (*fac >= 1.0f) { - BKE_curvemapping_evaluate_premulRGBF(curveMapping_, output, image); + BKE_curvemapping_evaluate_premulRGBF(curve_mapping_, output, image); } else if (*fac <= 0.0f) { copy_v3_v3(output, image); } else { float col[4]; - BKE_curvemapping_evaluate_premulRGBF(curveMapping_, col, image); + BKE_curvemapping_evaluate_premulRGBF(curve_mapping_, col, image); interp_v3_v3v3(output, image, col, *fac); } output[3] = image[3]; } -void ConstantLevelColorCurveOperation::deinitExecution() +void ConstantLevelColorCurveOperation::deinit_execution() { - CurveBaseOperation::deinitExecution(); - inputFacProgram_ = nullptr; - inputImageProgram_ = nullptr; + CurveBaseOperation::deinit_execution(); + input_fac_program_ = nullptr; + input_image_program_ = nullptr; } void ConstantLevelColorCurveOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - CurveMapping *cumap = curveMapping_; + CurveMapping *cumap = curve_mapping_; for (BuffersIterator 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 6f16c45d11e..eaebf1f3ff6 100644 --- a/source/blender/compositor/operations/COM_ColorCurveOperation.h +++ b/source/blender/compositor/operations/COM_ColorCurveOperation.h @@ -25,12 +25,12 @@ namespace blender::compositor { class ColorCurveOperation : public CurveBaseOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputFacProgram_; - SocketReader *inputImageProgram_; - SocketReader *inputBlackProgram_; - SocketReader *inputWhiteProgram_; + SocketReader *input_fac_program_; + SocketReader *input_image_program_; + SocketReader *input_black_program_; + SocketReader *input_white_program_; public: ColorCurveOperation(); @@ -38,17 +38,17 @@ class ColorCurveOperation : public CurveBaseOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -58,10 +58,10 @@ class ColorCurveOperation : public CurveBaseOperation { class ConstantLevelColorCurveOperation : public CurveBaseOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputFacProgram_; - SocketReader *inputImageProgram_; + SocketReader *input_fac_program_; + SocketReader *input_image_program_; float black_[3]; float white_[3]; @@ -71,23 +71,23 @@ class ConstantLevelColorCurveOperation : public CurveBaseOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setBlackLevel(float black[3]) + void set_black_level(float black[3]) { copy_v3_v3(black_, black); } - void setWhiteLevel(float white[3]) + void set_white_level(float white[3]) { copy_v3_v3(white_, white); } diff --git a/source/blender/compositor/operations/COM_ColorExposureOperation.cc b/source/blender/compositor/operations/COM_ColorExposureOperation.cc index f0e6abe67f9..9a785962bd5 100644 --- a/source/blender/compositor/operations/COM_ColorExposureOperation.cc +++ b/source/blender/compositor/operations/COM_ColorExposureOperation.cc @@ -22,35 +22,35 @@ namespace blender::compositor { ExposureOperation::ExposureOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); - inputProgram_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); + input_program_ = nullptr; flags.can_be_constant = true; } -void ExposureOperation::initExecution() +void ExposureOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); - inputExposureProgram_ = this->getInputSocketReader(1); + input_program_ = this->get_input_socket_reader(0); + input_exposure_program_ = this->get_input_socket_reader(1); } -void ExposureOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ExposureOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue[4]; - float inputExposure[4]; - inputProgram_->readSampled(inputValue, x, y, sampler); - inputExposureProgram_->readSampled(inputExposure, x, y, sampler); - const float exposure = pow(2, inputExposure[0]); + float input_value[4]; + float input_exposure[4]; + input_program_->read_sampled(input_value, x, y, sampler); + input_exposure_program_->read_sampled(input_exposure, x, y, sampler); + const float exposure = pow(2, input_exposure[0]); - output[0] = inputValue[0] * exposure; - output[1] = inputValue[1] * exposure; - output[2] = inputValue[2] * exposure; + output[0] = input_value[0] * exposure; + output[1] = input_value[1] * exposure; + output[2] = input_value[2] * exposure; - output[3] = inputValue[3]; + output[3] = input_value[3]; } void ExposureOperation::update_memory_buffer_row(PixelCursor &p) @@ -66,10 +66,10 @@ void ExposureOperation::update_memory_buffer_row(PixelCursor &p) } } -void ExposureOperation::deinitExecution() +void ExposureOperation::deinit_execution() { - inputProgram_ = nullptr; - inputExposureProgram_ = nullptr; + input_program_ = nullptr; + input_exposure_program_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ColorExposureOperation.h b/source/blender/compositor/operations/COM_ColorExposureOperation.h index 1a0f912d6bd..6de93a24ddd 100644 --- a/source/blender/compositor/operations/COM_ColorExposureOperation.h +++ b/source/blender/compositor/operations/COM_ColorExposureOperation.h @@ -25,10 +25,10 @@ namespace blender::compositor { class ExposureOperation : public MultiThreadedRowOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; - SocketReader *inputExposureProgram_; + SocketReader *input_program_; + SocketReader *input_exposure_program_; public: ExposureOperation(); @@ -36,17 +36,17 @@ class ExposureOperation : public MultiThreadedRowOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void update_memory_buffer_row(PixelCursor &p) override; }; diff --git a/source/blender/compositor/operations/COM_ColorMatteOperation.cc b/source/blender/compositor/operations/COM_ColorMatteOperation.cc index c693e7d06e1..c4bf1bdf1cf 100644 --- a/source/blender/compositor/operations/COM_ColorMatteOperation.cc +++ b/source/blender/compositor/operations/COM_ColorMatteOperation.cc @@ -22,34 +22,34 @@ namespace blender::compositor { ColorMatteOperation::ColorMatteOperation() { - addInputSocket(DataType::Color); - addInputSocket(DataType::Color); - addOutputSocket(DataType::Value); + add_input_socket(DataType::Color); + add_input_socket(DataType::Color); + add_output_socket(DataType::Value); - inputImageProgram_ = nullptr; - inputKeyProgram_ = nullptr; + input_image_program_ = nullptr; + input_key_program_ = nullptr; flags.can_be_constant = true; } -void ColorMatteOperation::initExecution() +void ColorMatteOperation::init_execution() { - inputImageProgram_ = this->getInputSocketReader(0); - inputKeyProgram_ = this->getInputSocketReader(1); + input_image_program_ = this->get_input_socket_reader(0); + input_key_program_ = this->get_input_socket_reader(1); } -void ColorMatteOperation::deinitExecution() +void ColorMatteOperation::deinit_execution() { - inputImageProgram_ = nullptr; - inputKeyProgram_ = nullptr; + input_image_program_ = nullptr; + input_key_program_ = nullptr; } -void ColorMatteOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ColorMatteOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inColor[4]; - float inKey[4]; + float in_color[4]; + float in_key[4]; const float hue = settings_->t1; const float sat = settings_->t2; @@ -57,8 +57,8 @@ void ColorMatteOperation::executePixelSampled(float output[4], float h_wrap; - inputImageProgram_->readSampled(inColor, x, y, sampler); - inputKeyProgram_->readSampled(inKey, x, y, sampler); + input_image_program_->read_sampled(in_color, x, y, sampler); + input_key_program_->read_sampled(in_key, x, y, sampler); /* Store matte(alpha) value in [0] to go with * COM_SetAlphaMultiplyOperation and the Value output. @@ -67,18 +67,19 @@ void ColorMatteOperation::executePixelSampled(float output[4], if ( /* Do hue last because it needs to wrap, and does some more checks. */ - /* sat */ (fabsf(inColor[1] - inKey[1]) < sat) && - /* val */ (fabsf(inColor[2] - inKey[2]) < val) && + /* sat */ (fabsf(in_color[1] - in_key[1]) < sat) && + /* val */ (fabsf(in_color[2] - in_key[2]) < val) && /* multiply by 2 because it wraps on both sides of the hue, * otherwise 0.5 would key all hue's */ - /* hue */ ((h_wrap = 2.0f * fabsf(inColor[0] - inKey[0])) < hue || (2.0f - h_wrap) < hue)) { + /* hue */ + ((h_wrap = 2.0f * fabsf(in_color[0] - in_key[0])) < hue || (2.0f - h_wrap) < hue)) { output[0] = 0.0f; /* make transparent */ } - else { /* Pixel is outside key color. */ - output[0] = inColor[3]; /* Make pixel just as transparent as it was before. */ + else { /* Pixel is outside key color. */ + output[0] = in_color[3]; /* Make pixel just as transparent as it was before. */ } } diff --git a/source/blender/compositor/operations/COM_ColorMatteOperation.h b/source/blender/compositor/operations/COM_ColorMatteOperation.h index 2037fa0cdc3..97cf568621a 100644 --- a/source/blender/compositor/operations/COM_ColorMatteOperation.h +++ b/source/blender/compositor/operations/COM_ColorMatteOperation.h @@ -29,8 +29,8 @@ namespace blender::compositor { class ColorMatteOperation : public MultiThreadedOperation { private: NodeChroma *settings_; - SocketReader *inputImageProgram_; - SocketReader *inputKeyProgram_; + SocketReader *input_image_program_; + SocketReader *input_key_program_; public: /** @@ -41,14 +41,14 @@ class ColorMatteOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setSettings(NodeChroma *nodeChroma) + void set_settings(NodeChroma *node_chroma) { - settings_ = nodeChroma; + settings_ = node_chroma; } 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 054bdcf5b04..bd86528d143 100644 --- a/source/blender/compositor/operations/COM_ColorRampOperation.cc +++ b/source/blender/compositor/operations/COM_ColorRampOperation.cc @@ -24,32 +24,32 @@ namespace blender::compositor { ColorRampOperation::ColorRampOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); - inputProgram_ = nullptr; - colorBand_ = nullptr; + input_program_ = nullptr; + color_band_ = nullptr; this->flags.can_be_constant = true; } -void ColorRampOperation::initExecution() +void ColorRampOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); + input_program_ = this->get_input_socket_reader(0); } -void ColorRampOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ColorRampOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float values[4]; - inputProgram_->readSampled(values, x, y, sampler); - BKE_colorband_evaluate(colorBand_, values[0], output); + input_program_->read_sampled(values, x, y, sampler); + BKE_colorband_evaluate(color_band_, values[0], output); } -void ColorRampOperation::deinitExecution() +void ColorRampOperation::deinit_execution() { - inputProgram_ = nullptr; + input_program_ = nullptr; } void ColorRampOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -57,7 +57,7 @@ void ColorRampOperation::update_memory_buffer_partial(MemoryBuffer *output, Span inputs) { for (BuffersIterator it = output->iterate_with(inputs, area); !it.is_end(); ++it) { - BKE_colorband_evaluate(colorBand_, *it.in(0), it.out); + BKE_colorband_evaluate(color_band_, *it.in(0), it.out); } } diff --git a/source/blender/compositor/operations/COM_ColorRampOperation.h b/source/blender/compositor/operations/COM_ColorRampOperation.h index 3cb5a7d83e1..2faaab4ba54 100644 --- a/source/blender/compositor/operations/COM_ColorRampOperation.h +++ b/source/blender/compositor/operations/COM_ColorRampOperation.h @@ -26,10 +26,10 @@ namespace blender::compositor { class ColorRampOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; - ColorBand *colorBand_; + SocketReader *input_program_; + ColorBand *color_band_; public: ColorRampOperation(); @@ -37,21 +37,21 @@ class ColorRampOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setColorBand(ColorBand *colorBand) + void set_color_band(ColorBand *color_band) { - colorBand_ = colorBand; + color_band_ = color_band; } 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 45197bf2b1d..39be05ece38 100644 --- a/source/blender/compositor/operations/COM_ColorSpillOperation.cc +++ b/source/blender/compositor/operations/COM_ColorSpillOperation.cc @@ -23,22 +23,22 @@ namespace blender::compositor { ColorSpillOperation::ColorSpillOperation() { - addInputSocket(DataType::Color); - addInputSocket(DataType::Value); - addOutputSocket(DataType::Color); + add_input_socket(DataType::Color); + add_input_socket(DataType::Value); + add_output_socket(DataType::Color); - inputImageReader_ = nullptr; - inputFacReader_ = nullptr; - spillChannel_ = 1; /* GREEN */ - spillMethod_ = 0; + input_image_reader_ = nullptr; + input_fac_reader_ = nullptr; + spill_channel_ = 1; /* GREEN */ + spill_method_ = 0; flags.can_be_constant = true; } -void ColorSpillOperation::initExecution() +void ColorSpillOperation::init_execution() { - inputImageReader_ = this->getInputSocketReader(0); - inputFacReader_ = this->getInputSocketReader(1); - if (spillChannel_ == 0) { + input_image_reader_ = this->get_input_socket_reader(0); + input_fac_reader_ = this->get_input_socket_reader(1); + if (spill_channel_ == 0) { rmut_ = -1.0f; gmut_ = 1.0f; bmut_ = 1.0f; @@ -50,7 +50,7 @@ void ColorSpillOperation::initExecution() settings_->uspillb = 0.0f; } } - else if (spillChannel_ == 1) { + else if (spill_channel_ == 1) { rmut_ = 1.0f; gmut_ = -1.0f; bmut_ = 1.0f; @@ -77,30 +77,30 @@ void ColorSpillOperation::initExecution() } } -void ColorSpillOperation::deinitExecution() +void ColorSpillOperation::deinit_execution() { - inputImageReader_ = nullptr; - inputFacReader_ = nullptr; + input_image_reader_ = nullptr; + input_fac_reader_ = nullptr; } -void ColorSpillOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ColorSpillOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float fac[4]; float input[4]; - inputFacReader_->readSampled(fac, x, y, sampler); - inputImageReader_->readSampled(input, x, y, sampler); + input_fac_reader_->read_sampled(fac, x, y, sampler); + input_image_reader_->read_sampled(input, x, y, sampler); float rfac = MIN2(1.0f, fac[0]); float map; - switch (spillMethod_) { + switch (spill_method_) { case 0: /* simple */ - map = rfac * (input[spillChannel_] - (settings_->limscale * input[settings_->limchan])); + map = rfac * (input[spill_channel_] - (settings_->limscale * input[settings_->limchan])); break; default: /* average */ - map = rfac * (input[spillChannel_] - + map = rfac * (input[spill_channel_] - (settings_->limscale * AVG(input[channel2_], input[channel3_]))); break; } @@ -125,12 +125,12 @@ void ColorSpillOperation::update_memory_buffer_partial(MemoryBuffer *output, const float factor = MIN2(1.0f, *it.in(1)); float map; - switch (spillMethod_) { + switch (spill_method_) { case 0: /* simple */ - map = factor * (color[spillChannel_] - (settings_->limscale * color[settings_->limchan])); + map = factor * (color[spill_channel_] - (settings_->limscale * color[settings_->limchan])); break; default: /* average */ - map = factor * (color[spillChannel_] - + map = factor * (color[spill_channel_] - (settings_->limscale * AVG(color[channel2_], color[channel3_]))); break; } diff --git a/source/blender/compositor/operations/COM_ColorSpillOperation.h b/source/blender/compositor/operations/COM_ColorSpillOperation.h index aab74e68f41..bfb0c6c963f 100644 --- a/source/blender/compositor/operations/COM_ColorSpillOperation.h +++ b/source/blender/compositor/operations/COM_ColorSpillOperation.h @@ -29,10 +29,10 @@ namespace blender::compositor { class ColorSpillOperation : public MultiThreadedOperation { protected: NodeColorspill *settings_; - SocketReader *inputImageReader_; - SocketReader *inputFacReader_; - int spillChannel_; - int spillMethod_; + SocketReader *input_image_reader_; + SocketReader *input_fac_reader_; + int spill_channel_; + int spill_method_; int channel2_; int channel3_; float rmut_, gmut_, bmut_; @@ -46,25 +46,25 @@ class ColorSpillOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setSettings(NodeColorspill *nodeColorSpill) + void set_settings(NodeColorspill *node_color_spill) { - settings_ = nodeColorSpill; + settings_ = node_color_spill; } - void setSpillChannel(int channel) + void set_spill_channel(int channel) { - spillChannel_ = channel; + spill_channel_ = channel; } - void setSpillMethod(int method) + void set_spill_method(int method) { - spillMethod_ = method; + spill_method_ = method; } - float calculateMapValue(float fac, float *input); + float calculate_map_value(float fac, float *input); void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_CompositorOperation.cc b/source/blender/compositor/operations/COM_CompositorOperation.cc index 029dec8c371..e27fc971a87 100644 --- a/source/blender/compositor/operations/COM_CompositorOperation.cc +++ b/source/blender/compositor/operations/COM_CompositorOperation.cc @@ -27,76 +27,76 @@ namespace blender::compositor { CompositorOperation::CompositorOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - - this->setRenderData(nullptr); - outputBuffer_ = nullptr; - depthBuffer_ = nullptr; - imageInput_ = nullptr; - alphaInput_ = nullptr; - depthInput_ = nullptr; - - useAlphaInput_ = false; + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + + this->set_render_data(nullptr); + output_buffer_ = nullptr; + depth_buffer_ = nullptr; + image_input_ = nullptr; + alpha_input_ = nullptr; + depth_input_ = nullptr; + + use_alpha_input_ = false; active_ = false; scene_ = nullptr; - sceneName_[0] = '\0'; - viewName_ = nullptr; + scene_name_[0] = '\0'; + view_name_ = nullptr; flags.use_render_border = true; } -void CompositorOperation::initExecution() +void CompositorOperation::init_execution() { if (!active_) { return; } /* When initializing the tree during initial load the width and height can be zero. */ - imageInput_ = getInputSocketReader(0); - alphaInput_ = getInputSocketReader(1); - depthInput_ = getInputSocketReader(2); - if (this->getWidth() * this->getHeight() != 0) { - outputBuffer_ = (float *)MEM_callocN(sizeof(float[4]) * this->getWidth() * this->getHeight(), - "CompositorOperation"); + image_input_ = get_input_socket_reader(0); + alpha_input_ = get_input_socket_reader(1); + depth_input_ = get_input_socket_reader(2); + if (this->get_width() * this->get_height() != 0) { + output_buffer_ = (float *)MEM_callocN( + sizeof(float[4]) * this->get_width() * this->get_height(), "CompositorOperation"); } - if (depthInput_ != nullptr) { - depthBuffer_ = (float *)MEM_callocN(sizeof(float) * this->getWidth() * this->getHeight(), - "CompositorOperation"); + if (depth_input_ != nullptr) { + depth_buffer_ = (float *)MEM_callocN(sizeof(float) * this->get_width() * this->get_height(), + "CompositorOperation"); } } -void CompositorOperation::deinitExecution() +void CompositorOperation::deinit_execution() { if (!active_) { return; } - if (!isBraked()) { + if (!is_braked()) { Render *re = RE_GetSceneRender(scene_); RenderResult *rr = RE_AcquireResultWrite(re); if (rr) { - RenderView *rv = RE_RenderViewGetByName(rr, viewName_); + RenderView *rv = RE_RenderViewGetByName(rr, view_name_); if (rv->rectf != nullptr) { MEM_freeN(rv->rectf); } - rv->rectf = outputBuffer_; + rv->rectf = output_buffer_; if (rv->rectz != nullptr) { MEM_freeN(rv->rectz); } - rv->rectz = depthBuffer_; + rv->rectz = depth_buffer_; rr->have_combined = true; } else { - if (outputBuffer_) { - MEM_freeN(outputBuffer_); + if (output_buffer_) { + MEM_freeN(output_buffer_); } - if (depthBuffer_) { - MEM_freeN(depthBuffer_); + if (depth_buffer_) { + MEM_freeN(depth_buffer_); } } @@ -113,26 +113,26 @@ void CompositorOperation::deinitExecution() BLI_thread_unlock(LOCK_DRAW_IMAGE); } else { - if (outputBuffer_) { - MEM_freeN(outputBuffer_); + if (output_buffer_) { + MEM_freeN(output_buffer_); } - if (depthBuffer_) { - MEM_freeN(depthBuffer_); + if (depth_buffer_) { + MEM_freeN(depth_buffer_); } } - outputBuffer_ = nullptr; - depthBuffer_ = nullptr; - imageInput_ = nullptr; - alphaInput_ = nullptr; - depthInput_ = nullptr; + output_buffer_ = nullptr; + depth_buffer_ = nullptr; + image_input_ = nullptr; + alpha_input_ = nullptr; + depth_input_ = nullptr; } -void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) +void CompositorOperation::execute_region(rcti *rect, unsigned int /*tile_number*/) { float color[8]; // 7 is enough - float *buffer = outputBuffer_; - float *zbuffer = depthBuffer_; + float *buffer = output_buffer_; + float *zbuffer = depth_buffer_; if (!buffer) { return; @@ -141,8 +141,8 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) int y1 = rect->ymin; int x2 = rect->xmax; int y2 = rect->ymax; - int offset = (y1 * this->getWidth() + x1); - int add = (this->getWidth() - (x2 - x1)); + int offset = (y1 * this->get_width() + x1); + int add = (this->get_width() - (x2 - x1)); int offset4 = offset * COM_DATA_TYPE_COLOR_CHANNELS; int x; int y; @@ -183,8 +183,8 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) int full_width = rd->xsch * rd->size / 100; int full_height = rd->ysch * rd->size / 100; - dx = rd->border.xmin * full_width - (full_width - this->getWidth()) / 2.0f; - dy = rd->border.ymin * full_height - (full_height - this->getHeight()) / 2.0f; + dx = rd->border.xmin * full_width - (full_width - this->get_width()) / 2.0f; + dy = rd->border.ymin * full_height - (full_height - this->get_height()) / 2.0f; } #endif @@ -192,18 +192,18 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) for (x = x1; x < x2 && (!breaked); x++) { int input_x = x + dx, input_y = y + dy; - imageInput_->readSampled(color, input_x, input_y, PixelSampler::Nearest); - if (useAlphaInput_) { - alphaInput_->readSampled(&(color[3]), input_x, input_y, PixelSampler::Nearest); + image_input_->read_sampled(color, input_x, input_y, PixelSampler::Nearest); + if (use_alpha_input_) { + alpha_input_->read_sampled(&(color[3]), input_x, input_y, PixelSampler::Nearest); } copy_v4_v4(buffer + offset4, color); - depthInput_->readSampled(color, input_x, input_y, PixelSampler::Nearest); + depth_input_->read_sampled(color, input_x, input_y, PixelSampler::Nearest); zbuffer[offset] = color[0]; offset4 += COM_DATA_TYPE_COLOR_CHANNELS; offset++; - if (isBraked()) { + if (is_braked()) { breaked = true; } } @@ -216,15 +216,15 @@ void CompositorOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(outp const rcti &area, Span inputs) { - if (!outputBuffer_) { + if (!output_buffer_) { return; } - MemoryBuffer output_buf(outputBuffer_, COM_DATA_TYPE_COLOR_CHANNELS, getWidth(), getHeight()); + MemoryBuffer output_buf(output_buffer_, COM_DATA_TYPE_COLOR_CHANNELS, get_width(), get_height()); output_buf.copy_from(inputs[0], area); - if (useAlphaInput_) { + if (use_alpha_input_) { output_buf.copy_from(inputs[1], area, 0, COM_DATA_TYPE_VALUE_CHANNELS, 3); } - MemoryBuffer depth_buf(depthBuffer_, COM_DATA_TYPE_VALUE_CHANNELS, getWidth(), getHeight()); + MemoryBuffer depth_buf(depth_buffer_, COM_DATA_TYPE_VALUE_CHANNELS, get_width(), get_height()); depth_buf.copy_from(inputs[2], area); } diff --git a/source/blender/compositor/operations/COM_CompositorOperation.h b/source/blender/compositor/operations/COM_CompositorOperation.h index e9539ae66fd..a0960074708 100644 --- a/source/blender/compositor/operations/COM_CompositorOperation.h +++ b/source/blender/compositor/operations/COM_CompositorOperation.h @@ -33,7 +33,7 @@ class CompositorOperation : public MultiThreadedOperation { /** * \brief Scene name, used for getting the render output, includes 'SC' prefix. */ - char sceneName_[MAX_ID_NAME]; + char scene_name_[MAX_ID_NAME]; /** * \brief local reference to the scene @@ -43,32 +43,32 @@ class CompositorOperation : public MultiThreadedOperation { /** * \brief reference to the output float buffer */ - float *outputBuffer_; + float *output_buffer_; /** * \brief reference to the output depth float buffer */ - float *depthBuffer_; + float *depth_buffer_; /** * \brief local reference to the input image operation */ - SocketReader *imageInput_; + SocketReader *image_input_; /** * \brief local reference to the input alpha operation */ - SocketReader *alphaInput_; + SocketReader *alpha_input_; /** * \brief local reference to the depth operation */ - SocketReader *depthInput_; + SocketReader *depth_input_; /** * \brief Ignore any alpha input */ - bool useAlphaInput_; + bool use_alpha_input_; /** * \brief operation is active for calculating final compo result @@ -78,47 +78,47 @@ class CompositorOperation : public MultiThreadedOperation { /** * \brief View name, used for multiview */ - const char *viewName_; + const char *view_name_; public: CompositorOperation(); - bool isActiveCompositorOutput() const + bool is_active_compositor_output() const { return active_; } - void executeRegion(rcti *rect, unsigned int tileNumber) override; - void setScene(const struct Scene *scene) + void execute_region(rcti *rect, unsigned int tile_number) override; + void set_scene(const struct Scene *scene) { scene_ = scene; } - void setSceneName(const char *sceneName) + void set_scene_name(const char *scene_name) { - BLI_strncpy(sceneName_, sceneName, sizeof(sceneName_)); + BLI_strncpy(scene_name_, scene_name, sizeof(scene_name_)); } - void setViewName(const char *viewName) + void set_view_name(const char *view_name) { - viewName_ = viewName; + view_name_ = view_name; } - void setRenderData(const RenderData *rd) + void set_render_data(const RenderData *rd) { rd_ = rd; } - bool isOutputOperation(bool /*rendering*/) const override + bool is_output_operation(bool /*rendering*/) const override { - return this->isActiveCompositorOutput(); + return this->is_active_compositor_output(); } - void initExecution() override; - void deinitExecution() override; - eCompositorPriority getRenderPriority() const override + void init_execution() override; + void deinit_execution() override; + eCompositorPriority get_render_priority() const override { return eCompositorPriority::Medium; } void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void setUseAlphaInput(bool value) + void set_use_alpha_input(bool value) { - useAlphaInput_ = value; + use_alpha_input_ = value; } - void setActive(bool active) + void set_active(bool active) { active_ = active; } diff --git a/source/blender/compositor/operations/COM_ConstantOperation.h b/source/blender/compositor/operations/COM_ConstantOperation.h index d44d1939424..d0db1ef1366 100644 --- a/source/blender/compositor/operations/COM_ConstantOperation.h +++ b/source/blender/compositor/operations/COM_ConstantOperation.h @@ -22,7 +22,7 @@ namespace blender::compositor { -/* TODO(manzanilla): After removing tiled implementation, implement a default #determineResolution +/* TODO(manzanilla): After removing tiled implementation, implement a default #determine_resolution * for all constant operations and make all initialization and deinitilization methods final. */ /** * Base class for operations that are always constant. Operations that can be constant only when diff --git a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cc b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cc index 4f78c919695..db75b2724c4 100644 --- a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cc +++ b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cc @@ -24,30 +24,31 @@ namespace blender::compositor { ConvertColorProfileOperation::ConvertColorProfileOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); - inputOperation_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); + input_operation_ = nullptr; predivided_ = false; } -void ConvertColorProfileOperation::initExecution() +void ConvertColorProfileOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); + input_operation_ = this->get_input_socket_reader(0); } -void ConvertColorProfileOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertColorProfileOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float color[4]; - inputOperation_->readSampled(color, x, y, sampler); - IMB_buffer_float_from_float(output, color, 4, toProfile_, fromProfile_, predivided_, 1, 1, 0, 0); + input_operation_->read_sampled(color, x, y, sampler); + IMB_buffer_float_from_float( + output, color, 4, to_profile_, from_profile_, predivided_, 1, 1, 0, 0); } -void ConvertColorProfileOperation::deinitExecution() +void ConvertColorProfileOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h index 532fad86091..960d267b906 100644 --- a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h +++ b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h @@ -29,19 +29,19 @@ namespace blender::compositor { class ConvertColorProfileOperation : public NodeOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputOperation_; + SocketReader *input_operation_; /** * \brief color profile where to convert from */ - int fromProfile_; + int from_profile_; /** * \brief color profile where to convert to */ - int toProfile_; + int to_profile_; /** * \brief is color predivided @@ -57,27 +57,27 @@ class ConvertColorProfileOperation : public NodeOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setFromColorProfile(int colorProfile) + void set_from_color_profile(int color_profile) { - fromProfile_ = colorProfile; + from_profile_ = color_profile; } - void setToColorProfile(int colorProfile) + void set_to_color_profile(int color_profile) { - toProfile_ = colorProfile; + to_profile_ = color_profile; } - void setPredivided(bool predivided) + void set_predivided(bool predivided) { predivided_ = predivided; } diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc index fcd9d26c3f0..a781b3ea1ed 100644 --- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc +++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cc @@ -24,65 +24,65 @@ namespace blender::compositor { ConvertDepthToRadiusOperation::ConvertDepthToRadiusOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - inputOperation_ = nullptr; - fStop_ = 128.0f; - cameraObject_ = nullptr; - maxRadius_ = 32.0f; - blurPostOperation_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + input_operation_ = nullptr; + f_stop_ = 128.0f; + camera_object_ = nullptr; + max_radius_ = 32.0f; + blur_post_operation_ = nullptr; } -float ConvertDepthToRadiusOperation::determineFocalDistance() +float ConvertDepthToRadiusOperation::determine_focal_distance() { - if (cameraObject_ && cameraObject_->type == OB_CAMERA) { - Camera *camera = (Camera *)cameraObject_->data; + if (camera_object_ && camera_object_->type == OB_CAMERA) { + Camera *camera = (Camera *)camera_object_->data; cam_lens_ = camera->lens; - return BKE_camera_object_dof_distance(cameraObject_); + return BKE_camera_object_dof_distance(camera_object_); } return 10.0f; } -void ConvertDepthToRadiusOperation::initExecution() +void ConvertDepthToRadiusOperation::init_execution() { float cam_sensor = DEFAULT_SENSOR_WIDTH; Camera *camera = nullptr; - if (cameraObject_ && cameraObject_->type == OB_CAMERA) { - camera = (Camera *)cameraObject_->data; + if (camera_object_ && camera_object_->type == OB_CAMERA) { + camera = (Camera *)camera_object_->data; cam_sensor = BKE_camera_sensor_size(camera->sensor_fit, camera->sensor_x, camera->sensor_y); } - 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. */ + input_operation_ = this->get_input_socket_reader(0); + float focal_distance = determine_focal_distance(); + if (focal_distance == 0.0f) { + focal_distance = 1e10f; /* If the DOF is 0.0 then set it to be far away. */ } - 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()); + inverse_focal_distance_ = 1.0f / focal_distance; + aspect_ = (this->get_width() > this->get_height()) ? + (this->get_height() / (float)this->get_width()) : + (this->get_width() / (float)this->get_height()); + aperture_ = 0.5f * (cam_lens_ / (aspect_ * cam_sensor)) / f_stop_; + const float minsz = MIN2(get_width(), get_height()); dof_sp_ = minsz / ((cam_sensor / 2.0f) / cam_lens_); /* <- == `aspect * MIN2(img->x, img->y) / tan(0.5f * fov)` */ - if (blurPostOperation_) { - blurPostOperation_->setSigma(MIN2(aperture_ * 128.0f, maxRadius_)); + if (blur_post_operation_) { + blur_post_operation_->set_sigma(MIN2(aperture_ * 128.0f, max_radius_)); } } -void ConvertDepthToRadiusOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertDepthToRadiusOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue[4]; + float input_value[4]; float z; float radius; - inputOperation_->readSampled(inputValue, x, y, sampler); - z = inputValue[0]; + input_operation_->read_sampled(input_value, x, y, sampler); + z = input_value[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(aperture_ * (dof_sp_ * (inverseFocalDistance_ - iZ) - 1.0f)); + radius = 0.5f * fabsf(aperture_ * (dof_sp_ * (inverse_focal_distance_ - 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 > maxRadius_) { - radius = maxRadius_; + if (radius > max_radius_) { + radius = max_radius_; } output[0] = radius; } @@ -108,9 +108,9 @@ void ConvertDepthToRadiusOperation::executePixelSampled(float output[4], } } -void ConvertDepthToRadiusOperation::deinitExecution() +void ConvertDepthToRadiusOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = 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(aperture_ * (dof_sp_ * (inverseFocalDistance_ - inv_z) - 1.0f)); + fabsf(aperture_ * (dof_sp_ * (inverse_focal_distance_ - 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, maxRadius_); + *it.out = CLAMPIS(radius, 0.0f, max_radius_); } } diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h index d3beff60207..72d19eb3dd8 100644 --- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h +++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h @@ -31,19 +31,19 @@ namespace blender::compositor { class ConvertDepthToRadiusOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputOperation_; - float fStop_; + SocketReader *input_operation_; + float f_stop_; float aspect_; - float maxRadius_; - float inverseFocalDistance_; + float max_radius_; + float inverse_focal_distance_; float aperture_; float cam_lens_; float dof_sp_; - Object *cameraObject_; + Object *camera_object_; - FastGaussianBlurValueOperation *blurPostOperation_; + FastGaussianBlurValueOperation *blur_post_operation_; public: /** @@ -54,34 +54,34 @@ class ConvertDepthToRadiusOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setfStop(float fStop) + void setf_stop(float f_stop) { - fStop_ = fStop; + f_stop_ = f_stop; } - void setMaxRadius(float maxRadius) + void set_max_radius(float max_radius) { - maxRadius_ = maxRadius; + max_radius_ = max_radius; } - void setCameraObject(Object *camera) + void set_camera_object(Object *camera) { - cameraObject_ = camera; + camera_object_ = camera; } - float determineFocalDistance(); - void setPostBlur(FastGaussianBlurValueOperation *operation) + float determine_focal_distance(); + void set_post_blur(FastGaussianBlurValueOperation *operation) { - blurPostOperation_ = operation; + blur_post_operation_ = 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 88de54e8c41..7f1018ca71e 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() { - inputOperation_ = nullptr; + input_operation_ = nullptr; this->flags.can_be_constant = true; } -void ConvertBaseOperation::initExecution() +void ConvertBaseOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); + input_operation_ = this->get_input_socket_reader(0); } -void ConvertBaseOperation::deinitExecution() +void ConvertBaseOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = nullptr; } void ConvertBaseOperation::hash_output_params() @@ -56,17 +56,17 @@ void ConvertBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, ConvertValueToColorOperation::ConvertValueToColorOperation() : ConvertBaseOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); } -void ConvertValueToColorOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertValueToColorOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float value; - inputOperation_->readSampled(&value, x, y, sampler); + input_operation_->read_sampled(&value, x, y, sampler); output[0] = output[1] = output[2] = value; output[3] = 1.0f; } @@ -83,18 +83,18 @@ void ConvertValueToColorOperation::update_memory_buffer_partial(BuffersIterator< ConvertColorToValueOperation::ConvertColorToValueOperation() : ConvertBaseOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Value); } -void ConvertColorToValueOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertColorToValueOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputOperation_->readSampled(inputColor, x, y, sampler); - output[0] = (inputColor[0] + inputColor[1] + inputColor[2]) / 3.0f; + float input_color[4]; + input_operation_->read_sampled(input_color, x, y, sampler); + output[0] = (input_color[0] + input_color[1] + input_color[2]) / 3.0f; } void ConvertColorToValueOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -109,18 +109,18 @@ void ConvertColorToValueOperation::update_memory_buffer_partial(BuffersIterator< ConvertColorToBWOperation::ConvertColorToBWOperation() : ConvertBaseOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Value); } -void ConvertColorToBWOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertColorToBWOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputOperation_->readSampled(inputColor, x, y, sampler); - output[0] = IMB_colormanagement_get_luminance(inputColor); + float input_color[4]; + input_operation_->read_sampled(input_color, x, y, sampler); + output[0] = IMB_colormanagement_get_luminance(input_color); } void ConvertColorToBWOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -134,17 +134,17 @@ void ConvertColorToBWOperation::update_memory_buffer_partial(BuffersIteratoraddInputSocket(DataType::Color); - this->addOutputSocket(DataType::Vector); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Vector); } -void ConvertColorToVectorOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertColorToVectorOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float color[4]; - inputOperation_->readSampled(color, x, y, sampler); + input_operation_->read_sampled(color, x, y, sampler); copy_v3_v3(output, color); } @@ -159,17 +159,17 @@ void ConvertColorToVectorOperation::update_memory_buffer_partial(BuffersIterator ConvertValueToVectorOperation::ConvertValueToVectorOperation() : ConvertBaseOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Vector); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Vector); } -void ConvertValueToVectorOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertValueToVectorOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float value; - inputOperation_->readSampled(&value, x, y, sampler); + input_operation_->read_sampled(&value, x, y, sampler); output[0] = output[1] = output[2] = value; } @@ -184,16 +184,16 @@ void ConvertValueToVectorOperation::update_memory_buffer_partial(BuffersIterator ConvertVectorToColorOperation::ConvertVectorToColorOperation() : ConvertBaseOperation() { - this->addInputSocket(DataType::Vector); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Vector); + this->add_output_socket(DataType::Color); } -void ConvertVectorToColorOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertVectorToColorOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - inputOperation_->readSampled(output, x, y, sampler); + input_operation_->read_sampled(output, x, y, sampler); output[3] = 1.0f; } @@ -209,17 +209,17 @@ void ConvertVectorToColorOperation::update_memory_buffer_partial(BuffersIterator ConvertVectorToValueOperation::ConvertVectorToValueOperation() : ConvertBaseOperation() { - this->addInputSocket(DataType::Vector); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Vector); + this->add_output_socket(DataType::Value); } -void ConvertVectorToValueOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertVectorToValueOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float input[4]; - inputOperation_->readSampled(input, x, y, sampler); + input_operation_->read_sampled(input, x, y, sampler); output[0] = (input[0] + input[1] + input[2]) / 3.0f; } @@ -235,11 +235,11 @@ void ConvertVectorToValueOperation::update_memory_buffer_partial(BuffersIterator ConvertRGBToYCCOperation::ConvertRGBToYCCOperation() : ConvertBaseOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void ConvertRGBToYCCOperation::setMode(int mode) +void ConvertRGBToYCCOperation::set_mode(int mode) { switch (mode) { case 0: @@ -255,21 +255,22 @@ void ConvertRGBToYCCOperation::setMode(int mode) } } -void ConvertRGBToYCCOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertRGBToYCCOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; + float input_color[4]; float color[3]; - inputOperation_->readSampled(inputColor, x, y, sampler); - rgb_to_ycc(inputColor[0], inputColor[1], inputColor[2], &color[0], &color[1], &color[2], mode_); + input_operation_->read_sampled(input_color, x, y, sampler); + rgb_to_ycc( + input_color[0], input_color[1], input_color[2], &color[0], &color[1], &color[2], mode_); /* divided by 255 to normalize for viewing in */ /* R,G,B --> Y,Cb,Cr */ mul_v3_v3fl(output, color, 1.0f / 255.0f); - output[3] = inputColor[3]; + output[3] = input_color[3]; } void ConvertRGBToYCCOperation::hash_output_params() @@ -294,11 +295,11 @@ void ConvertRGBToYCCOperation::update_memory_buffer_partial(BuffersIteratoraddInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void ConvertYCCToRGBOperation::setMode(int mode) +void ConvertYCCToRGBOperation::set_mode(int mode) { switch (mode) { case 0: @@ -314,21 +315,21 @@ void ConvertYCCToRGBOperation::setMode(int mode) } } -void ConvertYCCToRGBOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertYCCToRGBOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputOperation_->readSampled(inputColor, x, y, sampler); + float input_color[4]; + input_operation_->read_sampled(input_color, x, y, sampler); /* need to un-normalize the data */ /* R,G,B --> Y,Cb,Cr */ - mul_v3_fl(inputColor, 255.0f); + mul_v3_fl(input_color, 255.0f); ycc_to_rgb( - inputColor[0], inputColor[1], inputColor[2], &output[0], &output[1], &output[2], mode_); - output[3] = inputColor[3]; + input_color[0], input_color[1], input_color[2], &output[0], &output[1], &output[2], mode_); + output[3] = input_color[3]; } void ConvertYCCToRGBOperation::hash_output_params() @@ -352,25 +353,25 @@ void ConvertYCCToRGBOperation::update_memory_buffer_partial(BuffersIteratoraddInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void ConvertRGBToYUVOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertRGBToYUVOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputOperation_->readSampled(inputColor, x, y, sampler); - rgb_to_yuv(inputColor[0], - inputColor[1], - inputColor[2], + float input_color[4]; + input_operation_->read_sampled(input_color, x, y, sampler); + rgb_to_yuv(input_color[0], + input_color[1], + input_color[2], &output[0], &output[1], &output[2], BLI_YUV_ITU_BT709); - output[3] = inputColor[3]; + output[3] = input_color[3]; } void ConvertRGBToYUVOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -386,25 +387,25 @@ void ConvertRGBToYUVOperation::update_memory_buffer_partial(BuffersIteratoraddInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void ConvertYUVToRGBOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertYUVToRGBOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputOperation_->readSampled(inputColor, x, y, sampler); - yuv_to_rgb(inputColor[0], - inputColor[1], - inputColor[2], + float input_color[4]; + input_operation_->read_sampled(input_color, x, y, sampler); + yuv_to_rgb(input_color[0], + input_color[1], + input_color[2], &output[0], &output[1], &output[2], BLI_YUV_ITU_BT709); - output[3] = inputColor[3]; + output[3] = input_color[3]; } void ConvertYUVToRGBOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -420,19 +421,19 @@ void ConvertYUVToRGBOperation::update_memory_buffer_partial(BuffersIteratoraddInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void ConvertRGBToHSVOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertRGBToHSVOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputOperation_->readSampled(inputColor, x, y, sampler); - rgb_to_hsv_v(inputColor, output); - output[3] = inputColor[3]; + float input_color[4]; + input_operation_->read_sampled(input_color, x, y, sampler); + rgb_to_hsv_v(input_color, output); + output[3] = input_color[3]; } void ConvertRGBToHSVOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -448,22 +449,22 @@ void ConvertRGBToHSVOperation::update_memory_buffer_partial(BuffersIteratoraddInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void ConvertHSVToRGBOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertHSVToRGBOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputOperation_->readSampled(inputColor, x, y, sampler); - hsv_to_rgb_v(inputColor, output); + float input_color[4]; + input_operation_->read_sampled(input_color, x, y, sampler); + hsv_to_rgb_v(input_color, output); output[0] = max_ff(output[0], 0.0f); output[1] = max_ff(output[1], 0.0f); output[2] = max_ff(output[2], 0.0f); - output[3] = inputColor[3]; + output[3] = input_color[3]; } void ConvertHSVToRGBOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -482,17 +483,17 @@ void ConvertHSVToRGBOperation::update_memory_buffer_partial(BuffersIteratoraddInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void ConvertPremulToStraightOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertPremulToStraightOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { ColorSceneLinear4f input; - inputOperation_->readSampled(input, x, y, sampler); + input_operation_->read_sampled(input, x, y, sampler); ColorSceneLinear4f converted = input.unpremultiply_alpha(); copy_v4_v4(output, converted); } @@ -508,17 +509,17 @@ void ConvertPremulToStraightOperation::update_memory_buffer_partial(BuffersItera ConvertStraightToPremulOperation::ConvertStraightToPremulOperation() : ConvertBaseOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void ConvertStraightToPremulOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ConvertStraightToPremulOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { ColorSceneLinear4f input; - inputOperation_->readSampled(input, x, y, sampler); + input_operation_->read_sampled(input, x, y, sampler); ColorSceneLinear4f converted = input.premultiply_alpha(); copy_v4_v4(output, converted); } @@ -534,27 +535,27 @@ void ConvertStraightToPremulOperation::update_memory_buffer_partial(BuffersItera SeparateChannelOperation::SeparateChannelOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Value); - inputOperation_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Value); + input_operation_ = nullptr; } -void SeparateChannelOperation::initExecution() +void SeparateChannelOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); + input_operation_ = this->get_input_socket_reader(0); } -void SeparateChannelOperation::deinitExecution() +void SeparateChannelOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = nullptr; } -void SeparateChannelOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void SeparateChannelOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float input[4]; - inputOperation_->readSampled(input, x, y, sampler); + input_operation_->read_sampled(input, x, y, sampler); output[0] = input[channel_]; } @@ -571,54 +572,54 @@ void SeparateChannelOperation::update_memory_buffer_partial(MemoryBuffer *output CombineChannelsOperation::CombineChannelsOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); this->set_canvas_input_index(0); - inputChannel1Operation_ = nullptr; - inputChannel2Operation_ = nullptr; - inputChannel3Operation_ = nullptr; - inputChannel4Operation_ = nullptr; + input_channel1_operation_ = nullptr; + input_channel2_operation_ = nullptr; + input_channel3_operation_ = nullptr; + input_channel4_operation_ = nullptr; } -void CombineChannelsOperation::initExecution() +void CombineChannelsOperation::init_execution() { - inputChannel1Operation_ = this->getInputSocketReader(0); - inputChannel2Operation_ = this->getInputSocketReader(1); - inputChannel3Operation_ = this->getInputSocketReader(2); - inputChannel4Operation_ = this->getInputSocketReader(3); + input_channel1_operation_ = this->get_input_socket_reader(0); + input_channel2_operation_ = this->get_input_socket_reader(1); + input_channel3_operation_ = this->get_input_socket_reader(2); + input_channel4_operation_ = this->get_input_socket_reader(3); } -void CombineChannelsOperation::deinitExecution() +void CombineChannelsOperation::deinit_execution() { - inputChannel1Operation_ = nullptr; - inputChannel2Operation_ = nullptr; - inputChannel3Operation_ = nullptr; - inputChannel4Operation_ = nullptr; + input_channel1_operation_ = nullptr; + input_channel2_operation_ = nullptr; + input_channel3_operation_ = nullptr; + input_channel4_operation_ = nullptr; } -void CombineChannelsOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void CombineChannelsOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float input[4]; - if (inputChannel1Operation_) { - inputChannel1Operation_->readSampled(input, x, y, sampler); + if (input_channel1_operation_) { + input_channel1_operation_->read_sampled(input, x, y, sampler); output[0] = input[0]; } - if (inputChannel2Operation_) { - inputChannel2Operation_->readSampled(input, x, y, sampler); + if (input_channel2_operation_) { + input_channel2_operation_->read_sampled(input, x, y, sampler); output[1] = input[0]; } - if (inputChannel3Operation_) { - inputChannel3Operation_->readSampled(input, x, y, sampler); + if (input_channel3_operation_) { + input_channel3_operation_->read_sampled(input, x, y, sampler); output[2] = input[0]; } - if (inputChannel4Operation_) { - inputChannel4Operation_->readSampled(input, x, y, sampler); + if (input_channel4_operation_) { + input_channel4_operation_->read_sampled(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 9d4539c8faa..3c4ce358eec 100644 --- a/source/blender/compositor/operations/COM_ConvertOperation.h +++ b/source/blender/compositor/operations/COM_ConvertOperation.h @@ -24,13 +24,13 @@ namespace blender::compositor { class ConvertBaseOperation : public MultiThreadedOperation { protected: - SocketReader *inputOperation_; + SocketReader *input_operation_; public: ConvertBaseOperation(); - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -45,7 +45,7 @@ class ConvertValueToColorOperation : public ConvertBaseOperation { public: ConvertValueToColorOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -55,7 +55,7 @@ class ConvertColorToValueOperation : public ConvertBaseOperation { public: ConvertColorToValueOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -65,7 +65,7 @@ class ConvertColorToBWOperation : public ConvertBaseOperation { public: ConvertColorToBWOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -75,7 +75,7 @@ class ConvertColorToVectorOperation : public ConvertBaseOperation { public: ConvertColorToVectorOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -85,7 +85,7 @@ class ConvertValueToVectorOperation : public ConvertBaseOperation { public: ConvertValueToVectorOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -95,7 +95,7 @@ class ConvertVectorToColorOperation : public ConvertBaseOperation { public: ConvertVectorToColorOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -105,7 +105,7 @@ class ConvertVectorToValueOperation : public ConvertBaseOperation { public: ConvertVectorToValueOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -119,10 +119,10 @@ class ConvertRGBToYCCOperation : public ConvertBaseOperation { public: ConvertRGBToYCCOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** Set the YCC mode */ - void setMode(int mode); + void set_mode(int mode); protected: void hash_output_params() override; @@ -137,10 +137,10 @@ class ConvertYCCToRGBOperation : public ConvertBaseOperation { public: ConvertYCCToRGBOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** Set the YCC mode */ - void setMode(int mode); + void set_mode(int mode); protected: void hash_output_params() override; @@ -151,7 +151,7 @@ class ConvertRGBToYUVOperation : public ConvertBaseOperation { public: ConvertRGBToYUVOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -161,7 +161,7 @@ class ConvertYUVToRGBOperation : public ConvertBaseOperation { public: ConvertYUVToRGBOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -171,7 +171,7 @@ class ConvertRGBToHSVOperation : public ConvertBaseOperation { public: ConvertRGBToHSVOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -181,7 +181,7 @@ class ConvertHSVToRGBOperation : public ConvertBaseOperation { public: ConvertHSVToRGBOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -191,7 +191,7 @@ class ConvertPremulToStraightOperation : public ConvertBaseOperation { public: ConvertPremulToStraightOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -201,7 +201,7 @@ class ConvertStraightToPremulOperation : public ConvertBaseOperation { public: ConvertStraightToPremulOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -209,17 +209,17 @@ class ConvertStraightToPremulOperation : public ConvertBaseOperation { class SeparateChannelOperation : public MultiThreadedOperation { private: - SocketReader *inputOperation_; + SocketReader *input_operation_; int channel_; public: SeparateChannelOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setChannel(int channel) + void set_channel(int channel) { channel_ = channel; } @@ -231,17 +231,17 @@ class SeparateChannelOperation : public MultiThreadedOperation { class CombineChannelsOperation : public MultiThreadedOperation { private: - SocketReader *inputChannel1Operation_; - SocketReader *inputChannel2Operation_; - SocketReader *inputChannel3Operation_; - SocketReader *inputChannel4Operation_; + SocketReader *input_channel1_operation_; + SocketReader *input_channel2_operation_; + SocketReader *input_channel3_operation_; + SocketReader *input_channel4_operation_; public: CombineChannelsOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cc b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cc index 343cc32b625..7ba1f0bbe14 100644 --- a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cc +++ b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cc @@ -20,7 +20,7 @@ namespace blender::compositor { -void ConvolutionEdgeFilterOperation::executePixel(float output[4], int x, int y, void * /*data*/) +void ConvolutionEdgeFilterOperation::execute_pixel(float output[4], int x, int y, void * /*data*/) { float in1[4], in2[4], res1[4] = {0.0}, res2[4] = {0.0}; @@ -30,50 +30,50 @@ void ConvolutionEdgeFilterOperation::executePixel(float output[4], int x, int y, int y1 = y - 1; int y2 = y; int y3 = y + 1; - CLAMP(x1, 0, getWidth() - 1); - CLAMP(x2, 0, getWidth() - 1); - CLAMP(x3, 0, getWidth() - 1); - CLAMP(y1, 0, getHeight() - 1); - CLAMP(y2, 0, getHeight() - 1); - CLAMP(y3, 0, getHeight() - 1); + CLAMP(x1, 0, get_width() - 1); + CLAMP(x2, 0, get_width() - 1); + CLAMP(x3, 0, get_width() - 1); + CLAMP(y1, 0, get_height() - 1); + CLAMP(y2, 0, get_height() - 1); + CLAMP(y3, 0, get_height() - 1); float value[4]; - inputValueOperation_->read(value, x2, y2, nullptr); + input_value_operation_->read(value, x2, y2, nullptr); float mval = 1.0f - value[0]; - inputOperation_->read(in1, x1, y1, nullptr); + input_operation_->read(in1, x1, y1, nullptr); madd_v3_v3fl(res1, in1, filter_[0]); madd_v3_v3fl(res2, in1, filter_[0]); - inputOperation_->read(in1, x2, y1, nullptr); + input_operation_->read(in1, x2, y1, nullptr); madd_v3_v3fl(res1, in1, filter_[1]); madd_v3_v3fl(res2, in1, filter_[3]); - inputOperation_->read(in1, x3, y1, nullptr); + input_operation_->read(in1, x3, y1, nullptr); madd_v3_v3fl(res1, in1, filter_[2]); madd_v3_v3fl(res2, in1, filter_[6]); - inputOperation_->read(in1, x1, y2, nullptr); + input_operation_->read(in1, x1, y2, nullptr); madd_v3_v3fl(res1, in1, filter_[3]); madd_v3_v3fl(res2, in1, filter_[1]); - inputOperation_->read(in2, x2, y2, nullptr); + input_operation_->read(in2, x2, y2, nullptr); madd_v3_v3fl(res1, in2, filter_[4]); madd_v3_v3fl(res2, in2, filter_[4]); - inputOperation_->read(in1, x3, y2, nullptr); + input_operation_->read(in1, x3, y2, nullptr); madd_v3_v3fl(res1, in1, filter_[5]); madd_v3_v3fl(res2, in1, filter_[7]); - inputOperation_->read(in1, x1, y3, nullptr); + input_operation_->read(in1, x1, y3, nullptr); madd_v3_v3fl(res1, in1, filter_[6]); madd_v3_v3fl(res2, in1, filter_[2]); - inputOperation_->read(in1, x2, y3, nullptr); + input_operation_->read(in1, x2, y3, nullptr); madd_v3_v3fl(res1, in1, filter_[7]); madd_v3_v3fl(res2, in1, filter_[5]); - inputOperation_->read(in1, x3, y3, nullptr); + input_operation_->read(in1, x3, y3, nullptr); madd_v3_v3fl(res1, in1, filter_[8]); madd_v3_v3fl(res2, in1, filter_[8]); @@ -99,8 +99,8 @@ void ConvolutionEdgeFilterOperation::update_memory_buffer_partial(MemoryBuffer * Span inputs) { const MemoryBuffer *image = inputs[IMAGE_INPUT_INDEX]; - const int last_x = getWidth() - 1; - const int last_y = getHeight() - 1; + const int last_x = get_width() - 1; + const int last_y = get_height() - 1; for (BuffersIterator it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const int left_offset = (it.x == 0) ? 0 : -image->elem_stride; const int right_offset = (it.x == last_x) ? 0 : image->elem_stride; diff --git a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h index bd38e27165a..a89a9412cf2 100644 --- a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h +++ b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h @@ -24,7 +24,7 @@ namespace blender::compositor { class ConvolutionEdgeFilterOperation : public ConvolutionFilterOperation { public: - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cc b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cc index a4ef88e7a33..6ee5a1c86f9 100644 --- a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cc +++ b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cc @@ -22,17 +22,17 @@ namespace blender::compositor { ConvolutionFilterOperation::ConvolutionFilterOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); this->set_canvas_input_index(0); - inputOperation_ = nullptr; + input_operation_ = nullptr; this->flags.complex = true; } -void ConvolutionFilterOperation::initExecution() +void ConvolutionFilterOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); - inputValueOperation_ = this->getInputSocketReader(1); + input_operation_ = this->get_input_socket_reader(0); + input_value_operation_ = this->get_input_socket_reader(1); } void ConvolutionFilterOperation::set3x3Filter( @@ -47,17 +47,17 @@ void ConvolutionFilterOperation::set3x3Filter( filter_[6] = f7; filter_[7] = f8; filter_[8] = f9; - filterHeight_ = 3; - filterWidth_ = 3; + filter_height_ = 3; + filter_width_ = 3; } -void ConvolutionFilterOperation::deinitExecution() +void ConvolutionFilterOperation::deinit_execution() { - inputOperation_ = nullptr; - inputValueOperation_ = nullptr; + input_operation_ = nullptr; + input_value_operation_ = nullptr; } -void ConvolutionFilterOperation::executePixel(float output[4], int x, int y, void * /*data*/) +void ConvolutionFilterOperation::execute_pixel(float output[4], int x, int y, void * /*data*/) { float in1[4]; float in2[4]; @@ -67,34 +67,34 @@ void ConvolutionFilterOperation::executePixel(float output[4], int x, int y, voi int y1 = y - 1; int y2 = y; int y3 = y + 1; - CLAMP(x1, 0, getWidth() - 1); - CLAMP(x2, 0, getWidth() - 1); - CLAMP(x3, 0, getWidth() - 1); - CLAMP(y1, 0, getHeight() - 1); - CLAMP(y2, 0, getHeight() - 1); - CLAMP(y3, 0, getHeight() - 1); + CLAMP(x1, 0, get_width() - 1); + CLAMP(x2, 0, get_width() - 1); + CLAMP(x3, 0, get_width() - 1); + CLAMP(y1, 0, get_height() - 1); + CLAMP(y2, 0, get_height() - 1); + CLAMP(y3, 0, get_height() - 1); float value[4]; - inputValueOperation_->read(value, x2, y2, nullptr); + input_value_operation_->read(value, x2, y2, nullptr); const float mval = 1.0f - value[0]; zero_v4(output); - inputOperation_->read(in1, x1, y1, nullptr); + input_operation_->read(in1, x1, y1, nullptr); madd_v4_v4fl(output, in1, filter_[0]); - inputOperation_->read(in1, x2, y1, nullptr); + input_operation_->read(in1, x2, y1, nullptr); madd_v4_v4fl(output, in1, filter_[1]); - inputOperation_->read(in1, x3, y1, nullptr); + input_operation_->read(in1, x3, y1, nullptr); madd_v4_v4fl(output, in1, filter_[2]); - inputOperation_->read(in1, x1, y2, nullptr); + input_operation_->read(in1, x1, y2, nullptr); madd_v4_v4fl(output, in1, filter_[3]); - inputOperation_->read(in2, x2, y2, nullptr); + input_operation_->read(in2, x2, y2, nullptr); madd_v4_v4fl(output, in2, filter_[4]); - inputOperation_->read(in1, x3, y2, nullptr); + input_operation_->read(in1, x3, y2, nullptr); madd_v4_v4fl(output, in1, filter_[5]); - inputOperation_->read(in1, x1, y3, nullptr); + input_operation_->read(in1, x1, y3, nullptr); madd_v4_v4fl(output, in1, filter_[6]); - inputOperation_->read(in1, x2, y3, nullptr); + input_operation_->read(in1, x2, y3, nullptr); madd_v4_v4fl(output, in1, filter_[7]); - inputOperation_->read(in1, x3, y3, nullptr); + input_operation_->read(in1, x3, y3, nullptr); madd_v4_v4fl(output, in1, filter_[8]); output[0] = output[0] * value[0] + in2[0] * mval; @@ -109,18 +109,18 @@ void ConvolutionFilterOperation::executePixel(float output[4], int x, int y, voi output[3] = MAX2(output[3], 0.0f); } -bool ConvolutionFilterOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool ConvolutionFilterOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; - 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; - newInput.ymin = input->ymin - addy; - - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + rcti new_input; + int addx = (filter_width_ - 1) / 2 + 1; + int addy = (filter_height_ - 1) / 2 + 1; + new_input.xmax = input->xmax + addx; + new_input.xmin = input->xmin - addx; + new_input.ymax = input->ymax + addy; + new_input.ymin = input->ymin - addy; + + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void ConvolutionFilterOperation::get_area_of_interest(const int input_idx, @@ -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 = (filterWidth_ - 1) / 2 + 1; - const int add_y = (filterHeight_ - 1) / 2 + 1; + const int add_x = (filter_width_ - 1) / 2 + 1; + const int add_y = (filter_height_ - 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; @@ -149,8 +149,8 @@ void ConvolutionFilterOperation::update_memory_buffer_partial(MemoryBuffer *outp Span inputs) { const MemoryBuffer *image = inputs[IMAGE_INPUT_INDEX]; - const int last_x = getWidth() - 1; - const int last_y = getHeight() - 1; + const int last_x = get_width() - 1; + const int last_y = get_height() - 1; for (BuffersIterator it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const int left_offset = (it.x == 0) ? 0 : -image->elem_stride; const int right_offset = (it.x == last_x) ? 0 : image->elem_stride; diff --git a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h index 7000a0f69d6..d764c7c9081 100644 --- a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h +++ b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h @@ -28,25 +28,25 @@ class ConvolutionFilterOperation : public MultiThreadedOperation { static constexpr int FACTOR_INPUT_INDEX = 1; private: - int filterWidth_; - int filterHeight_; + int filter_width_; + int filter_height_; protected: - SocketReader *inputOperation_; - SocketReader *inputValueOperation_; + SocketReader *input_operation_; + SocketReader *input_value_operation_; float filter_[9]; public: ConvolutionFilterOperation(); void set3x3Filter( float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixel(float output[4], int x, int y, void *data) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) final; virtual void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_CropOperation.cc b/source/blender/compositor/operations/COM_CropOperation.cc index d8a402cc582..5d78ed9d41a 100644 --- a/source/blender/compositor/operations/COM_CropOperation.cc +++ b/source/blender/compositor/operations/COM_CropOperation.cc @@ -22,17 +22,17 @@ namespace blender::compositor { CropBaseOperation::CropBaseOperation() { - this->addInputSocket(DataType::Color, ResizeMode::Align); - this->addOutputSocket(DataType::Color); - inputOperation_ = nullptr; + this->add_input_socket(DataType::Color, ResizeMode::Align); + this->add_output_socket(DataType::Color); + input_operation_ = nullptr; settings_ = nullptr; } -void CropBaseOperation::updateArea() +void CropBaseOperation::update_area() { - SocketReader *inputReference = this->getInputSocketReader(0); - float width = inputReference->getWidth(); - float height = inputReference->getHeight(); + SocketReader *input_reference = this->get_input_socket_reader(0); + float width = input_reference->get_width(); + float height = input_reference->get_height(); NodeTwoXYs local_settings = *settings_; if (width > 0.0f && height > 0.0f) { @@ -68,15 +68,15 @@ void CropBaseOperation::updateArea() } } -void CropBaseOperation::initExecution() +void CropBaseOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); - updateArea(); + input_operation_ = this->get_input_socket_reader(0); + update_area(); } -void CropBaseOperation::deinitExecution() +void CropBaseOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = nullptr; } CropOperation::CropOperation() : CropBaseOperation() @@ -84,10 +84,10 @@ CropOperation::CropOperation() : CropBaseOperation() /* pass */ } -void CropOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void CropOperation::execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) { if ((x < xmax_ && x >= xmin_) && (y < ymax_ && y >= ymin_)) { - inputOperation_->readSampled(output, x, y, sampler); + input_operation_->read_sampled(output, x, y, sampler); } else { zero_v4(output); @@ -115,18 +115,18 @@ CropImageOperation::CropImageOperation() : CropBaseOperation() /* pass */ } -bool CropImageOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool CropImageOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; + rcti new_input; - newInput.xmax = input->xmax + xmin_; - newInput.xmin = input->xmin + xmin_; - newInput.ymax = input->ymax + ymin_; - newInput.ymin = input->ymin + ymin_; + new_input.xmax = input->xmax + xmin_; + new_input.xmin = input->xmin + xmin_; + new_input.ymax = input->ymax + ymin_; + new_input.ymin = input->ymin + ymin_; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void CropImageOperation::get_area_of_interest(const int input_idx, @@ -144,18 +144,18 @@ void CropImageOperation::get_area_of_interest(const int input_idx, void CropImageOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { NodeOperation::determine_canvas(preferred_area, r_area); - updateArea(); + update_area(); r_area.xmax = r_area.xmin + (xmax_ - xmin_); r_area.ymax = r_area.ymin + (ymax_ - ymin_); } -void CropImageOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void CropImageOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - if (x >= 0 && x < getWidth() && y >= 0 && y < getHeight()) { - inputOperation_->readSampled(output, (x + xmin_), (y + ymin_), sampler); + if (x >= 0 && x < get_width() && y >= 0 && y < get_height()) { + input_operation_->read_sampled(output, (x + xmin_), (y + ymin_), sampler); } else { zero_v4(output); @@ -167,7 +167,7 @@ void CropImageOperation::update_memory_buffer_partial(MemoryBuffer *output, Span inputs) { rcti op_area; - BLI_rcti_init(&op_area, 0, getWidth(), 0, getHeight()); + BLI_rcti_init(&op_area, 0, get_width(), 0, get_height()); const MemoryBuffer *input = inputs[0]; for (BuffersIterator it = output->iterate_with({}, area); !it.is_end(); ++it) { if (BLI_rcti_isect_pt(&op_area, it.x, it.y)) { diff --git a/source/blender/compositor/operations/COM_CropOperation.h b/source/blender/compositor/operations/COM_CropOperation.h index 50d4d3c5126..69bfd72b052 100644 --- a/source/blender/compositor/operations/COM_CropOperation.h +++ b/source/blender/compositor/operations/COM_CropOperation.h @@ -24,7 +24,7 @@ namespace blender::compositor { class CropBaseOperation : public MultiThreadedOperation { protected: - SocketReader *inputOperation_; + SocketReader *input_operation_; NodeTwoXYs *settings_; bool relative_; int xmax_; @@ -32,17 +32,17 @@ class CropBaseOperation : public MultiThreadedOperation { int ymax_; int ymin_; - void updateArea(); + void update_area(); public: CropBaseOperation(); - void initExecution() override; - void deinitExecution() override; - void setCropSettings(NodeTwoXYs *settings) + void init_execution() override; + void deinit_execution() override; + void set_crop_settings(NodeTwoXYs *settings) { settings_ = settings; } - void setRelative(bool rel) + void set_relative(bool rel) { relative_ = rel; } @@ -52,7 +52,7 @@ class CropOperation : public CropBaseOperation { private: public: CropOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -63,11 +63,11 @@ class CropImageOperation : public CropBaseOperation { private: public: CropImageOperation(); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_CryptomatteOperation.cc b/source/blender/compositor/operations/COM_CryptomatteOperation.cc index a6b9e2c2ee4..078ec9b6dfe 100644 --- a/source/blender/compositor/operations/COM_CryptomatteOperation.cc +++ b/source/blender/compositor/operations/COM_CryptomatteOperation.cc @@ -24,27 +24,27 @@ CryptomatteOperation::CryptomatteOperation(size_t num_inputs) { inputs.resize(num_inputs); for (size_t i = 0; i < num_inputs; i++) { - this->addInputSocket(DataType::Color); + this->add_input_socket(DataType::Color); } - this->addOutputSocket(DataType::Color); + this->add_output_socket(DataType::Color); this->flags.complex = true; } -void CryptomatteOperation::initExecution() +void CryptomatteOperation::init_execution() { for (size_t i = 0; i < inputs.size(); i++) { - inputs[i] = this->getInputSocketReader(i); + inputs[i] = this->get_input_socket_reader(i); } } -void CryptomatteOperation::addObjectIndex(float objectIndex) +void CryptomatteOperation::add_object_index(float object_index) { - if (objectIndex != 0.0f) { - objectIndex_.append(objectIndex); + if (object_index != 0.0f) { + object_index_.append(object_index); } } -void CryptomatteOperation::executePixel(float output[4], int x, int y, void *data) +void CryptomatteOperation::execute_pixel(float output[4], int x, int y, void *data) { float input[4]; output[0] = output[1] = output[2] = output[3] = 0.0f; @@ -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 : objectIndex_) { + for (float hash : object_index_) { 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 : objectIndex_) { + for (const float hash : object_index_) { 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 039b4e3b07a..2fa6fbc8390 100644 --- a/source/blender/compositor/operations/COM_CryptomatteOperation.h +++ b/source/blender/compositor/operations/COM_CryptomatteOperation.h @@ -24,17 +24,17 @@ namespace blender::compositor { class CryptomatteOperation : public MultiThreadedOperation { private: - Vector objectIndex_; + Vector object_index_; public: Vector inputs; CryptomatteOperation(size_t num_inputs = 6); - void initExecution() override; - void executePixel(float output[4], int x, int y, void *data) override; + void init_execution() override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void addObjectIndex(float objectIndex); + void add_object_index(float object_index); void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_CurveBaseOperation.cc b/source/blender/compositor/operations/COM_CurveBaseOperation.cc index 9ae4cad73d3..c65a1a45750 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() { - curveMapping_ = nullptr; + curve_mapping_ = nullptr; this->flags.can_be_constant = true; } CurveBaseOperation::~CurveBaseOperation() { - if (curveMapping_) { - BKE_curvemapping_free(curveMapping_); - curveMapping_ = nullptr; + if (curve_mapping_) { + BKE_curvemapping_free(curve_mapping_); + curve_mapping_ = nullptr; } } -void CurveBaseOperation::initExecution() +void CurveBaseOperation::init_execution() { - BKE_curvemapping_init(curveMapping_); + BKE_curvemapping_init(curve_mapping_); } -void CurveBaseOperation::deinitExecution() +void CurveBaseOperation::deinit_execution() { - if (curveMapping_) { - BKE_curvemapping_free(curveMapping_); - curveMapping_ = nullptr; + if (curve_mapping_) { + BKE_curvemapping_free(curve_mapping_); + curve_mapping_ = nullptr; } } -void CurveBaseOperation::setCurveMapping(CurveMapping *mapping) +void CurveBaseOperation::set_curve_mapping(CurveMapping *mapping) { /* duplicate the curve to avoid glitches while drawing, see bug T32374. */ - if (curveMapping_) { - BKE_curvemapping_free(curveMapping_); + if (curve_mapping_) { + BKE_curvemapping_free(curve_mapping_); } - curveMapping_ = BKE_curvemapping_copy(mapping); + curve_mapping_ = 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 70e9fa9da76..d3548c36870 100644 --- a/source/blender/compositor/operations/COM_CurveBaseOperation.h +++ b/source/blender/compositor/operations/COM_CurveBaseOperation.h @@ -27,9 +27,9 @@ namespace blender::compositor { class CurveBaseOperation : public MultiThreadedOperation { protected: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - CurveMapping *curveMapping_; + CurveMapping *curve_mapping_; public: CurveBaseOperation(); @@ -38,10 +38,10 @@ class CurveBaseOperation : public MultiThreadedOperation { /** * Initialize the execution */ - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setCurveMapping(CurveMapping *mapping); + void set_curve_mapping(CurveMapping *mapping); }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_DenoiseOperation.cc b/source/blender/compositor/operations/COM_DenoiseOperation.cc index 2e41181559e..dd8e6df69fc 100644 --- a/source/blender/compositor/operations/COM_DenoiseOperation.cc +++ b/source/blender/compositor/operations/COM_DenoiseOperation.cc @@ -81,10 +81,10 @@ class DenoiseFilter { BLI_assert(initialized_); BLI_assert(!buffer->is_a_single_elem()); filter.setImage(name.data(), - buffer->getBuffer(), + buffer->get_buffer(), oidn::Format::Float3, - buffer->getWidth(), - buffer->getHeight(), + buffer->get_width(), + buffer->get_height(), 0, buffer->get_elem_bytes_len()); } @@ -131,20 +131,19 @@ DenoiseBaseOperation::DenoiseBaseOperation() output_rendered_ = false; } -bool DenoiseBaseOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool DenoiseBaseOperation::determine_depending_area_of_interest( + rcti * /*input*/, ReadBufferOperation *read_operation, rcti *output) { - if (isCached()) { + if (is_cached()) { return false; } - rcti newInput; - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + rcti new_input; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void DenoiseBaseOperation::get_area_of_interest(const int UNUSED(input_idx), @@ -156,26 +155,26 @@ void DenoiseBaseOperation::get_area_of_interest(const int UNUSED(input_idx), DenoiseOperation::DenoiseOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Vector); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Vector); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); settings_ = nullptr; } -void DenoiseOperation::initExecution() +void DenoiseOperation::init_execution() { - SingleThreadedOperation::initExecution(); - inputProgramColor_ = getInputSocketReader(0); - inputProgramNormal_ = getInputSocketReader(1); - inputProgramAlbedo_ = getInputSocketReader(2); + SingleThreadedOperation::init_execution(); + input_program_color_ = get_input_socket_reader(0); + input_program_normal_ = get_input_socket_reader(1); + input_program_albedo_ = get_input_socket_reader(2); } -void DenoiseOperation::deinitExecution() +void DenoiseOperation::deinit_execution() { - inputProgramColor_ = nullptr; - inputProgramNormal_ = nullptr; - inputProgramAlbedo_ = nullptr; - SingleThreadedOperation::deinitExecution(); + input_program_color_ = nullptr; + input_program_normal_ = nullptr; + input_program_albedo_ = nullptr; + SingleThreadedOperation::deinit_execution(); } static bool are_guiding_passes_noise_free(NodeDenoise *settings) @@ -197,29 +196,29 @@ void DenoiseOperation::hash_output_params() } } -MemoryBuffer *DenoiseOperation::createMemoryBuffer(rcti *rect2) +MemoryBuffer *DenoiseOperation::create_memory_buffer(rcti *rect2) { - MemoryBuffer *tileColor = (MemoryBuffer *)inputProgramColor_->initializeTileData(rect2); - MemoryBuffer *tileNormal = (MemoryBuffer *)inputProgramNormal_->initializeTileData(rect2); - MemoryBuffer *tileAlbedo = (MemoryBuffer *)inputProgramAlbedo_->initializeTileData(rect2); + MemoryBuffer *tile_color = (MemoryBuffer *)input_program_color_->initialize_tile_data(rect2); + MemoryBuffer *tile_normal = (MemoryBuffer *)input_program_normal_->initialize_tile_data(rect2); + MemoryBuffer *tile_albedo = (MemoryBuffer *)input_program_albedo_->initialize_tile_data(rect2); rcti rect; rect.xmin = 0; rect.ymin = 0; - rect.xmax = getWidth(); - rect.ymax = getHeight(); + rect.xmax = get_width(); + rect.ymax = get_height(); MemoryBuffer *result = new MemoryBuffer(DataType::Color, rect); - this->generateDenoise(result, tileColor, tileNormal, tileAlbedo, settings_); + this->generate_denoise(result, tile_color, tile_normal, tile_albedo, settings_); return result; } -void DenoiseOperation::generateDenoise(MemoryBuffer *output, - MemoryBuffer *input_color, - MemoryBuffer *input_normal, - MemoryBuffer *input_albedo, - NodeDenoise *settings) +void DenoiseOperation::generate_denoise(MemoryBuffer *output, + MemoryBuffer *input_color, + MemoryBuffer *input_normal, + MemoryBuffer *input_albedo, + NodeDenoise *settings) { - BLI_assert(input_color->getBuffer()); - if (!input_color->getBuffer()) { + BLI_assert(input_color->get_buffer()); + if (!input_color->get_buffer()) { return; } @@ -244,7 +243,7 @@ void DenoiseOperation::generateDenoise(MemoryBuffer *output, if (settings) { filter.set("hdr", settings->hdr); filter.set("srgb", false); - filter.set("cleanAux", are_guiding_passes_noise_free(settings)); + filter.set("clean_aux", are_guiding_passes_noise_free(settings)); } filter.execute(); @@ -270,15 +269,15 @@ void DenoiseOperation::update_memory_buffer(MemoryBuffer *output, Span inputs) { if (!output_rendered_) { - this->generateDenoise(output, inputs[0], inputs[1], inputs[2], settings_); + this->generate_denoise(output, inputs[0], inputs[1], inputs[2], settings_); output_rendered_ = true; } } DenoisePrefilterOperation::DenoisePrefilterOperation(DataType data_type) { - this->addInputSocket(data_type); - this->addOutputSocket(data_type); + this->add_input_socket(data_type); + this->add_output_socket(data_type); image_name_ = ""; } @@ -287,13 +286,13 @@ void DenoisePrefilterOperation::hash_output_params() hash_param(image_name_); } -MemoryBuffer *DenoisePrefilterOperation::createMemoryBuffer(rcti *rect2) +MemoryBuffer *DenoisePrefilterOperation::create_memory_buffer(rcti *rect2) { - MemoryBuffer *input = (MemoryBuffer *)this->get_input_operation(0)->initializeTileData(rect2); + MemoryBuffer *input = (MemoryBuffer *)this->get_input_operation(0)->initialize_tile_data(rect2); rcti rect; - BLI_rcti_init(&rect, 0, getWidth(), 0, getHeight()); + BLI_rcti_init(&rect, 0, get_width(), 0, get_height()); - MemoryBuffer *result = new MemoryBuffer(getOutputSocket()->getDataType(), rect); + MemoryBuffer *result = new MemoryBuffer(get_output_socket()->get_data_type(), rect); generate_denoise(result, input); return result; diff --git a/source/blender/compositor/operations/COM_DenoiseOperation.h b/source/blender/compositor/operations/COM_DenoiseOperation.h index 24852009e6d..a3eb1f57f2f 100644 --- a/source/blender/compositor/operations/COM_DenoiseOperation.h +++ b/source/blender/compositor/operations/COM_DenoiseOperation.h @@ -33,9 +33,9 @@ class DenoiseBaseOperation : public SingleThreadedOperation { DenoiseBaseOperation(); public: - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; }; @@ -45,9 +45,9 @@ class DenoiseOperation : public DenoiseBaseOperation { /** * \brief Cached reference to the input programs */ - SocketReader *inputProgramColor_; - SocketReader *inputProgramAlbedo_; - SocketReader *inputProgramNormal_; + SocketReader *input_program_color_; + SocketReader *input_program_albedo_; + SocketReader *input_program_normal_; /** * \brief settings of the denoise node. @@ -59,14 +59,14 @@ class DenoiseOperation : public DenoiseBaseOperation { /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setDenoiseSettings(NodeDenoise *settings) + void set_denoise_settings(NodeDenoise *settings) { settings_ = settings; } @@ -77,13 +77,13 @@ class DenoiseOperation : public DenoiseBaseOperation { protected: void hash_output_params() override; - void generateDenoise(MemoryBuffer *output, - MemoryBuffer *input_color, - MemoryBuffer *input_normal, - MemoryBuffer *input_albedo, - NodeDenoise *settings); + void generate_denoise(MemoryBuffer *output, + MemoryBuffer *input_color, + MemoryBuffer *input_normal, + MemoryBuffer *input_albedo, + NodeDenoise *settings); - MemoryBuffer *createMemoryBuffer(rcti *rect) override; + MemoryBuffer *create_memory_buffer(rcti *rect) override; }; class DenoisePrefilterOperation : public DenoiseBaseOperation { @@ -104,7 +104,7 @@ class DenoisePrefilterOperation : public DenoiseBaseOperation { protected: void hash_output_params() override; - MemoryBuffer *createMemoryBuffer(rcti *rect) override; + MemoryBuffer *create_memory_buffer(rcti *rect) override; private: void generate_denoise(MemoryBuffer *output, MemoryBuffer *input); diff --git a/source/blender/compositor/operations/COM_DespeckleOperation.cc b/source/blender/compositor/operations/COM_DespeckleOperation.cc index f655c17fdf2..be0dc06b8ec 100644 --- a/source/blender/compositor/operations/COM_DespeckleOperation.cc +++ b/source/blender/compositor/operations/COM_DespeckleOperation.cc @@ -24,23 +24,23 @@ namespace blender::compositor { DespeckleOperation::DespeckleOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); this->set_canvas_input_index(0); - inputOperation_ = nullptr; + input_operation_ = nullptr; this->flags.complex = true; } -void DespeckleOperation::initExecution() +void DespeckleOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); - inputValueOperation_ = this->getInputSocketReader(1); + input_operation_ = this->get_input_socket_reader(0); + input_value_operation_ = this->get_input_socket_reader(1); } -void DespeckleOperation::deinitExecution() +void DespeckleOperation::deinit_execution() { - inputOperation_ = nullptr; - inputValueOperation_ = nullptr; + input_operation_ = nullptr; + input_value_operation_ = nullptr; } BLI_INLINE int color_diff(const float a[3], const float b[3], const float threshold) @@ -49,7 +49,7 @@ BLI_INLINE int color_diff(const float a[3], const float b[3], const float thresh (fabsf(a[2] - b[2]) > threshold)); } -void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*data*/) +void DespeckleOperation::execute_pixel(float output[4], int x, int y, void * /*data*/) { float w = 0.0f; float color_org[4]; @@ -62,17 +62,17 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da int y1 = y - 1; int y2 = y; int y3 = y + 1; - CLAMP(x1, 0, getWidth() - 1); - CLAMP(x2, 0, getWidth() - 1); - CLAMP(x3, 0, getWidth() - 1); - CLAMP(y1, 0, getHeight() - 1); - CLAMP(y2, 0, getHeight() - 1); - CLAMP(y3, 0, getHeight() - 1); + CLAMP(x1, 0, get_width() - 1); + CLAMP(x2, 0, get_width() - 1); + CLAMP(x3, 0, get_width() - 1); + CLAMP(y1, 0, get_height() - 1); + CLAMP(y2, 0, get_height() - 1); + CLAMP(y3, 0, get_height() - 1); float value[4]; - inputValueOperation_->read(value, x2, y2, nullptr); + input_value_operation_->read(value, x2, y2, nullptr); // const float mval = 1.0f - value[0]; - inputOperation_->read(color_org, x2, y2, nullptr); + input_operation_->read(color_org, x2, y2, nullptr); #define TOT_DIV_ONE 1.0f #define TOT_DIV_CNR (float)M_SQRT1_2 @@ -91,27 +91,27 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da zero_v4(color_mid); zero_v4(color_mid_ok); - inputOperation_->read(in1, x1, y1, nullptr); + input_operation_->read(in1, x1, y1, nullptr); COLOR_ADD(TOT_DIV_CNR) - inputOperation_->read(in1, x2, y1, nullptr); + input_operation_->read(in1, x2, y1, nullptr); COLOR_ADD(TOT_DIV_ONE) - inputOperation_->read(in1, x3, y1, nullptr); + input_operation_->read(in1, x3, y1, nullptr); COLOR_ADD(TOT_DIV_CNR) - inputOperation_->read(in1, x1, y2, nullptr); + input_operation_->read(in1, x1, y2, nullptr); COLOR_ADD(TOT_DIV_ONE) #if 0 - inputOperation_->read(in2, x2, y2, nullptr); + input_operation_->read(in2, x2, y2, nullptr); madd_v4_v4fl(color_mid, in2, filter_[4]); #endif - inputOperation_->read(in1, x3, y2, nullptr); + input_operation_->read(in1, x3, y2, nullptr); COLOR_ADD(TOT_DIV_ONE) - inputOperation_->read(in1, x1, y3, nullptr); + input_operation_->read(in1, x1, y3, nullptr); COLOR_ADD(TOT_DIV_CNR) - inputOperation_->read(in1, x2, y3, nullptr); + input_operation_->read(in1, x2, y3, nullptr); COLOR_ADD(TOT_DIV_ONE) - inputOperation_->read(in1, x3, y3, nullptr); + input_operation_->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))); @@ -132,19 +132,19 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da #undef COLOR_ADD } -bool DespeckleOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool DespeckleOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; - 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; - newInput.ymin = input->ymin - addy; - - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + rcti new_input; + int addx = 2; //(filter_width_ - 1) / 2 + 1; + int addy = 2; //(filter_height_ - 1) / 2 + 1; + new_input.xmax = input->xmax + addx; + new_input.xmin = input->xmin - addx; + new_input.ymax = input->ymax + addy; + new_input.ymin = input->ymin - addy; + + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void DespeckleOperation::get_area_of_interest(const int input_idx, @@ -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; //(filterWidth_ - 1) / 2 + 1; - const int add_y = 2; //(filterHeight_ - 1) / 2 + 1; + const int add_x = 2; //(filter_width_ - 1) / 2 + 1; + const int add_y = 2; //(filter_height_ - 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; @@ -173,8 +173,8 @@ void DespeckleOperation::update_memory_buffer_partial(MemoryBuffer *output, Span inputs) { const MemoryBuffer *image = inputs[IMAGE_INPUT_INDEX]; - const int last_x = getWidth() - 1; - const int last_y = getHeight() - 1; + const int last_x = get_width() - 1; + const int last_y = get_height() - 1; for (BuffersIterator it = output->iterate_with(inputs, area); !it.is_end(); ++it) { const int x1 = MAX2(it.x - 1, 0); const int x2 = it.x; diff --git a/source/blender/compositor/operations/COM_DespeckleOperation.h b/source/blender/compositor/operations/COM_DespeckleOperation.h index 9aca01000a7..bb5b012a330 100644 --- a/source/blender/compositor/operations/COM_DespeckleOperation.h +++ b/source/blender/compositor/operations/COM_DespeckleOperation.h @@ -30,31 +30,31 @@ class DespeckleOperation : public MultiThreadedOperation { float threshold_; float threshold_neighbor_; - // int filterWidth_; - // int filterHeight_; + // int filter_width_; + // int filter_height_; protected: - SocketReader *inputOperation_; - SocketReader *inputValueOperation_; + SocketReader *input_operation_; + SocketReader *input_value_operation_; public: DespeckleOperation(); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixel(float output[4], int x, int y, void *data) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void setThreshold(float threshold) + void set_threshold(float threshold) { threshold_ = threshold; } - void setThresholdNeighbor(float threshold) + void set_threshold_neighbor(float threshold) { threshold_neighbor_ = threshold; } - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cc b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cc index d5f11ff8e35..8391bbb799a 100644 --- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cc +++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cc @@ -22,44 +22,44 @@ namespace blender::compositor { DifferenceMatteOperation::DifferenceMatteOperation() { - addInputSocket(DataType::Color); - addInputSocket(DataType::Color); - addOutputSocket(DataType::Value); + add_input_socket(DataType::Color); + add_input_socket(DataType::Color); + add_output_socket(DataType::Value); - inputImage1Program_ = nullptr; - inputImage2Program_ = nullptr; + input_image1_program_ = nullptr; + input_image2_program_ = nullptr; flags.can_be_constant = true; } -void DifferenceMatteOperation::initExecution() +void DifferenceMatteOperation::init_execution() { - inputImage1Program_ = this->getInputSocketReader(0); - inputImage2Program_ = this->getInputSocketReader(1); + input_image1_program_ = this->get_input_socket_reader(0); + input_image2_program_ = this->get_input_socket_reader(1); } -void DifferenceMatteOperation::deinitExecution() +void DifferenceMatteOperation::deinit_execution() { - inputImage1Program_ = nullptr; - inputImage2Program_ = nullptr; + input_image1_program_ = nullptr; + input_image2_program_ = nullptr; } -void DifferenceMatteOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void DifferenceMatteOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inColor1[4]; - float inColor2[4]; + float in_color1[4]; + float in_color2[4]; const float tolerance = settings_->t1; const float falloff = settings_->t2; float difference; float alpha; - inputImage1Program_->readSampled(inColor1, x, y, sampler); - inputImage2Program_->readSampled(inColor2, x, y, sampler); + input_image1_program_->read_sampled(in_color1, x, y, sampler); + input_image2_program_->read_sampled(in_color2, x, y, sampler); - difference = (fabsf(inColor2[0] - inColor1[0]) + fabsf(inColor2[1] - inColor1[1]) + - fabsf(inColor2[2] - inColor1[2])); + difference = (fabsf(in_color2[0] - in_color1[0]) + fabsf(in_color2[1] - in_color1[1]) + + fabsf(in_color2[2] - in_color1[2])); /* average together the distances */ difference = difference / 3.0f; @@ -73,16 +73,16 @@ void DifferenceMatteOperation::executePixelSampled(float output[4], difference = difference - tolerance; alpha = difference / falloff; /* Only change if more transparent than before. */ - if (alpha < inColor1[3]) { + if (alpha < in_color1[3]) { output[0] = alpha; } else { /* leave as before */ - output[0] = inColor1[3]; + output[0] = in_color1[3]; } } else { /* foreground object */ - output[0] = inColor1[3]; + output[0] = in_color1[3]; } } diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.h b/source/blender/compositor/operations/COM_DifferenceMatteOperation.h index 31ce0d3dbe5..700dabc9b8d 100644 --- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.h +++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.h @@ -29,8 +29,8 @@ namespace blender::compositor { class DifferenceMatteOperation : public MultiThreadedOperation { private: NodeChroma *settings_; - SocketReader *inputImage1Program_; - SocketReader *inputImage2Program_; + SocketReader *input_image1_program_; + SocketReader *input_image2_program_; public: /** @@ -41,14 +41,14 @@ class DifferenceMatteOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setSettings(NodeChroma *nodeChroma) + void set_settings(NodeChroma *node_chroma) { - settings_ = nodeChroma; + settings_ = node_chroma; } 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 1366eb43776..7fc186df35f 100644 --- a/source/blender/compositor/operations/COM_DilateErodeOperation.cc +++ b/source/blender/compositor/operations/COM_DilateErodeOperation.cc @@ -24,10 +24,10 @@ namespace blender::compositor { /* DilateErode Distance Threshold */ DilateErodeThresholdOperation::DilateErodeThresholdOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); this->flags.complex = true; - inputProgram_ = nullptr; + input_program_ = nullptr; inset_ = 0.0f; switch_ = 0.5f; distance_ = 0.0f; @@ -51,20 +51,20 @@ void DilateErodeThresholdOperation::init_data() } } -void DilateErodeThresholdOperation::initExecution() +void DilateErodeThresholdOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); + input_program_ = this->get_input_socket_reader(0); } -void *DilateErodeThresholdOperation::initializeTileData(rcti * /*rect*/) +void *DilateErodeThresholdOperation::initialize_tile_data(rcti * /*rect*/) { - void *buffer = inputProgram_->initializeTileData(nullptr); + void *buffer = input_program_->initialize_tile_data(nullptr); return buffer; } -void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y, void *data) +void DilateErodeThresholdOperation::execute_pixel(float output[4], int x, int y, void *data) { - float inputValue[4]; + float input_value[4]; const float sw = switch_; const float distance = distance_; float pixelvalue; @@ -72,21 +72,21 @@ void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y, const float inset = inset_; float mindist = rd * 2; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - float *buffer = inputBuffer->getBuffer(); - const rcti &input_rect = inputBuffer->get_rect(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + float *buffer = input_buffer->get_buffer(); + const rcti &input_rect = input_buffer->get_rect(); 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(); + const int buffer_width = input_buffer->get_width(); int offset; - inputBuffer->read(inputValue, x, y); - if (inputValue[0] > sw) { + input_buffer->read(input_value, x, y); + if (input_value[0] > sw) { for (int yi = miny; yi < maxy; yi++) { const float dy = yi - y; - offset = ((yi - input_rect.ymin) * bufferWidth + (minx - input_rect.xmin)); + offset = ((yi - input_rect.ymin) * buffer_width + (minx - input_rect.xmin)); for (int xi = minx; xi < maxx; xi++) { if (buffer[offset] < sw) { const float dx = xi - x; @@ -101,7 +101,7 @@ void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y, else { for (int yi = miny; yi < maxy; yi++) { const float dy = yi - y; - offset = ((yi - input_rect.ymin) * bufferWidth + (minx - input_rect.xmin)); + offset = ((yi - input_rect.ymin) * buffer_width + (minx - input_rect.xmin)); for (int xi = minx; xi < maxx; xi++) { if (buffer[offset] > sw) { const float dx = xi - x; @@ -144,22 +144,22 @@ void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y, } } -void DilateErodeThresholdOperation::deinitExecution() +void DilateErodeThresholdOperation::deinit_execution() { - inputProgram_ = nullptr; + input_program_ = nullptr; } -bool DilateErodeThresholdOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool DilateErodeThresholdOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; - newInput.xmax = input->xmax + scope_; - newInput.xmin = input->xmin - scope_; - newInput.ymax = input->ymax + scope_; - newInput.ymin = input->ymin - scope_; + new_input.xmax = input->xmax + scope_; + new_input.xmin = input->xmin - scope_; + new_input.ymax = input->ymax + scope_; + new_input.ymin = input->ymin - scope_; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void DilateErodeThresholdOperation::get_area_of_interest(const int input_idx, @@ -271,9 +271,9 @@ void DilateErodeThresholdOperation::update_memory_buffer_partial(MemoryBuffer *o /* Dilate Distance. */ DilateDistanceOperation::DilateDistanceOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - inputProgram_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + input_program_ = nullptr; distance_ = 0.0f; flags.complex = true; flags.open_cl = true; @@ -287,37 +287,37 @@ void DilateDistanceOperation::init_data() } } -void DilateDistanceOperation::initExecution() +void DilateDistanceOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); + input_program_ = this->get_input_socket_reader(0); } -void *DilateDistanceOperation::initializeTileData(rcti * /*rect*/) +void *DilateDistanceOperation::initialize_tile_data(rcti * /*rect*/) { - void *buffer = inputProgram_->initializeTileData(nullptr); + void *buffer = input_program_->initialize_tile_data(nullptr); return buffer; } -void DilateDistanceOperation::executePixel(float output[4], int x, int y, void *data) +void DilateDistanceOperation::execute_pixel(float output[4], int x, int y, void *data) { const float distance = distance_; const float mindist = distance * distance; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - float *buffer = inputBuffer->getBuffer(); - const rcti &input_rect = inputBuffer->get_rect(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + float *buffer = input_buffer->get_buffer(); + const rcti &input_rect = input_buffer->get_rect(); 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(); + const int buffer_width = input_buffer->get_width(); int offset; float value = 0.0f; for (int yi = miny; yi < maxy; yi++) { const float dy = yi - y; - offset = ((yi - input_rect.ymin) * bufferWidth + (minx - input_rect.xmin)); + offset = ((yi - input_rect.ymin) * buffer_width + (minx - input_rect.xmin)); for (int xi = minx; xi < maxx; xi++) { const float dx = xi - x; const float dis = dx * dx + dy * dy; @@ -330,45 +330,46 @@ void DilateDistanceOperation::executePixel(float output[4], int x, int y, void * output[0] = value; } -void DilateDistanceOperation::deinitExecution() +void DilateDistanceOperation::deinit_execution() { - inputProgram_ = nullptr; + input_program_ = nullptr; } -bool DilateDistanceOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool DilateDistanceOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; - newInput.xmax = input->xmax + scope_; - newInput.xmin = input->xmin - scope_; - newInput.ymax = input->ymax + scope_; - newInput.ymin = input->ymin - scope_; + new_input.xmax = input->xmax + scope_; + new_input.xmin = input->xmin - scope_; + new_input.ymax = input->ymax + scope_; + new_input.ymin = input->ymin - scope_; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } -void DilateDistanceOperation::executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list * /*clKernelsToCleanUp*/) +void DilateDistanceOperation::execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list * /*cl_kernels_to_clean_up*/) { - cl_kernel dilateKernel = device->COM_clCreateKernel("dilateKernel", nullptr); + cl_kernel dilate_kernel = device->COM_cl_create_kernel("dilate_kernel", nullptr); - cl_int distanceSquared = distance_ * distance_; + cl_int distance_squared = distance_ * distance_; cl_int scope = scope_; - device->COM_clAttachMemoryBufferToKernelParameter( - 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); - clSetKernelArg(dilateKernel, 5, sizeof(cl_int), &distanceSquared); - device->COM_clAttachSizeToKernelParameter(dilateKernel, 6, this); - device->COM_clEnqueueRange(dilateKernel, outputMemoryBuffer, 7, this); + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + dilate_kernel, 0, 2, cl_mem_to_clean_up, input_memory_buffers, input_program_); + device->COM_cl_attach_output_memory_buffer_to_kernel_parameter( + dilate_kernel, 1, cl_output_buffer); + device->COM_cl_attach_memory_buffer_offset_to_kernel_parameter( + dilate_kernel, 3, output_memory_buffer); + clSetKernelArg(dilate_kernel, 4, sizeof(cl_int), &scope); + clSetKernelArg(dilate_kernel, 5, sizeof(cl_int), &distance_squared); + device->COM_cl_attach_size_to_kernel_parameter(dilate_kernel, 6, this); + device->COM_cl_enqueue_range(dilate_kernel, output_memory_buffer, 7, this); } void DilateDistanceOperation::get_area_of_interest(const int input_idx, @@ -463,26 +464,26 @@ ErodeDistanceOperation::ErodeDistanceOperation() : DilateDistanceOperation() /* pass */ } -void ErodeDistanceOperation::executePixel(float output[4], int x, int y, void *data) +void ErodeDistanceOperation::execute_pixel(float output[4], int x, int y, void *data) { const float distance = distance_; const float mindist = distance * distance; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - float *buffer = inputBuffer->getBuffer(); - const rcti &input_rect = inputBuffer->get_rect(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + float *buffer = input_buffer->get_buffer(); + const rcti &input_rect = input_buffer->get_rect(); 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(); + const int buffer_width = input_buffer->get_width(); int offset; float value = 1.0f; for (int yi = miny; yi < maxy; yi++) { const float dy = yi - y; - offset = ((yi - input_rect.ymin) * bufferWidth + (minx - input_rect.xmin)); + offset = ((yi - input_rect.ymin) * buffer_width + (minx - input_rect.xmin)); for (int xi = minx; xi < maxx; xi++) { const float dx = xi - x; const float dis = dx * dx + dy * dy; @@ -495,26 +496,28 @@ void ErodeDistanceOperation::executePixel(float output[4], int x, int y, void *d output[0] = value; } -void ErodeDistanceOperation::executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list * /*clKernelsToCleanUp*/) +void ErodeDistanceOperation::execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list * /*cl_kernels_to_clean_up*/) { - cl_kernel erodeKernel = device->COM_clCreateKernel("erodeKernel", nullptr); + cl_kernel erode_kernel = device->COM_cl_create_kernel("erode_kernel", nullptr); - cl_int distanceSquared = distance_ * distance_; + cl_int distance_squared = distance_ * distance_; cl_int scope = scope_; - device->COM_clAttachMemoryBufferToKernelParameter( - 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); - clSetKernelArg(erodeKernel, 5, sizeof(cl_int), &distanceSquared); - device->COM_clAttachSizeToKernelParameter(erodeKernel, 6, this); - device->COM_clEnqueueRange(erodeKernel, outputMemoryBuffer, 7, this); + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + erode_kernel, 0, 2, cl_mem_to_clean_up, input_memory_buffers, input_program_); + device->COM_cl_attach_output_memory_buffer_to_kernel_parameter( + erode_kernel, 1, cl_output_buffer); + device->COM_cl_attach_memory_buffer_offset_to_kernel_parameter( + erode_kernel, 3, output_memory_buffer); + clSetKernelArg(erode_kernel, 4, sizeof(cl_int), &scope); + clSetKernelArg(erode_kernel, 5, sizeof(cl_int), &distance_squared); + device->COM_cl_attach_size_to_kernel_parameter(erode_kernel, 6, this); + device->COM_cl_enqueue_range(erode_kernel, output_memory_buffer, 7, this); } void ErodeDistanceOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -531,17 +534,17 @@ void ErodeDistanceOperation::update_memory_buffer_partial(MemoryBuffer *output, /* Dilate step */ DilateStepOperation::DilateStepOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); this->flags.complex = true; - inputProgram_ = nullptr; + input_program_ = nullptr; } -void DilateStepOperation::initExecution() +void DilateStepOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); + input_program_ = this->get_input_socket_reader(0); } -/* Small helper to pass data from initializeTileData to executePixel. */ +/* Small helper to pass data from initialize_tile_data to execute_pixel. */ struct tile_info { rcti rect; int width; @@ -561,13 +564,13 @@ static tile_info *create_cache(int xmin, int xmax, int ymin, int ymax) return result; } -void *DilateStepOperation::initializeTileData(rcti *rect) +void *DilateStepOperation::initialize_tile_data(rcti *rect) { - MemoryBuffer *tile = (MemoryBuffer *)inputProgram_->initializeTileData(nullptr); + MemoryBuffer *tile = (MemoryBuffer *)input_program_->initialize_tile_data(nullptr); int x, y, i; - int width = tile->getWidth(); - int height = tile->getHeight(); - float *buffer = tile->getBuffer(); + int width = tile->get_width(); + int height = tile->get_height(); + float *buffer = tile->get_buffer(); int half_window = iterations_; int window = half_window * 2 + 1; @@ -651,7 +654,7 @@ void *DilateStepOperation::initializeTileData(rcti *rect) return result; } -void DilateStepOperation::executePixel(float output[4], int x, int y, void *data) +void DilateStepOperation::execute_pixel(float output[4], int x, int y, void *data) { tile_info *tile = (tile_info *)data; int nx = x - tile->rect.xmin; @@ -659,30 +662,30 @@ void DilateStepOperation::executePixel(float output[4], int x, int y, void *data output[0] = tile->buffer[tile->width * ny + nx]; } -void DilateStepOperation::deinitExecution() +void DilateStepOperation::deinit_execution() { - inputProgram_ = nullptr; + input_program_ = nullptr; } -void DilateStepOperation::deinitializeTileData(rcti * /*rect*/, void *data) +void DilateStepOperation::deinitialize_tile_data(rcti * /*rect*/, void *data) { tile_info *tile = (tile_info *)data; MEM_freeN(tile->buffer); MEM_freeN(tile); } -bool DilateStepOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool DilateStepOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; + rcti new_input; int it = iterations_; - newInput.xmax = input->xmax + it; - newInput.xmin = input->xmin - it; - newInput.ymax = input->ymax + it; - newInput.ymin = input->ymin - it; + new_input.xmax = input->xmax + it; + new_input.xmin = input->xmin - it; + new_input.ymax = input->ymax + it; + new_input.ymin = input->ymin - it; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void DilateStepOperation::get_area_of_interest(const int input_idx, @@ -706,8 +709,8 @@ static void step_update_memory_buffer(MemoryBuffer *output, { TCompareSelector selector; - const int width = output->getWidth(); - const int height = output->getHeight(); + const int width = output->get_width(); + const int height = output->get_height(); const int half_window = num_iterations; const int window = half_window * 2 + 1; @@ -812,13 +815,13 @@ ErodeStepOperation::ErodeStepOperation() : DilateStepOperation() /* pass */ } -void *ErodeStepOperation::initializeTileData(rcti *rect) +void *ErodeStepOperation::initialize_tile_data(rcti *rect) { - MemoryBuffer *tile = (MemoryBuffer *)inputProgram_->initializeTileData(nullptr); + MemoryBuffer *tile = (MemoryBuffer *)input_program_->initialize_tile_data(nullptr); int x, y, i; - int width = tile->getWidth(); - int height = tile->getHeight(); - float *buffer = tile->getBuffer(); + int width = tile->get_width(); + int height = tile->get_height(); + float *buffer = tile->get_buffer(); int half_window = iterations_; int window = half_window * 2 + 1; diff --git a/source/blender/compositor/operations/COM_DilateErodeOperation.h b/source/blender/compositor/operations/COM_DilateErodeOperation.h index 1919c926710..04d25a1fca6 100644 --- a/source/blender/compositor/operations/COM_DilateErodeOperation.h +++ b/source/blender/compositor/operations/COM_DilateErodeOperation.h @@ -28,9 +28,9 @@ class DilateErodeThresholdOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; float distance_; float switch_; @@ -48,36 +48,36 @@ class DilateErodeThresholdOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; void init_data() override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setDistance(float distance) + void set_distance(float distance) { distance_ = distance; } - void setSwitch(float sw) + void set_switch(float sw) { switch_ = sw; } - void setInset(float inset) + void set_inset(float inset) { inset_ = inset; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, @@ -91,9 +91,9 @@ class DilateDistanceOperation : public MultiThreadedOperation { protected: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; float distance_; int scope_; @@ -103,34 +103,34 @@ class DilateDistanceOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; void init_data() override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setDistance(float distance) + void set_distance(float distance) { distance_ = distance; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list *clKernelsToCleanUp) override; + void execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list *cl_kernels_to_clean_up) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) final; virtual void update_memory_buffer_partial(MemoryBuffer *output, @@ -145,14 +145,14 @@ class ErodeDistanceOperation : public DilateDistanceOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list *clKernelsToCleanUp) override; + void execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list *cl_kernels_to_clean_up) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -162,9 +162,9 @@ class ErodeDistanceOperation : public DilateDistanceOperation { class DilateStepOperation : public MultiThreadedOperation { protected: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; int iterations_; @@ -174,28 +174,28 @@ class DilateStepOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; - void deinitializeTileData(rcti *rect, void *data) override; + void deinit_execution() override; + void deinitialize_tile_data(rcti *rect, void *data) override; - void setIterations(int iterations) + void set_iterations(int iterations) { iterations_ = iterations; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) final; virtual void update_memory_buffer_partial(MemoryBuffer *output, @@ -207,7 +207,7 @@ class ErodeStepOperation : public DilateStepOperation { public: ErodeStepOperation(); - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) override; diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cc b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cc index 3cf3ee3b0c8..eff7fa84475 100644 --- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cc +++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cc @@ -23,17 +23,17 @@ namespace blender::compositor { DirectionalBlurOperation::DirectionalBlurOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); flags.complex = true; flags.open_cl = true; - inputProgram_ = nullptr; + input_program_ = nullptr; } -void DirectionalBlurOperation::initExecution() +void DirectionalBlurOperation::init_execution() { - inputProgram_ = getInputSocketReader(0); - QualityStepHelper::initExecution(COM_QH_INCREASE); + input_program_ = get_input_socket_reader(0); + QualityStepHelper::init_execution(COM_QH_INCREASE); const float angle = data_->angle; const float zoom = data_->zoom; const float spin = data_->spin; @@ -41,8 +41,8 @@ void DirectionalBlurOperation::initExecution() 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(); + const float width = get_width(); + const float height = get_height(); const float a = angle; const float itsc = 1.0f / powf(2.0f, (float)iterations); @@ -58,12 +58,12 @@ void DirectionalBlurOperation::initExecution() rot_ = itsc * spin; } -void DirectionalBlurOperation::executePixel(float output[4], int x, int y, void * /*data*/) +void DirectionalBlurOperation::execute_pixel(float output[4], int x, int y, void * /*data*/) { 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}; - inputProgram_->readSampled(col2, x, y, PixelSampler::Bilinear); + input_program_->read_sampled(col2, x, y, PixelSampler::Bilinear); float ltx = tx_; float lty = ty_; float lsc = sc_; @@ -76,10 +76,10 @@ void DirectionalBlurOperation::executePixel(float output[4], int x, int y, void const float v = isc * (y - center_y_pix_) + lty; const float u = isc * (x - center_x_pix_) + ltx; - inputProgram_->readSampled(col, - cs * u + ss * v + center_x_pix_, - cs * v - ss * u + center_y_pix_, - PixelSampler::Bilinear); + input_program_->read_sampled(col, + cs * u + ss * v + center_x_pix_, + cs * v - ss * u + center_y_pix_, + PixelSampler::Bilinear); add_v4_v4(col2, col); @@ -93,14 +93,15 @@ void DirectionalBlurOperation::executePixel(float output[4], int x, int y, void mul_v4_v4fl(output, col2, 1.0f / (iterations + 1)); } -void DirectionalBlurOperation::executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list * /*clKernelsToCleanUp*/) +void DirectionalBlurOperation::execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list * /*cl_kernels_to_clean_up*/) { - cl_kernel directionalBlurKernel = device->COM_clCreateKernel("directionalBlurKernel", nullptr); + cl_kernel directional_blur_kernel = device->COM_cl_create_kernel("directional_blur_kernel", + nullptr); cl_int iterations = pow(2.0f, data_->iter); cl_float2 ltxy = {{tx_, ty_}}; @@ -108,38 +109,37 @@ void DirectionalBlurOperation::executeOpenCL(OpenCLDevice *device, cl_float lsc = sc_; cl_float lrot = rot_; - device->COM_clAttachMemoryBufferToKernelParameter( - directionalBlurKernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, inputProgram_); - device->COM_clAttachOutputMemoryBufferToKernelParameter( - directionalBlurKernel, 1, clOutputBuffer); - device->COM_clAttachMemoryBufferOffsetToKernelParameter( - directionalBlurKernel, 2, outputMemoryBuffer); - clSetKernelArg(directionalBlurKernel, 3, sizeof(cl_int), &iterations); - clSetKernelArg(directionalBlurKernel, 4, sizeof(cl_float), &lsc); - clSetKernelArg(directionalBlurKernel, 5, sizeof(cl_float), &lrot); - clSetKernelArg(directionalBlurKernel, 6, sizeof(cl_float2), <xy); - clSetKernelArg(directionalBlurKernel, 7, sizeof(cl_float2), ¢erpix); - - device->COM_clEnqueueRange(directionalBlurKernel, outputMemoryBuffer, 8, this); + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + directional_blur_kernel, 0, -1, cl_mem_to_clean_up, input_memory_buffers, input_program_); + device->COM_cl_attach_output_memory_buffer_to_kernel_parameter( + directional_blur_kernel, 1, cl_output_buffer); + device->COM_cl_attach_memory_buffer_offset_to_kernel_parameter( + directional_blur_kernel, 2, output_memory_buffer); + clSetKernelArg(directional_blur_kernel, 3, sizeof(cl_int), &iterations); + clSetKernelArg(directional_blur_kernel, 4, sizeof(cl_float), &lsc); + clSetKernelArg(directional_blur_kernel, 5, sizeof(cl_float), &lrot); + clSetKernelArg(directional_blur_kernel, 6, sizeof(cl_float2), <xy); + clSetKernelArg(directional_blur_kernel, 7, sizeof(cl_float2), ¢erpix); + + device->COM_cl_enqueue_range(directional_blur_kernel, output_memory_buffer, 8, this); } -void DirectionalBlurOperation::deinitExecution() +void DirectionalBlurOperation::deinit_execution() { - inputProgram_ = nullptr; + input_program_ = nullptr; } -bool DirectionalBlurOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool DirectionalBlurOperation::determine_depending_area_of_interest( + rcti * /*input*/, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void DirectionalBlurOperation::get_area_of_interest(const int input_idx, diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.h b/source/blender/compositor/operations/COM_DirectionalBlurOperation.h index 0687ff4ae5d..2dd2fc98ccd 100644 --- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.h +++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.h @@ -25,7 +25,7 @@ namespace blender::compositor { class DirectionalBlurOperation : public MultiThreadedOperation, public QualityStepHelper { private: - SocketReader *inputProgram_; + SocketReader *input_program_; NodeDBlurData *data_; float center_x_pix_, center_y_pix_; @@ -38,33 +38,33 @@ class DirectionalBlurOperation : public MultiThreadedOperation, public QualitySt /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void setData(NodeDBlurData *data) + void set_data(NodeDBlurData *data) { data_ = data; } - void executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list *clKernelsToCleanUp) override; + void execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list *cl_kernels_to_clean_up) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_DisplaceOperation.cc b/source/blender/compositor/operations/COM_DisplaceOperation.cc index 8476db73b32..0c5b8dea2e6 100644 --- a/source/blender/compositor/operations/COM_DisplaceOperation.cc +++ b/source/blender/compositor/operations/COM_DisplaceOperation.cc @@ -22,55 +22,55 @@ namespace blender::compositor { DisplaceOperation::DisplaceOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Vector); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Vector); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); this->flags.complex = true; - inputColorProgram_ = nullptr; + input_color_program_ = nullptr; } -void DisplaceOperation::initExecution() +void DisplaceOperation::init_execution() { - inputColorProgram_ = this->getInputSocketReader(0); - NodeOperation *vector = this->getInputSocketReader(1); - NodeOperation *scale_x = this->getInputSocketReader(2); - NodeOperation *scale_y = this->getInputSocketReader(3); + input_color_program_ = this->get_input_socket_reader(0); + NodeOperation *vector = this->get_input_socket_reader(1); + NodeOperation *scale_x = this->get_input_socket_reader(2); + NodeOperation *scale_y = this->get_input_socket_reader(3); if (execution_model_ == eExecutionModel::Tiled) { vector_read_fn_ = [=](float x, float y, float *out) { - vector->readSampled(out, x, y, PixelSampler::Bilinear); + vector->read_sampled(out, x, y, PixelSampler::Bilinear); }; scale_x_read_fn_ = [=](float x, float y, float *out) { - scale_x->readSampled(out, x, y, PixelSampler::Nearest); + scale_x->read_sampled(out, x, y, PixelSampler::Nearest); }; scale_y_read_fn_ = [=](float x, float y, float *out) { - scale_y->readSampled(out, x, y, PixelSampler::Nearest); + scale_y->read_sampled(out, x, y, PixelSampler::Nearest); }; } - width_x4_ = this->getWidth() * 4; - height_x4_ = this->getHeight() * 4; - input_vector_width_ = vector->getWidth(); - input_vector_height_ = vector->getHeight(); + width_x4_ = this->get_width() * 4; + height_x4_ = this->get_height() * 4; + input_vector_width_ = vector->get_width(); + input_vector_height_ = vector->get_height(); } -void DisplaceOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void DisplaceOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { float xy[2] = {x, y}; float uv[2], deriv[2][2]; - pixelTransform(xy, uv, deriv); + pixel_transform(xy, uv, deriv); if (is_zero_v2(deriv[0]) && is_zero_v2(deriv[1])) { - inputColorProgram_->readSampled(output, uv[0], uv[1], PixelSampler::Bilinear); + input_color_program_->read_sampled(output, uv[0], uv[1], PixelSampler::Bilinear); } else { /* EWA filtering (without nearest it gets blurry with NO distortion) */ - inputColorProgram_->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); + input_color_program_->read_filtered(output, uv[0], uv[1], deriv[0], deriv[1]); } } @@ -92,7 +92,7 @@ bool DisplaceOperation::read_displacement( return true; } -void DisplaceOperation::pixelTransform(const float xy[2], float r_uv[2], float r_deriv[2][2]) +void DisplaceOperation::pixel_transform(const float xy[2], float r_uv[2], float r_deriv[2][2]) { float col[4]; float uv[2]; /* temporary variables for derivative estimation */ @@ -151,52 +151,52 @@ void DisplaceOperation::pixelTransform(const float xy[2], float r_uv[2], float r } } -void DisplaceOperation::deinitExecution() +void DisplaceOperation::deinit_execution() { - inputColorProgram_ = nullptr; + input_color_program_ = nullptr; vector_read_fn_ = nullptr; scale_x_read_fn_ = nullptr; scale_y_read_fn_ = nullptr; } -bool DisplaceOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool DisplaceOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti colorInput; - rcti vectorInput; + rcti color_input; + rcti vector_input; NodeOperation *operation = nullptr; /* the vector buffer only needs a 2x2 buffer. The image needs whole buffer */ /* image */ - operation = getInputOperation(0); - colorInput.xmax = operation->getWidth(); - colorInput.xmin = 0; - colorInput.ymax = operation->getHeight(); - colorInput.ymin = 0; - if (operation->determineDependingAreaOfInterest(&colorInput, readOperation, output)) { + operation = get_input_operation(0); + color_input.xmax = operation->get_width(); + color_input.xmin = 0; + color_input.ymax = operation->get_height(); + color_input.ymin = 0; + if (operation->determine_depending_area_of_interest(&color_input, read_operation, output)) { return true; } /* vector */ - operation = getInputOperation(1); - vectorInput.xmax = input->xmax + 1; - vectorInput.xmin = input->xmin - 1; - vectorInput.ymax = input->ymax + 1; - vectorInput.ymin = input->ymin - 1; - if (operation->determineDependingAreaOfInterest(&vectorInput, readOperation, output)) { + operation = get_input_operation(1); + vector_input.xmax = input->xmax + 1; + vector_input.xmin = input->xmin - 1; + vector_input.ymax = input->ymax + 1; + vector_input.ymin = input->ymin - 1; + if (operation->determine_depending_area_of_interest(&vector_input, read_operation, output)) { return true; } /* scale x */ - operation = getInputOperation(2); - if (operation->determineDependingAreaOfInterest(input, readOperation, output)) { + operation = get_input_operation(2); + if (operation->determine_depending_area_of_interest(input, read_operation, output)) { return true; } /* scale y */ - operation = getInputOperation(3); - if (operation->determineDependingAreaOfInterest(input, readOperation, output)) { + operation = get_input_operation(3); + if (operation->determine_depending_area_of_interest(input, read_operation, output)) { return true; } @@ -209,7 +209,7 @@ void DisplaceOperation::get_area_of_interest(const int input_idx, { switch (input_idx) { case 0: { - r_input_area = getInputOperation(input_idx)->get_canvas(); + r_input_area = get_input_operation(input_idx)->get_canvas(); break; } case 1: { @@ -246,7 +246,7 @@ void DisplaceOperation::update_memory_buffer_partial(MemoryBuffer *output, float uv[2]; float deriv[2][2]; - pixelTransform(xy, uv, deriv); + pixel_transform(xy, uv, deriv); if (is_zero_v2(deriv[0]) && is_zero_v2(deriv[1])) { input_color->read_elem_bilinear(uv[0], uv[1], it.out); } diff --git a/source/blender/compositor/operations/COM_DisplaceOperation.h b/source/blender/compositor/operations/COM_DisplaceOperation.h index 56cd1c1f2a6..a6f6927407f 100644 --- a/source/blender/compositor/operations/COM_DisplaceOperation.h +++ b/source/blender/compositor/operations/COM_DisplaceOperation.h @@ -25,9 +25,9 @@ namespace blender::compositor { class DisplaceOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputColorProgram_; + SocketReader *input_color_program_; float width_x4_; float height_x4_; @@ -45,26 +45,26 @@ class DisplaceOperation : public MultiThreadedOperation { /** * we need a 2x2 differential filter for Vector Input and full buffer for the image */ - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void pixelTransform(const float xy[2], float r_uv[2], float r_deriv[2][2]); + void pixel_transform(const float xy[2], float r_uv[2], float r_deriv[2][2]); /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_started(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cc b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cc index 77d7831c680..729b01d924d 100644 --- a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cc +++ b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cc @@ -22,108 +22,107 @@ namespace blender::compositor { DisplaceSimpleOperation::DisplaceSimpleOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Vector); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); - - inputColorProgram_ = nullptr; - inputVectorProgram_ = nullptr; - inputScaleXProgram_ = nullptr; - inputScaleYProgram_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Vector); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); + + input_color_program_ = nullptr; + input_vector_program_ = nullptr; + input_scale_xprogram_ = nullptr; + input_scale_yprogram_ = nullptr; } -void DisplaceSimpleOperation::initExecution() +void DisplaceSimpleOperation::init_execution() { - inputColorProgram_ = this->getInputSocketReader(0); - inputVectorProgram_ = this->getInputSocketReader(1); - inputScaleXProgram_ = this->getInputSocketReader(2); - inputScaleYProgram_ = this->getInputSocketReader(3); + input_color_program_ = this->get_input_socket_reader(0); + input_vector_program_ = this->get_input_socket_reader(1); + input_scale_xprogram_ = this->get_input_socket_reader(2); + input_scale_yprogram_ = this->get_input_socket_reader(3); - width_x4_ = this->getWidth() * 4; - height_x4_ = this->getHeight() * 4; + width_x4_ = this->get_width() * 4; + height_x4_ = this->get_height() * 4; } /* minimum distance (in pixels) a pixel has to be displaced * in order to take effect */ // #define DISPLACE_EPSILON 0.01f -void DisplaceSimpleOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void DisplaceSimpleOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inVector[4]; - float inScale[4]; + float in_vector[4]; + float in_scale[4]; float p_dx, p_dy; /* main displacement in pixel space */ float u, v; - inputScaleXProgram_->readSampled(inScale, x, y, sampler); - float xs = inScale[0]; - inputScaleYProgram_->readSampled(inScale, x, y, sampler); - float ys = inScale[0]; + input_scale_xprogram_->read_sampled(in_scale, x, y, sampler); + float xs = in_scale[0]; + input_scale_yprogram_->read_sampled(in_scale, x, y, sampler); + float ys = in_scale[0]; /* clamp x and y displacement to triple image resolution - * to prevent hangs from huge values mistakenly plugged in eg. z buffers */ CLAMP(xs, -width_x4_, width_x4_); CLAMP(ys, -height_x4_, height_x4_); - inputVectorProgram_->readSampled(inVector, x, y, sampler); - p_dx = inVector[0] * xs; - p_dy = inVector[1] * ys; + input_vector_program_->read_sampled(in_vector, x, y, sampler); + p_dx = in_vector[0] * xs; + p_dy = in_vector[1] * ys; /* displaced pixel in uv coords, for image sampling */ /* clamp nodes to avoid glitches */ u = x - p_dx + 0.5f; v = y - p_dy + 0.5f; - CLAMP(u, 0.0f, this->getWidth() - 1.0f); - CLAMP(v, 0.0f, this->getHeight() - 1.0f); + CLAMP(u, 0.0f, this->get_width() - 1.0f); + CLAMP(v, 0.0f, this->get_height() - 1.0f); - inputColorProgram_->readSampled(output, u, v, sampler); + input_color_program_->read_sampled(output, u, v, sampler); } -void DisplaceSimpleOperation::deinitExecution() +void DisplaceSimpleOperation::deinit_execution() { - inputColorProgram_ = nullptr; - inputVectorProgram_ = nullptr; - inputScaleXProgram_ = nullptr; - inputScaleYProgram_ = nullptr; + input_color_program_ = nullptr; + input_vector_program_ = nullptr; + input_scale_xprogram_ = nullptr; + input_scale_yprogram_ = nullptr; } -bool DisplaceSimpleOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool DisplaceSimpleOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti colorInput; + rcti color_input; NodeOperation *operation = nullptr; /* the vector buffer only needs a 2x2 buffer. The image needs whole buffer */ /* image */ - operation = getInputOperation(0); - colorInput.xmax = operation->getWidth(); - colorInput.xmin = 0; - colorInput.ymax = operation->getHeight(); - colorInput.ymin = 0; - if (operation->determineDependingAreaOfInterest(&colorInput, readOperation, output)) { + operation = get_input_operation(0); + color_input.xmax = operation->get_width(); + color_input.xmin = 0; + color_input.ymax = operation->get_height(); + color_input.ymin = 0; + if (operation->determine_depending_area_of_interest(&color_input, read_operation, output)) { return true; } /* vector */ - if (operation->determineDependingAreaOfInterest(input, readOperation, output)) { + if (operation->determine_depending_area_of_interest(input, read_operation, output)) { return true; } /* scale x */ - operation = getInputOperation(2); - if (operation->determineDependingAreaOfInterest(input, readOperation, output)) { + operation = get_input_operation(2); + if (operation->determine_depending_area_of_interest(input, read_operation, output)) { return true; } /* scale y */ - operation = getInputOperation(3); - if (operation->determineDependingAreaOfInterest(input, readOperation, output)) { + operation = get_input_operation(3); + if (operation->determine_depending_area_of_interest(input, read_operation, output)) { return true; } @@ -150,8 +149,8 @@ void DisplaceSimpleOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - const float width = this->getWidth(); - const float height = this->getHeight(); + const float width = this->get_width(); + const float height = this->get_height(); const MemoryBuffer *input_color = inputs[0]; for (BuffersIterator it = output->iterate_with(inputs.drop_front(1), area); !it.is_end(); ++it) { diff --git a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h index 1baf8c8275c..c16146dc464 100644 --- a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h +++ b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h @@ -25,12 +25,12 @@ namespace blender::compositor { class DisplaceSimpleOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputColorProgram_; - SocketReader *inputVectorProgram_; - SocketReader *inputScaleXProgram_; - SocketReader *inputScaleYProgram_; + SocketReader *input_color_program_; + SocketReader *input_vector_program_; + SocketReader *input_scale_xprogram_; + SocketReader *input_scale_yprogram_; float width_x4_; float height_x4_; @@ -41,24 +41,24 @@ class DisplaceSimpleOperation : public MultiThreadedOperation { /** * we need a full buffer for the image */ - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cc b/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cc index e076bf4ae7d..95593d7d49f 100644 --- a/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cc +++ b/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cc @@ -22,39 +22,39 @@ namespace blender::compositor { DistanceRGBMatteOperation::DistanceRGBMatteOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Value); - inputImageProgram_ = nullptr; - inputKeyProgram_ = nullptr; + input_image_program_ = nullptr; + input_key_program_ = nullptr; flags.can_be_constant = true; } -void DistanceRGBMatteOperation::initExecution() +void DistanceRGBMatteOperation::init_execution() { - inputImageProgram_ = this->getInputSocketReader(0); - inputKeyProgram_ = this->getInputSocketReader(1); + input_image_program_ = this->get_input_socket_reader(0); + input_key_program_ = this->get_input_socket_reader(1); } -void DistanceRGBMatteOperation::deinitExecution() +void DistanceRGBMatteOperation::deinit_execution() { - inputImageProgram_ = nullptr; - inputKeyProgram_ = nullptr; + input_image_program_ = nullptr; + input_key_program_ = nullptr; } -float DistanceRGBMatteOperation::calculateDistance(const float key[4], const float image[4]) +float DistanceRGBMatteOperation::calculate_distance(const float key[4], const float image[4]) { return len_v3v3(key, image); } -void DistanceRGBMatteOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void DistanceRGBMatteOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inKey[4]; - float inImage[4]; + float in_key[4]; + float in_image[4]; const float tolerance = settings_->t1; const float falloff = settings_->t2; @@ -62,10 +62,10 @@ void DistanceRGBMatteOperation::executePixelSampled(float output[4], float distance; float alpha; - inputKeyProgram_->readSampled(inKey, x, y, sampler); - inputImageProgram_->readSampled(inImage, x, y, sampler); + input_key_program_->read_sampled(in_key, x, y, sampler); + input_image_program_->read_sampled(in_image, x, y, sampler); - distance = this->calculateDistance(inKey, inImage); + distance = this->calculate_distance(in_key, in_image); /* Store matte(alpha) value in [0] to go with * COM_SetAlphaMultiplyOperation and the Value output. @@ -80,16 +80,16 @@ void DistanceRGBMatteOperation::executePixelSampled(float output[4], distance = distance - tolerance; alpha = distance / falloff; /* Only change if more transparent than before. */ - if (alpha < inImage[3]) { + if (alpha < in_image[3]) { output[0] = alpha; } else { /* leave as before */ - output[0] = inImage[3]; + output[0] = in_image[3]; } } else { /* leave as before */ - output[0] = inImage[3]; + output[0] = in_image[3]; } } @@ -101,7 +101,7 @@ void DistanceRGBMatteOperation::update_memory_buffer_partial(MemoryBuffer *outpu const float *in_image = it.in(0); const float *in_key = it.in(1); - float distance = this->calculateDistance(in_key, in_image); + float distance = this->calculate_distance(in_key, in_image); const float tolerance = settings_->t1; const float falloff = settings_->t2; diff --git a/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h b/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h index e741a9b80d5..306a4e316f5 100644 --- a/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h +++ b/source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h @@ -29,10 +29,10 @@ namespace blender::compositor { class DistanceRGBMatteOperation : public MultiThreadedOperation { protected: NodeChroma *settings_; - SocketReader *inputImageProgram_; - SocketReader *inputKeyProgram_; + SocketReader *input_image_program_; + SocketReader *input_key_program_; - virtual float calculateDistance(const float key[4], const float image[4]); + virtual float calculate_distance(const float key[4], const float image[4]); public: /** @@ -43,14 +43,14 @@ class DistanceRGBMatteOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setSettings(NodeChroma *nodeChroma) + void set_settings(NodeChroma *node_chroma) { - settings_ = nodeChroma; + settings_ = node_chroma; } void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.cc b/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.cc index 9903b80ce02..682c01a63d5 100644 --- a/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.cc +++ b/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.cc @@ -20,7 +20,7 @@ namespace blender::compositor { -float DistanceYCCMatteOperation::calculateDistance(const float key[4], const float image[4]) +float DistanceYCCMatteOperation::calculate_distance(const float key[4], const float image[4]) { /* only measure the second 2 values */ return len_v2v2(key + 1, image + 1); diff --git a/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.h b/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.h index 0e178fddc39..1d5ed9f0de1 100644 --- a/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.h +++ b/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.h @@ -29,7 +29,7 @@ namespace blender::compositor { */ class DistanceYCCMatteOperation : public DistanceRGBMatteOperation { protected: - float calculateDistance(const float key[4], const float image[4]) override; + float calculate_distance(const float key[4], const float image[4]) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_DotproductOperation.cc b/source/blender/compositor/operations/COM_DotproductOperation.cc index ef309392d4d..9507f991b52 100644 --- a/source/blender/compositor/operations/COM_DotproductOperation.cc +++ b/source/blender/compositor/operations/COM_DotproductOperation.cc @@ -22,21 +22,21 @@ namespace blender::compositor { DotproductOperation::DotproductOperation() { - this->addInputSocket(DataType::Vector); - this->addInputSocket(DataType::Vector); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Vector); + this->add_input_socket(DataType::Vector); + this->add_output_socket(DataType::Value); this->set_canvas_input_index(0); input1Operation_ = nullptr; input2Operation_ = nullptr; flags.can_be_constant = true; } -void DotproductOperation::initExecution() +void DotproductOperation::init_execution() { - input1Operation_ = this->getInputSocketReader(0); - input2Operation_ = this->getInputSocketReader(1); + input1Operation_ = this->get_input_socket_reader(0); + input2Operation_ = this->get_input_socket_reader(1); } -void DotproductOperation::deinitExecution() +void DotproductOperation::deinit_execution() { input1Operation_ = nullptr; input2Operation_ = nullptr; @@ -44,15 +44,15 @@ void DotproductOperation::deinitExecution() /** \todo current implementation is the inverse of a dot-product. not 'logically' correct */ -void DotproductOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void DotproductOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float input1[4]; float input2[4]; - input1Operation_->readSampled(input1, x, y, sampler); - input2Operation_->readSampled(input2, x, y, sampler); + input1Operation_->read_sampled(input1, x, y, sampler); + input2Operation_->read_sampled(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 5190a161533..f9e5d4d39c4 100644 --- a/source/blender/compositor/operations/COM_DotproductOperation.h +++ b/source/blender/compositor/operations/COM_DotproductOperation.h @@ -29,10 +29,10 @@ class DotproductOperation : public MultiThreadedOperation { public: DotproductOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc index 2ae33d5451f..559df4abb0c 100644 --- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc +++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc @@ -945,8 +945,8 @@ static void do_createEdgeLocationBuffer(unsigned int t, const unsigned int *lres, float *res, unsigned short *gbuf, - unsigned int *innerEdgeOffset, - unsigned int *outerEdgeOffset, + unsigned int *inner_edge_offset, + unsigned int *outer_edge_offset, unsigned int isz, unsigned int gsz) { @@ -956,14 +956,14 @@ static void do_createEdgeLocationBuffer(unsigned int t, unsigned int dmin; /* Minimum edge distance. */ unsigned int rsl; /* Long used for finding fast `1.0/sqrt`. */ - unsigned int gradientFillOffset; + unsigned int gradient_fill_offset; /* For looping inner edge pixel indexes, represents current position from offset. */ - unsigned int innerAccum = 0; + unsigned int inner_accum = 0; /* For looping outer edge pixel indexes, represents current position from offset. */ - unsigned int outerAccum = 0; + unsigned int outer_accum = 0; /* For looping gradient pixel indexes, represents current position from offset. */ - unsigned int gradientAccum = 0; + unsigned int gradient_accum = 0; /* Disable clang-format to prevent line-wrapping. */ /* clang-format off */ @@ -996,7 +996,7 @@ static void do_createEdgeLocationBuffer(unsigned int t, * ..oooo... * .oggggo.. * .oggiggo. - * .ogiFigo. + * .ogi_figo. * .oggiggo. * .oggggo.. * ..oooo... @@ -1009,7 +1009,7 @@ static void do_createEdgeLocationBuffer(unsigned int t, * * The memory in gbuf[] after filling will look like this: * - * gradientFillOffset (0 pixels) innerEdgeOffset (18 pixels) outerEdgeOffset (22 pixels) + * gradient_fill_offset (0 pixels) inner_edge_offset (18 pixels) outer_edge_offset (22 pixels) * / / / * / / / * |X Y X Y X Y X Y > = 0; x--) { - gradientFillOffset = x << 1; - t = gbuf[gradientFillOffset]; /* Calculate column of pixel indexed by `gbuf[x]`. */ - fsz = gbuf[gradientFillOffset + 1]; /* Calculate row of pixel indexed by `gbuf[x]`. */ - dmin = 0xffffffff; /* Reset min distance to edge pixel. */ - for (a = outerEdgeOffset + osz - 1; a >= outerEdgeOffset; + gradient_fill_offset = x << 1; + t = gbuf[gradient_fill_offset]; /* Calculate column of pixel indexed by `gbuf[x]`. */ + fsz = gbuf[gradient_fill_offset + 1]; /* Calculate row of pixel indexed by `gbuf[x]`. */ + dmin = 0xffffffff; /* Reset min distance to edge pixel. */ + for (a = outer_edge_offset + osz - 1; a >= outer_edge_offset; a--) { /* Loop through all outer edge buffer pixels. */ ud = a << 1; dy = t - gbuf[ud]; /* Set dx to gradient pixel column - outer edge pixel row. */ @@ -1173,7 +1173,7 @@ static void do_fillGradientBuffer(unsigned int rw, odist = odist * (rsopf - (rsf * odist * odist)); /* -- This line can be iterated for more accuracy. -- */ dmin = 0xffffffff; /* Reset min distance to edge pixel. */ - for (a = innerEdgeOffset + isz - 1; a >= innerEdgeOffset; + for (a = inner_edge_offset + isz - 1; a >= inner_edge_offset; a--) { /* Loop through all inside edge pixels. */ ud = a << 1; dy = t - gbuf[ud]; /* Compute delta in Y from gradient pixel to inside edge pixel. */ @@ -1201,14 +1201,14 @@ static void do_fillGradientBuffer(unsigned int rw, /* Here we reconstruct the pixel's memory location in the CompBuf by * `Pixel Index = Pixel Column + ( Pixel Row * Row Width )`. */ - res[gbuf[gradientFillOffset + 1] + (gbuf[gradientFillOffset] * rw)] = + res[gbuf[gradient_fill_offset + 1] + (gbuf[gradient_fill_offset] * rw)] = (idist / (idist + odist)); /* Set intensity. */ } } /* End of copy. */ -void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float *res) +void DoubleEdgeMaskOperation::do_double_edge_mask(float *imask, float *omask, float *res) { unsigned int *lres; /* Pointer to output pixel buffer (for bit operations). */ unsigned int *limask; /* Pointer to inner mask (for bit operations). */ @@ -1222,17 +1222,17 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float unsigned int osz = 0; /* Size (in pixels) of outside edge pixel index buffer. */ unsigned int gsz = 0; /* Size (in pixels) of gradient pixel index buffer. */ unsigned int rsize[3]; /* Size storage to pass to helper functions. */ - unsigned int innerEdgeOffset = + unsigned int inner_edge_offset = 0; /* Offset into final buffer where inner edge pixel indexes start. */ - unsigned int outerEdgeOffset = + unsigned int outer_edge_offset = 0; /* Offset into final buffer where outer edge pixel indexes start. */ unsigned short *gbuf; /* Gradient/inner/outer pixel location index buffer. */ if (true) { /* If both input sockets have some data coming in... */ - rw = this->getWidth(); /* Width of a row of pixels. */ - t = (rw * this->getHeight()) - 1; /* Determine size of the frame. */ + rw = this->get_width(); /* Width of a row of pixels. */ + t = (rw * this->get_height()) - 1; /* Determine size of the frame. */ memset(res, 0, sizeof(float) * @@ -1267,8 +1267,8 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float * * Each version has slightly different criteria for detecting an edge pixel. */ - if (adjacentOnly_) { /* If "adjacent only" inner edge mode is turned on. */ - if (keepInside_) { /* If "keep inside" buffer edge mode is turned on. */ + if (adjacent_only_) { /* If "adjacent only" inner edge mode is turned on. */ + if (keep_inside_) { /* 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 (keepInside_) { /* If "keep inside" buffer edge mode is turned on. */ + else { /* "all" inner edge mode is turned on. */ + if (keep_inside_) { /* 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. */ @@ -1309,8 +1309,8 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float gbuf = (unsigned short *)MEM_callocN(sizeof(unsigned short) * fsz * 2, "DEM"); do_createEdgeLocationBuffer( - t, rw, lres, res, gbuf, &innerEdgeOffset, &outerEdgeOffset, isz, gsz); - do_fillGradientBuffer(rw, res, gbuf, isz, osz, gsz, innerEdgeOffset, outerEdgeOffset); + t, rw, lres, res, gbuf, &inner_edge_offset, &outer_edge_offset, isz, gsz); + do_fillGradientBuffer(rw, res, gbuf, isz, osz, gsz, inner_edge_offset, outer_edge_offset); /* Free the gradient index buffer. */ MEM_freeN(gbuf); @@ -1319,76 +1319,75 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float DoubleEdgeMaskOperation::DoubleEdgeMaskOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - inputInnerMask_ = nullptr; - inputOuterMask_ = nullptr; - adjacentOnly_ = false; - keepInside_ = false; + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + input_inner_mask_ = nullptr; + input_outer_mask_ = nullptr; + adjacent_only_ = false; + keep_inside_ = false; this->flags.complex = true; is_output_rendered_ = false; } -bool DoubleEdgeMaskOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool DoubleEdgeMaskOperation::determine_depending_area_of_interest( + rcti * /*input*/, ReadBufferOperation *read_operation, rcti *output) { - if (cachedInstance_ == nullptr) { - rcti newInput; - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + if (cached_instance_ == nullptr) { + rcti new_input; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } return false; } -void DoubleEdgeMaskOperation::initExecution() +void DoubleEdgeMaskOperation::init_execution() { - inputInnerMask_ = this->getInputSocketReader(0); - inputOuterMask_ = this->getInputSocketReader(1); - initMutex(); - cachedInstance_ = nullptr; + input_inner_mask_ = this->get_input_socket_reader(0); + input_outer_mask_ = this->get_input_socket_reader(1); + init_mutex(); + cached_instance_ = nullptr; } -void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect) +void *DoubleEdgeMaskOperation::initialize_tile_data(rcti *rect) { - if (cachedInstance_) { - return cachedInstance_; + if (cached_instance_) { + return cached_instance_; } - lockMutex(); - 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(), + lock_mutex(); + if (cached_instance_ == nullptr) { + MemoryBuffer *inner_mask = (MemoryBuffer *)input_inner_mask_->initialize_tile_data(rect); + MemoryBuffer *outer_mask = (MemoryBuffer *)input_outer_mask_->initialize_tile_data(rect); + float *data = (float *)MEM_mallocN(sizeof(float) * this->get_width() * this->get_height(), __func__); - float *imask = innerMask->getBuffer(); - float *omask = outerMask->getBuffer(); - doDoubleEdgeMask(imask, omask, data); - cachedInstance_ = data; + float *imask = inner_mask->get_buffer(); + float *omask = outer_mask->get_buffer(); + do_double_edge_mask(imask, omask, data); + cached_instance_ = data; } - unlockMutex(); - return cachedInstance_; + unlock_mutex(); + return cached_instance_; } -void DoubleEdgeMaskOperation::executePixel(float output[4], int x, int y, void *data) +void DoubleEdgeMaskOperation::execute_pixel(float output[4], int x, int y, void *data) { float *buffer = (float *)data; - int index = (y * this->getWidth() + x); + int index = (y * this->get_width() + x); output[0] = buffer[index]; } -void DoubleEdgeMaskOperation::deinitExecution() +void DoubleEdgeMaskOperation::deinit_execution() { - inputInnerMask_ = nullptr; - inputOuterMask_ = nullptr; - deinitMutex(); - if (cachedInstance_) { - MEM_freeN(cachedInstance_); - cachedInstance_ = nullptr; + input_inner_mask_ = nullptr; + input_outer_mask_ = nullptr; + deinit_mutex(); + if (cached_instance_) { + MEM_freeN(cached_instance_); + cached_instance_ = nullptr; } } @@ -1412,11 +1411,11 @@ void DoubleEdgeMaskOperation::update_memory_buffer(MemoryBuffer *output, MemoryBuffer *outer_mask = input_outer_mask->is_a_single_elem() ? input_outer_mask->inflate() : input_outer_mask; - BLI_assert(output->getWidth() == this->getWidth()); - BLI_assert(output->getHeight() == this->getHeight()); + BLI_assert(output->get_width() == this->get_width()); + BLI_assert(output->get_height() == this->get_height()); /* TODO(manzanilla): Once tiled implementation is removed, use execution system to run * multi-threaded where possible. */ - doDoubleEdgeMask(inner_mask->getBuffer(), outer_mask->getBuffer(), output->getBuffer()); + do_double_edge_mask(inner_mask->get_buffer(), outer_mask->get_buffer(), output->get_buffer()); is_output_rendered_ = true; if (inner_mask != input_inner_mask) { diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h index 29cb40c29af..f2086d9ebd4 100644 --- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h +++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h @@ -25,50 +25,50 @@ namespace blender::compositor { class DoubleEdgeMaskOperation : public NodeOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputOuterMask_; - SocketReader *inputInnerMask_; - bool adjacentOnly_; - bool keepInside_; + SocketReader *input_outer_mask_; + SocketReader *input_inner_mask_; + bool adjacent_only_; + bool keep_inside_; /* TODO(manzanilla): To be removed with tiled implementation. */ - float *cachedInstance_; + float *cached_instance_; bool is_output_rendered_; public: DoubleEdgeMaskOperation(); - void doDoubleEdgeMask(float *imask, float *omask, float *res); + void do_double_edge_mask(float *imask, float *omask, float *res); /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void setAdjecentOnly(bool adjacentOnly) + void set_adjecent_only(bool adjacent_only) { - adjacentOnly_ = adjacentOnly; + adjacent_only_ = adjacent_only; } - void setKeepInside(bool keepInside) + void set_keep_inside(bool keep_inside) { - keepInside_ = keepInside; + keep_inside_ = keep_inside; } 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 57cd3cb1423..19497c38131 100644 --- a/source/blender/compositor/operations/COM_EllipseMaskOperation.cc +++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.cc @@ -22,75 +22,75 @@ namespace blender::compositor { EllipseMaskOperation::EllipseMaskOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - inputMask_ = nullptr; - inputValue_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + input_mask_ = nullptr; + input_value_ = nullptr; cosine_ = 0.0f; sine_ = 0.0f; } -void EllipseMaskOperation::initExecution() +void EllipseMaskOperation::init_execution() { - inputMask_ = this->getInputSocketReader(0); - inputValue_ = this->getInputSocketReader(1); + input_mask_ = this->get_input_socket_reader(0); + input_value_ = this->get_input_socket_reader(1); const double rad = (double)data_->rotation; cosine_ = cos(rad); sine_ = sin(rad); - aspectRatio_ = ((float)this->getWidth()) / this->getHeight(); + aspect_ratio_ = ((float)this->get_width()) / this->get_height(); } -void EllipseMaskOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void EllipseMaskOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputMask[4]; - float inputValue[4]; + float input_mask[4]; + float input_value[4]; - float rx = x / this->getWidth(); - float ry = y / this->getHeight(); + float rx = x / this->get_width(); + float ry = y / this->get_height(); - const float dy = (ry - data_->y) / aspectRatio_; + const float dy = (ry - data_->y) / aspect_ratio_; const float dx = rx - data_->x; rx = data_->x + (cosine_ * dx + sine_ * dy); ry = data_->y + (-sine_ * dx + cosine_ * dy); - inputMask_->readSampled(inputMask, x, y, sampler); - inputValue_->readSampled(inputValue, x, y, sampler); + input_mask_->read_sampled(input_mask, x, y, sampler); + input_value_->read_sampled(input_value, x, y, sampler); - const float halfHeight = (data_->height) / 2.0f; - const float halfWidth = data_->width / 2.0f; + const float half_height = (data_->height) / 2.0f; + const float half_width = data_->width / 2.0f; float sx = rx - data_->x; sx *= sx; - const float tx = halfWidth * halfWidth; + const float tx = half_width * half_width; float sy = ry - data_->y; sy *= sy; - const float ty = halfHeight * halfHeight; + const float ty = half_height * half_height; bool inside = ((sx / tx) + (sy / ty)) < 1.0f; - switch (maskType_) { + switch (mask_type_) { case CMP_NODE_MASKTYPE_ADD: if (inside) { - output[0] = MAX2(inputMask[0], inputValue[0]); + output[0] = MAX2(input_mask[0], input_value[0]); } else { - output[0] = inputMask[0]; + output[0] = input_mask[0]; } break; case CMP_NODE_MASKTYPE_SUBTRACT: if (inside) { - output[0] = inputMask[0] - inputValue[0]; + output[0] = input_mask[0] - input_value[0]; CLAMP(output[0], 0, 1); } else { - output[0] = inputMask[0]; + output[0] = input_mask[0]; } break; case CMP_NODE_MASKTYPE_MULTIPLY: if (inside) { - output[0] = inputMask[0] * inputValue[0]; + output[0] = input_mask[0] * input_value[0]; } else { output[0] = 0; @@ -98,15 +98,15 @@ void EllipseMaskOperation::executePixelSampled(float output[4], break; case CMP_NODE_MASKTYPE_NOT: if (inside) { - if (inputMask[0] > 0.0f) { + if (input_mask[0] > 0.0f) { output[0] = 0; } else { - output[0] = inputValue[0]; + output[0] = input_value[0]; } } else { - output[0] = inputMask[0]; + output[0] = input_mask[0]; } break; } @@ -117,7 +117,7 @@ void EllipseMaskOperation::update_memory_buffer_partial(MemoryBuffer *output, Span inputs) { MaskFunc mask_func; - switch (maskType_) { + switch (mask_type_) { 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]; @@ -152,15 +152,15 @@ void EllipseMaskOperation::apply_mask(MemoryBuffer *output, { const MemoryBuffer *input_mask = inputs[0]; const MemoryBuffer *input_value = inputs[1]; - const float op_w = this->getWidth(); - const float op_h = this->getHeight(); + const float op_w = this->get_width(); + const float op_h = this->get_height(); 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 - data_->y) / aspectRatio_; + const float dy = (op_ry - data_->y) / aspect_ratio_; 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); @@ -183,10 +183,10 @@ void EllipseMaskOperation::apply_mask(MemoryBuffer *output, } } -void EllipseMaskOperation::deinitExecution() +void EllipseMaskOperation::deinit_execution() { - inputMask_ = nullptr; - inputValue_ = nullptr; + input_mask_ = nullptr; + input_value_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_EllipseMaskOperation.h b/source/blender/compositor/operations/COM_EllipseMaskOperation.h index ec6fb4624f7..7a6f96ab1b1 100644 --- a/source/blender/compositor/operations/COM_EllipseMaskOperation.h +++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.h @@ -27,15 +27,15 @@ class EllipseMaskOperation : public MultiThreadedOperation { using MaskFunc = std::function; /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputMask_; - SocketReader *inputValue_; + SocketReader *input_mask_; + SocketReader *input_value_; float sine_; float cosine_; - float aspectRatio_; - int maskType_; + float aspect_ratio_; + int mask_type_; NodeEllipseMask *data_; @@ -45,26 +45,26 @@ class EllipseMaskOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setData(NodeEllipseMask *data) + void set_data(NodeEllipseMask *data) { data_ = data; } - void setMaskType(int maskType) + void set_mask_type(int mask_type) { - maskType_ = maskType; + mask_type_ = mask_type; } 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 b1843a225e0..e39db9e06eb 100644 --- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cc +++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cc @@ -27,24 +27,24 @@ FastGaussianBlurOperation::FastGaussianBlurOperation() : BlurBaseOperation(DataT iirgaus_ = nullptr; } -void FastGaussianBlurOperation::executePixel(float output[4], int x, int y, void *data) +void FastGaussianBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { - MemoryBuffer *newData = (MemoryBuffer *)data; - newData->read(output, x, y); + MemoryBuffer *new_data = (MemoryBuffer *)data; + new_data->read(output, x, y); } -bool FastGaussianBlurOperation::determineDependingAreaOfInterest( - rcti * /*input*/, ReadBufferOperation *readOperation, rcti *output) +bool FastGaussianBlurOperation::determine_depending_area_of_interest( + rcti * /*input*/, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; - rcti sizeInput; - sizeInput.xmin = 0; - sizeInput.ymin = 0; - sizeInput.xmax = 5; - sizeInput.ymax = 5; - - NodeOperation *operation = this->getInputOperation(1); - if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) { + rcti new_input; + rcti size_input; + size_input.xmin = 0; + size_input.ymin = 0; + size_input.xmax = 5; + size_input.ymax = 5; + + NodeOperation *operation = this->get_input_operation(1); + if (operation->determine_depending_area_of_interest(&size_input, read_operation, output)) { return true; } @@ -52,12 +52,12 @@ bool FastGaussianBlurOperation::determineDependingAreaOfInterest( return false; } - newInput.xmin = 0; - newInput.ymin = 0; - newInput.xmax = this->getWidth(); - newInput.ymax = this->getHeight(); + new_input.xmin = 0; + new_input.ymin = 0; + new_input.xmax = this->get_width(); + new_input.ymax = this->get_height(); - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void FastGaussianBlurOperation::init_data() @@ -67,28 +67,28 @@ void FastGaussianBlurOperation::init_data() sy_ = data_.sizey * size_ / 2.0f; } -void FastGaussianBlurOperation::initExecution() +void FastGaussianBlurOperation::init_execution() { - BlurBaseOperation::initExecution(); - BlurBaseOperation::initMutex(); + BlurBaseOperation::init_execution(); + BlurBaseOperation::init_mutex(); } -void FastGaussianBlurOperation::deinitExecution() +void FastGaussianBlurOperation::deinit_execution() { if (iirgaus_) { delete iirgaus_; iirgaus_ = nullptr; } - BlurBaseOperation::deinitMutex(); + BlurBaseOperation::deinit_mutex(); } -void *FastGaussianBlurOperation::initializeTileData(rcti *rect) +void *FastGaussianBlurOperation::initialize_tile_data(rcti *rect) { - lockMutex(); + lock_mutex(); if (!iirgaus_) { - MemoryBuffer *newBuf = (MemoryBuffer *)inputProgram_->initializeTileData(rect); - MemoryBuffer *copy = new MemoryBuffer(*newBuf); - updateSize(); + MemoryBuffer *new_buf = (MemoryBuffer *)input_program_->initialize_tile_data(rect); + MemoryBuffer *copy = new MemoryBuffer(*new_buf); + update_size(); int c; sx_ = data_.sizex * size_ / 2.0f; @@ -113,7 +113,7 @@ void *FastGaussianBlurOperation::initializeTileData(rcti *rect) } iirgaus_ = copy; } - unlockMutex(); + unlock_mutex(); return iirgaus_; } @@ -125,11 +125,11 @@ void FastGaussianBlurOperation::IIR_gauss(MemoryBuffer *src, BLI_assert(!src->is_a_single_elem()); double q, q2, sc, cf[4], tsM[9], tsu[3], tsv[3]; double *X, *Y, *W; - const unsigned int src_width = src->getWidth(); - const unsigned int src_height = src->getHeight(); + const unsigned int src_width = src->get_width(); + const unsigned int src_height = src->get_height(); unsigned int x, y, sz; unsigned int i; - float *buffer = src->getBuffer(); + float *buffer = src->get_buffer(); const uint8_t num_channels = src->get_num_channels(); /* <0.5 not valid, though can have a possibly useful sort of sharpening effect. */ @@ -290,7 +290,7 @@ void FastGaussianBlurOperation::update_memory_buffer_started(MemoryBuffer *outpu image = output; } else { - image = new MemoryBuffer(getOutputSocket()->getDataType(), area); + image = new MemoryBuffer(get_output_socket()->get_data_type(), area); } image->copy_from(input, area); @@ -320,8 +320,8 @@ void FastGaussianBlurOperation::update_memory_buffer_started(MemoryBuffer *outpu FastGaussianBlurValueOperation::FastGaussianBlurValueOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); iirgaus_ = nullptr; inputprogram_ = nullptr; sigma_ = 1.0f; @@ -329,56 +329,56 @@ FastGaussianBlurValueOperation::FastGaussianBlurValueOperation() flags.complex = true; } -void FastGaussianBlurValueOperation::executePixel(float output[4], int x, int y, void *data) +void FastGaussianBlurValueOperation::execute_pixel(float output[4], int x, int y, void *data) { - MemoryBuffer *newData = (MemoryBuffer *)data; - newData->read(output, x, y); + MemoryBuffer *new_data = (MemoryBuffer *)data; + new_data->read(output, x, y); } -bool FastGaussianBlurValueOperation::determineDependingAreaOfInterest( - rcti * /*input*/, ReadBufferOperation *readOperation, rcti *output) +bool FastGaussianBlurValueOperation::determine_depending_area_of_interest( + rcti * /*input*/, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; if (iirgaus_) { return false; } - newInput.xmin = 0; - newInput.ymin = 0; - newInput.xmax = this->getWidth(); - newInput.ymax = this->getHeight(); + new_input.xmin = 0; + new_input.ymin = 0; + new_input.xmax = this->get_width(); + new_input.ymax = this->get_height(); - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } -void FastGaussianBlurValueOperation::initExecution() +void FastGaussianBlurValueOperation::init_execution() { - inputprogram_ = getInputSocketReader(0); - initMutex(); + inputprogram_ = get_input_socket_reader(0); + init_mutex(); } -void FastGaussianBlurValueOperation::deinitExecution() +void FastGaussianBlurValueOperation::deinit_execution() { if (iirgaus_) { delete iirgaus_; iirgaus_ = nullptr; } - deinitMutex(); + deinit_mutex(); } -void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect) +void *FastGaussianBlurValueOperation::initialize_tile_data(rcti *rect) { - lockMutex(); + lock_mutex(); if (!iirgaus_) { - MemoryBuffer *newBuf = (MemoryBuffer *)inputprogram_->initializeTileData(rect); - MemoryBuffer *copy = new MemoryBuffer(*newBuf); + MemoryBuffer *new_buf = (MemoryBuffer *)inputprogram_->initialize_tile_data(rect); + MemoryBuffer *copy = new MemoryBuffer(*new_buf); FastGaussianBlurOperation::IIR_gauss(copy, sigma_, 0, 3); if (overlay_ == FAST_GAUSS_OVERLAY_MIN) { - float *src = newBuf->getBuffer(); - float *dst = copy->getBuffer(); - for (int i = copy->getWidth() * copy->getHeight(); i != 0; + float *src = new_buf->get_buffer(); + float *dst = copy->get_buffer(); + for (int i = copy->get_width() * copy->get_height(); i != 0; i--, src += COM_DATA_TYPE_VALUE_CHANNELS, dst += COM_DATA_TYPE_VALUE_CHANNELS) { if (*src < *dst) { *dst = *src; @@ -386,9 +386,9 @@ void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect) } } else if (overlay_ == FAST_GAUSS_OVERLAY_MAX) { - float *src = newBuf->getBuffer(); - float *dst = copy->getBuffer(); - for (int i = copy->getWidth() * copy->getHeight(); i != 0; + float *src = new_buf->get_buffer(); + float *dst = copy->get_buffer(); + for (int i = copy->get_width() * copy->get_height(); i != 0; i--, src += COM_DATA_TYPE_VALUE_CHANNELS, dst += COM_DATA_TYPE_VALUE_CHANNELS) { if (*src > *dst) { *dst = *src; @@ -398,7 +398,7 @@ void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect) iirgaus_ = copy; } - unlockMutex(); + unlock_mutex(); return iirgaus_; } diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h index 2a0ed078612..8d33e5ef244 100644 --- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h +++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h @@ -31,16 +31,16 @@ class FastGaussianBlurOperation : public BlurBaseOperation { public: FastGaussianBlurOperation(); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixel(float output[4], int x, int y, void *data) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel(float output[4], int x, int y, void *data) override; static void IIR_gauss(MemoryBuffer *src, float sigma, unsigned int channel, unsigned int xy); - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; void init_data() override; - void deinitExecution() override; - void initExecution() override; + void deinit_execution() override; + void init_execution() override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_started(MemoryBuffer *output, @@ -73,21 +73,21 @@ class FastGaussianBlurValueOperation : public MultiThreadedOperation { public: FastGaussianBlurValueOperation(); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixel(float output[4], int x, int y, void *data) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void *initializeTileData(rcti *rect) override; - void deinitExecution() override; - void initExecution() override; - void setSigma(float sigma) + void *initialize_tile_data(rcti *rect) override; + void deinit_execution() override; + void init_execution() override; + void set_sigma(float sigma) { sigma_ = sigma; } /* used for DOF blurring ZBuffer */ - void setOverlay(int overlay) + void set_overlay(int overlay) { overlay_ = overlay; } diff --git a/source/blender/compositor/operations/COM_FlipOperation.cc b/source/blender/compositor/operations/COM_FlipOperation.cc index ae2aa21131a..7ca12a504b7 100644 --- a/source/blender/compositor/operations/COM_FlipOperation.cc +++ b/source/blender/compositor/operations/COM_FlipOperation.cc @@ -22,57 +22,57 @@ namespace blender::compositor { FlipOperation::FlipOperation() { - this->addInputSocket(DataType::Color, ResizeMode::None); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color, ResizeMode::None); + this->add_output_socket(DataType::Color); this->set_canvas_input_index(0); - inputOperation_ = nullptr; - flipX_ = true; - flipY_ = false; + input_operation_ = nullptr; + flip_x_ = true; + flip_y_ = false; } -void FlipOperation::initExecution() +void FlipOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); + input_operation_ = this->get_input_socket_reader(0); } -void FlipOperation::deinitExecution() +void FlipOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = nullptr; } -void FlipOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void FlipOperation::execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) { - float nx = flipX_ ? ((int)this->getWidth() - 1) - x : x; - float ny = flipY_ ? ((int)this->getHeight() - 1) - y : y; + float nx = flip_x_ ? ((int)this->get_width() - 1) - x : x; + float ny = flip_y_ ? ((int)this->get_height() - 1) - y : y; - inputOperation_->readSampled(output, nx, ny, sampler); + input_operation_->read_sampled(output, nx, ny, sampler); } -bool FlipOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool FlipOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; + rcti new_input; - if (flipX_) { - const int w = (int)this->getWidth() - 1; - newInput.xmax = (w - input->xmin) + 1; - newInput.xmin = (w - input->xmax) - 1; + if (flip_x_) { + const int w = (int)this->get_width() - 1; + new_input.xmax = (w - input->xmin) + 1; + new_input.xmin = (w - input->xmax) - 1; } else { - newInput.xmin = input->xmin; - newInput.xmax = input->xmax; + new_input.xmin = input->xmin; + new_input.xmax = input->xmax; } - if (flipY_) { - const int h = (int)this->getHeight() - 1; - newInput.ymax = (h - input->ymin) + 1; - newInput.ymin = (h - input->ymax) - 1; + if (flip_y_) { + const int h = (int)this->get_height() - 1; + new_input.ymax = (h - input->ymin) + 1; + new_input.ymin = (h - input->ymax) - 1; } else { - newInput.ymin = input->ymin; - newInput.ymax = input->ymax; + new_input.ymin = input->ymin; + new_input.ymax = input->ymax; } - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void FlipOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -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 (flipX_) { + if (flip_x_) { 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 (flipY_) { + if (flip_y_) { 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,8 +99,8 @@ void FlipOperation::get_area_of_interest(const int input_idx, { BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); - if (flipX_) { - const int w = (int)this->getWidth() - 1; + if (flip_x_) { + const int w = (int)this->get_width() - 1; r_input_area.xmax = (w - output_area.xmin) + 1; r_input_area.xmin = (w - output_area.xmax) + 1; } @@ -108,8 +108,8 @@ 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 (flipY_) { - const int h = (int)this->getHeight() - 1; + if (flip_y_) { + const int h = (int)this->get_height() - 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 it = output->iterate_with({}, area); !it.is_end(); ++it) { - const int nx = flipX_ ? ((int)this->getWidth() - 1) - it.x : it.x; - const int ny = flipY_ ? ((int)this->getHeight() - 1) - it.y : it.y; + const int nx = flip_x_ ? ((int)this->get_width() - 1) - it.x : it.x; + const int ny = flip_y_ ? ((int)this->get_height() - 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 3310819051a..001fd652740 100644 --- a/source/blender/compositor/operations/COM_FlipOperation.h +++ b/source/blender/compositor/operations/COM_FlipOperation.h @@ -24,26 +24,26 @@ namespace blender::compositor { class FlipOperation : public MultiThreadedOperation { private: - SocketReader *inputOperation_; - bool flipX_; - bool flipY_; + SocketReader *input_operation_; + bool flip_x_; + bool flip_y_; public: FlipOperation(); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void setFlipX(bool flipX) { - flipX_ = flipX; + flip_x_ = flipX; } void setFlipY(bool flipY) { - flipY_ = flipY; + flip_y_ = 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 9a51c789943..0271e57b2c4 100644 --- a/source/blender/compositor/operations/COM_GammaCorrectOperation.cc +++ b/source/blender/compositor/operations/COM_GammaCorrectOperation.cc @@ -22,39 +22,39 @@ namespace blender::compositor { GammaCorrectOperation::GammaCorrectOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); - inputProgram_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); + input_program_ = nullptr; flags.can_be_constant = true; } -void GammaCorrectOperation::initExecution() +void GammaCorrectOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); + input_program_ = this->get_input_socket_reader(0); } -void GammaCorrectOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void GammaCorrectOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputProgram_->readSampled(inputColor, x, y, sampler); - if (inputColor[3] > 0.0f) { - inputColor[0] /= inputColor[3]; - inputColor[1] /= inputColor[3]; - inputColor[2] /= inputColor[3]; + float input_color[4]; + input_program_->read_sampled(input_color, x, y, sampler); + if (input_color[3] > 0.0f) { + input_color[0] /= input_color[3]; + input_color[1] /= input_color[3]; + input_color[2] /= input_color[3]; } /* check for negative to avoid nan's */ - output[0] = inputColor[0] > 0.0f ? inputColor[0] * inputColor[0] : 0.0f; - output[1] = inputColor[1] > 0.0f ? inputColor[1] * inputColor[1] : 0.0f; - output[2] = inputColor[2] > 0.0f ? inputColor[2] * inputColor[2] : 0.0f; - output[3] = inputColor[3]; - - if (inputColor[3] > 0.0f) { - output[0] *= inputColor[3]; - output[1] *= inputColor[3]; - output[2] *= inputColor[3]; + output[0] = input_color[0] > 0.0f ? input_color[0] * input_color[0] : 0.0f; + output[1] = input_color[1] > 0.0f ? input_color[1] * input_color[1] : 0.0f; + output[2] = input_color[2] > 0.0f ? input_color[2] * input_color[2] : 0.0f; + output[3] = input_color[3]; + + if (input_color[3] > 0.0f) { + output[0] *= input_color[3]; + output[1] *= input_color[3]; + output[2] *= input_color[3]; } } @@ -86,46 +86,46 @@ void GammaCorrectOperation::update_memory_buffer_partial(MemoryBuffer *output, } } -void GammaCorrectOperation::deinitExecution() +void GammaCorrectOperation::deinit_execution() { - inputProgram_ = nullptr; + input_program_ = nullptr; } GammaUncorrectOperation::GammaUncorrectOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); - inputProgram_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); + input_program_ = nullptr; flags.can_be_constant = true; } -void GammaUncorrectOperation::initExecution() +void GammaUncorrectOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); + input_program_ = this->get_input_socket_reader(0); } -void GammaUncorrectOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void GammaUncorrectOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor[4]; - inputProgram_->readSampled(inputColor, x, y, sampler); + float input_color[4]; + input_program_->read_sampled(input_color, x, y, sampler); - if (inputColor[3] > 0.0f) { - inputColor[0] /= inputColor[3]; - inputColor[1] /= inputColor[3]; - inputColor[2] /= inputColor[3]; + if (input_color[3] > 0.0f) { + input_color[0] /= input_color[3]; + input_color[1] /= input_color[3]; + input_color[2] /= input_color[3]; } - output[0] = inputColor[0] > 0.0f ? sqrtf(inputColor[0]) : 0.0f; - output[1] = inputColor[1] > 0.0f ? sqrtf(inputColor[1]) : 0.0f; - output[2] = inputColor[2] > 0.0f ? sqrtf(inputColor[2]) : 0.0f; - output[3] = inputColor[3]; + output[0] = input_color[0] > 0.0f ? sqrtf(input_color[0]) : 0.0f; + output[1] = input_color[1] > 0.0f ? sqrtf(input_color[1]) : 0.0f; + output[2] = input_color[2] > 0.0f ? sqrtf(input_color[2]) : 0.0f; + output[3] = input_color[3]; - if (inputColor[3] > 0.0f) { - output[0] *= inputColor[3]; - output[1] *= inputColor[3]; - output[2] *= inputColor[3]; + if (input_color[3] > 0.0f) { + output[0] *= input_color[3]; + output[1] *= input_color[3]; + output[2] *= input_color[3]; } } @@ -156,9 +156,9 @@ void GammaUncorrectOperation::update_memory_buffer_partial(MemoryBuffer *output, } } -void GammaUncorrectOperation::deinitExecution() +void GammaUncorrectOperation::deinit_execution() { - inputProgram_ = nullptr; + input_program_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GammaCorrectOperation.h b/source/blender/compositor/operations/COM_GammaCorrectOperation.h index 5c6307fe6d0..e13d96184ad 100644 --- a/source/blender/compositor/operations/COM_GammaCorrectOperation.h +++ b/source/blender/compositor/operations/COM_GammaCorrectOperation.h @@ -25,9 +25,9 @@ namespace blender::compositor { class GammaCorrectOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; public: GammaCorrectOperation(); @@ -35,17 +35,17 @@ class GammaCorrectOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -55,9 +55,9 @@ class GammaCorrectOperation : public MultiThreadedOperation { class GammaUncorrectOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; public: GammaUncorrectOperation(); @@ -65,17 +65,17 @@ class GammaUncorrectOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_GammaOperation.cc b/source/blender/compositor/operations/COM_GammaOperation.cc index a809b16f523..fb8f18bcc28 100644 --- a/source/blender/compositor/operations/COM_GammaOperation.cc +++ b/source/blender/compositor/operations/COM_GammaOperation.cc @@ -22,33 +22,33 @@ namespace blender::compositor { GammaOperation::GammaOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); - inputProgram_ = nullptr; - inputGammaProgram_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); + input_program_ = nullptr; + input_gamma_program_ = nullptr; flags.can_be_constant = true; } -void GammaOperation::initExecution() +void GammaOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); - inputGammaProgram_ = this->getInputSocketReader(1); + input_program_ = this->get_input_socket_reader(0); + input_gamma_program_ = this->get_input_socket_reader(1); } -void GammaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void GammaOperation::execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) { - float inputValue[4]; - float inputGamma[4]; + float input_value[4]; + float input_gamma[4]; - inputProgram_->readSampled(inputValue, x, y, sampler); - inputGammaProgram_->readSampled(inputGamma, x, y, sampler); - const float gamma = inputGamma[0]; + input_program_->read_sampled(input_value, x, y, sampler); + input_gamma_program_->read_sampled(input_gamma, x, y, sampler); + const float gamma = input_gamma[0]; /* check for negative to avoid nan's */ - output[0] = inputValue[0] > 0.0f ? powf(inputValue[0], gamma) : inputValue[0]; - output[1] = inputValue[1] > 0.0f ? powf(inputValue[1], gamma) : inputValue[1]; - output[2] = inputValue[2] > 0.0f ? powf(inputValue[2], gamma) : inputValue[2]; + output[0] = input_value[0] > 0.0f ? powf(input_value[0], gamma) : input_value[0]; + output[1] = input_value[1] > 0.0f ? powf(input_value[1], gamma) : input_value[1]; + output[2] = input_value[2] > 0.0f ? powf(input_value[2], gamma) : input_value[2]; - output[3] = inputValue[3]; + output[3] = input_value[3]; } void GammaOperation::update_memory_buffer_row(PixelCursor &p) @@ -65,10 +65,10 @@ void GammaOperation::update_memory_buffer_row(PixelCursor &p) } } -void GammaOperation::deinitExecution() +void GammaOperation::deinit_execution() { - inputProgram_ = nullptr; - inputGammaProgram_ = nullptr; + input_program_ = nullptr; + input_gamma_program_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GammaOperation.h b/source/blender/compositor/operations/COM_GammaOperation.h index 9b68a2c8a1b..d8703a0a19a 100644 --- a/source/blender/compositor/operations/COM_GammaOperation.h +++ b/source/blender/compositor/operations/COM_GammaOperation.h @@ -25,10 +25,10 @@ namespace blender::compositor { class GammaOperation : public MultiThreadedRowOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; - SocketReader *inputGammaProgram_; + SocketReader *input_program_; + SocketReader *input_gamma_program_; public: GammaOperation(); @@ -36,17 +36,17 @@ class GammaOperation : public MultiThreadedRowOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void update_memory_buffer_row(PixelCursor &p) override; }; diff --git a/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.cc b/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.cc index fa742775f24..1a8c000cdd8 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.cc @@ -39,18 +39,18 @@ void GaussianAlphaBlurBaseOperation::init_data() } } -void GaussianAlphaBlurBaseOperation::initExecution() +void GaussianAlphaBlurBaseOperation::init_execution() { - BlurBaseOperation::initExecution(); + BlurBaseOperation::init_execution(); if (execution_model_ == eExecutionModel::FullFrame) { gausstab_ = BlurBaseOperation::make_gausstab(rad_, filtersize_); distbuf_inv_ = BlurBaseOperation::make_dist_fac_inverse(rad_, filtersize_, falloff_); } } -void GaussianAlphaBlurBaseOperation::deinitExecution() +void GaussianAlphaBlurBaseOperation::deinit_execution() { - BlurBaseOperation::deinitExecution(); + BlurBaseOperation::deinit_execution(); if (gausstab_) { MEM_freeN(gausstab_); @@ -133,7 +133,7 @@ void GaussianAlphaBlurBaseOperation::update_memory_buffer_partial(MemoryBuffer * float value_max = finv_test(*it.in(0), do_invert); float distfacinv_max = 1.0f; /* 0 to 1 */ - const int step = QualityStepHelper::getStep(); + const int step = QualityStepHelper::get_step(); 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) + filtersize_; diff --git a/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.h b/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.h index 307d8b0dff5..0f83a67cef7 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.h +++ b/source/blender/compositor/operations/COM_GaussianAlphaBlurBaseOperation.h @@ -36,8 +36,8 @@ class GaussianAlphaBlurBaseOperation : public BlurBaseOperation { GaussianAlphaBlurBaseOperation(eDimension dim); virtual void init_data() override; - virtual void initExecution() override; - virtual void deinitExecution() override; + virtual void init_execution() override; + virtual void deinit_execution() override; void get_area_of_interest(const int input_idx, const rcti &output_area, @@ -49,11 +49,11 @@ class GaussianAlphaBlurBaseOperation : public BlurBaseOperation { /** * Set subtract for Dilate/Erode functionality */ - void setSubtract(bool subtract) + void set_subtract(bool subtract) { do_subtract_ = subtract; } - void setFalloff(int falloff) + void set_falloff(int falloff) { falloff_ = falloff; } diff --git a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cc index b854ea736b3..de0010fcb58 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cc @@ -25,22 +25,22 @@ GaussianAlphaXBlurOperation::GaussianAlphaXBlurOperation() { } -void *GaussianAlphaXBlurOperation::initializeTileData(rcti * /*rect*/) +void *GaussianAlphaXBlurOperation::initialize_tile_data(rcti * /*rect*/) { - lockMutex(); + lock_mutex(); if (!sizeavailable_) { - updateGauss(); + update_gauss(); } - void *buffer = getInputOperation(0)->initializeTileData(nullptr); - unlockMutex(); + void *buffer = get_input_operation(0)->initialize_tile_data(nullptr); + unlock_mutex(); return buffer; } -void GaussianAlphaXBlurOperation::initExecution() +void GaussianAlphaXBlurOperation::init_execution() { - GaussianAlphaBlurBaseOperation::initExecution(); + GaussianAlphaBlurBaseOperation::init_execution(); - initMutex(); + init_mutex(); if (sizeavailable_ && execution_model_ == eExecutionModel::Tiled) { float rad = max_ff(size_ * data_.sizex, 0.0f); @@ -51,10 +51,10 @@ void GaussianAlphaXBlurOperation::initExecution() } } -void GaussianAlphaXBlurOperation::updateGauss() +void GaussianAlphaXBlurOperation::update_gauss() { if (gausstab_ == nullptr) { - updateSize(); + update_size(); float rad = max_ff(size_ * data_.sizex, 0.0f); filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); @@ -62,7 +62,7 @@ void GaussianAlphaXBlurOperation::updateGauss() } if (distbuf_inv_ == nullptr) { - updateSize(); + update_size(); float rad = max_ff(size_ * data_.sizex, 0.0f); rad = min_ff(rad, MAX_GAUSSTAB_RADIUS); filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); @@ -76,23 +76,23 @@ BLI_INLINE float finv_test(const float f, const bool test) return (LIKELY(test == false)) ? f : 1.0f - f; } -void GaussianAlphaXBlurOperation::executePixel(float output[4], int x, int y, void *data) +void GaussianAlphaXBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { const bool do_invert = do_subtract_; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - float *buffer = inputBuffer->getBuffer(); - int bufferwidth = inputBuffer->getWidth(); - const rcti &input_rect = inputBuffer->get_rect(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + float *buffer = input_buffer->get_buffer(); + int bufferwidth = input_buffer->get_width(); + const rcti &input_rect = input_buffer->get_rect(); int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; - const rcti &rect = inputBuffer->get_rect(); + const rcti &rect = input_buffer->get_rect(); 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' *** */ - int step = getStep(); + int step = get_step(); int bufferindex = ((xmin - bufferstartx)) + ((ymin - bufferstarty) * bufferwidth); /* gauss */ @@ -135,9 +135,9 @@ void GaussianAlphaXBlurOperation::executePixel(float output[4], int x, int y, vo output[0] = finv_test(value_final, do_invert); } -void GaussianAlphaXBlurOperation::deinitExecution() +void GaussianAlphaXBlurOperation::deinit_execution() { - GaussianAlphaBlurBaseOperation::deinitExecution(); + GaussianAlphaBlurBaseOperation::deinit_execution(); if (gausstab_) { MEM_freeN(gausstab_); @@ -149,40 +149,40 @@ void GaussianAlphaXBlurOperation::deinitExecution() distbuf_inv_ = nullptr; } - deinitMutex(); + deinit_mutex(); } -bool GaussianAlphaXBlurOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool GaussianAlphaXBlurOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; #if 0 /* until we add size input */ - rcti sizeInput; - sizeInput.xmin = 0; - sizeInput.ymin = 0; - sizeInput.xmax = 5; - sizeInput.ymax = 5; - - NodeOperation *operation = this->getInputOperation(1); - if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) { + rcti size_input; + size_input.xmin = 0; + size_input.ymin = 0; + size_input.xmax = 5; + size_input.ymax = 5; + + NodeOperation *operation = this->get_input_operation(1); + if (operation->determine_depending_area_of_interest(&size_input, read_operation, output)) { return true; } else #endif { if (sizeavailable_ && gausstab_ != nullptr) { - newInput.xmax = input->xmax + filtersize_ + 1; - newInput.xmin = input->xmin - filtersize_ - 1; - newInput.ymax = input->ymax; - newInput.ymin = input->ymin; + new_input.xmax = input->xmax + filtersize_ + 1; + new_input.xmin = input->xmin - filtersize_ - 1; + new_input.ymax = input->ymax; + new_input.ymin = input->ymin; } else { - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; } - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } } diff --git a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h index 2a44c639665..31b4a582c4b 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h @@ -25,7 +25,7 @@ namespace blender::compositor { /* TODO(manzanilla): everything to be removed with tiled implementation except the constructor. */ class GaussianAlphaXBlurOperation : public GaussianAlphaBlurBaseOperation { private: - void updateGauss(); + void update_gauss(); public: GaussianAlphaXBlurOperation(); @@ -33,22 +33,22 @@ class GaussianAlphaXBlurOperation : public GaussianAlphaBlurBaseOperation { /** * \brief The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * \brief initialize the execution */ - void initExecution() override; + void init_execution() override; /** * \brief Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + void *initialize_tile_data(rcti *rect) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cc index eaf3abc18cd..90a80e6779a 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cc @@ -25,23 +25,23 @@ GaussianAlphaYBlurOperation::GaussianAlphaYBlurOperation() { } -void *GaussianAlphaYBlurOperation::initializeTileData(rcti * /*rect*/) +void *GaussianAlphaYBlurOperation::initialize_tile_data(rcti * /*rect*/) { - lockMutex(); + lock_mutex(); if (!sizeavailable_) { - updateGauss(); + update_gauss(); } - void *buffer = getInputOperation(0)->initializeTileData(nullptr); - unlockMutex(); + void *buffer = get_input_operation(0)->initialize_tile_data(nullptr); + unlock_mutex(); return buffer; } /* TODO(manzanilla): to be removed with tiled implementation. */ -void GaussianAlphaYBlurOperation::initExecution() +void GaussianAlphaYBlurOperation::init_execution() { - GaussianAlphaBlurBaseOperation::initExecution(); + GaussianAlphaBlurBaseOperation::init_execution(); - initMutex(); + init_mutex(); if (sizeavailable_ && execution_model_ == eExecutionModel::Tiled) { float rad = max_ff(size_ * data_.sizey, 0.0f); @@ -53,10 +53,10 @@ void GaussianAlphaYBlurOperation::initExecution() } /* TODO(manzanilla): to be removed with tiled implementation. */ -void GaussianAlphaYBlurOperation::updateGauss() +void GaussianAlphaYBlurOperation::update_gauss() { if (gausstab_ == nullptr) { - updateSize(); + update_size(); float rad = max_ff(size_ * data_.sizey, 0.0f); rad = min_ff(rad, MAX_GAUSSTAB_RADIUS); filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); @@ -65,7 +65,7 @@ void GaussianAlphaYBlurOperation::updateGauss() } if (distbuf_inv_ == nullptr) { - updateSize(); + update_size(); float rad = max_ff(size_ * data_.sizey, 0.0f); filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); @@ -78,13 +78,13 @@ BLI_INLINE float finv_test(const float f, const bool test) return (LIKELY(test == false)) ? f : 1.0f - f; } -void GaussianAlphaYBlurOperation::executePixel(float output[4], int x, int y, void *data) +void GaussianAlphaYBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { const bool do_invert = do_subtract_; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - const rcti &input_rect = inputBuffer->get_rect(); - float *buffer = inputBuffer->getBuffer(); - int bufferwidth = inputBuffer->getWidth(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + const rcti &input_rect = input_buffer->get_rect(); + float *buffer = input_buffer->get_buffer(); + int bufferwidth = input_buffer->get_width(); int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; @@ -93,7 +93,7 @@ void GaussianAlphaYBlurOperation::executePixel(float output[4], int x, int y, vo int ymax = min_ii(y + filtersize_ + 1, input_rect.ymax); /* *** this is the main part which is different to 'GaussianYBlurOperation' *** */ - int step = getStep(); + int step = get_step(); /* gauss */ float alpha_accum = 0.0f; @@ -136,9 +136,9 @@ void GaussianAlphaYBlurOperation::executePixel(float output[4], int x, int y, vo output[0] = finv_test(value_final, do_invert); } -void GaussianAlphaYBlurOperation::deinitExecution() +void GaussianAlphaYBlurOperation::deinit_execution() { - GaussianAlphaBlurBaseOperation::deinitExecution(); + GaussianAlphaBlurBaseOperation::deinit_execution(); if (gausstab_) { MEM_freeN(gausstab_); @@ -150,40 +150,40 @@ void GaussianAlphaYBlurOperation::deinitExecution() distbuf_inv_ = nullptr; } - deinitMutex(); + deinit_mutex(); } -bool GaussianAlphaYBlurOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool GaussianAlphaYBlurOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; #if 0 /* until we add size input */ - rcti sizeInput; - sizeInput.xmin = 0; - sizeInput.ymin = 0; - sizeInput.xmax = 5; - sizeInput.ymax = 5; - - NodeOperation *operation = this->getInputOperation(1); - if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) { + rcti size_input; + size_input.xmin = 0; + size_input.ymin = 0; + size_input.xmax = 5; + size_input.ymax = 5; + + NodeOperation *operation = this->get_input_operation(1); + if (operation->determine_depending_area_of_interest(&size_input, read_operation, output)) { return true; } else #endif { if (sizeavailable_ && gausstab_ != nullptr) { - newInput.xmax = input->xmax; - newInput.xmin = input->xmin; - newInput.ymax = input->ymax + filtersize_ + 1; - newInput.ymin = input->ymin - filtersize_ - 1; + new_input.xmax = input->xmax; + new_input.xmin = input->xmin; + new_input.ymax = input->ymax + filtersize_ + 1; + new_input.ymin = input->ymin - filtersize_ - 1; } else { - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; } - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } } diff --git a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h index ef01f7e0f92..28dc289c445 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h @@ -25,7 +25,7 @@ namespace blender::compositor { /* TODO(manzanilla): everything to be removed with tiled implementation except the constructor. */ class GaussianAlphaYBlurOperation : public GaussianAlphaBlurBaseOperation { private: - void updateGauss(); + void update_gauss(); public: GaussianAlphaYBlurOperation(); @@ -33,22 +33,22 @@ class GaussianAlphaYBlurOperation : public GaussianAlphaBlurBaseOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * \brief initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + void *initialize_tile_data(rcti *rect) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.cc b/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.cc index e6d3b3d4424..9f4ee376fbf 100644 --- a/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.cc @@ -42,9 +42,9 @@ void GaussianBlurBaseOperation::init_data() } } -void GaussianBlurBaseOperation::initExecution() +void GaussianBlurBaseOperation::init_execution() { - BlurBaseOperation::initExecution(); + BlurBaseOperation::init_execution(); if (execution_model_ == eExecutionModel::FullFrame) { gausstab_ = BlurBaseOperation::make_gausstab(rad_, filtersize_); #ifdef BLI_HAVE_SSE2 @@ -53,9 +53,9 @@ void GaussianBlurBaseOperation::initExecution() } } -void GaussianBlurBaseOperation::deinitExecution() +void GaussianBlurBaseOperation::deinit_execution() { - BlurBaseOperation::deinitExecution(); + BlurBaseOperation::deinit_execution(); if (gausstab_) { MEM_freeN(gausstab_); @@ -126,7 +126,7 @@ void GaussianBlurBaseOperation::update_memory_buffer_partial(MemoryBuffer *outpu float ATTR_ALIGN(16) color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; float multiplier_accum = 0.0f; - const int step = QualityStepHelper::getStep(); + const int step = QualityStepHelper::get_step(); 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) + filtersize_; diff --git a/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.h b/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.h index 0e3a86e63ec..31b045241f8 100644 --- a/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.h +++ b/source/blender/compositor/operations/COM_GaussianBlurBaseOperation.h @@ -36,8 +36,8 @@ class GaussianBlurBaseOperation : public BlurBaseOperation { GaussianBlurBaseOperation(eDimension dim); virtual void init_data() override; - virtual void initExecution() override; - virtual void deinitExecution() override; + virtual void init_execution() override; + virtual void deinit_execution() override; void get_area_of_interest(const int input_idx, const rcti &output_area, diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cc index b5d6aa69423..db5f9c7c35d 100644 --- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cc @@ -27,25 +27,25 @@ GaussianBokehBlurOperation::GaussianBokehBlurOperation() : BlurBaseOperation(Dat gausstab_ = nullptr; } -void *GaussianBokehBlurOperation::initializeTileData(rcti * /*rect*/) +void *GaussianBokehBlurOperation::initialize_tile_data(rcti * /*rect*/) { - lockMutex(); + lock_mutex(); if (!sizeavailable_) { - updateGauss(); + update_gauss(); } - void *buffer = getInputOperation(0)->initializeTileData(nullptr); - unlockMutex(); + void *buffer = get_input_operation(0)->initialize_tile_data(nullptr); + unlock_mutex(); return buffer; } void GaussianBokehBlurOperation::init_data() { BlurBaseOperation::init_data(); - const float width = this->getWidth(); - const float height = this->getHeight(); + const float width = this->get_width(); + const float height = this->get_height(); if (!sizeavailable_) { - updateSize(); + update_size(); } radxf_ = size_ * (float)data_.sizex; @@ -59,18 +59,18 @@ void GaussianBokehBlurOperation::init_data() rady_ = ceil(radyf_); } -void GaussianBokehBlurOperation::initExecution() +void GaussianBokehBlurOperation::init_execution() { - BlurBaseOperation::initExecution(); + BlurBaseOperation::init_execution(); - initMutex(); + init_mutex(); if (sizeavailable_) { - updateGauss(); + update_gauss(); } } -void GaussianBokehBlurOperation::updateGauss() +void GaussianBokehBlurOperation::update_gauss() { if (gausstab_ == nullptr) { int ddwidth = 2 * radx_ + 1; @@ -109,18 +109,18 @@ void GaussianBokehBlurOperation::updateGauss() } } -void GaussianBokehBlurOperation::executePixel(float output[4], int x, int y, void *data) +void GaussianBokehBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { - float tempColor[4]; - tempColor[0] = 0; - tempColor[1] = 0; - tempColor[2] = 0; - tempColor[3] = 0; + float temp_color[4]; + temp_color[0] = 0; + temp_color[1] = 0; + temp_color[2] = 0; + temp_color[3] = 0; float multiplier_accum = 0; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - float *buffer = inputBuffer->getBuffer(); - int bufferwidth = inputBuffer->getWidth(); - const rcti &input_rect = inputBuffer->get_rect(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + float *buffer = input_buffer->get_buffer(); + int bufferwidth = input_buffer->get_width(); + const rcti &input_rect = input_buffer->get_rect(); int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; @@ -130,67 +130,68 @@ void GaussianBokehBlurOperation::executePixel(float output[4], int x, int y, voi 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 + radx_); - const int mulConst = (radx_ * 2 + 1); + int step = QualityStepHelper::get_step(); + int offsetadd = QualityStepHelper::get_offset_add(); + const int add_const = (xmin - x + radx_); + const int mul_const = (radx_ * 2 + 1); for (int ny = ymin; ny < ymax; ny += step) { - index = ((ny - y) + rady_) * mulConst + addConst; + index = ((ny - y) + rady_) * mul_const + add_const; int bufferindex = ((xmin - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth); for (int nx = xmin; nx < xmax; nx += step) { const float multiplier = gausstab_[index]; - madd_v4_v4fl(tempColor, &buffer[bufferindex], multiplier); + madd_v4_v4fl(temp_color, &buffer[bufferindex], multiplier); multiplier_accum += multiplier; index += step; bufferindex += offsetadd; } } - mul_v4_v4fl(output, tempColor, 1.0f / multiplier_accum); + mul_v4_v4fl(output, temp_color, 1.0f / multiplier_accum); } -void GaussianBokehBlurOperation::deinitExecution() +void GaussianBokehBlurOperation::deinit_execution() { - BlurBaseOperation::deinitExecution(); + BlurBaseOperation::deinit_execution(); if (gausstab_) { MEM_freeN(gausstab_); gausstab_ = nullptr; } - deinitMutex(); + deinit_mutex(); } -bool GaussianBokehBlurOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool GaussianBokehBlurOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; - rcti sizeInput; - sizeInput.xmin = 0; - sizeInput.ymin = 0; - sizeInput.xmax = 5; - sizeInput.ymax = 5; - NodeOperation *operation = this->getInputOperation(1); - - if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) { + rcti new_input; + rcti size_input; + size_input.xmin = 0; + size_input.ymin = 0; + size_input.xmax = 5; + size_input.ymax = 5; + NodeOperation *operation = this->get_input_operation(1); + + if (operation->determine_depending_area_of_interest(&size_input, read_operation, output)) { return true; } if (sizeavailable_ && gausstab_ != nullptr) { - newInput.xmin = 0; - newInput.ymin = 0; - newInput.xmax = this->getWidth(); - newInput.ymax = this->getHeight(); + new_input.xmin = 0; + new_input.ymin = 0; + new_input.xmax = this->get_width(); + new_input.ymax = this->get_height(); } else { int addx = radx_; int addy = rady_; - newInput.xmax = input->xmax + addx; - newInput.xmin = input->xmin - addx; - newInput.ymax = input->ymax + addy; - newInput.ymin = input->ymin - addy; + new_input.xmax = input->xmax + addx; + new_input.xmin = input->xmin - addx; + new_input.ymax = input->ymax + addy; + new_input.ymin = input->ymin - addy; } - return BlurBaseOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return BlurBaseOperation::determine_depending_area_of_interest( + &new_input, read_operation, output); } void GaussianBokehBlurOperation::get_area_of_interest(const int input_idx, @@ -224,9 +225,9 @@ void GaussianBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *outp 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 temp_color[4] = {0}; float multiplier_accum = 0; - const int step = QualityStepHelper::getStep(); + const int step = QualityStepHelper::get_step(); const int elem_step = step * input->elem_stride; const int add_const = (xmin - x + radx_); const int mul_const = (radx_ * 2 + 1); @@ -236,12 +237,12 @@ void GaussianBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer *outp const int gauss_end = gauss_index + (xmax - xmin); for (; gauss_index < gauss_end; gauss_index += step, color += elem_step) { const float multiplier = gausstab_[gauss_index]; - madd_v4_v4fl(tempColor, color, multiplier); + madd_v4_v4fl(temp_color, color, multiplier); multiplier_accum += multiplier; } } - mul_v4_v4fl(it.out, tempColor, 1.0f / multiplier_accum); + mul_v4_v4fl(it.out, temp_color, 1.0f / multiplier_accum); } } @@ -256,8 +257,8 @@ GaussianBlurReferenceOperation::GaussianBlurReferenceOperation() void GaussianBlurReferenceOperation::init_data() { /* Setup variables for gausstab and area of interest. */ - data_.image_in_width = this->getWidth(); - data_.image_in_height = this->getHeight(); + data_.image_in_width = this->get_width(); + data_.image_in_height = this->get_height(); if (data_.relative) { switch (data_.aspect) { case CMP_NODE_BLUR_ASPECT_NONE: @@ -277,7 +278,7 @@ void GaussianBlurReferenceOperation::init_data() /* Horizontal. */ filtersizex_ = (float)data_.sizex; - int imgx = getWidth() / 2; + int imgx = get_width() / 2; if (filtersizex_ > imgx) { filtersizex_ = imgx; } @@ -288,7 +289,7 @@ void GaussianBlurReferenceOperation::init_data() /* Vertical. */ filtersizey_ = (float)data_.sizey; - int imgy = getHeight() / 2; + int imgy = get_height() / 2; if (filtersizey_ > imgy) { filtersizey_ = imgy; } @@ -298,20 +299,20 @@ void GaussianBlurReferenceOperation::init_data() rady_ = (float)filtersizey_; } -void *GaussianBlurReferenceOperation::initializeTileData(rcti * /*rect*/) +void *GaussianBlurReferenceOperation::initialize_tile_data(rcti * /*rect*/) { - void *buffer = getInputOperation(0)->initializeTileData(nullptr); + void *buffer = get_input_operation(0)->initialize_tile_data(nullptr); return buffer; } -void GaussianBlurReferenceOperation::initExecution() +void GaussianBlurReferenceOperation::init_execution() { - BlurBaseOperation::initExecution(); + BlurBaseOperation::init_execution(); - updateGauss(); + update_gauss(); } -void GaussianBlurReferenceOperation::updateGauss() +void GaussianBlurReferenceOperation::update_gauss() { int i; int x = MAX2(filtersizex_, filtersizey_); @@ -321,23 +322,23 @@ void GaussianBlurReferenceOperation::updateGauss() } } -void GaussianBlurReferenceOperation::executePixel(float output[4], int x, int y, void *data) +void GaussianBlurReferenceOperation::execute_pixel(float output[4], int x, int y, void *data) { MemoryBuffer *memorybuffer = (MemoryBuffer *)data; - float *buffer = memorybuffer->getBuffer(); + float *buffer = memorybuffer->get_buffer(); float *gausstabx, *gausstabcenty; float *gausstaby, *gausstabcentx; int i, j; float *src; float sum, val; float rval, gval, bval, aval; - int imgx = getWidth(); - int imgy = getHeight(); - float tempSize[4]; - inputSize_->read(tempSize, x, y, data); - float refSize = tempSize[0]; - int refradx = (int)(refSize * radx_); - int refrady = (int)(refSize * rady_); + int imgx = get_width(); + int imgy = get_height(); + float temp_size[4]; + input_size_->read(temp_size, x, y, data); + float ref_size = temp_size[0]; + int refradx = (int)(ref_size * radx_); + int refrady = (int)(ref_size * rady_); if (refradx > filtersizex_) { refradx = filtersizex_; } @@ -352,7 +353,7 @@ void GaussianBlurReferenceOperation::executePixel(float output[4], int x, int y, } if (refradx == 1 && refrady == 1) { - memorybuffer->readNoCheck(output, x, y); + memorybuffer->read_no_check(output, x, y); } else { int minxr = x - refradx < 0 ? -x : -refradx; @@ -388,7 +389,7 @@ void GaussianBlurReferenceOperation::executePixel(float output[4], int x, int y, } } -void GaussianBlurReferenceOperation::deinitExecution() +void GaussianBlurReferenceOperation::deinit_execution() { int x, i; x = MAX2(filtersizex_, filtersizey_); @@ -396,26 +397,26 @@ void GaussianBlurReferenceOperation::deinitExecution() MEM_freeN(maintabs_[i]); } MEM_freeN(maintabs_); - BlurBaseOperation::deinitExecution(); + BlurBaseOperation::deinit_execution(); } -bool GaussianBlurReferenceOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool GaussianBlurReferenceOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; - NodeOperation *operation = this->getInputOperation(1); + rcti new_input; + NodeOperation *operation = this->get_input_operation(1); - if (operation->determineDependingAreaOfInterest(input, readOperation, output)) { + if (operation->determine_depending_area_of_interest(input, read_operation, output)) { return true; } 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; - newInput.ymin = input->ymin - addy; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + new_input.xmax = input->xmax + addx; + new_input.xmin = input->xmin - addx; + new_input.ymax = input->ymax + addy; + new_input.ymin = input->ymin - addy; + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void GaussianBlurReferenceOperation::get_area_of_interest(const int input_idx, @@ -465,8 +466,8 @@ void GaussianBlurReferenceOperation::update_memory_buffer_partial(MemoryBuffer * continue; } - const int w = getWidth(); - const int height = getHeight(); + const int w = get_width(); + const int height = get_height(); const int minxr = x - ref_radx < 0 ? -x : -ref_radx; const int maxxr = x + ref_radx > w ? w - x : ref_radx; const int minyr = y - ref_rady < 0 ? -y : -ref_rady; diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h index 5e6eeefa512..923daf7a447 100644 --- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h @@ -30,26 +30,26 @@ class GaussianBokehBlurOperation : public BlurBaseOperation { int radx_, rady_; float radxf_; float radyf_; - void updateGauss(); + void update_gauss(); public: GaussianBokehBlurOperation(); void init_data() override; - void initExecution() override; - void *initializeTileData(rcti *rect) override; + void init_execution() override; + void *initialize_tile_data(rcti *rect) override; /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(const int input_idx, const rcti &output_area, @@ -63,7 +63,7 @@ class GaussianBlurReferenceOperation : public BlurBaseOperation { private: float **maintabs_; - void updateGauss(); + void update_gauss(); int filtersizex_; int filtersizey_; float radx_; @@ -72,21 +72,21 @@ class GaussianBlurReferenceOperation : public BlurBaseOperation { public: GaussianBlurReferenceOperation(); void init_data() override; - void initExecution() override; - void *initializeTileData(rcti *rect) override; + void init_execution() override; + void *initialize_tile_data(rcti *rect) override; /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(const int input_idx, const rcti &output_area, diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cc b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cc index 4720b3f69d0..b43db5ba664 100644 --- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cc @@ -25,23 +25,23 @@ GaussianXBlurOperation::GaussianXBlurOperation() : GaussianBlurBaseOperation(eDi { } -void *GaussianXBlurOperation::initializeTileData(rcti * /*rect*/) +void *GaussianXBlurOperation::initialize_tile_data(rcti * /*rect*/) { - lockMutex(); + lock_mutex(); if (!sizeavailable_) { - updateGauss(); + update_gauss(); } - void *buffer = getInputOperation(0)->initializeTileData(nullptr); - unlockMutex(); + void *buffer = get_input_operation(0)->initialize_tile_data(nullptr); + unlock_mutex(); return buffer; } /* TODO(manzanilla): to be removed with tiled implementation. */ -void GaussianXBlurOperation::initExecution() +void GaussianXBlurOperation::init_execution() { - GaussianBlurBaseOperation::initExecution(); + GaussianBlurBaseOperation::init_execution(); - initMutex(); + init_mutex(); if (sizeavailable_ && execution_model_ == eExecutionModel::Tiled) { float rad = max_ff(size_ * data_.sizex, 0.0f); @@ -56,10 +56,10 @@ void GaussianXBlurOperation::initExecution() } /* TODO(manzanilla): to be removed with tiled implementation. */ -void GaussianXBlurOperation::updateGauss() +void GaussianXBlurOperation::update_gauss() { if (gausstab_ == nullptr) { - updateSize(); + update_size(); float rad = max_ff(size_ * data_.sizex, 0.0f); rad = min_ff(rad, MAX_GAUSSTAB_RADIUS); filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); @@ -71,14 +71,14 @@ void GaussianXBlurOperation::updateGauss() } } -void GaussianXBlurOperation::executePixel(float output[4], int x, int y, void *data) +void GaussianXBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { float ATTR_ALIGN(16) color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; float multiplier_accum = 0.0f; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - const rcti &input_rect = inputBuffer->get_rect(); - float *buffer = inputBuffer->getBuffer(); - int bufferwidth = inputBuffer->getWidth(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + const rcti &input_rect = input_buffer->get_rect(); + float *buffer = input_buffer->get_buffer(); + int bufferwidth = input_buffer->get_width(); int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; @@ -86,8 +86,8 @@ void GaussianXBlurOperation::executePixel(float output[4], int x, int y, void *d int xmax = min_ii(x + filtersize_ + 1, input_rect.xmax); int ymin = max_ii(y, input_rect.ymin); - int step = getStep(); - int offsetadd = getOffsetAdd(); + int step = get_step(); + int offsetadd = get_offset_add(); int bufferindex = ((xmin - bufferstartx) * 4) + ((ymin - bufferstarty) * 4 * bufferwidth); #ifdef BLI_HAVE_SSE2 @@ -111,41 +111,45 @@ void GaussianXBlurOperation::executePixel(float output[4], int x, int y, void *d mul_v4_v4fl(output, color_accum, 1.0f / multiplier_accum); } -void GaussianXBlurOperation::executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list * /*clKernelsToCleanUp*/) +void GaussianXBlurOperation::execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list * /*cl_kernels_to_clean_up*/) { - cl_kernel gaussianXBlurOperationKernel = device->COM_clCreateKernel( - "gaussianXBlurOperationKernel", nullptr); + cl_kernel gaussian_xblur_operation_kernel = device->COM_cl_create_kernel( + "gaussian_xblur_operation_kernel", nullptr); cl_int filter_size = filtersize_; - cl_mem gausstab = clCreateBuffer(device->getContext(), + cl_mem gausstab = clCreateBuffer(device->get_context(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * (filtersize_ * 2 + 1), gausstab_, nullptr); - device->COM_clAttachMemoryBufferToKernelParameter( - gaussianXBlurOperationKernel, 0, 1, clMemToCleanUp, inputMemoryBuffers, inputProgram_); - device->COM_clAttachOutputMemoryBufferToKernelParameter( - gaussianXBlurOperationKernel, 2, clOutputBuffer); - device->COM_clAttachMemoryBufferOffsetToKernelParameter( - gaussianXBlurOperationKernel, 3, outputMemoryBuffer); - clSetKernelArg(gaussianXBlurOperationKernel, 4, sizeof(cl_int), &filter_size); - device->COM_clAttachSizeToKernelParameter(gaussianXBlurOperationKernel, 5, this); - clSetKernelArg(gaussianXBlurOperationKernel, 6, sizeof(cl_mem), &gausstab); - - device->COM_clEnqueueRange(gaussianXBlurOperationKernel, outputMemoryBuffer, 7, this); + device->COM_cl_attach_memory_buffer_to_kernel_parameter(gaussian_xblur_operation_kernel, + 0, + 1, + cl_mem_to_clean_up, + input_memory_buffers, + input_program_); + device->COM_cl_attach_output_memory_buffer_to_kernel_parameter( + gaussian_xblur_operation_kernel, 2, cl_output_buffer); + device->COM_cl_attach_memory_buffer_offset_to_kernel_parameter( + gaussian_xblur_operation_kernel, 3, output_memory_buffer); + clSetKernelArg(gaussian_xblur_operation_kernel, 4, sizeof(cl_int), &filter_size); + device->COM_cl_attach_size_to_kernel_parameter(gaussian_xblur_operation_kernel, 5, this); + clSetKernelArg(gaussian_xblur_operation_kernel, 6, sizeof(cl_mem), &gausstab); + + device->COM_cl_enqueue_range(gaussian_xblur_operation_kernel, output_memory_buffer, 7, this); clReleaseMemObject(gausstab); } -void GaussianXBlurOperation::deinitExecution() +void GaussianXBlurOperation::deinit_execution() { - GaussianBlurBaseOperation::deinitExecution(); + GaussianBlurBaseOperation::deinit_execution(); if (gausstab_) { MEM_freeN(gausstab_); @@ -158,40 +162,39 @@ void GaussianXBlurOperation::deinitExecution() } #endif - deinitMutex(); + deinit_mutex(); } -bool GaussianXBlurOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool GaussianXBlurOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; if (!sizeavailable_) { - rcti sizeInput; - sizeInput.xmin = 0; - sizeInput.ymin = 0; - sizeInput.xmax = 5; - sizeInput.ymax = 5; - NodeOperation *operation = this->getInputOperation(1); - if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) { + rcti size_input; + size_input.xmin = 0; + size_input.ymin = 0; + size_input.xmax = 5; + size_input.ymax = 5; + NodeOperation *operation = this->get_input_operation(1); + if (operation->determine_depending_area_of_interest(&size_input, read_operation, output)) { return true; } } { if (sizeavailable_ && gausstab_ != nullptr) { - newInput.xmax = input->xmax + filtersize_ + 1; - newInput.xmin = input->xmin - filtersize_ - 1; - newInput.ymax = input->ymax; - newInput.ymin = input->ymin; + new_input.xmax = input->xmax + filtersize_ + 1; + new_input.xmin = input->xmin - filtersize_ - 1; + new_input.ymax = input->ymax; + new_input.ymin = input->ymin; } else { - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; } - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } } diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.h b/source/blender/compositor/operations/COM_GaussianXBlurOperation.h index 1bb77031056..b9bbe1df900 100644 --- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.h @@ -25,7 +25,7 @@ namespace blender::compositor { /* TODO(manzanilla): everything to be removed with tiled implementation except the constructor. */ class GaussianXBlurOperation : public GaussianBlurBaseOperation { private: - void updateGauss(); + void update_gauss(); public: GaussianXBlurOperation(); @@ -33,31 +33,31 @@ class GaussianXBlurOperation : public GaussianBlurBaseOperation { /** * \brief The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list *clKernelsToCleanUp) override; + void execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list *cl_kernels_to_clean_up) override; /** * \brief initialize the execution */ - void initExecution() override; + void init_execution() override; /** * \brief Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + void *initialize_tile_data(rcti *rect) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void checkOpenCL() + void check_opencl() { 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 50edc0bea29..639536ebcc1 100644 --- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cc +++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cc @@ -25,22 +25,22 @@ GaussianYBlurOperation::GaussianYBlurOperation() : GaussianBlurBaseOperation(eDi { } -void *GaussianYBlurOperation::initializeTileData(rcti * /*rect*/) +void *GaussianYBlurOperation::initialize_tile_data(rcti * /*rect*/) { - lockMutex(); + lock_mutex(); if (!sizeavailable_) { - updateGauss(); + update_gauss(); } - void *buffer = getInputOperation(0)->initializeTileData(nullptr); - unlockMutex(); + void *buffer = get_input_operation(0)->initialize_tile_data(nullptr); + unlock_mutex(); return buffer; } -void GaussianYBlurOperation::initExecution() +void GaussianYBlurOperation::init_execution() { - GaussianBlurBaseOperation::initExecution(); + GaussianBlurBaseOperation::init_execution(); - initMutex(); + init_mutex(); if (sizeavailable_ && execution_model_ == eExecutionModel::Tiled) { float rad = max_ff(size_ * data_.sizey, 0.0f); @@ -53,10 +53,10 @@ void GaussianYBlurOperation::initExecution() } } -void GaussianYBlurOperation::updateGauss() +void GaussianYBlurOperation::update_gauss() { if (gausstab_ == nullptr) { - updateSize(); + update_size(); float rad = max_ff(size_ * data_.sizey, 0.0f); rad = min_ff(rad, MAX_GAUSSTAB_RADIUS); filtersize_ = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); @@ -68,14 +68,14 @@ void GaussianYBlurOperation::updateGauss() } } -void GaussianYBlurOperation::executePixel(float output[4], int x, int y, void *data) +void GaussianYBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { float ATTR_ALIGN(16) color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; float multiplier_accum = 0.0f; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - const rcti &input_rect = inputBuffer->get_rect(); - float *buffer = inputBuffer->getBuffer(); - int bufferwidth = inputBuffer->getWidth(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + const rcti &input_rect = input_buffer->get_rect(); + float *buffer = input_buffer->get_buffer(); + int bufferwidth = input_buffer->get_width(); int bufferstartx = input_rect.xmin; int bufferstarty = input_rect.ymin; @@ -84,14 +84,14 @@ void GaussianYBlurOperation::executePixel(float output[4], int x, int y, void *d int ymax = min_ii(y + filtersize_ + 1, input_rect.ymax); int index; - int step = getStep(); - const int bufferIndexx = ((xmin - bufferstartx) * 4); + int step = get_step(); + const int buffer_indexx = ((xmin - bufferstartx) * 4); #ifdef BLI_HAVE_SSE2 __m128 accum_r = _mm_load_ps(color_accum); for (int ny = ymin; ny < ymax; ny += step) { index = (ny - y) + filtersize_; - int bufferindex = bufferIndexx + ((ny - bufferstarty) * 4 * bufferwidth); + int bufferindex = buffer_indexx + ((ny - bufferstarty) * 4 * bufferwidth); const float multiplier = gausstab_[index]; __m128 reg_a = _mm_load_ps(&buffer[bufferindex]); reg_a = _mm_mul_ps(reg_a, gausstab_sse_[index]); @@ -102,7 +102,7 @@ void GaussianYBlurOperation::executePixel(float output[4], int x, int y, void *d #else for (int ny = ymin; ny < ymax; ny += step) { index = (ny - y) + filtersize_; - int bufferindex = bufferIndexx + ((ny - bufferstarty) * 4 * bufferwidth); + int bufferindex = buffer_indexx + ((ny - bufferstarty) * 4 * bufferwidth); const float multiplier = gausstab_[index]; madd_v4_v4fl(color_accum, &buffer[bufferindex], multiplier); multiplier_accum += multiplier; @@ -111,41 +111,45 @@ void GaussianYBlurOperation::executePixel(float output[4], int x, int y, void *d mul_v4_v4fl(output, color_accum, 1.0f / multiplier_accum); } -void GaussianYBlurOperation::executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list * /*clKernelsToCleanUp*/) +void GaussianYBlurOperation::execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list * /*cl_kernels_to_clean_up*/) { - cl_kernel gaussianYBlurOperationKernel = device->COM_clCreateKernel( - "gaussianYBlurOperationKernel", nullptr); + cl_kernel gaussian_yblur_operation_kernel = device->COM_cl_create_kernel( + "gaussian_yblur_operation_kernel", nullptr); cl_int filter_size = filtersize_; - cl_mem gausstab = clCreateBuffer(device->getContext(), + cl_mem gausstab = clCreateBuffer(device->get_context(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * (filtersize_ * 2 + 1), gausstab_, nullptr); - device->COM_clAttachMemoryBufferToKernelParameter( - gaussianYBlurOperationKernel, 0, 1, clMemToCleanUp, inputMemoryBuffers, inputProgram_); - device->COM_clAttachOutputMemoryBufferToKernelParameter( - gaussianYBlurOperationKernel, 2, clOutputBuffer); - device->COM_clAttachMemoryBufferOffsetToKernelParameter( - gaussianYBlurOperationKernel, 3, outputMemoryBuffer); - clSetKernelArg(gaussianYBlurOperationKernel, 4, sizeof(cl_int), &filter_size); - device->COM_clAttachSizeToKernelParameter(gaussianYBlurOperationKernel, 5, this); - clSetKernelArg(gaussianYBlurOperationKernel, 6, sizeof(cl_mem), &gausstab); - - device->COM_clEnqueueRange(gaussianYBlurOperationKernel, outputMemoryBuffer, 7, this); + device->COM_cl_attach_memory_buffer_to_kernel_parameter(gaussian_yblur_operation_kernel, + 0, + 1, + cl_mem_to_clean_up, + input_memory_buffers, + input_program_); + device->COM_cl_attach_output_memory_buffer_to_kernel_parameter( + gaussian_yblur_operation_kernel, 2, cl_output_buffer); + device->COM_cl_attach_memory_buffer_offset_to_kernel_parameter( + gaussian_yblur_operation_kernel, 3, output_memory_buffer); + clSetKernelArg(gaussian_yblur_operation_kernel, 4, sizeof(cl_int), &filter_size); + device->COM_cl_attach_size_to_kernel_parameter(gaussian_yblur_operation_kernel, 5, this); + clSetKernelArg(gaussian_yblur_operation_kernel, 6, sizeof(cl_mem), &gausstab); + + device->COM_cl_enqueue_range(gaussian_yblur_operation_kernel, output_memory_buffer, 7, this); clReleaseMemObject(gausstab); } -void GaussianYBlurOperation::deinitExecution() +void GaussianYBlurOperation::deinit_execution() { - GaussianBlurBaseOperation::deinitExecution(); + GaussianBlurBaseOperation::deinit_execution(); if (gausstab_) { MEM_freeN(gausstab_); @@ -158,40 +162,39 @@ void GaussianYBlurOperation::deinitExecution() } #endif - deinitMutex(); + deinit_mutex(); } -bool GaussianYBlurOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool GaussianYBlurOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; if (!sizeavailable_) { - rcti sizeInput; - sizeInput.xmin = 0; - sizeInput.ymin = 0; - sizeInput.xmax = 5; - sizeInput.ymax = 5; - NodeOperation *operation = this->getInputOperation(1); - if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) { + rcti size_input; + size_input.xmin = 0; + size_input.ymin = 0; + size_input.xmax = 5; + size_input.ymax = 5; + NodeOperation *operation = this->get_input_operation(1); + if (operation->determine_depending_area_of_interest(&size_input, read_operation, output)) { return true; } } { if (sizeavailable_ && gausstab_ != nullptr) { - newInput.xmax = input->xmax; - newInput.xmin = input->xmin; - newInput.ymax = input->ymax + filtersize_ + 1; - newInput.ymin = input->ymin - filtersize_ - 1; + new_input.xmax = input->xmax; + new_input.xmin = input->xmin; + new_input.ymax = input->ymax + filtersize_ + 1; + new_input.ymin = input->ymin - filtersize_ - 1; } else { - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; } - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } } diff --git a/source/blender/compositor/operations/COM_GaussianYBlurOperation.h b/source/blender/compositor/operations/COM_GaussianYBlurOperation.h index 92c2d71f487..4390c9544e4 100644 --- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.h @@ -25,7 +25,7 @@ namespace blender::compositor { /* TODO(manzanilla): everything to be removed with tiled implementation except the constructor. */ class GaussianYBlurOperation : public GaussianBlurBaseOperation { private: - void updateGauss(); + void update_gauss(); public: GaussianYBlurOperation(); @@ -33,31 +33,31 @@ class GaussianYBlurOperation : public GaussianBlurBaseOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list *clKernelsToCleanUp) override; + void execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list *cl_kernels_to_clean_up) override; /** * \brief initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + void *initialize_tile_data(rcti *rect) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void checkOpenCL() + void check_opencl() { 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 0987f0efb31..37082f29579 100644 --- a/source/blender/compositor/operations/COM_GlareBaseOperation.cc +++ b/source/blender/compositor/operations/COM_GlareBaseOperation.cc @@ -22,52 +22,52 @@ namespace blender::compositor { GlareBaseOperation::GlareBaseOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); settings_ = nullptr; flags.is_fullframe_operation = true; is_output_rendered_ = false; } -void GlareBaseOperation::initExecution() +void GlareBaseOperation::init_execution() { - SingleThreadedOperation::initExecution(); - inputProgram_ = getInputSocketReader(0); + SingleThreadedOperation::init_execution(); + input_program_ = get_input_socket_reader(0); } -void GlareBaseOperation::deinitExecution() +void GlareBaseOperation::deinit_execution() { - inputProgram_ = nullptr; - SingleThreadedOperation::deinitExecution(); + input_program_ = nullptr; + SingleThreadedOperation::deinit_execution(); } -MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2) +MemoryBuffer *GlareBaseOperation::create_memory_buffer(rcti *rect2) { - MemoryBuffer *tile = (MemoryBuffer *)inputProgram_->initializeTileData(rect2); + MemoryBuffer *tile = (MemoryBuffer *)input_program_->initialize_tile_data(rect2); rcti rect; rect.xmin = 0; rect.ymin = 0; - rect.xmax = getWidth(); - rect.ymax = getHeight(); + rect.xmax = get_width(); + rect.ymax = get_height(); MemoryBuffer *result = new MemoryBuffer(DataType::Color, rect); - float *data = result->getBuffer(); - this->generateGlare(data, tile, settings_); + float *data = result->get_buffer(); + this->generate_glare(data, tile, settings_); return result; } -bool GlareBaseOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool GlareBaseOperation::determine_depending_area_of_interest(rcti * /*input*/, + ReadBufferOperation *read_operation, + rcti *output) { - if (isCached()) { + if (is_cached()) { return false; } - rcti newInput; - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + rcti new_input; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void GlareBaseOperation::get_area_of_interest(const int input_idx, @@ -77,9 +77,9 @@ void GlareBaseOperation::get_area_of_interest(const int input_idx, BLI_assert(input_idx == 0); UNUSED_VARS_NDEBUG(input_idx); r_input_area.xmin = 0; - r_input_area.xmax = this->getWidth(); + r_input_area.xmax = this->get_width(); r_input_area.ymin = 0; - r_input_area.ymax = this->getHeight(); + r_input_area.ymax = this->get_height(); } void GlareBaseOperation::update_memory_buffer(MemoryBuffer *output, @@ -93,7 +93,7 @@ void GlareBaseOperation::update_memory_buffer(MemoryBuffer *output, input = input->inflate(); } - this->generateGlare(output->getBuffer(), input, settings_); + this->generate_glare(output->get_buffer(), 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 a50042f1ff4..09db5efcec9 100644 --- a/source/blender/compositor/operations/COM_GlareBaseOperation.h +++ b/source/blender/compositor/operations/COM_GlareBaseOperation.h @@ -40,9 +40,9 @@ typedef float fRGB[4]; class GlareBaseOperation : public SingleThreadedOperation { private: /** - * \brief Cached reference to the inputProgram + * \brief Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; /** * \brief settings of the glare node. @@ -55,20 +55,20 @@ class GlareBaseOperation : public SingleThreadedOperation { /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setGlareSettings(NodeGlare *settings) + void set_glare_settings(NodeGlare *settings) { settings_ = settings; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(const int input_idx, const rcti &output_area, @@ -81,9 +81,9 @@ class GlareBaseOperation : public SingleThreadedOperation { protected: GlareBaseOperation(); - virtual void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings) = 0; + virtual void generate_glare(float *data, MemoryBuffer *input_tile, NodeGlare *settings) = 0; - MemoryBuffer *createMemoryBuffer(rcti *rect) override; + MemoryBuffer *create_memory_buffer(rcti *rect) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GlareFogGlowOperation.cc b/source/blender/compositor/operations/COM_GlareFogGlowOperation.cc index 2142a1b822e..fa2e2597452 100644 --- a/source/blender/compositor/operations/COM_GlareFogGlowOperation.cc +++ b/source/blender/compositor/operations/COM_GlareFogGlowOperation.cc @@ -27,7 +27,7 @@ namespace blender::compositor { using fREAL = float; /* Returns next highest power of 2 of x, as well its log2 in L2. */ -static unsigned int nextPow2(unsigned int x, unsigned int *L2) +static unsigned int next_pow2(unsigned int x, unsigned int *L2) { unsigned int pw, x_notpow2 = x & (x - 1); *L2 = 0; @@ -262,24 +262,24 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) int x, y, ch; int xbl, ybl, nxb, nyb, xbsz, ybsz; bool in2done = false; - const unsigned int kernelWidth = in2->getWidth(); - const unsigned int kernelHeight = in2->getHeight(); - const unsigned int imageWidth = in1->getWidth(); - const unsigned int imageHeight = in1->getHeight(); - float *kernelBuffer = in2->getBuffer(); - float *imageBuffer = in1->getBuffer(); + const unsigned int kernel_width = in2->get_width(); + const unsigned int kernel_height = in2->get_height(); + const unsigned int image_width = in1->get_width(); + const unsigned int image_height = in1->get_height(); + float *kernel_buffer = in2->get_buffer(); + float *image_buffer = in1->get_buffer(); MemoryBuffer *rdst = new MemoryBuffer(DataType::Color, in1->get_rect()); - memset(rdst->getBuffer(), + memset(rdst->get_buffer(), 0, - rdst->getWidth() * rdst->getHeight() * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float)); + rdst->get_width() * rdst->get_height() * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float)); /* Convolution result width & height. */ - w2 = 2 * kernelWidth - 1; - h2 = 2 * kernelHeight - 1; + w2 = 2 * kernel_width - 1; + h2 = 2 * kernel_height - 1; /* FFT pow2 required size & log2. */ - w2 = nextPow2(w2, &log2_w); - h2 = nextPow2(h2, &log2_h); + w2 = next_pow2(w2, &log2_w); + h2 = next_pow2(h2, &log2_h); /* Allocate space. */ data1 = (fREAL *)MEM_callocN(3 * w2 * h2 * sizeof(fREAL), "convolve_fast FHT data1"); @@ -287,9 +287,9 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) /* Normalize convolutor. */ wt[0] = wt[1] = wt[2] = 0.0f; - for (y = 0; y < kernelHeight; y++) { - colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_DATA_TYPE_COLOR_CHANNELS]; - for (x = 0; x < kernelWidth; x++) { + for (y = 0; y < kernel_height; y++) { + colp = (fRGB *)&kernel_buffer[y * kernel_width * COM_DATA_TYPE_COLOR_CHANNELS]; + for (x = 0; x < kernel_width; x++) { add_v3_v3(wt, colp[x]); } } @@ -302,9 +302,9 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) if (wt[2] != 0.0f) { wt[2] = 1.0f / wt[2]; } - for (y = 0; y < kernelHeight; y++) { - colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_DATA_TYPE_COLOR_CHANNELS]; - for (x = 0; x < kernelWidth; x++) { + for (y = 0; y < kernel_height; y++) { + colp = (fRGB *)&kernel_buffer[y * kernel_width * COM_DATA_TYPE_COLOR_CHANNELS]; + for (x = 0; x < kernel_width; x++) { mul_v3_v3(colp[x], wt); } } @@ -313,16 +313,16 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) * only need to calc data1 once. */ /* Block add-overlap. */ - hw = kernelWidth >> 1; - hh = kernelHeight >> 1; - xbsz = (w2 + 1) - kernelWidth; - ybsz = (h2 + 1) - kernelHeight; - nxb = imageWidth / xbsz; - if (imageWidth % xbsz) { + hw = kernel_width >> 1; + hh = kernel_height >> 1; + xbsz = (w2 + 1) - kernel_width; + ybsz = (h2 + 1) - kernel_height; + nxb = image_width / xbsz; + if (image_width % xbsz) { nxb++; } - nyb = imageHeight / ybsz; - if (imageHeight % ybsz) { + nyb = image_height / ybsz; + if (image_height % ybsz) { nyb++; } for (ybl = 0; ybl < nyb; ybl++) { @@ -335,10 +335,10 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) /* Only need to calc fht data from in2 once, can re-use for every block. */ if (!in2done) { /* in2, channel ch -> data1 */ - for (y = 0; y < kernelHeight; y++) { + for (y = 0; y < kernel_height; y++) { fp = &data1ch[y * w2]; - colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_DATA_TYPE_COLOR_CHANNELS]; - for (x = 0; x < kernelWidth; x++) { + colp = (fRGB *)&kernel_buffer[y * kernel_width * COM_DATA_TYPE_COLOR_CHANNELS]; + for (x = 0; x < kernel_width; x++) { fp[x] = colp[x][ch]; } } @@ -348,14 +348,14 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) memset(data2, 0, w2 * h2 * sizeof(fREAL)); for (y = 0; y < ybsz; y++) { int yy = ybl * ybsz + y; - if (yy >= imageHeight) { + if (yy >= image_height) { continue; } fp = &data2[y * w2]; - colp = (fRGB *)&imageBuffer[yy * imageWidth * COM_DATA_TYPE_COLOR_CHANNELS]; + colp = (fRGB *)&image_buffer[yy * image_width * COM_DATA_TYPE_COLOR_CHANNELS]; for (x = 0; x < xbsz; x++) { int xx = xbl * xbsz + x; - if (xx >= imageWidth) { + if (xx >= image_width) { continue; } fp[x] = colp[xx][ch]; @@ -365,9 +365,9 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) /* Forward FHT * zero pad data start is different for each == height+1. */ if (!in2done) { - FHT2D(data1ch, log2_w, log2_h, kernelHeight + 1, 0); + FHT2D(data1ch, log2_w, log2_h, kernel_height + 1, 0); } - FHT2D(data2, log2_w, log2_h, kernelHeight + 1, 0); + FHT2D(data2, log2_w, log2_h, kernel_height + 1, 0); /* FHT2D transposed data, row/col now swapped * convolve & inverse FHT. */ @@ -378,14 +378,14 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) /* Overlap-add result. */ for (y = 0; y < (int)h2; y++) { const int yy = ybl * ybsz + y - hh; - if ((yy < 0) || (yy >= imageHeight)) { + if ((yy < 0) || (yy >= image_height)) { continue; } fp = &data2[y * w2]; - colp = (fRGB *)&rdst->getBuffer()[yy * imageWidth * COM_DATA_TYPE_COLOR_CHANNELS]; + colp = (fRGB *)&rdst->get_buffer()[yy * image_width * COM_DATA_TYPE_COLOR_CHANNELS]; for (x = 0; x < (int)w2; x++) { const int xx = xbl * xbsz + x - hw; - if ((xx < 0) || (xx >= imageWidth)) { + if ((xx < 0) || (xx >= image_width)) { continue; } colp[xx][ch] += fp[x]; @@ -399,14 +399,14 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2) MEM_freeN(data2); MEM_freeN(data1); memcpy(dst, - rdst->getBuffer(), - sizeof(float) * imageWidth * imageHeight * COM_DATA_TYPE_COLOR_CHANNELS); + rdst->get_buffer(), + sizeof(float) * image_width * image_height * COM_DATA_TYPE_COLOR_CHANNELS); delete (rdst); } -void GlareFogGlowOperation::generateGlare(float *data, - MemoryBuffer *inputTile, - NodeGlare *settings) +void GlareFogGlowOperation::generate_glare(float *data, + MemoryBuffer *input_tile, + NodeGlare *settings) { int x, y; float scale, u, v, r, w, d; @@ -417,9 +417,9 @@ void GlareFogGlowOperation::generateGlare(float *data, /* Temp. src image * make the convolution kernel. */ - rcti kernelRect; - BLI_rcti_init(&kernelRect, 0, sz, 0, sz); - ckrn = new MemoryBuffer(DataType::Color, kernelRect); + rcti kernel_rect; + BLI_rcti_init(&kernel_rect, 0, sz, 0, sz); + ckrn = new MemoryBuffer(DataType::Color, kernel_rect); scale = 0.25f * sqrtf((float)(sz * sz)); @@ -437,11 +437,11 @@ void GlareFogGlowOperation::generateGlare(float *data, * actually, Hanning window is ok, `cos^2` for some reason is slower. */ w = (0.5f + 0.5f * cosf(u * (float)M_PI)) * (0.5f + 0.5f * cosf(v * (float)M_PI)); mul_v3_fl(fcol, w); - ckrn->writePixel(x, y, fcol); + ckrn->write_pixel(x, y, fcol); } } - convolve(data, inputTile, ckrn); + convolve(data, input_tile, ckrn); delete ckrn; } diff --git a/source/blender/compositor/operations/COM_GlareFogGlowOperation.h b/source/blender/compositor/operations/COM_GlareFogGlowOperation.h index 5701f76ab13..648351fa692 100644 --- a/source/blender/compositor/operations/COM_GlareFogGlowOperation.h +++ b/source/blender/compositor/operations/COM_GlareFogGlowOperation.h @@ -31,7 +31,7 @@ class GlareFogGlowOperation : public GlareBaseOperation { } protected: - void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings) override; + void generate_glare(float *data, MemoryBuffer *input_tile, NodeGlare *settings) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GlareGhostOperation.cc b/source/blender/compositor/operations/COM_GlareGhostOperation.cc index c5ecfed024c..930c723e94e 100644 --- a/source/blender/compositor/operations/COM_GlareGhostOperation.cc +++ b/source/blender/compositor/operations/COM_GlareGhostOperation.cc @@ -21,7 +21,7 @@ namespace blender::compositor { -static float smoothMask(float x, float y) +static float smooth_mask(float x, float y) { float t; x = 2.0f * x - 1.0f; @@ -33,7 +33,9 @@ static float smoothMask(float x, float y) return 0.0f; } -void GlareGhostOperation::generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings) +void GlareGhostOperation::generate_glare(float *data, + MemoryBuffer *input_tile, + NodeGlare *settings) { const int qt = 1 << settings->quality; const float s1 = 4.0f / (float)qt, s2 = 2.0f * s1; @@ -42,8 +44,8 @@ void GlareGhostOperation::generateGlare(float *data, MemoryBuffer *inputTile, No float sc, isc, u, v, sm, s, t, ofs, scalef[64]; const float cmo = 1.0f - settings->colmod; - MemoryBuffer gbuf(*inputTile); - MemoryBuffer tbuf1(*inputTile); + MemoryBuffer gbuf(*input_tile); + MemoryBuffer tbuf1(*input_tile); bool breaked = false; @@ -51,7 +53,7 @@ void GlareGhostOperation::generateGlare(float *data, MemoryBuffer *inputTile, No if (!breaked) { FastGaussianBlurOperation::IIR_gauss(&tbuf1, s1, 1, 3); } - if (isBraked()) { + if (is_braked()) { breaked = true; } if (!breaked) { @@ -60,19 +62,19 @@ void GlareGhostOperation::generateGlare(float *data, MemoryBuffer *inputTile, No MemoryBuffer tbuf2(tbuf1); - if (isBraked()) { + if (is_braked()) { breaked = true; } if (!breaked) { FastGaussianBlurOperation::IIR_gauss(&tbuf2, s2, 0, 3); } - if (isBraked()) { + if (is_braked()) { breaked = true; } if (!breaked) { FastGaussianBlurOperation::IIR_gauss(&tbuf2, s2, 1, 3); } - if (isBraked()) { + if (is_braked()) { breaked = true; } if (!breaked) { @@ -100,59 +102,59 @@ void GlareGhostOperation::generateGlare(float *data, MemoryBuffer *inputTile, No sc = 2.13; isc = -0.97; - for (y = 0; y < gbuf.getHeight() && (!breaked); y++) { - v = ((float)y + 0.5f) / (float)gbuf.getHeight(); - for (x = 0; x < gbuf.getWidth(); x++) { - u = ((float)x + 0.5f) / (float)gbuf.getWidth(); + for (y = 0; y < gbuf.get_height() && (!breaked); y++) { + v = ((float)y + 0.5f) / (float)gbuf.get_height(); + for (x = 0; x < gbuf.get_width(); x++) { + u = ((float)x + 0.5f) / (float)gbuf.get_width(); s = (u - 0.5f) * sc + 0.5f; t = (v - 0.5f) * sc + 0.5f; - tbuf1.readBilinear(c, s * gbuf.getWidth(), t * gbuf.getHeight()); - sm = smoothMask(s, t); + tbuf1.read_bilinear(c, s * gbuf.get_width(), t * gbuf.get_height()); + sm = smooth_mask(s, t); mul_v3_fl(c, sm); s = (u - 0.5f) * isc + 0.5f; t = (v - 0.5f) * isc + 0.5f; - tbuf2.readBilinear(tc, s * gbuf.getWidth() - 0.5f, t * gbuf.getHeight() - 0.5f); - sm = smoothMask(s, t); + tbuf2.read_bilinear(tc, s * gbuf.get_width() - 0.5f, t * gbuf.get_height() - 0.5f); + sm = smooth_mask(s, t); madd_v3_v3fl(c, tc, sm); - gbuf.writePixel(x, y, c); + gbuf.write_pixel(x, y, c); } - if (isBraked()) { + if (is_braked()) { breaked = true; } } - memset(tbuf1.getBuffer(), + memset(tbuf1.get_buffer(), 0, - tbuf1.getWidth() * tbuf1.getHeight() * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float)); + tbuf1.get_width() * tbuf1.get_height() * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float)); for (n = 1; n < settings->iter && (!breaked); n++) { - for (y = 0; y < gbuf.getHeight() && (!breaked); y++) { - v = ((float)y + 0.5f) / (float)gbuf.getHeight(); - for (x = 0; x < gbuf.getWidth(); x++) { - u = ((float)x + 0.5f) / (float)gbuf.getWidth(); + for (y = 0; y < gbuf.get_height() && (!breaked); y++) { + v = ((float)y + 0.5f) / (float)gbuf.get_height(); + for (x = 0; x < gbuf.get_width(); x++) { + u = ((float)x + 0.5f) / (float)gbuf.get_width(); tc[0] = tc[1] = tc[2] = 0.0f; for (p = 0; p < 4; p++) { np = (n << 2) + p; s = (u - 0.5f) * scalef[np] + 0.5f; t = (v - 0.5f) * scalef[np] + 0.5f; - gbuf.readBilinear(c, s * gbuf.getWidth() - 0.5f, t * gbuf.getHeight() - 0.5f); + gbuf.read_bilinear(c, s * gbuf.get_width() - 0.5f, t * gbuf.get_height() - 0.5f); mul_v3_v3(c, cm[np]); - sm = smoothMask(s, t) * 0.25f; + sm = smooth_mask(s, t) * 0.25f; madd_v3_v3fl(tc, c, sm); } - tbuf1.addPixel(x, y, tc); + tbuf1.add_pixel(x, y, tc); } - if (isBraked()) { + if (is_braked()) { breaked = true; } } - memcpy(gbuf.getBuffer(), - tbuf1.getBuffer(), - tbuf1.getWidth() * tbuf1.getHeight() * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float)); + memcpy(gbuf.get_buffer(), + tbuf1.get_buffer(), + tbuf1.get_width() * tbuf1.get_height() * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float)); } memcpy(data, - gbuf.getBuffer(), - gbuf.getWidth() * gbuf.getHeight() * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float)); + gbuf.get_buffer(), + gbuf.get_width() * gbuf.get_height() * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float)); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GlareGhostOperation.h b/source/blender/compositor/operations/COM_GlareGhostOperation.h index 60256d8e0ef..e84084c3f6e 100644 --- a/source/blender/compositor/operations/COM_GlareGhostOperation.h +++ b/source/blender/compositor/operations/COM_GlareGhostOperation.h @@ -31,7 +31,7 @@ class GlareGhostOperation : public GlareBaseOperation { } protected: - void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings) override; + void generate_glare(float *data, MemoryBuffer *input_tile, NodeGlare *settings) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GlareSimpleStarOperation.cc b/source/blender/compositor/operations/COM_GlareSimpleStarOperation.cc index cc24a50a307..5d8dca055aa 100644 --- a/source/blender/compositor/operations/COM_GlareSimpleStarOperation.cc +++ b/source/blender/compositor/operations/COM_GlareSimpleStarOperation.cc @@ -20,26 +20,26 @@ namespace blender::compositor { -void GlareSimpleStarOperation::generateGlare(float *data, - MemoryBuffer *inputTile, - NodeGlare *settings) +void GlareSimpleStarOperation::generate_glare(float *data, + MemoryBuffer *input_tile, + NodeGlare *settings) { int i, x, y, ym, yp, xm, xp; float c[4] = {0, 0, 0, 0}, tc[4] = {0, 0, 0, 0}; const float f1 = 1.0f - settings->fade; const float f2 = (1.0f - f1) * 0.5f; - MemoryBuffer tbuf1(*inputTile); - MemoryBuffer tbuf2(*inputTile); + MemoryBuffer tbuf1(*input_tile); + MemoryBuffer tbuf2(*input_tile); bool breaked = false; for (i = 0; i < settings->iter && (!breaked); i++) { // // (x || x-1, y-1) to (x || x+1, y+1) // // F - for (y = 0; y < this->getHeight() && (!breaked); y++) { + for (y = 0; y < this->get_height() && (!breaked); y++) { ym = y - i; yp = y + i; - for (x = 0; x < this->getWidth(); x++) { + for (x = 0; x < this->get_width(); x++) { xm = x - i; xp = x + i; tbuf1.read(c, x, y); @@ -49,7 +49,7 @@ void GlareSimpleStarOperation::generateGlare(float *data, tbuf1.read(tc, (settings->star_45 ? xp : x), yp); madd_v3_v3fl(c, tc, f2); c[3] = 1.0f; - tbuf1.writePixel(x, y, c); + tbuf1.write_pixel(x, y, c); tbuf2.read(c, x, y); mul_v3_fl(c, f1); @@ -58,17 +58,17 @@ void GlareSimpleStarOperation::generateGlare(float *data, tbuf2.read(tc, xp, (settings->star_45 ? ym : y)); madd_v3_v3fl(c, tc, f2); c[3] = 1.0f; - tbuf2.writePixel(x, y, c); + tbuf2.write_pixel(x, y, c); } - if (isBraked()) { + if (is_braked()) { breaked = true; } } // // B - for (y = this->getHeight() - 1; y >= 0 && (!breaked); y--) { + for (y = this->get_height() - 1; y >= 0 && (!breaked); y--) { ym = y - i; yp = y + i; - for (x = this->getWidth() - 1; x >= 0; x--) { + for (x = this->get_width() - 1; x >= 0; x--) { xm = x - i; xp = x + i; tbuf1.read(c, x, y); @@ -78,7 +78,7 @@ void GlareSimpleStarOperation::generateGlare(float *data, tbuf1.read(tc, (settings->star_45 ? xp : x), yp); madd_v3_v3fl(c, tc, f2); c[3] = 1.0f; - tbuf1.writePixel(x, y, c); + tbuf1.write_pixel(x, y, c); tbuf2.read(c, x, y); mul_v3_fl(c, f1); @@ -87,16 +87,16 @@ void GlareSimpleStarOperation::generateGlare(float *data, tbuf2.read(tc, xp, (settings->star_45 ? ym : y)); madd_v3_v3fl(c, tc, f2); c[3] = 1.0f; - tbuf2.writePixel(x, y, c); + tbuf2.write_pixel(x, y, c); } - if (isBraked()) { + if (is_braked()) { breaked = true; } } } - for (i = 0; i < this->getWidth() * this->getHeight() * 4; i++) { - data[i] = tbuf1.getBuffer()[i] + tbuf2.getBuffer()[i]; + for (i = 0; i < this->get_width() * this->get_height() * 4; i++) { + data[i] = tbuf1.get_buffer()[i] + tbuf2.get_buffer()[i]; } } diff --git a/source/blender/compositor/operations/COM_GlareSimpleStarOperation.h b/source/blender/compositor/operations/COM_GlareSimpleStarOperation.h index 4a074f53e7b..be162bbda44 100644 --- a/source/blender/compositor/operations/COM_GlareSimpleStarOperation.h +++ b/source/blender/compositor/operations/COM_GlareSimpleStarOperation.h @@ -31,7 +31,7 @@ class GlareSimpleStarOperation : public GlareBaseOperation { } protected: - void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings) override; + void generate_glare(float *data, MemoryBuffer *input_tile, NodeGlare *settings) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GlareStreaksOperation.cc b/source/blender/compositor/operations/COM_GlareStreaksOperation.cc index 8ffe44d9a36..f4d9b588917 100644 --- a/source/blender/compositor/operations/COM_GlareStreaksOperation.cc +++ b/source/blender/compositor/operations/COM_GlareStreaksOperation.cc @@ -20,22 +20,22 @@ namespace blender::compositor { -void GlareStreaksOperation::generateGlare(float *data, - MemoryBuffer *inputTile, - NodeGlare *settings) +void GlareStreaksOperation::generate_glare(float *data, + MemoryBuffer *input_tile, + NodeGlare *settings) { int x, y, n; unsigned int nump = 0; float c1[4], c2[4], c3[4], c4[4]; float a, ang = DEG2RADF(360.0f) / (float)settings->streaks; - int size = inputTile->getWidth() * inputTile->getHeight(); + int size = input_tile->get_width() * input_tile->get_height(); int size4 = size * 4; bool breaked = false; - MemoryBuffer tsrc(*inputTile); - MemoryBuffer tdst(DataType::Color, inputTile->get_rect()); + MemoryBuffer tsrc(*input_tile); + MemoryBuffer tdst(DataType::Color, input_tile->get_rect()); tdst.clear(); memset(data, 0, size4 * sizeof(float)); @@ -50,9 +50,9 @@ void GlareStreaksOperation::generateGlare(float *data, /* Color-modulation amount relative to current pass. */ const float cmo = 1.0f - (float)pow((double)settings->colmod, (double)n + 1); - float *tdstcol = tdst.getBuffer(); - for (y = 0; y < tsrc.getHeight() && (!breaked); y++) { - for (x = 0; x < tsrc.getWidth(); x++, tdstcol += 4) { + float *tdstcol = tdst.get_buffer(); + for (y = 0; y < tsrc.get_height() && (!breaked); y++) { + for (x = 0; x < tsrc.get_width(); x++, tdstcol += 4) { /* First pass no offset, always same for every pass, exact copy, * otherwise results in uneven brightness, only need once. */ if (n == 0) { @@ -61,9 +61,9 @@ void GlareStreaksOperation::generateGlare(float *data, else { c1[0] = c1[1] = c1[2] = 0; } - tsrc.readBilinear(c2, x + vxp, y + vyp); - tsrc.readBilinear(c3, x + vxp * 2.0f, y + vyp * 2.0f); - tsrc.readBilinear(c4, x + vxp * 3.0f, y + vyp * 3.0f); + tsrc.read_bilinear(c2, x + vxp, y + vyp); + tsrc.read_bilinear(c3, x + vxp * 2.0f, y + vyp * 2.0f); + tsrc.read_bilinear(c4, x + vxp * 3.0f, y + vyp * 3.0f); /* Modulate color to look vaguely similar to a color spectrum. */ c2[1] *= cmo; c2[2] *= cmo; @@ -79,14 +79,14 @@ void GlareStreaksOperation::generateGlare(float *data, tdstcol[2] = 0.5f * (tdstcol[2] + c1[2] + wt * (c2[2] + wt * (c3[2] + wt * c4[2]))); tdstcol[3] = 1.0f; } - if (isBraked()) { + if (is_braked()) { breaked = true; } } - memcpy(tsrc.getBuffer(), tdst.getBuffer(), sizeof(float) * size4); + memcpy(tsrc.get_buffer(), tdst.get_buffer(), sizeof(float) * size4); } - float *sourcebuffer = tsrc.getBuffer(); + float *sourcebuffer = tsrc.get_buffer(); float factor = 1.0f / (float)(6 - settings->iter); for (int i = 0; i < size4; i += 4) { madd_v3_v3fl(&data[i], &sourcebuffer[i], factor); @@ -94,7 +94,7 @@ void GlareStreaksOperation::generateGlare(float *data, } tdst.clear(); - memcpy(tsrc.getBuffer(), inputTile->getBuffer(), sizeof(float) * size4); + memcpy(tsrc.get_buffer(), input_tile->get_buffer(), sizeof(float) * size4); nump++; } } diff --git a/source/blender/compositor/operations/COM_GlareStreaksOperation.h b/source/blender/compositor/operations/COM_GlareStreaksOperation.h index 487c910960a..bad73687afd 100644 --- a/source/blender/compositor/operations/COM_GlareStreaksOperation.h +++ b/source/blender/compositor/operations/COM_GlareStreaksOperation.h @@ -31,7 +31,7 @@ class GlareStreaksOperation : public GlareBaseOperation { } protected: - void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings) override; + void generate_glare(float *data, MemoryBuffer *input_tile, NodeGlare *settings) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_GlareThresholdOperation.cc b/source/blender/compositor/operations/COM_GlareThresholdOperation.cc index 7135155cb68..0538b4e48a0 100644 --- a/source/blender/compositor/operations/COM_GlareThresholdOperation.cc +++ b/source/blender/compositor/operations/COM_GlareThresholdOperation.cc @@ -24,9 +24,9 @@ namespace blender::compositor { GlareThresholdOperation::GlareThresholdOperation() { - this->addInputSocket(DataType::Color, ResizeMode::FitAny); - this->addOutputSocket(DataType::Color); - inputProgram_ = nullptr; + this->add_input_socket(DataType::Color, ResizeMode::FitAny); + this->add_output_socket(DataType::Color); + input_program_ = nullptr; } void GlareThresholdOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -38,19 +38,19 @@ void GlareThresholdOperation::determine_canvas(const rcti &preferred_area, rcti r_area.ymax = r_area.ymin + height; } -void GlareThresholdOperation::initExecution() +void GlareThresholdOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); + input_program_ = this->get_input_socket_reader(0); } -void GlareThresholdOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void GlareThresholdOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { const float threshold = settings_->threshold; - inputProgram_->readSampled(output, x, y, sampler); + input_program_->read_sampled(output, x, y, sampler); if (IMB_colormanagement_get_luminance(output) >= threshold) { output[0] -= threshold; output[1] -= threshold; @@ -65,9 +65,9 @@ void GlareThresholdOperation::executePixelSampled(float output[4], } } -void GlareThresholdOperation::deinitExecution() +void GlareThresholdOperation::deinit_execution() { - inputProgram_ = nullptr; + input_program_ = nullptr; } void GlareThresholdOperation::update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_GlareThresholdOperation.h b/source/blender/compositor/operations/COM_GlareThresholdOperation.h index f37020b61a8..41eac34375d 100644 --- a/source/blender/compositor/operations/COM_GlareThresholdOperation.h +++ b/source/blender/compositor/operations/COM_GlareThresholdOperation.h @@ -26,9 +26,9 @@ namespace blender::compositor { class GlareThresholdOperation : public MultiThreadedOperation { private: /** - * \brief Cached reference to the inputProgram + * \brief Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; /** * \brief settings of the glare node. @@ -41,19 +41,19 @@ class GlareThresholdOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setGlareSettings(NodeGlare *settings) + void set_glare_settings(NodeGlare *settings) { settings_ = settings; } diff --git a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cc b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cc index e2f4552c69c..d1fad29498a 100644 --- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cc +++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cc @@ -26,36 +26,36 @@ namespace blender::compositor { HueSaturationValueCorrectOperation::HueSaturationValueCorrectOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); - inputProgram_ = nullptr; + input_program_ = nullptr; } -void HueSaturationValueCorrectOperation::initExecution() +void HueSaturationValueCorrectOperation::init_execution() { - CurveBaseOperation::initExecution(); - inputProgram_ = this->getInputSocketReader(0); + CurveBaseOperation::init_execution(); + input_program_ = this->get_input_socket_reader(0); } -void HueSaturationValueCorrectOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void HueSaturationValueCorrectOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float hsv[4], f; - inputProgram_->readSampled(hsv, x, y, sampler); + input_program_->read_sampled(hsv, x, y, sampler); /* adjust hue, scaling returned default 0.5 up to 1 */ - f = BKE_curvemapping_evaluateF(curveMapping_, 0, hsv[0]); + f = BKE_curvemapping_evaluateF(curve_mapping_, 0, hsv[0]); hsv[0] += f - 0.5f; /* adjust saturation, scaling returned default 0.5 up to 1 */ - f = BKE_curvemapping_evaluateF(curveMapping_, 1, hsv[0]); + f = BKE_curvemapping_evaluateF(curve_mapping_, 1, hsv[0]); hsv[1] *= (f * 2.0f); /* adjust value, scaling returned default 0.5 up to 1 */ - f = BKE_curvemapping_evaluateF(curveMapping_, 2, hsv[0]); + f = BKE_curvemapping_evaluateF(curve_mapping_, 2, hsv[0]); hsv[2] *= (f * 2.0f); hsv[0] = hsv[0] - floorf(hsv[0]); /* mod 1.0 */ @@ -67,10 +67,10 @@ void HueSaturationValueCorrectOperation::executePixelSampled(float output[4], output[3] = hsv[3]; } -void HueSaturationValueCorrectOperation::deinitExecution() +void HueSaturationValueCorrectOperation::deinit_execution() { - CurveBaseOperation::deinitExecution(); - inputProgram_ = nullptr; + CurveBaseOperation::deinit_execution(); + input_program_ = 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(curveMapping_, 0, hsv[0]); + float f = BKE_curvemapping_evaluateF(curve_mapping_, 0, hsv[0]); hsv[0] += f - 0.5f; /* Adjust saturation, scaling returned default 0.5 up to 1. */ - f = BKE_curvemapping_evaluateF(curveMapping_, 1, hsv[0]); + f = BKE_curvemapping_evaluateF(curve_mapping_, 1, hsv[0]); hsv[1] *= (f * 2.0f); /* Adjust value, scaling returned default 0.5 up to 1. */ - f = BKE_curvemapping_evaluateF(curveMapping_, 2, hsv[0]); + f = BKE_curvemapping_evaluateF(curve_mapping_, 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 26792a54d26..ac64d31e494 100644 --- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h +++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h @@ -26,9 +26,9 @@ namespace blender::compositor { class HueSaturationValueCorrectOperation : public CurveBaseOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; public: HueSaturationValueCorrectOperation(); @@ -36,17 +36,17 @@ class HueSaturationValueCorrectOperation : public CurveBaseOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_IDMaskOperation.cc b/source/blender/compositor/operations/COM_IDMaskOperation.cc index 677d0a8ccff..5837cb1fda9 100644 --- a/source/blender/compositor/operations/COM_IDMaskOperation.cc +++ b/source/blender/compositor/operations/COM_IDMaskOperation.cc @@ -22,25 +22,25 @@ namespace blender::compositor { IDMaskOperation::IDMaskOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); this->flags.complex = true; flags.can_be_constant = true; } -void *IDMaskOperation::initializeTileData(rcti *rect) +void *IDMaskOperation::initialize_tile_data(rcti *rect) { - void *buffer = getInputOperation(0)->initializeTileData(rect); + void *buffer = get_input_operation(0)->initialize_tile_data(rect); return buffer; } -void IDMaskOperation::executePixel(float output[4], int x, int y, void *data) +void IDMaskOperation::execute_pixel(float output[4], int x, int y, void *data) { MemoryBuffer *input_buffer = (MemoryBuffer *)data; - const int buffer_width = input_buffer->getWidth(); - float *buffer = input_buffer->getBuffer(); + const int buffer_width = input_buffer->get_width(); + float *buffer = input_buffer->get_buffer(); int buffer_index = (y * buffer_width + x); - output[0] = (roundf(buffer[buffer_index]) == objectIndex_) ? 1.0f : 0.0f; + output[0] = (roundf(buffer[buffer_index]) == object_index_) ? 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]) == objectIndex_) ? 1.0f : 0.0f; + out[0] = (roundf(in[0]) == object_index_) ? 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 333f9eeee98..3a7ceec8c49 100644 --- a/source/blender/compositor/operations/COM_IDMaskOperation.h +++ b/source/blender/compositor/operations/COM_IDMaskOperation.h @@ -24,17 +24,17 @@ namespace blender::compositor { class IDMaskOperation : public MultiThreadedOperation { private: - float objectIndex_; + float object_index_; public: IDMaskOperation(); - void *initializeTileData(rcti *rect) override; - void executePixel(float output[4], int x, int y, void *data) override; + void *initialize_tile_data(rcti *rect) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void setObjectIndex(float objectIndex) + void set_object_index(float object_index) { - objectIndex_ = objectIndex; + object_index_ = object_index; } 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 84c5b9654ce..e32343cfbf2 100644 --- a/source/blender/compositor/operations/COM_ImageOperation.cc +++ b/source/blender/compositor/operations/COM_ImageOperation.cc @@ -30,35 +30,35 @@ BaseImageOperation::BaseImageOperation() { image_ = nullptr; buffer_ = nullptr; - imageFloatBuffer_ = nullptr; - imageByteBuffer_ = nullptr; - imageUser_ = nullptr; + image_float_buffer_ = nullptr; + image_byte_buffer_ = nullptr; + image_user_ = nullptr; imagewidth_ = 0; imageheight_ = 0; framenumber_ = 0; - depthBuffer_ = nullptr; + image_depth_buffer_ = nullptr; depth_buffer_ = nullptr; - numberOfChannels_ = 0; + number_of_channels_ = 0; rd_ = nullptr; - viewName_ = nullptr; + view_name_ = nullptr; } ImageOperation::ImageOperation() : BaseImageOperation() { - this->addOutputSocket(DataType::Color); + this->add_output_socket(DataType::Color); } ImageAlphaOperation::ImageAlphaOperation() : BaseImageOperation() { - this->addOutputSocket(DataType::Value); + this->add_output_socket(DataType::Value); } ImageDepthOperation::ImageDepthOperation() : BaseImageOperation() { - this->addOutputSocket(DataType::Value); + this->add_output_socket(DataType::Value); } -ImBuf *BaseImageOperation::getImBuf() +ImBuf *BaseImageOperation::get_im_buf() { ImBuf *ibuf; - ImageUser iuser = *imageUser_; + ImageUser iuser = *image_user_; if (image_ == nullptr) { return nullptr; @@ -66,7 +66,7 @@ ImBuf *BaseImageOperation::getImBuf() /* local changes to the original ImageUser */ if (BKE_image_is_multilayer(image_) == false) { - iuser.multi_index = BKE_scene_multiview_view_id_get(rd_, viewName_); + iuser.multi_index = BKE_scene_multiview_view_id_get(rd_, view_name_); } ibuf = BKE_image_acquire_ibuf(image_, &iuser, nullptr); @@ -77,27 +77,27 @@ ImBuf *BaseImageOperation::getImBuf() return ibuf; } -void BaseImageOperation::initExecution() +void BaseImageOperation::init_execution() { - ImBuf *stackbuf = getImBuf(); + ImBuf *stackbuf = get_im_buf(); buffer_ = stackbuf; if (stackbuf) { - imageFloatBuffer_ = stackbuf->rect_float; - imageByteBuffer_ = stackbuf->rect; - depthBuffer_ = stackbuf->zbuf_float; + image_float_buffer_ = stackbuf->rect_float; + image_byte_buffer_ = stackbuf->rect; + image_depth_buffer_ = stackbuf->zbuf_float; if (stackbuf->zbuf_float) { depth_buffer_ = new MemoryBuffer(stackbuf->zbuf_float, 1, stackbuf->x, stackbuf->y); } imagewidth_ = stackbuf->x; imageheight_ = stackbuf->y; - numberOfChannels_ = stackbuf->channels; + number_of_channels_ = stackbuf->channels; } } -void BaseImageOperation::deinitExecution() +void BaseImageOperation::deinit_execution() { - imageFloatBuffer_ = nullptr; - imageByteBuffer_ = nullptr; + image_float_buffer_ = nullptr; + image_byte_buffer_ = nullptr; BKE_image_release_ibuf(image_, buffer_, nullptr); if (depth_buffer_) { delete depth_buffer_; @@ -107,7 +107,7 @@ void BaseImageOperation::deinitExecution() void BaseImageOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area) { - ImBuf *stackbuf = getImBuf(); + ImBuf *stackbuf = get_im_buf(); r_area = COM_AREA_NONE; @@ -118,7 +118,7 @@ void BaseImageOperation::determine_canvas(const rcti &UNUSED(preferred_area), rc BKE_image_release_ibuf(image_, stackbuf, nullptr); } -static void sampleImageAtLocation( +static void sample_image_at_location( ImBuf *ibuf, float x, float y, PixelSampler sampler, bool make_linear_rgb, float color[4]) { if (ibuf->rect_float) { @@ -154,17 +154,17 @@ static void sampleImageAtLocation( } } -void ImageOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void ImageOperation::execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) { int ix = x, iy = y; - if (imageFloatBuffer_ == nullptr && imageByteBuffer_ == nullptr) { + if (image_float_buffer_ == nullptr && image_byte_buffer_ == nullptr) { zero_v4(output); } else if (ix < 0 || iy < 0 || ix >= buffer_->x || iy >= buffer_->y) { zero_v4(output); } else { - sampleImageAtLocation(buffer_, x, y, sampler, true, output); + sample_image_at_location(buffer_, x, y, sampler, true, output); } } @@ -175,19 +175,19 @@ void ImageOperation::update_memory_buffer_partial(MemoryBuffer *output, output->copy_from(buffer_, area, true); } -void ImageAlphaOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ImageAlphaOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float tempcolor[4]; - if (imageFloatBuffer_ == nullptr && imageByteBuffer_ == nullptr) { + if (image_float_buffer_ == nullptr && image_byte_buffer_ == nullptr) { output[0] = 0.0f; } else { tempcolor[3] = 1.0f; - sampleImageAtLocation(buffer_, x, y, sampler, false, tempcolor); + sample_image_at_location(buffer_, x, y, sampler, false, tempcolor); output[0] = tempcolor[3]; } } @@ -199,21 +199,21 @@ void ImageAlphaOperation::update_memory_buffer_partial(MemoryBuffer *output, output->copy_from(buffer_, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0); } -void ImageDepthOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void ImageDepthOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { - if (depthBuffer_ == nullptr) { + if (image_depth_buffer_ == nullptr) { output[0] = 0.0f; } else { - if (x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight()) { + if (x < 0 || y < 0 || x >= this->get_width() || y >= this->get_height()) { output[0] = 0.0f; } else { - int offset = y * getWidth() + x; - output[0] = depthBuffer_[offset]; + int offset = y * get_width() + x; + output[0] = image_depth_buffer_[offset]; } } } diff --git a/source/blender/compositor/operations/COM_ImageOperation.h b/source/blender/compositor/operations/COM_ImageOperation.h index 40ef9f38f79..054398604b6 100644 --- a/source/blender/compositor/operations/COM_ImageOperation.h +++ b/source/blender/compositor/operations/COM_ImageOperation.h @@ -36,19 +36,19 @@ class BaseImageOperation : public MultiThreadedOperation { protected: ImBuf *buffer_; Image *image_; - ImageUser *imageUser_; + ImageUser *image_user_; /* TODO: Remove raw buffers when removing Tiled implementation. */ - float *imageFloatBuffer_; - unsigned int *imageByteBuffer_; - float *depthBuffer_; + float *image_float_buffer_; + unsigned int *image_byte_buffer_; + float *image_depth_buffer_; MemoryBuffer *depth_buffer_; int imageheight_; int imagewidth_; int framenumber_; - int numberOfChannels_; + int number_of_channels_; const RenderData *rd_; - const char *viewName_; + const char *view_name_; BaseImageOperation(); /** @@ -56,28 +56,28 @@ class BaseImageOperation : public MultiThreadedOperation { */ void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - virtual ImBuf *getImBuf(); + virtual ImBuf *get_im_buf(); public: - void initExecution() override; - void deinitExecution() override; - void setImage(Image *image) + void init_execution() override; + void deinit_execution() override; + void set_image(Image *image) { image_ = image; } - void setImageUser(ImageUser *imageuser) + void set_image_user(ImageUser *imageuser) { - imageUser_ = imageuser; + image_user_ = imageuser; } - void setRenderData(const RenderData *rd) + void set_render_data(const RenderData *rd) { rd_ = rd; } - void setViewName(const char *viewName) + void set_view_name(const char *view_name) { - viewName_ = viewName; + view_name_ = view_name; } - void setFramenumber(int framenumber) + void set_framenumber(int framenumber) { framenumber_ = framenumber; } @@ -88,7 +88,7 @@ class ImageOperation : public BaseImageOperation { * Constructor */ ImageOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -100,7 +100,7 @@ class ImageAlphaOperation : public BaseImageOperation { * Constructor */ ImageAlphaOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -112,7 +112,7 @@ class ImageDepthOperation : public BaseImageOperation { * Constructor */ ImageDepthOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_InpaintOperation.cc b/source/blender/compositor/operations/COM_InpaintOperation.cc index 45b163c7e8b..96cd0043470 100644 --- a/source/blender/compositor/operations/COM_InpaintOperation.cc +++ b/source/blender/compositor/operations/COM_InpaintOperation.cc @@ -23,37 +23,37 @@ namespace blender::compositor { #define ASSERT_XY_RANGE(x, y) \ - BLI_assert(x >= 0 && x < this->getWidth() && y >= 0 && y < this->getHeight()) + BLI_assert(x >= 0 && x < this->get_width() && y >= 0 && y < this->get_height()) /* In-paint (simple convolve using average of known pixels). */ InpaintSimpleOperation::InpaintSimpleOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); this->flags.complex = true; - inputImageProgram_ = nullptr; + input_image_program_ = nullptr; pixelorder_ = nullptr; manhattan_distance_ = nullptr; cached_buffer_ = nullptr; cached_buffer_ready_ = false; flags.is_fullframe_operation = true; } -void InpaintSimpleOperation::initExecution() +void InpaintSimpleOperation::init_execution() { - inputImageProgram_ = this->getInputSocketReader(0); + input_image_program_ = this->get_input_socket_reader(0); pixelorder_ = nullptr; manhattan_distance_ = nullptr; cached_buffer_ = nullptr; cached_buffer_ready_ = false; - this->initMutex(); + this->init_mutex(); } void InpaintSimpleOperation::clamp_xy(int &x, int &y) { - int width = this->getWidth(); - int height = this->getHeight(); + int width = this->get_width(); + int height = this->get_height(); if (x < 0) { x = 0; @@ -72,7 +72,7 @@ void InpaintSimpleOperation::clamp_xy(int &x, int &y) float *InpaintSimpleOperation::get_pixel(int x, int y) { - int width = this->getWidth(); + int width = this->get_width(); ASSERT_XY_RANGE(x, y); @@ -82,7 +82,7 @@ float *InpaintSimpleOperation::get_pixel(int x, int y) int InpaintSimpleOperation::mdist(int x, int y) { - int width = this->getWidth(); + int width = this->get_width(); ASSERT_XY_RANGE(x, y); @@ -91,7 +91,7 @@ int InpaintSimpleOperation::mdist(int x, int y) bool InpaintSimpleOperation::next_pixel(int &x, int &y, int &curr, int iters) { - int width = this->getWidth(); + int width = this->get_width(); if (curr >= area_size_) { return false; @@ -111,8 +111,8 @@ bool InpaintSimpleOperation::next_pixel(int &x, int &y, int &curr, int iters) void InpaintSimpleOperation::calc_manhattan_distance() { - int width = this->getWidth(); - int height = this->getHeight(); + int width = this->get_width(); + int height = this->get_height(); short *m = manhattan_distance_ = (short *)MEM_mallocN(sizeof(short) * width * height, __func__); int *offsets; @@ -213,15 +213,15 @@ void InpaintSimpleOperation::pix_step(int x, int y) } } -void *InpaintSimpleOperation::initializeTileData(rcti *rect) +void *InpaintSimpleOperation::initialize_tile_data(rcti *rect) { if (cached_buffer_ready_) { return cached_buffer_; } - lockMutex(); + lock_mutex(); if (!cached_buffer_ready_) { - MemoryBuffer *buf = (MemoryBuffer *)inputImageProgram_->initializeTileData(rect); - cached_buffer_ = (float *)MEM_dupallocN(buf->getBuffer()); + MemoryBuffer *buf = (MemoryBuffer *)input_image_program_->initialize_tile_data(rect); + cached_buffer_ = (float *)MEM_dupallocN(buf->get_buffer()); this->calc_manhattan_distance(); @@ -234,20 +234,20 @@ void *InpaintSimpleOperation::initializeTileData(rcti *rect) cached_buffer_ready_ = true; } - unlockMutex(); + unlock_mutex(); return cached_buffer_; } -void InpaintSimpleOperation::executePixel(float output[4], int x, int y, void * /*data*/) +void InpaintSimpleOperation::execute_pixel(float output[4], int x, int y, void * /*data*/) { this->clamp_xy(x, y); copy_v4_v4(output, this->get_pixel(x, y)); } -void InpaintSimpleOperation::deinitExecution() +void InpaintSimpleOperation::deinit_execution() { - inputImageProgram_ = nullptr; - this->deinitMutex(); + input_image_program_ = nullptr; + this->deinit_mutex(); if (cached_buffer_) { MEM_freeN(cached_buffer_); cached_buffer_ = nullptr; @@ -265,22 +265,21 @@ void InpaintSimpleOperation::deinitExecution() cached_buffer_ready_ = false; } -bool InpaintSimpleOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool InpaintSimpleOperation::determine_depending_area_of_interest( + rcti * /*input*/, ReadBufferOperation *read_operation, rcti *output) { if (cached_buffer_ready_) { return false; } - rcti newInput; + rcti new_input; - newInput.xmax = getWidth(); - newInput.xmin = 0; - newInput.ymax = getHeight(); - newInput.ymin = 0; + new_input.xmax = get_width(); + new_input.xmin = 0; + new_input.ymax = get_height(); + new_input.ymin = 0; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void InpaintSimpleOperation::get_area_of_interest(const int input_idx, @@ -305,7 +304,7 @@ void InpaintSimpleOperation::update_memory_buffer(MemoryBuffer *output, delete tmp; } else { - cached_buffer_ = (float *)MEM_dupallocN(input->getBuffer()); + cached_buffer_ = (float *)MEM_dupallocN(input->get_buffer()); } this->calc_manhattan_distance(); @@ -318,8 +317,8 @@ void InpaintSimpleOperation::update_memory_buffer(MemoryBuffer *output, cached_buffer_ready_ = true; } - const int num_channels = COM_data_type_num_channels(getOutputSocket()->getDataType()); - MemoryBuffer buf(cached_buffer_, num_channels, input->getWidth(), input->getHeight()); + const int num_channels = COM_data_type_num_channels(get_output_socket()->get_data_type()); + MemoryBuffer buf(cached_buffer_, num_channels, input->get_width(), input->get_height()); output->copy_from(&buf, area); } diff --git a/source/blender/compositor/operations/COM_InpaintOperation.h b/source/blender/compositor/operations/COM_InpaintOperation.h index 4187099f346..b0d44e22b85 100644 --- a/source/blender/compositor/operations/COM_InpaintOperation.h +++ b/source/blender/compositor/operations/COM_InpaintOperation.h @@ -25,9 +25,9 @@ namespace blender::compositor { class InpaintSimpleOperation : public NodeOperation { protected: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputImageProgram_; + SocketReader *input_image_program_; int iterations_; @@ -44,27 +44,27 @@ class InpaintSimpleOperation : public NodeOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setIterations(int iterations) + void set_iterations(int iterations) { iterations_ = iterations; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(const int input_idx, const rcti &output_area, diff --git a/source/blender/compositor/operations/COM_InvertOperation.cc b/source/blender/compositor/operations/COM_InvertOperation.cc index ba36dd35e47..cbc15c95f46 100644 --- a/source/blender/compositor/operations/COM_InvertOperation.cc +++ b/source/blender/compositor/operations/COM_InvertOperation.cc @@ -22,53 +22,56 @@ namespace blender::compositor { InvertOperation::InvertOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); - inputValueProgram_ = nullptr; - inputColorProgram_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); + input_value_program_ = nullptr; + input_color_program_ = nullptr; color_ = true; alpha_ = false; set_canvas_input_index(1); this->flags.can_be_constant = true; } -void InvertOperation::initExecution() +void InvertOperation::init_execution() { - inputValueProgram_ = this->getInputSocketReader(0); - inputColorProgram_ = this->getInputSocketReader(1); + input_value_program_ = this->get_input_socket_reader(0); + input_color_program_ = this->get_input_socket_reader(1); } -void InvertOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void InvertOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue[4]; - float inputColor[4]; - inputValueProgram_->readSampled(inputValue, x, y, sampler); - inputColorProgram_->readSampled(inputColor, x, y, sampler); + float input_value[4]; + float input_color[4]; + input_value_program_->read_sampled(input_value, x, y, sampler); + input_color_program_->read_sampled(input_color, x, y, sampler); - const float value = inputValue[0]; - const float invertedValue = 1.0f - value; + const float value = input_value[0]; + const float inverted_value = 1.0f - value; 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; + output[0] = (1.0f - input_color[0]) * value + input_color[0] * inverted_value; + output[1] = (1.0f - input_color[1]) * value + input_color[1] * inverted_value; + output[2] = (1.0f - input_color[2]) * value + input_color[2] * inverted_value; } else { - copy_v3_v3(output, inputColor); + copy_v3_v3(output, input_color); } if (alpha_) { - output[3] = (1.0f - inputColor[3]) * value + inputColor[3] * invertedValue; + output[3] = (1.0f - input_color[3]) * value + input_color[3] * inverted_value; } else { - output[3] = inputColor[3]; + output[3] = input_color[3]; } } -void InvertOperation::deinitExecution() +void InvertOperation::deinit_execution() { - inputValueProgram_ = nullptr; - inputColorProgram_ = nullptr; + input_value_program_ = nullptr; + input_color_program_ = nullptr; } void InvertOperation::update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_InvertOperation.h b/source/blender/compositor/operations/COM_InvertOperation.h index 7db0394ad7a..19abca968c0 100644 --- a/source/blender/compositor/operations/COM_InvertOperation.h +++ b/source/blender/compositor/operations/COM_InvertOperation.h @@ -25,10 +25,10 @@ namespace blender::compositor { class InvertOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputValueProgram_; - SocketReader *inputColorProgram_; + SocketReader *input_value_program_; + SocketReader *input_color_program_; bool alpha_; bool color_; @@ -39,23 +39,23 @@ class InvertOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setColor(bool color) + void set_color(bool color) { color_ = color; } - void setAlpha(bool alpha) + void set_alpha(bool alpha) { alpha_ = alpha; } diff --git a/source/blender/compositor/operations/COM_KeyingBlurOperation.cc b/source/blender/compositor/operations/COM_KeyingBlurOperation.cc index fcf304de174..bb82e74f92a 100644 --- a/source/blender/compositor/operations/COM_KeyingBlurOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingBlurOperation.cc @@ -22,8 +22,8 @@ namespace blender::compositor { KeyingBlurOperation::KeyingBlurOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); size_ = 0; axis_ = BLUR_AXIS_X; @@ -31,34 +31,34 @@ KeyingBlurOperation::KeyingBlurOperation() this->flags.complex = true; } -void *KeyingBlurOperation::initializeTileData(rcti *rect) +void *KeyingBlurOperation::initialize_tile_data(rcti *rect) { - void *buffer = getInputOperation(0)->initializeTileData(rect); + void *buffer = get_input_operation(0)->initialize_tile_data(rect); return buffer; } -void KeyingBlurOperation::executePixel(float output[4], int x, int y, void *data) +void KeyingBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - const int bufferWidth = inputBuffer->getWidth(); - float *buffer = inputBuffer->getBuffer(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + const int buffer_width = input_buffer->get_width(); + float *buffer = input_buffer->get_buffer(); int count = 0; float average = 0.0f; if (axis_ == 0) { - const int start = MAX2(0, x - size_ + 1), end = MIN2(bufferWidth, x + size_); + const int start = MAX2(0, x - size_ + 1), end = MIN2(buffer_width, x + size_); for (int cx = start; cx < end; cx++) { - int bufferIndex = (y * bufferWidth + cx); - average += buffer[bufferIndex]; + int buffer_index = (y * buffer_width + cx); + average += buffer[buffer_index]; count++; } } else { - const int start = MAX2(0, y - size_ + 1), end = MIN2(inputBuffer->getHeight(), y + size_); + const int start = MAX2(0, y - size_ + 1), end = MIN2(input_buffer->get_height(), y + size_); for (int cy = start; cy < end; cy++) { - int bufferIndex = (cy * bufferWidth + x); - average += buffer[bufferIndex]; + int buffer_index = (cy * buffer_width + x); + average += buffer[buffer_index]; count++; } } @@ -68,26 +68,26 @@ void KeyingBlurOperation::executePixel(float output[4], int x, int y, void *data output[0] = average; } -bool KeyingBlurOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool KeyingBlurOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; + rcti new_input; if (axis_ == BLUR_AXIS_X) { - newInput.xmin = input->xmin - size_; - newInput.ymin = input->ymin; - newInput.xmax = input->xmax + size_; - newInput.ymax = input->ymax; + new_input.xmin = input->xmin - size_; + new_input.ymin = input->ymin; + new_input.xmax = input->xmax + size_; + new_input.ymax = input->ymax; } else { - newInput.xmin = input->xmin; - newInput.ymin = input->ymin - size_; - newInput.xmax = input->xmax; - newInput.ymax = input->ymax + size_; + new_input.xmin = input->xmin; + new_input.ymin = input->ymin - size_; + new_input.xmax = input->xmax; + new_input.ymax = input->ymax + size_; } - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void KeyingBlurOperation::get_area_of_interest(const int UNUSED(input_idx), @@ -126,12 +126,12 @@ void KeyingBlurOperation::update_memory_buffer_partial(MemoryBuffer *output, switch (axis_) { case BLUR_AXIS_X: get_current_coord = [&] { return it.x; }; - coord_max = this->getWidth(); + coord_max = this->get_width(); elem_stride = input->elem_stride; break; case BLUR_AXIS_Y: get_current_coord = [&] { return it.y; }; - coord_max = this->getHeight(); + coord_max = this->get_height(); elem_stride = input->row_stride; break; } diff --git a/source/blender/compositor/operations/COM_KeyingBlurOperation.h b/source/blender/compositor/operations/COM_KeyingBlurOperation.h index 56fa0f84880..11fde5f5436 100644 --- a/source/blender/compositor/operations/COM_KeyingBlurOperation.h +++ b/source/blender/compositor/operations/COM_KeyingBlurOperation.h @@ -38,22 +38,22 @@ class KeyingBlurOperation : public MultiThreadedOperation { KeyingBlurOperation(); - void setSize(int value) + void set_size(int value) { size_ = value; } - void setAxis(int value) + void set_axis(int value) { axis_ = value; } - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(const int input_idx, const rcti &output_area, diff --git a/source/blender/compositor/operations/COM_KeyingClipOperation.cc b/source/blender/compositor/operations/COM_KeyingClipOperation.cc index e6097dd71a6..03e3f0611c0 100644 --- a/source/blender/compositor/operations/COM_KeyingClipOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingClipOperation.cc @@ -22,47 +22,47 @@ namespace blender::compositor { KeyingClipOperation::KeyingClipOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); - kernelRadius_ = 3; - kernelTolerance_ = 0.1f; + kernel_radius_ = 3; + kernel_tolerance_ = 0.1f; - clipBlack_ = 0.0f; - clipWhite_ = 1.0f; + clip_black_ = 0.0f; + clip_white_ = 1.0f; - isEdgeMatte_ = false; + is_edge_matte_ = false; this->flags.complex = true; } -void *KeyingClipOperation::initializeTileData(rcti *rect) +void *KeyingClipOperation::initialize_tile_data(rcti *rect) { - void *buffer = getInputOperation(0)->initializeTileData(rect); + void *buffer = get_input_operation(0)->initialize_tile_data(rect); return buffer; } -void KeyingClipOperation::executePixel(float output[4], int x, int y, void *data) +void KeyingClipOperation::execute_pixel(float output[4], int x, int y, void *data) { - const int delta = kernelRadius_; - const float tolerance = kernelTolerance_; + const int delta = kernel_radius_; + const float tolerance = kernel_tolerance_; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - float *buffer = inputBuffer->getBuffer(); + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + float *buffer = input_buffer->get_buffer(); - int bufferWidth = inputBuffer->getWidth(); - int bufferHeight = inputBuffer->getHeight(); + int buffer_width = input_buffer->get_width(); + int buffer_height = input_buffer->get_height(); - float value = buffer[(y * bufferWidth + x)]; + float value = buffer[(y * buffer_width + x)]; bool ok = false; int start_x = max_ff(0, x - delta + 1), start_y = max_ff(0, y - delta + 1), - end_x = min_ff(x + delta - 1, bufferWidth - 1), - end_y = min_ff(y + delta - 1, bufferHeight - 1); + end_x = min_ff(x + delta - 1, buffer_width - 1), + end_y = min_ff(y + delta - 1, buffer_height - 1); - int count = 0, totalCount = (end_x - start_x + 1) * (end_y - start_y + 1) - 1; - int thresholdCount = ceil((float)totalCount * 0.9f); + int count = 0, total_count = (end_x - start_x + 1) * (end_y - start_y + 1) - 1; + int threshold_count = ceil((float)total_count * 0.9f); if (delta == 0) { ok = true; @@ -74,19 +74,19 @@ void KeyingClipOperation::executePixel(float output[4], int x, int y, void *data continue; } - int bufferIndex = (cy * bufferWidth + cx); - float currentValue = buffer[bufferIndex]; + int buffer_index = (cy * buffer_width + cx); + float current_value = buffer[buffer_index]; - if (fabsf(currentValue - value) < tolerance) { + if (fabsf(current_value - value) < tolerance) { count++; - if (count >= thresholdCount) { + if (count >= threshold_count) { ok = true; } } } } - if (isEdgeMatte_) { + if (is_edge_matte_) { if (ok) { output[0] = 0.0f; } @@ -98,31 +98,31 @@ void KeyingClipOperation::executePixel(float output[4], int x, int y, void *data output[0] = value; if (ok) { - if (output[0] < clipBlack_) { + if (output[0] < clip_black_) { output[0] = 0.0f; } - else if (output[0] >= clipWhite_) { + else if (output[0] >= clip_white_) { output[0] = 1.0f; } else { - output[0] = (output[0] - clipBlack_) / (clipWhite_ - clipBlack_); + output[0] = (output[0] - clip_black_) / (clip_white_ - clip_black_); } } } } -bool KeyingClipOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool KeyingClipOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; + rcti new_input; - newInput.xmin = input->xmin - kernelRadius_; - newInput.ymin = input->ymin - kernelRadius_; - newInput.xmax = input->xmax + kernelRadius_; - newInput.ymax = input->ymax + kernelRadius_; + new_input.xmin = input->xmin - kernel_radius_; + new_input.ymin = input->ymin - kernel_radius_; + new_input.xmax = input->xmax + kernel_radius_; + new_input.ymax = input->ymax + kernel_radius_; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void KeyingClipOperation::get_area_of_interest(const int input_idx, @@ -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 - 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_; + r_input_area.xmin = output_area.xmin - kernel_radius_; + r_input_area.xmax = output_area.xmax + kernel_radius_; + r_input_area.ymin = output_area.ymin - kernel_radius_; + r_input_area.ymax = output_area.ymax + kernel_radius_; } void KeyingClipOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -144,10 +144,10 @@ void KeyingClipOperation::update_memory_buffer_partial(MemoryBuffer *output, const MemoryBuffer *input = inputs[0]; BuffersIterator it = output->iterate_with(inputs, area); - const int delta = kernelRadius_; - const float tolerance = kernelTolerance_; - const int width = this->getWidth(); - const int height = this->getHeight(); + const int delta = kernel_radius_; + const float tolerance = kernel_tolerance_; + const int width = this->get_width(); + const int height = this->get_height(); const int row_stride = input->row_stride; const int elem_stride = input->elem_stride; for (; !it.is_end(); ++it) { @@ -190,21 +190,21 @@ void KeyingClipOperation::update_memory_buffer_partial(MemoryBuffer *output, } } - if (isEdgeMatte_) { + if (is_edge_matte_) { *it.out = ok ? 0.0f : 1.0f; } else { if (!ok) { *it.out = value; } - else if (value < clipBlack_) { + else if (value < clip_black_) { *it.out = 0.0f; } - else if (value >= clipWhite_) { + else if (value >= clip_white_) { *it.out = 1.0f; } else { - *it.out = (value - clipBlack_) / (clipWhite_ - clipBlack_); + *it.out = (value - clip_black_) / (clip_white_ - clip_black_); } } } diff --git a/source/blender/compositor/operations/COM_KeyingClipOperation.h b/source/blender/compositor/operations/COM_KeyingClipOperation.h index 422d79597ce..3bdc7281683 100644 --- a/source/blender/compositor/operations/COM_KeyingClipOperation.h +++ b/source/blender/compositor/operations/COM_KeyingClipOperation.h @@ -27,47 +27,47 @@ namespace blender::compositor { */ class KeyingClipOperation : public MultiThreadedOperation { protected: - float clipBlack_; - float clipWhite_; + float clip_black_; + float clip_white_; - int kernelRadius_; - float kernelTolerance_; + int kernel_radius_; + float kernel_tolerance_; - bool isEdgeMatte_; + bool is_edge_matte_; public: KeyingClipOperation(); - void setClipBlack(float value) + void set_clip_black(float value) { - clipBlack_ = value; + clip_black_ = value; } - void setClipWhite(float value) + void set_clip_white(float value) { - clipWhite_ = value; + clip_white_ = value; } - void setKernelRadius(int value) + void set_kernel_radius(int value) { - kernelRadius_ = value; + kernel_radius_ = value; } - void setKernelTolerance(float value) + void set_kernel_tolerance(float value) { - kernelTolerance_ = value; + kernel_tolerance_ = value; } - void setIsEdgeMatte(bool value) + void set_is_edge_matte(bool value) { - isEdgeMatte_ = value; + is_edge_matte_ = value; } - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(const int input_idx, const rcti &output_area, diff --git a/source/blender/compositor/operations/COM_KeyingDespillOperation.cc b/source/blender/compositor/operations/COM_KeyingDespillOperation.cc index 8b090d5dc38..f819a39e9e0 100644 --- a/source/blender/compositor/operations/COM_KeyingDespillOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingDespillOperation.cc @@ -22,42 +22,42 @@ namespace blender::compositor { KeyingDespillOperation::KeyingDespillOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); - despillFactor_ = 0.5f; - colorBalance_ = 0.5f; + despill_factor_ = 0.5f; + color_balance_ = 0.5f; - pixelReader_ = nullptr; - screenReader_ = nullptr; + pixel_reader_ = nullptr; + screen_reader_ = nullptr; flags.can_be_constant = true; } -void KeyingDespillOperation::initExecution() +void KeyingDespillOperation::init_execution() { - pixelReader_ = this->getInputSocketReader(0); - screenReader_ = this->getInputSocketReader(1); + pixel_reader_ = this->get_input_socket_reader(0); + screen_reader_ = this->get_input_socket_reader(1); } -void KeyingDespillOperation::deinitExecution() +void KeyingDespillOperation::deinit_execution() { - pixelReader_ = nullptr; - screenReader_ = nullptr; + pixel_reader_ = nullptr; + screen_reader_ = nullptr; } -void KeyingDespillOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void KeyingDespillOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float pixelColor[4]; - float screenColor[4]; + float pixel_color[4]; + float screen_color[4]; - pixelReader_->readSampled(pixelColor, x, y, sampler); - screenReader_->readSampled(screenColor, x, y, sampler); + pixel_reader_->read_sampled(pixel_color, x, y, sampler); + screen_reader_->read_sampled(screen_color, x, y, sampler); - const int screen_primary_channel = max_axis_v3(screenColor); + const int screen_primary_channel = max_axis_v3(screen_color); const int other_1 = (screen_primary_channel + 1) % 3; const int other_2 = (screen_primary_channel + 2) % 3; @@ -66,15 +66,15 @@ void KeyingDespillOperation::executePixelSampled(float output[4], float average_value, amount; - average_value = colorBalance_ * pixelColor[min_channel] + - (1.0f - colorBalance_) * pixelColor[max_channel]; - amount = (pixelColor[screen_primary_channel] - average_value); + average_value = color_balance_ * pixel_color[min_channel] + + (1.0f - color_balance_) * pixel_color[max_channel]; + amount = (pixel_color[screen_primary_channel] - average_value); - copy_v4_v4(output, pixelColor); + copy_v4_v4(output, pixel_color); - const float amount_despill = despillFactor_ * amount; + const float amount_despill = despill_factor_ * amount; if (amount_despill > 0.0f) { - output[screen_primary_channel] = pixelColor[screen_primary_channel] - amount_despill; + output[screen_primary_channel] = pixel_color[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 = colorBalance_ * pixel_color[min_channel] + - (1.0f - colorBalance_) * pixel_color[max_channel]; + const float average_value = color_balance_ * pixel_color[min_channel] + + (1.0f - color_balance_) * 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 = despillFactor_ * amount; + const float amount_despill = despill_factor_ * 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 51efa44ce1c..b57fbd09e74 100644 --- a/source/blender/compositor/operations/COM_KeyingDespillOperation.h +++ b/source/blender/compositor/operations/COM_KeyingDespillOperation.h @@ -27,27 +27,27 @@ namespace blender::compositor { */ class KeyingDespillOperation : public MultiThreadedOperation { protected: - SocketReader *pixelReader_; - SocketReader *screenReader_; - float despillFactor_; - float colorBalance_; + SocketReader *pixel_reader_; + SocketReader *screen_reader_; + float despill_factor_; + float color_balance_; public: KeyingDespillOperation(); - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setDespillFactor(float value) + void set_despill_factor(float value) { - despillFactor_ = value; + despill_factor_ = value; } - void setColorBalance(float value) + void set_color_balance(float value) { - colorBalance_ = value; + color_balance_ = value; } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_KeyingOperation.cc b/source/blender/compositor/operations/COM_KeyingOperation.cc index 7a7fe716fb5..c7ab3aca2e2 100644 --- a/source/blender/compositor/operations/COM_KeyingOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingOperation.cc @@ -20,7 +20,7 @@ namespace blender::compositor { -static float get_pixel_saturation(const float pixelColor[4], +static float get_pixel_saturation(const float pixel_color[4], float screen_balance, int primary_channel) { @@ -30,43 +30,46 @@ static float get_pixel_saturation(const float pixelColor[4], const int min_channel = MIN2(other_1, other_2); const int max_channel = MAX2(other_1, other_2); - const float val = screen_balance * pixelColor[min_channel] + - (1.0f - screen_balance) * pixelColor[max_channel]; + const float val = screen_balance * pixel_color[min_channel] + + (1.0f - screen_balance) * pixel_color[max_channel]; - return (pixelColor[primary_channel] - val) * fabsf(1.0f - val); + return (pixel_color[primary_channel] - val) * fabsf(1.0f - val); } KeyingOperation::KeyingOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Value); - screenBalance_ = 0.5f; + screen_balance_ = 0.5f; - pixelReader_ = nullptr; - screenReader_ = nullptr; + pixel_reader_ = nullptr; + screen_reader_ = nullptr; } -void KeyingOperation::initExecution() +void KeyingOperation::init_execution() { - pixelReader_ = this->getInputSocketReader(0); - screenReader_ = this->getInputSocketReader(1); + pixel_reader_ = this->get_input_socket_reader(0); + screen_reader_ = this->get_input_socket_reader(1); } -void KeyingOperation::deinitExecution() +void KeyingOperation::deinit_execution() { - pixelReader_ = nullptr; - screenReader_ = nullptr; + pixel_reader_ = nullptr; + screen_reader_ = nullptr; } -void KeyingOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void KeyingOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float pixel_color[4]; float screen_color[4]; - pixelReader_->readSampled(pixel_color, x, y, sampler); - screenReader_->readSampled(screen_color, x, y, sampler); + pixel_reader_->read_sampled(pixel_color, x, y, sampler); + screen_reader_->read_sampled(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 +83,8 @@ void KeyingOperation::executePixelSampled(float output[4], float x, float y, Pix output[0] = 1.0f; } else { - float saturation = get_pixel_saturation(pixel_color, screenBalance_, primary_channel); - float screen_saturation = get_pixel_saturation(screen_color, screenBalance_, primary_channel); + float saturation = get_pixel_saturation(pixel_color, screen_balance_, primary_channel); + float screen_saturation = get_pixel_saturation(screen_color, screen_balance_, primary_channel); if (saturation < 0) { /* means main channel of pixel is different from screen, @@ -124,9 +127,9 @@ void KeyingOperation::update_memory_buffer_partial(MemoryBuffer *output, it.out[0] = 1.0f; } else { - const float saturation = get_pixel_saturation(pixel_color, screenBalance_, primary_channel); + const float saturation = get_pixel_saturation(pixel_color, screen_balance_, primary_channel); const float screen_saturation = get_pixel_saturation( - screen_color, screenBalance_, primary_channel); + screen_color, screen_balance_, 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 3ad18085f6b..d7be4872065 100644 --- a/source/blender/compositor/operations/COM_KeyingOperation.h +++ b/source/blender/compositor/operations/COM_KeyingOperation.h @@ -31,23 +31,23 @@ namespace blender::compositor { */ class KeyingOperation : public MultiThreadedOperation { protected: - SocketReader *pixelReader_; - SocketReader *screenReader_; + SocketReader *pixel_reader_; + SocketReader *screen_reader_; - float screenBalance_; + float screen_balance_; public: KeyingOperation(); - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setScreenBalance(float value) + void set_screen_balance(float value) { - screenBalance_ = value; + screen_balance_ = value; } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_KeyingScreenOperation.cc b/source/blender/compositor/operations/COM_KeyingScreenOperation.cc index 8f14b5415b5..d7e56aaa7c6 100644 --- a/source/blender/compositor/operations/COM_KeyingScreenOperation.cc +++ b/source/blender/compositor/operations/COM_KeyingScreenOperation.cc @@ -28,32 +28,32 @@ namespace blender::compositor { KeyingScreenOperation::KeyingScreenOperation() { - this->addOutputSocket(DataType::Color); - movieClip_ = nullptr; + this->add_output_socket(DataType::Color); + movie_clip_ = nullptr; framenumber_ = 0; - trackingObject_[0] = 0; + tracking_object_[0] = 0; flags.complex = true; - cachedTriangulation_ = nullptr; + cached_triangulation_ = nullptr; } -void KeyingScreenOperation::initExecution() +void KeyingScreenOperation::init_execution() { - initMutex(); + init_mutex(); if (execution_model_ == eExecutionModel::FullFrame) { - BLI_assert(cachedTriangulation_ == nullptr); - if (movieClip_) { - cachedTriangulation_ = buildVoronoiTriangulation(); + BLI_assert(cached_triangulation_ == nullptr); + if (movie_clip_) { + cached_triangulation_ = build_voronoi_triangulation(); } } else { - cachedTriangulation_ = nullptr; + cached_triangulation_ = nullptr; } } -void KeyingScreenOperation::deinitExecution() +void KeyingScreenOperation::deinit_execution() { - if (cachedTriangulation_) { - TriangulationData *triangulation = cachedTriangulation_; + if (cached_triangulation_) { + TriangulationData *triangulation = cached_triangulation_; if (triangulation->triangulated_points) { MEM_freeN(triangulation->triangulated_points); @@ -67,17 +67,17 @@ void KeyingScreenOperation::deinitExecution() MEM_freeN(triangulation->triangles_AABB); } - MEM_freeN(cachedTriangulation_); + MEM_freeN(cached_triangulation_); - cachedTriangulation_ = nullptr; + cached_triangulation_ = nullptr; } } -KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTriangulation() +KeyingScreenOperation::TriangulationData *KeyingScreenOperation::build_voronoi_triangulation() { MovieClipUser user = {0}; TriangulationData *triangulation; - MovieTracking *tracking = &movieClip_->tracking; + MovieTracking *tracking = &movie_clip_->tracking; MovieTrackingTrack *track; VoronoiSite *sites, *site; ImBuf *ibuf; @@ -85,12 +85,12 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri ListBase edges = {nullptr, nullptr}; int sites_total; int i; - int width = this->getWidth(); - int height = this->getHeight(); - int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, framenumber_); + int width = this->get_width(); + int height = this->get_height(); + int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, framenumber_); - if (trackingObject_[0]) { - MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, trackingObject_); + if (tracking_object_[0]) { + MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, tracking_object_); 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(movieClip_, &user); + ibuf = BKE_movieclip_get_ibuf(movie_clip_, &user); if (!ibuf) { return nullptr; @@ -237,7 +237,7 @@ KeyingScreenOperation::TileData *KeyingScreenOperation::triangulate(const rcti * int chunk_size = 20; int i; - triangulation = cachedTriangulation_; + triangulation = cached_triangulation_; if (!triangulation) { return nullptr; @@ -269,24 +269,24 @@ KeyingScreenOperation::TileData *KeyingScreenOperation::triangulate(const rcti * return tile_data; } -void *KeyingScreenOperation::initializeTileData(rcti *rect) +void *KeyingScreenOperation::initialize_tile_data(rcti *rect) { - if (movieClip_ == nullptr) { + if (movie_clip_ == nullptr) { return nullptr; } - if (!cachedTriangulation_) { - lockMutex(); - if (cachedTriangulation_ == nullptr) { - cachedTriangulation_ = buildVoronoiTriangulation(); + if (!cached_triangulation_) { + lock_mutex(); + if (cached_triangulation_ == nullptr) { + cached_triangulation_ = build_voronoi_triangulation(); } - unlockMutex(); + unlock_mutex(); } return triangulate(rect); } -void KeyingScreenOperation::deinitializeTileData(rcti * /*rect*/, void *data) +void KeyingScreenOperation::deinitialize_tile_data(rcti * /*rect*/, void *data) { TileData *tile_data = (TileData *)data; @@ -301,28 +301,28 @@ void KeyingScreenOperation::determine_canvas(const rcti &preferred_area, rcti &r { r_area = COM_AREA_NONE; - if (movieClip_) { + if (movie_clip_) { MovieClipUser user = {0}; int width, height; - int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, framenumber_); + int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, framenumber_); BKE_movieclip_user_set_frame(&user, clip_frame); - BKE_movieclip_get_size(movieClip_, &user, &width, &height); + BKE_movieclip_get_size(movie_clip_, &user, &width, &height); r_area = preferred_area; r_area.xmax = r_area.xmin + width; r_area.ymax = r_area.ymin + height; } } -void KeyingScreenOperation::executePixel(float output[4], int x, int y, void *data) +void KeyingScreenOperation::execute_pixel(float output[4], int x, int y, void *data) { output[0] = 0.0f; output[1] = 0.0f; output[2] = 0.0f; output[3] = 1.0f; - if (movieClip_ && data) { - TriangulationData *triangulation = cachedTriangulation_; + if (movie_clip_ && data) { + TriangulationData *triangulation = cached_triangulation_; 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 inputs) { - if (movieClip_ == nullptr) { + if (movie_clip_ == 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 = cachedTriangulation_; + const TriangulationData *triangulation = cached_triangulation_; for (BuffersIterator 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 a828513d9fa..3450a82a485 100644 --- a/source/blender/compositor/operations/COM_KeyingScreenOperation.h +++ b/source/blender/compositor/operations/COM_KeyingScreenOperation.h @@ -49,41 +49,41 @@ class KeyingScreenOperation : public MultiThreadedOperation { int triangles_total; } TileData; - MovieClip *movieClip_; + MovieClip *movie_clip_; int framenumber_; - TriangulationData *cachedTriangulation_; - char trackingObject_[64]; + TriangulationData *cached_triangulation_; + char tracking_object_[64]; /** * Determine the output resolution. The resolution is retrieved from the Renderer */ void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - TriangulationData *buildVoronoiTriangulation(); + TriangulationData *build_voronoi_triangulation(); public: KeyingScreenOperation(); - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; - void deinitializeTileData(rcti *rect, void *data) override; + void *initialize_tile_data(rcti *rect) override; + void deinitialize_tile_data(rcti *rect, void *data) override; - void setMovieClip(MovieClip *clip) + void set_movie_clip(MovieClip *clip) { - movieClip_ = clip; + movie_clip_ = clip; } - void setTrackingObject(const char *object) + void set_tracking_object(const char *object) { - BLI_strncpy(trackingObject_, object, sizeof(trackingObject_)); + BLI_strncpy(tracking_object_, object, sizeof(tracking_object_)); } - void setFramenumber(int framenumber) + void set_framenumber(int framenumber) { framenumber_ = framenumber; } - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_LuminanceMatteOperation.cc b/source/blender/compositor/operations/COM_LuminanceMatteOperation.cc index d266cbd00f5..36dc9c42b8b 100644 --- a/source/blender/compositor/operations/COM_LuminanceMatteOperation.cc +++ b/source/blender/compositor/operations/COM_LuminanceMatteOperation.cc @@ -24,39 +24,39 @@ namespace blender::compositor { LuminanceMatteOperation::LuminanceMatteOperation() { - addInputSocket(DataType::Color); - addOutputSocket(DataType::Value); + add_input_socket(DataType::Color); + add_output_socket(DataType::Value); - inputImageProgram_ = nullptr; + input_image_program_ = nullptr; flags.can_be_constant = true; } -void LuminanceMatteOperation::initExecution() +void LuminanceMatteOperation::init_execution() { - inputImageProgram_ = this->getInputSocketReader(0); + input_image_program_ = this->get_input_socket_reader(0); } -void LuminanceMatteOperation::deinitExecution() +void LuminanceMatteOperation::deinit_execution() { - inputImageProgram_ = nullptr; + input_image_program_ = nullptr; } -void LuminanceMatteOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void LuminanceMatteOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inColor[4]; - inputImageProgram_->readSampled(inColor, x, y, sampler); + float in_color[4]; + input_image_program_->read_sampled(in_color, x, y, sampler); const float high = settings_->t1; const float low = settings_->t2; - const float luminance = IMB_colormanagement_get_luminance(inColor); + const float luminance = IMB_colormanagement_get_luminance(in_color); float alpha; /* one line thread-friend algorithm: - * output[0] = MIN2(inputValue[3], MIN2(1.0f, MAX2(0.0f, ((luminance - low) / (high - low)))); + * output[0] = MIN2(input_value[3], MIN2(1.0f, MAX2(0.0f, ((luminance - low) / (high - low)))); */ /* test range */ @@ -75,7 +75,7 @@ void LuminanceMatteOperation::executePixelSampled(float output[4], */ /* don't make something that was more transparent less transparent */ - output[0] = min_ff(alpha, inColor[3]); + output[0] = min_ff(alpha, in_color[3]); } void LuminanceMatteOperation::update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_LuminanceMatteOperation.h b/source/blender/compositor/operations/COM_LuminanceMatteOperation.h index 6262d1999bc..7f9ccfc83ac 100644 --- a/source/blender/compositor/operations/COM_LuminanceMatteOperation.h +++ b/source/blender/compositor/operations/COM_LuminanceMatteOperation.h @@ -29,7 +29,7 @@ namespace blender::compositor { class LuminanceMatteOperation : public MultiThreadedOperation { private: NodeChroma *settings_; - SocketReader *inputImageProgram_; + SocketReader *input_image_program_; public: /** @@ -40,14 +40,14 @@ class LuminanceMatteOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setSettings(NodeChroma *nodeChroma) + void set_settings(NodeChroma *node_chroma) { - settings_ = nodeChroma; + settings_ = node_chroma; } 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 0fcdbd1fd99..e8ce1f100c3 100644 --- a/source/blender/compositor/operations/COM_MapRangeOperation.cc +++ b/source/blender/compositor/operations/COM_MapRangeOperation.cc @@ -22,45 +22,45 @@ namespace blender::compositor { MapRangeOperation::MapRangeOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - inputOperation_ = nullptr; - useClamp_ = false; + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + input_operation_ = nullptr; + use_clamp_ = false; flags.can_be_constant = true; } -void MapRangeOperation::initExecution() +void MapRangeOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); - sourceMinOperation_ = this->getInputSocketReader(1); - sourceMaxOperation_ = this->getInputSocketReader(2); - destMinOperation_ = this->getInputSocketReader(3); - destMaxOperation_ = this->getInputSocketReader(4); + input_operation_ = this->get_input_socket_reader(0); + source_min_operation_ = this->get_input_socket_reader(1); + source_max_operation_ = this->get_input_socket_reader(2); + dest_min_operation_ = this->get_input_socket_reader(3); + dest_max_operation_ = this->get_input_socket_reader(4); } /* The code below assumes all data is inside range +- this, and that input buffer is single channel */ #define BLENDER_ZMAX 10000.0f -void MapRangeOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MapRangeOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float inputs[8]; /* includes the 5 inputs + 3 pads */ float value; float source_min, source_max; float dest_min, dest_max; - 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); + input_operation_->read_sampled(inputs, x, y, sampler); + source_min_operation_->read_sampled(inputs + 1, x, y, sampler); + source_max_operation_->read_sampled(inputs + 2, x, y, sampler); + dest_min_operation_->read_sampled(inputs + 3, x, y, sampler); + dest_max_operation_->read_sampled(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 (useClamp_) { + if (use_clamp_) { if (dest_max > dest_min) { CLAMP(value, dest_min, dest_max); } @@ -96,13 +96,13 @@ void MapRangeOperation::executePixelSampled(float output[4], output[0] = value; } -void MapRangeOperation::deinitExecution() +void MapRangeOperation::deinit_execution() { - inputOperation_ = nullptr; - sourceMinOperation_ = nullptr; - sourceMaxOperation_ = nullptr; - destMinOperation_ = nullptr; - destMaxOperation_ = nullptr; + input_operation_ = nullptr; + source_min_operation_ = nullptr; + source_max_operation_ = nullptr; + dest_min_operation_ = nullptr; + dest_max_operation_ = 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 (useClamp_) { + if (use_clamp_) { 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 f5c42d19079..0d0f3c90e35 100644 --- a/source/blender/compositor/operations/COM_MapRangeOperation.h +++ b/source/blender/compositor/operations/COM_MapRangeOperation.h @@ -30,15 +30,15 @@ namespace blender::compositor { class MapRangeOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputOperation_; - SocketReader *sourceMinOperation_; - SocketReader *sourceMaxOperation_; - SocketReader *destMinOperation_; - SocketReader *destMaxOperation_; + SocketReader *input_operation_; + SocketReader *source_min_operation_; + SocketReader *source_max_operation_; + SocketReader *dest_min_operation_; + SocketReader *dest_max_operation_; - bool useClamp_; + bool use_clamp_; public: /** @@ -49,24 +49,24 @@ class MapRangeOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; /** * Clamp the output */ - void setUseClamp(bool value) + void set_use_clamp(bool value) { - useClamp_ = value; + use_clamp_ = 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 a5140c30fed..fb4fcff381d 100644 --- a/source/blender/compositor/operations/COM_MapUVOperation.cc +++ b/source/blender/compositor/operations/COM_MapUVOperation.cc @@ -22,55 +22,55 @@ namespace blender::compositor { MapUVOperation::MapUVOperation() { - this->addInputSocket(DataType::Color, ResizeMode::Align); - this->addInputSocket(DataType::Vector); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color, ResizeMode::Align); + this->add_input_socket(DataType::Vector); + this->add_output_socket(DataType::Color); alpha_ = 0.0f; this->flags.complex = true; set_canvas_input_index(UV_INPUT_INDEX); inputUVProgram_ = nullptr; - inputColorProgram_ = nullptr; + input_color_program_ = nullptr; } void MapUVOperation::init_data() { NodeOperation *image_input = get_input_operation(IMAGE_INPUT_INDEX); - image_width_ = image_input->getWidth(); - image_height_ = image_input->getHeight(); + image_width_ = image_input->get_width(); + image_height_ = image_input->get_height(); NodeOperation *uv_input = get_input_operation(UV_INPUT_INDEX); - uv_width_ = uv_input->getWidth(); - uv_height_ = uv_input->getHeight(); + uv_width_ = uv_input->get_width(); + uv_height_ = uv_input->get_height(); } -void MapUVOperation::initExecution() +void MapUVOperation::init_execution() { - inputColorProgram_ = this->getInputSocketReader(0); - inputUVProgram_ = this->getInputSocketReader(1); + input_color_program_ = this->get_input_socket_reader(0); + inputUVProgram_ = this->get_input_socket_reader(1); if (execution_model_ == eExecutionModel::Tiled) { uv_input_read_fn_ = [=](float x, float y, float *out) { - inputUVProgram_->readSampled(out, x, y, PixelSampler::Bilinear); + inputUVProgram_->read_sampled(out, x, y, PixelSampler::Bilinear); }; } } -void MapUVOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void MapUVOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { float xy[2] = {x, y}; float uv[2], deriv[2][2], alpha; - pixelTransform(xy, uv, deriv, alpha); + pixel_transform(xy, uv, deriv, alpha); if (alpha == 0.0f) { zero_v4(output); return; } /* EWA filtering */ - inputColorProgram_->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); + input_color_program_->read_filtered(output, uv[0], uv[1], deriv[0], deriv[1]); /* UV to alpha threshold */ const float threshold = alpha_ * 0.05f; @@ -79,8 +79,8 @@ void MapUVOperation::executePixelSampled(float output[4], */ float du = len_v2(deriv[0]); float dv = len_v2(deriv[1]); - float factor = 1.0f - threshold * (du / inputColorProgram_->getWidth() + - dv / inputColorProgram_->getHeight()); + float factor = 1.0f - threshold * (du / input_color_program_->get_width() + + dv / input_color_program_->get_height()); if (factor < 0.0f) { alpha = 0.0f; } @@ -111,10 +111,10 @@ bool MapUVOperation::read_uv(float x, float y, float &r_u, float &r_v, float &r_ return true; } -void MapUVOperation::pixelTransform(const float xy[2], - float r_uv[2], - float r_deriv[2][2], - float &r_alpha) +void MapUVOperation::pixel_transform(const float xy[2], + float r_uv[2], + float r_deriv[2][2], + float &r_alpha) { float uv[2], alpha; /* temporary variables for derivative estimation */ int num; @@ -162,37 +162,37 @@ void MapUVOperation::pixelTransform(const float xy[2], } } -void MapUVOperation::deinitExecution() +void MapUVOperation::deinit_execution() { inputUVProgram_ = nullptr; - inputColorProgram_ = nullptr; + input_color_program_ = nullptr; } -bool MapUVOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool MapUVOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti colorInput; - rcti uvInput; + rcti color_input; + rcti uv_input; NodeOperation *operation = nullptr; /* the uv buffer only needs a 3x3 buffer. The image needs whole buffer */ - operation = getInputOperation(0); - colorInput.xmax = operation->getWidth(); - colorInput.xmin = 0; - colorInput.ymax = operation->getHeight(); - colorInput.ymin = 0; - if (operation->determineDependingAreaOfInterest(&colorInput, readOperation, output)) { + operation = get_input_operation(0); + color_input.xmax = operation->get_width(); + color_input.xmin = 0; + color_input.ymax = operation->get_height(); + color_input.ymin = 0; + if (operation->determine_depending_area_of_interest(&color_input, read_operation, output)) { return true; } - operation = getInputOperation(1); - uvInput.xmax = input->xmax + 1; - uvInput.xmin = input->xmin - 1; - uvInput.ymax = input->ymax + 1; - uvInput.ymin = input->ymin - 1; - if (operation->determineDependingAreaOfInterest(&uvInput, readOperation, output)) { + operation = get_input_operation(1); + uv_input.xmax = input->xmax + 1; + uv_input.xmin = input->xmin - 1; + uv_input.ymax = input->ymax + 1; + uv_input.ymin = input->ymin - 1; + if (operation->determine_depending_area_of_interest(&uv_input, read_operation, output)) { return true; } @@ -236,7 +236,7 @@ void MapUVOperation::update_memory_buffer_partial(MemoryBuffer *output, float uv[2]; float deriv[2][2]; float alpha; - pixelTransform(xy, uv, deriv, alpha); + pixel_transform(xy, uv, deriv, alpha); if (alpha == 0.0f) { zero_v4(it.out); continue; diff --git a/source/blender/compositor/operations/COM_MapUVOperation.h b/source/blender/compositor/operations/COM_MapUVOperation.h index 7025e02e069..38d848f61a0 100644 --- a/source/blender/compositor/operations/COM_MapUVOperation.h +++ b/source/blender/compositor/operations/COM_MapUVOperation.h @@ -27,10 +27,10 @@ class MapUVOperation : public MultiThreadedOperation { static constexpr int IMAGE_INPUT_INDEX = 0; static constexpr int UV_INPUT_INDEX = 1; /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ SocketReader *inputUVProgram_; - SocketReader *inputColorProgram_; + SocketReader *input_color_program_; int uv_width_; int uv_height_; @@ -47,30 +47,30 @@ class MapUVOperation : public MultiThreadedOperation { /** * we need a 3x3 differential filter for UV Input and full buffer for the image */ - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void pixelTransform(const float xy[2], float r_uv[2], float r_deriv[2][2], float &r_alpha); + void pixel_transform(const float xy[2], float r_uv[2], float r_deriv[2][2], float &r_alpha); void init_data() override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setAlpha(float alpha) + void set_alpha(float alpha) { alpha_ = alpha; } diff --git a/source/blender/compositor/operations/COM_MapValueOperation.cc b/source/blender/compositor/operations/COM_MapValueOperation.cc index 0f4175c3d3d..da5ab04cc98 100644 --- a/source/blender/compositor/operations/COM_MapValueOperation.cc +++ b/source/blender/compositor/operations/COM_MapValueOperation.cc @@ -22,24 +22,24 @@ namespace blender::compositor { MapValueOperation::MapValueOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - inputOperation_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + input_operation_ = nullptr; flags.can_be_constant = true; } -void MapValueOperation::initExecution() +void MapValueOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); + input_operation_ = this->get_input_socket_reader(0); } -void MapValueOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MapValueOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float src[4]; - inputOperation_->readSampled(src, x, y, sampler); + input_operation_->read_sampled(src, x, y, sampler); TexMapping *texmap = settings_; float value = (src[0] + texmap->loc[0]) * texmap->size[0]; if (texmap->flag & TEXMAP_CLIP_MIN) { @@ -56,9 +56,9 @@ void MapValueOperation::executePixelSampled(float output[4], output[0] = value; } -void MapValueOperation::deinitExecution() +void MapValueOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = nullptr; } void MapValueOperation::update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_MapValueOperation.h b/source/blender/compositor/operations/COM_MapValueOperation.h index 38cb75869d5..77d3a4a2932 100644 --- a/source/blender/compositor/operations/COM_MapValueOperation.h +++ b/source/blender/compositor/operations/COM_MapValueOperation.h @@ -30,9 +30,9 @@ namespace blender::compositor { class MapValueOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputOperation_; + SocketReader *input_operation_; TexMapping *settings_; public: @@ -44,22 +44,22 @@ class MapValueOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; /** * \brief set the TexMapping settings */ - void setSettings(TexMapping *settings) + void set_settings(TexMapping *settings) { settings_ = settings; } diff --git a/source/blender/compositor/operations/COM_MaskOperation.cc b/source/blender/compositor/operations/COM_MaskOperation.cc index d02d23445b6..4e4cc820edb 100644 --- a/source/blender/compositor/operations/COM_MaskOperation.cc +++ b/source/blender/compositor/operations/COM_MaskOperation.cc @@ -25,31 +25,31 @@ namespace blender::compositor { MaskOperation::MaskOperation() { - this->addOutputSocket(DataType::Value); + this->add_output_socket(DataType::Value); mask_ = nullptr; - maskWidth_ = 0; - maskHeight_ = 0; - maskWidthInv_ = 0.0f; - maskHeightInv_ = 0.0f; + mask_width_ = 0; + mask_height_ = 0; + mask_width_inv_ = 0.0f; + mask_height_inv_ = 0.0f; frame_shutter_ = 0.0f; frame_number_ = 0; - rasterMaskHandleTot_ = 1; - memset(rasterMaskHandles_, 0, sizeof(rasterMaskHandles_)); + raster_mask_handle_tot_ = 1; + memset(raster_mask_handles_, 0, sizeof(raster_mask_handles_)); } -void MaskOperation::initExecution() +void MaskOperation::init_execution() { - if (mask_ && rasterMaskHandles_[0] == nullptr) { - if (rasterMaskHandleTot_ == 1) { - rasterMaskHandles_[0] = BKE_maskrasterize_handle_new(); + if (mask_ && raster_mask_handles_[0] == nullptr) { + if (raster_mask_handle_tot_ == 1) { + raster_mask_handles_[0] = BKE_maskrasterize_handle_new(); BKE_maskrasterize_handle_init( - rasterMaskHandles_[0], mask_, maskWidth_, maskHeight_, true, true, do_feather_); + raster_mask_handles_[0], mask_, mask_width_, mask_height_, true, true, do_feather_); } else { /* make a throw away copy of the mask */ const float frame = (float)frame_number_ - frame_shutter_; - const float frame_step = (frame_shutter_ * 2.0f) / rasterMaskHandleTot_; + const float frame_step = (frame_shutter_ * 2.0f) / raster_mask_handle_tot_; float frame_iter = frame; Mask *mask_temp = (Mask *)BKE_id_copy_ex( @@ -67,14 +67,19 @@ void MaskOperation::initExecution() } } - for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) { - rasterMaskHandles_[i] = BKE_maskrasterize_handle_new(); + for (unsigned int i = 0; i < raster_mask_handle_tot_; i++) { + raster_mask_handles_[i] = BKE_maskrasterize_handle_new(); /* re-eval frame info */ BKE_mask_evaluate(mask_temp, frame_iter, true); - BKE_maskrasterize_handle_init( - rasterMaskHandles_[i], mask_temp, maskWidth_, maskHeight_, true, true, do_feather_); + BKE_maskrasterize_handle_init(raster_mask_handles_[i], + mask_temp, + mask_width_, + mask_height_, + true, + true, + do_feather_); frame_iter += frame_step; } @@ -84,41 +89,41 @@ void MaskOperation::initExecution() } } -void MaskOperation::deinitExecution() +void MaskOperation::deinit_execution() { - for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) { - if (rasterMaskHandles_[i]) { - BKE_maskrasterize_handle_free(rasterMaskHandles_[i]); - rasterMaskHandles_[i] = nullptr; + for (unsigned int i = 0; i < raster_mask_handle_tot_; i++) { + if (raster_mask_handles_[i]) { + BKE_maskrasterize_handle_free(raster_mask_handles_[i]); + raster_mask_handles_[i] = nullptr; } } } void MaskOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { - if (maskWidth_ == 0 || maskHeight_ == 0) { + if (mask_width_ == 0 || mask_height_ == 0) { r_area = COM_AREA_NONE; } else { r_area = preferred_area; - r_area.xmax = r_area.xmin + maskWidth_; - r_area.ymax = r_area.ymin + maskHeight_; + r_area.xmax = r_area.xmin + mask_width_; + r_area.ymax = r_area.ymin + mask_height_; } } -void MaskOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void MaskOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { const float xy[2] = { - (x * maskWidthInv_) + mask_px_ofs_[0], - (y * maskHeightInv_) + mask_px_ofs_[1], + (x * mask_width_inv_) + mask_px_ofs_[0], + (y * mask_height_inv_) + mask_px_ofs_[1], }; - if (rasterMaskHandleTot_ == 1) { - if (rasterMaskHandles_[0]) { - output[0] = BKE_maskrasterize_handle_sample(rasterMaskHandles_[0], xy); + if (raster_mask_handle_tot_ == 1) { + if (raster_mask_handles_[0]) { + output[0] = BKE_maskrasterize_handle_sample(raster_mask_handles_[0], xy); } else { output[0] = 0.0f; @@ -128,14 +133,14 @@ void MaskOperation::executePixelSampled(float output[4], /* In case loop below fails. */ output[0] = 0.0f; - for (unsigned int i = 0; i < rasterMaskHandleTot_; i++) { - if (rasterMaskHandles_[i]) { - output[0] += BKE_maskrasterize_handle_sample(rasterMaskHandles_[i], xy); + for (unsigned int i = 0; i < raster_mask_handle_tot_; i++) { + if (raster_mask_handles_[i]) { + output[0] += BKE_maskrasterize_handle_sample(raster_mask_handles_[i], xy); } } /* until we get better falloff */ - output[0] /= rasterMaskHandleTot_; + output[0] /= raster_mask_handle_tot_; } } @@ -151,23 +156,23 @@ void MaskOperation::update_memory_buffer_partial(MemoryBuffer *output, float xy[2]; for (BuffersIterator it = output->iterate_with({}, area); !it.is_end(); ++it) { - xy[0] = it.x * maskWidthInv_ + mask_px_ofs_[0]; - xy[1] = it.y * maskHeightInv_ + mask_px_ofs_[1]; + xy[0] = it.x * mask_width_inv_ + mask_px_ofs_[0]; + xy[1] = it.y * mask_height_inv_ + 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 /= rasterMaskHandleTot_; + *it.out /= raster_mask_handle_tot_; } } Vector MaskOperation::get_non_null_handles() const { Vector handles; - for (int i = 0; i < rasterMaskHandleTot_; i++) { - MaskRasterHandle *handle = rasterMaskHandles_[i]; + for (int i = 0; i < raster_mask_handle_tot_; i++) { + MaskRasterHandle *handle = raster_mask_handles_[i]; if (handle == nullptr) { continue; } diff --git a/source/blender/compositor/operations/COM_MaskOperation.h b/source/blender/compositor/operations/COM_MaskOperation.h index e8f386242b4..5fc0ed96c22 100644 --- a/source/blender/compositor/operations/COM_MaskOperation.h +++ b/source/blender/compositor/operations/COM_MaskOperation.h @@ -37,10 +37,10 @@ class MaskOperation : public MultiThreadedOperation { /* NOTE: these are used more like aspect, * but they _do_ impact on mask detail */ - int maskWidth_; - int maskHeight_; - float maskWidthInv_; /* `1 / maskWidth_` */ - float maskHeightInv_; /* `1 / maskHeight_` */ + int mask_width_; + int mask_height_; + float mask_width_inv_; /* `1 / mask_width_` */ + float mask_height_inv_; /* `1 / mask_height_` */ float mask_px_ofs_[2]; float frame_shutter_; @@ -48,8 +48,8 @@ class MaskOperation : public MultiThreadedOperation { bool do_feather_; - struct MaskRasterHandle *rasterMaskHandles_[CMP_NODE_MASK_MBLUR_SAMPLES_MAX]; - unsigned int rasterMaskHandleTot_; + struct MaskRasterHandle *raster_mask_handles_[CMP_NODE_MASK_MBLUR_SAMPLES_MAX]; + unsigned int raster_mask_handle_tot_; /** * Determine the output resolution. The resolution is retrieved from the Renderer @@ -59,44 +59,44 @@ class MaskOperation : public MultiThreadedOperation { public: MaskOperation(); - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setMask(Mask *mask) + void set_mask(Mask *mask) { mask_ = mask; } - void setMaskWidth(int width) + void set_mask_width(int width) { - maskWidth_ = width; - maskWidthInv_ = 1.0f / (float)width; - mask_px_ofs_[0] = maskWidthInv_ * 0.5f; + mask_width_ = width; + mask_width_inv_ = 1.0f / (float)width; + mask_px_ofs_[0] = mask_width_inv_ * 0.5f; } - void setMaskHeight(int height) + void set_mask_height(int height) { - maskHeight_ = height; - maskHeightInv_ = 1.0f / (float)height; - mask_px_ofs_[1] = maskHeightInv_ * 0.5f; + mask_height_ = height; + mask_height_inv_ = 1.0f / (float)height; + mask_px_ofs_[1] = mask_height_inv_ * 0.5f; } - void setFramenumber(int frame_number) + void set_framenumber(int frame_number) { frame_number_ = frame_number; } - void setFeather(bool feather) + void set_feather(bool feather) { do_feather_ = feather; } - void setMotionBlurSamples(int samples) + void set_motion_blur_samples(int samples) { - rasterMaskHandleTot_ = MIN2(MAX2(1, samples), CMP_NODE_MASK_MBLUR_SAMPLES_MAX); + raster_mask_handle_tot_ = MIN2(MAX2(1, samples), CMP_NODE_MASK_MBLUR_SAMPLES_MAX); } - void setMotionBlurShutter(float shutter) + void set_motion_blur_shutter(float shutter) { frame_shutter_ = shutter; } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.cc b/source/blender/compositor/operations/COM_MathBaseOperation.cc index 30b6e14a324..55151b70050 100644 --- a/source/blender/compositor/operations/COM_MathBaseOperation.cc +++ b/source/blender/compositor/operations/COM_MathBaseOperation.cc @@ -24,36 +24,36 @@ MathBaseOperation::MathBaseOperation() { /* TODO(manzanilla): after removing tiled implementation, template this class to only add needed * number of inputs. */ - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - inputValue1Operation_ = nullptr; - inputValue2Operation_ = nullptr; - inputValue3Operation_ = nullptr; - useClamp_ = false; + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + input_value1_operation_ = nullptr; + input_value2_operation_ = nullptr; + input_value3_operation_ = nullptr; + use_clamp_ = false; this->flags.can_be_constant = true; } -void MathBaseOperation::initExecution() +void MathBaseOperation::init_execution() { - inputValue1Operation_ = this->getInputSocketReader(0); - inputValue2Operation_ = this->getInputSocketReader(1); - inputValue3Operation_ = this->getInputSocketReader(2); + input_value1_operation_ = this->get_input_socket_reader(0); + input_value2_operation_ = this->get_input_socket_reader(1); + input_value3_operation_ = this->get_input_socket_reader(2); } -void MathBaseOperation::deinitExecution() +void MathBaseOperation::deinit_execution() { - inputValue1Operation_ = nullptr; - inputValue2Operation_ = nullptr; - inputValue3Operation_ = nullptr; + input_value1_operation_ = nullptr; + input_value2_operation_ = nullptr; + input_value3_operation_ = nullptr; } void MathBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { NodeOperationInput *socket; rcti temp_area; - socket = this->getInputSocket(0); + socket = this->get_input_socket(0); const bool determined = socket->determine_canvas(COM_AREA_NONE, temp_area); if (determined) { this->set_canvas_input_index(0); @@ -64,9 +64,9 @@ void MathBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_are NodeOperation::determine_canvas(preferred_area, r_area); } -void MathBaseOperation::clampIfNeeded(float *color) +void MathBaseOperation::clamp_if_needed(float *color) { - if (useClamp_) { + if (use_clamp_) { CLAMP(color[0], 0.0f, 1.0f); } } @@ -79,70 +79,73 @@ void MathBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, update_memory_buffer_partial(it); } -void MathAddOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void MathAddOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = inputValue1[0] + inputValue2[0]; + output[0] = input_value1[0] + input_value2[0]; - clampIfNeeded(output); + clamp_if_needed(output); } -void MathSubtractOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathSubtractOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = inputValue1[0] - inputValue2[0]; + output[0] = input_value1[0] - input_value2[0]; - clampIfNeeded(output); + clamp_if_needed(output); } -void MathMultiplyOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathMultiplyOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = inputValue1[0] * inputValue2[0]; + output[0] = input_value1[0] * input_value2[0]; - clampIfNeeded(output); + clamp_if_needed(output); } -void MathDivideOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathDivideOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - if (inputValue2[0] == 0) { /* We don't want to divide by zero. */ + if (input_value2[0] == 0) { /* We don't want to divide by zero. */ output[0] = 0.0; } else { - output[0] = inputValue1[0] / inputValue2[0]; + output[0] = input_value1[0] / input_value2[0]; } - clampIfNeeded(output); + clamp_if_needed(output); } void MathDivideOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -153,20 +156,20 @@ void MathDivideOperation::update_memory_buffer_partial(BuffersIterator &i } } -void MathSineOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathSineOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = sin(inputValue1[0]); + output[0] = sin(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathSineOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -177,20 +180,20 @@ void MathSineOperation::update_memory_buffer_partial(BuffersIterator &it) } } -void MathCosineOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathCosineOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = cos(inputValue1[0]); + output[0] = cos(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathCosineOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -201,20 +204,20 @@ void MathCosineOperation::update_memory_buffer_partial(BuffersIterator &i } } -void MathTangentOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathTangentOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = tan(inputValue1[0]); + output[0] = tan(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathTangentOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -225,20 +228,20 @@ void MathTangentOperation::update_memory_buffer_partial(BuffersIterator & } } -void MathHyperbolicSineOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathHyperbolicSineOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = sinh(inputValue1[0]); + output[0] = sinh(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathHyperbolicSineOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -249,20 +252,20 @@ void MathHyperbolicSineOperation::update_memory_buffer_partial(BuffersIteratorreadSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = cosh(inputValue1[0]); + output[0] = cosh(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathHyperbolicCosineOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -273,20 +276,20 @@ void MathHyperbolicCosineOperation::update_memory_buffer_partial(BuffersIterator } } -void MathHyperbolicTangentOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathHyperbolicTangentOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = tanh(inputValue1[0]); + output[0] = tanh(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathHyperbolicTangentOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -297,25 +300,25 @@ void MathHyperbolicTangentOperation::update_memory_buffer_partial(BuffersIterato } } -void MathArcSineOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathArcSineOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - if (inputValue1[0] <= 1 && inputValue1[0] >= -1) { - output[0] = asin(inputValue1[0]); + if (input_value1[0] <= 1 && input_value1[0] >= -1) { + output[0] = asin(input_value1[0]); } else { output[0] = 0.0; } - clampIfNeeded(output); + clamp_if_needed(output); } void MathArcSineOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -326,25 +329,25 @@ void MathArcSineOperation::update_memory_buffer_partial(BuffersIterator & } } -void MathArcCosineOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathArcCosineOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - if (inputValue1[0] <= 1 && inputValue1[0] >= -1) { - output[0] = acos(inputValue1[0]); + if (input_value1[0] <= 1 && input_value1[0] >= -1) { + output[0] = acos(input_value1[0]); } else { output[0] = 0.0; } - clampIfNeeded(output); + clamp_if_needed(output); } void MathArcCosineOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -355,20 +358,20 @@ void MathArcCosineOperation::update_memory_buffer_partial(BuffersIterator } } -void MathArcTangentOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathArcTangentOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = atan(inputValue1[0]); + output[0] = atan(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathArcTangentOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -379,32 +382,32 @@ void MathArcTangentOperation::update_memory_buffer_partial(BuffersIteratorreadSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - if (inputValue1[0] >= 0) { - output[0] = pow(inputValue1[0], inputValue2[0]); + if (input_value1[0] >= 0) { + output[0] = pow(input_value1[0], input_value2[0]); } else { - float y_mod_1 = fmod(inputValue2[0], 1); + float y_mod_1 = fmod(input_value2[0], 1); /* if input value is not nearly an integer, fall back to zero, nicer than straight rounding */ if (y_mod_1 > 0.999f || y_mod_1 < 0.001f) { - output[0] = pow(inputValue1[0], floorf(inputValue2[0] + 0.5f)); + output[0] = pow(input_value1[0], floorf(input_value2[0] + 0.5f)); } else { output[0] = 0.0; } } - clampIfNeeded(output); + clamp_if_needed(output); } void MathPowerOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -430,25 +433,25 @@ void MathPowerOperation::update_memory_buffer_partial(BuffersIterator &it } } -void MathLogarithmOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathLogarithmOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - if (inputValue1[0] > 0 && inputValue2[0] > 0) { - output[0] = log(inputValue1[0]) / log(inputValue2[0]); + if (input_value1[0] > 0 && input_value2[0] > 0) { + output[0] = log(input_value1[0]) / log(input_value2[0]); } else { output[0] = 0.0; } - clampIfNeeded(output); + clamp_if_needed(output); } void MathLogarithmOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -466,20 +469,20 @@ void MathLogarithmOperation::update_memory_buffer_partial(BuffersIterator } } -void MathMinimumOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathMinimumOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = MIN2(inputValue1[0], inputValue2[0]); + output[0] = MIN2(input_value1[0], input_value2[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathMinimumOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -490,20 +493,20 @@ void MathMinimumOperation::update_memory_buffer_partial(BuffersIterator & } } -void MathMaximumOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathMaximumOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = MAX2(inputValue1[0], inputValue2[0]); + output[0] = MAX2(input_value1[0], input_value2[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathMaximumOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -514,20 +517,20 @@ void MathMaximumOperation::update_memory_buffer_partial(BuffersIterator & } } -void MathRoundOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathRoundOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = round(inputValue1[0]); + output[0] = round(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathRoundOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -538,57 +541,57 @@ void MathRoundOperation::update_memory_buffer_partial(BuffersIterator &it } } -void MathLessThanOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathLessThanOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = inputValue1[0] < inputValue2[0] ? 1.0f : 0.0f; + output[0] = input_value1[0] < input_value2[0] ? 1.0f : 0.0f; - clampIfNeeded(output); + clamp_if_needed(output); } -void MathGreaterThanOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathGreaterThanOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = inputValue1[0] > inputValue2[0] ? 1.0f : 0.0f; + output[0] = input_value1[0] > input_value2[0] ? 1.0f : 0.0f; - clampIfNeeded(output); + clamp_if_needed(output); } -void MathModuloOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathModuloOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - if (inputValue2[0] == 0) { + if (input_value2[0] == 0) { output[0] = 0.0; } else { - output[0] = fmod(inputValue1[0], inputValue2[0]); + output[0] = fmod(input_value1[0], input_value2[0]); } - clampIfNeeded(output); + clamp_if_needed(output); } void MathModuloOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -600,18 +603,18 @@ void MathModuloOperation::update_memory_buffer_partial(BuffersIterator &i } } -void MathAbsoluteOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathAbsoluteOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = fabs(inputValue1[0]); + output[0] = fabs(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathAbsoluteOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -622,18 +625,18 @@ void MathAbsoluteOperation::update_memory_buffer_partial(BuffersIterator } } -void MathRadiansOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathRadiansOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = DEG2RADF(inputValue1[0]); + output[0] = DEG2RADF(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathRadiansOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -644,18 +647,18 @@ void MathRadiansOperation::update_memory_buffer_partial(BuffersIterator & } } -void MathDegreesOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathDegreesOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = RAD2DEGF(inputValue1[0]); + output[0] = RAD2DEGF(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathDegreesOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -666,20 +669,20 @@ void MathDegreesOperation::update_memory_buffer_partial(BuffersIterator & } } -void MathArcTan2Operation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathArcTan2Operation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = atan2(inputValue1[0], inputValue2[0]); + output[0] = atan2(input_value1[0], input_value2[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathArcTan2Operation::update_memory_buffer_partial(BuffersIterator &it) @@ -690,18 +693,18 @@ void MathArcTan2Operation::update_memory_buffer_partial(BuffersIterator & } } -void MathFloorOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathFloorOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = floor(inputValue1[0]); + output[0] = floor(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathFloorOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -712,18 +715,18 @@ void MathFloorOperation::update_memory_buffer_partial(BuffersIterator &it } } -void MathCeilOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathCeilOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = ceil(inputValue1[0]); + output[0] = ceil(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathCeilOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -734,18 +737,18 @@ void MathCeilOperation::update_memory_buffer_partial(BuffersIterator &it) } } -void MathFractOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathFractOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = inputValue1[0] - floor(inputValue1[0]); + output[0] = input_value1[0] - floor(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathFractOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -756,23 +759,23 @@ void MathFractOperation::update_memory_buffer_partial(BuffersIterator &it } } -void MathSqrtOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathSqrtOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - if (inputValue1[0] > 0) { - output[0] = sqrt(inputValue1[0]); + if (input_value1[0] > 0) { + output[0] = sqrt(input_value1[0]); } else { output[0] = 0.0f; } - clampIfNeeded(output); + clamp_if_needed(output); } void MathSqrtOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -783,23 +786,23 @@ void MathSqrtOperation::update_memory_buffer_partial(BuffersIterator &it) } } -void MathInverseSqrtOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathInverseSqrtOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - if (inputValue1[0] > 0) { - output[0] = 1.0f / sqrt(inputValue1[0]); + if (input_value1[0] > 0) { + output[0] = 1.0f / sqrt(input_value1[0]); } else { output[0] = 0.0f; } - clampIfNeeded(output); + clamp_if_needed(output); } void MathInverseSqrtOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -810,18 +813,18 @@ void MathInverseSqrtOperation::update_memory_buffer_partial(BuffersIteratorreadSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = compatible_signf(inputValue1[0]); + output[0] = compatible_signf(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathSignOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -832,18 +835,18 @@ void MathSignOperation::update_memory_buffer_partial(BuffersIterator &it) } } -void MathExponentOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathExponentOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = expf(inputValue1[0]); + output[0] = expf(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathExponentOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -854,18 +857,18 @@ void MathExponentOperation::update_memory_buffer_partial(BuffersIterator } } -void MathTruncOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathTruncOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; + float input_value1[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); - output[0] = (inputValue1[0] >= 0.0f) ? floor(inputValue1[0]) : ceil(inputValue1[0]); + output[0] = (input_value1[0] >= 0.0f) ? floor(input_value1[0]) : ceil(input_value1[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathTruncOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -877,25 +880,25 @@ void MathTruncOperation::update_memory_buffer_partial(BuffersIterator &it } } -void MathSnapOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathSnapOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - if (inputValue1[0] == 0 || inputValue2[0] == 0) { /* We don't want to divide by zero. */ + if (input_value1[0] == 0 || input_value2[0] == 0) { /* We don't want to divide by zero. */ output[0] = 0.0f; } else { - output[0] = floorf(inputValue1[0] / inputValue2[0]) * inputValue2[0]; + output[0] = floorf(input_value1[0] / input_value2[0]) * input_value2[0]; } - clampIfNeeded(output); + clamp_if_needed(output); } void MathSnapOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -913,22 +916,22 @@ void MathSnapOperation::update_memory_buffer_partial(BuffersIterator &it) } } -void MathWrapOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathWrapOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; - float inputValue3[4]; + float input_value1[4]; + float input_value2[4]; + float input_value3[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); - inputValue3Operation_->readSampled(inputValue3, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); + input_value3_operation_->read_sampled(input_value3, x, y, sampler); - output[0] = wrapf(inputValue1[0], inputValue2[0], inputValue3[0]); + output[0] = wrapf(input_value1[0], input_value2[0], input_value3[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathWrapOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -939,20 +942,20 @@ void MathWrapOperation::update_memory_buffer_partial(BuffersIterator &it) } } -void MathPingpongOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathPingpongOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; + float input_value1[4]; + float input_value2[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); - output[0] = pingpongf(inputValue1[0], inputValue2[0]); + output[0] = pingpongf(input_value1[0], input_value2[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathPingpongOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -963,23 +966,23 @@ void MathPingpongOperation::update_memory_buffer_partial(BuffersIterator } } -void MathCompareOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathCompareOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; - float inputValue3[4]; + float input_value1[4]; + float input_value2[4]; + float input_value3[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); - inputValue3Operation_->readSampled(inputValue3, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); + input_value3_operation_->read_sampled(input_value3, x, y, sampler); - output[0] = (fabsf(inputValue1[0] - inputValue2[0]) <= MAX2(inputValue3[0], 1e-5f)) ? 1.0f : - 0.0f; + output[0] = (fabsf(input_value1[0] - input_value2[0]) <= MAX2(input_value3[0], 1e-5f)) ? 1.0f : + 0.0f; - clampIfNeeded(output); + clamp_if_needed(output); } void MathCompareOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -990,22 +993,22 @@ void MathCompareOperation::update_memory_buffer_partial(BuffersIterator & } } -void MathMultiplyAddOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathMultiplyAddOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; - float inputValue3[4]; + float input_value1[4]; + float input_value2[4]; + float input_value3[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); - inputValue3Operation_->readSampled(inputValue3, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); + input_value3_operation_->read_sampled(input_value3, x, y, sampler); - output[0] = inputValue1[0] * inputValue2[0] + inputValue3[0]; + output[0] = input_value1[0] * input_value2[0] + input_value3[0]; - clampIfNeeded(output); + clamp_if_needed(output); } void MathMultiplyAddOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -1016,22 +1019,22 @@ void MathMultiplyAddOperation::update_memory_buffer_partial(BuffersIteratorreadSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); - inputValue3Operation_->readSampled(inputValue3, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); + input_value3_operation_->read_sampled(input_value3, x, y, sampler); - output[0] = smoothminf(inputValue1[0], inputValue2[0], inputValue3[0]); + output[0] = smoothminf(input_value1[0], input_value2[0], input_value3[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathSmoothMinOperation::update_memory_buffer_partial(BuffersIterator &it) @@ -1042,22 +1045,22 @@ void MathSmoothMinOperation::update_memory_buffer_partial(BuffersIterator } } -void MathSmoothMaxOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MathSmoothMaxOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue1[4]; - float inputValue2[4]; - float inputValue3[4]; + float input_value1[4]; + float input_value2[4]; + float input_value3[4]; - inputValue1Operation_->readSampled(inputValue1, x, y, sampler); - inputValue2Operation_->readSampled(inputValue2, x, y, sampler); - inputValue3Operation_->readSampled(inputValue3, x, y, sampler); + input_value1_operation_->read_sampled(input_value1, x, y, sampler); + input_value2_operation_->read_sampled(input_value2, x, y, sampler); + input_value3_operation_->read_sampled(input_value3, x, y, sampler); - output[0] = -smoothminf(-inputValue1[0], -inputValue2[0], inputValue3[0]); + output[0] = -smoothminf(-input_value1[0], -input_value2[0], input_value3[0]); - clampIfNeeded(output); + clamp_if_needed(output); } void MathSmoothMaxOperation::update_memory_buffer_partial(BuffersIterator &it) diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.h b/source/blender/compositor/operations/COM_MathBaseOperation.h index fcb735720b2..dc5a16ba4a1 100644 --- a/source/blender/compositor/operations/COM_MathBaseOperation.h +++ b/source/blender/compositor/operations/COM_MathBaseOperation.h @@ -29,13 +29,13 @@ namespace blender::compositor { class MathBaseOperation : public MultiThreadedOperation { protected: /** - * Prefetched reference to the inputProgram + * Prefetched reference to the input_program */ - SocketReader *inputValue1Operation_; - SocketReader *inputValue2Operation_; - SocketReader *inputValue3Operation_; + SocketReader *input_value1_operation_; + SocketReader *input_value2_operation_; + SocketReader *input_value3_operation_; - bool useClamp_; + bool use_clamp_; protected: /** @@ -44,11 +44,11 @@ class MathBaseOperation : public MultiThreadedOperation { MathBaseOperation(); /* TODO(manzanilla): to be removed with tiled implementation. */ - void clampIfNeeded(float color[4]); + void clamp_if_needed(float color[4]); float clamp_when_enabled(float value) { - if (useClamp_) { + if (use_clamp_) { return CLAMPIS(value, 0.0f, 1.0f); } return value; @@ -56,7 +56,7 @@ class MathBaseOperation : public MultiThreadedOperation { void clamp_when_enabled(float *out) { - if (useClamp_) { + if (use_clamp_) { CLAMP(*out, 0.0f, 1.0f); } } @@ -65,21 +65,21 @@ class MathBaseOperation : public MultiThreadedOperation { /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; /** * Determine resolution */ void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void setUseClamp(bool value) + void set_use_clamp(bool value) { - useClamp_ = value; + use_clamp_ = value; } void update_memory_buffer_partial(MemoryBuffer *output, @@ -104,40 +104,40 @@ class MathFunctor2Operation : public MathBaseOperation { class MathAddOperation : public MathFunctor2Operation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; }; class MathSubtractOperation : public MathFunctor2Operation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; }; class MathMultiplyOperation : public MathFunctor2Operation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; }; class MathDivideOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathSineOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathCosineOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathTangentOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -145,21 +145,21 @@ class MathTangentOperation : public MathBaseOperation { class MathHyperbolicSineOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathHyperbolicCosineOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathHyperbolicTangentOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -167,72 +167,72 @@ class MathHyperbolicTangentOperation : public MathBaseOperation { class MathArcSineOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathArcCosineOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathArcTangentOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathPowerOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathLogarithmOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathMinimumOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathMaximumOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathRoundOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; }; class MathLessThanOperation : public MathFunctor2Operation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; }; class MathGreaterThanOperation : public MathFunctor2Operation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; }; class MathModuloOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -240,7 +240,7 @@ class MathModuloOperation : public MathBaseOperation { class MathAbsoluteOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -248,7 +248,7 @@ class MathAbsoluteOperation : public MathBaseOperation { class MathRadiansOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -256,7 +256,7 @@ class MathRadiansOperation : public MathBaseOperation { class MathDegreesOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -264,7 +264,7 @@ class MathDegreesOperation : public MathBaseOperation { class MathArcTan2Operation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -272,7 +272,7 @@ class MathArcTan2Operation : public MathBaseOperation { class MathFloorOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -280,7 +280,7 @@ class MathFloorOperation : public MathBaseOperation { class MathCeilOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -288,7 +288,7 @@ class MathCeilOperation : public MathBaseOperation { class MathFractOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -296,7 +296,7 @@ class MathFractOperation : public MathBaseOperation { class MathSqrtOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -304,7 +304,7 @@ class MathSqrtOperation : public MathBaseOperation { class MathInverseSqrtOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -312,7 +312,7 @@ class MathInverseSqrtOperation : public MathBaseOperation { class MathSignOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -320,7 +320,7 @@ class MathSignOperation : public MathBaseOperation { class MathExponentOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -328,7 +328,7 @@ class MathExponentOperation : public MathBaseOperation { class MathTruncOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -336,7 +336,7 @@ class MathTruncOperation : public MathBaseOperation { class MathSnapOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -344,7 +344,7 @@ class MathSnapOperation : public MathBaseOperation { class MathWrapOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -352,7 +352,7 @@ class MathWrapOperation : public MathBaseOperation { class MathPingpongOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -360,7 +360,7 @@ class MathPingpongOperation : public MathBaseOperation { class MathCompareOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -368,7 +368,7 @@ class MathCompareOperation : public MathBaseOperation { class MathMultiplyAddOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -376,7 +376,7 @@ class MathMultiplyAddOperation : public MathBaseOperation { class MathSmoothMinOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; @@ -384,7 +384,7 @@ class MathSmoothMinOperation : public MathBaseOperation { class MathSmoothMaxOperation : public MathBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_partial(BuffersIterator &it) override; diff --git a/source/blender/compositor/operations/COM_MixOperation.cc b/source/blender/compositor/operations/COM_MixOperation.cc index 216dbc3a701..a40979fc1e6 100644 --- a/source/blender/compositor/operations/COM_MixOperation.cc +++ b/source/blender/compositor/operations/COM_MixOperation.cc @@ -24,44 +24,47 @@ namespace blender::compositor { MixBaseOperation::MixBaseOperation() { - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); - inputValueOperation_ = nullptr; - inputColor1Operation_ = nullptr; - inputColor2Operation_ = nullptr; - this->setUseValueAlphaMultiply(false); - this->setUseClamp(false); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); + input_value_operation_ = nullptr; + input_color1_operation_ = nullptr; + input_color2_operation_ = nullptr; + this->set_use_value_alpha_multiply(false); + this->set_use_clamp(false); flags.can_be_constant = true; } -void MixBaseOperation::initExecution() +void MixBaseOperation::init_execution() { - inputValueOperation_ = this->getInputSocketReader(0); - inputColor1Operation_ = this->getInputSocketReader(1); - inputColor2Operation_ = this->getInputSocketReader(2); + input_value_operation_ = this->get_input_socket_reader(0); + input_color1_operation_ = this->get_input_socket_reader(1); + input_color2_operation_ = this->get_input_socket_reader(2); } -void MixBaseOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void MixBaseOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - output[0] = valuem * (inputColor1[0]) + value * (inputColor2[0]); - output[1] = valuem * (inputColor1[1]) + value * (inputColor2[1]); - output[2] = valuem * (inputColor1[2]) + value * (inputColor2[2]); - output[3] = inputColor1[3]; + output[0] = valuem * (input_color1[0]) + value * (input_color2[0]); + output[1] = valuem * (input_color1[1]) + value * (input_color2[1]); + output[2] = valuem * (input_color1[2]) + value * (input_color2[2]); + output[3] = input_color1[3]; } void MixBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -69,13 +72,13 @@ void MixBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_area NodeOperationInput *socket; rcti temp_area; - socket = this->getInputSocket(1); + socket = this->get_input_socket(1); bool determined = socket->determine_canvas(COM_AREA_NONE, temp_area); if (determined) { this->set_canvas_input_index(1); } else { - socket = this->getInputSocket(2); + socket = this->get_input_socket(2); determined = socket->determine_canvas(COM_AREA_NONE, temp_area); if (determined) { this->set_canvas_input_index(2); @@ -87,11 +90,11 @@ void MixBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_area NodeOperation::determine_canvas(preferred_area, r_area); } -void MixBaseOperation::deinitExecution() +void MixBaseOperation::deinit_execution() { - inputValueOperation_ = nullptr; - inputColor1Operation_ = nullptr; - inputColor2Operation_ = nullptr; + input_value_operation_ = nullptr; + input_color1_operation_ = nullptr; + input_color2_operation_ = nullptr; } void MixBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -121,7 +124,7 @@ void MixBaseOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -135,33 +138,36 @@ void MixBaseOperation::update_memory_buffer_row(PixelCursor &p) /* ******** Mix Add Operation ******** */ -void MixAddOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void MixAddOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } - output[0] = inputColor1[0] + value * inputColor2[0]; - output[1] = inputColor1[1] + value * inputColor2[1]; - output[2] = inputColor1[2] + value * inputColor2[2]; - output[3] = inputColor1[3]; + output[0] = input_color1[0] + value * input_color2[0]; + output[1] = input_color1[1] + value * input_color2[1]; + output[2] = input_color1[2] + value * input_color2[2]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixAddOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } p.out[0] = p.color1[0] + value * p.color2[0]; @@ -169,45 +175,45 @@ void MixAddOperation::update_memory_buffer_row(PixelCursor &p) p.out[2] = p.color1[2] + value * p.color2[2]; p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Blend Operation ******** */ -void MixBlendOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixBlendOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; float value; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); - value = inputValue[0]; + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); + value = input_value[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - output[0] = valuem * (inputColor1[0]) + value * (inputColor2[0]); - output[1] = valuem * (inputColor1[1]) + value * (inputColor2[1]); - output[2] = valuem * (inputColor1[2]) + value * (inputColor2[2]); - output[3] = inputColor1[3]; + output[0] = valuem * (input_color1[0]) + value * (input_color2[0]); + output[1] = valuem * (input_color1[1]) + value * (input_color2[1]); + output[2] = valuem * (input_color1[2]) + value * (input_color2[2]); + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixBlendOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } float value_m = 1.0f - value; @@ -216,39 +222,39 @@ void MixBlendOperation::update_memory_buffer_row(PixelCursor &p) p.out[2] = value_m * p.color1[2] + value * p.color2[2]; p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Burn Operation ******** */ -void MixColorBurnOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixColorBurnOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; float tmp; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - tmp = valuem + value * inputColor2[0]; + tmp = valuem + value * input_color2[0]; if (tmp <= 0.0f) { output[0] = 0.0f; } else { - tmp = 1.0f - (1.0f - inputColor1[0]) / tmp; + tmp = 1.0f - (1.0f - input_color1[0]) / tmp; if (tmp < 0.0f) { output[0] = 0.0f; } @@ -260,12 +266,12 @@ void MixColorBurnOperation::executePixelSampled(float output[4], } } - tmp = valuem + value * inputColor2[1]; + tmp = valuem + value * input_color2[1]; if (tmp <= 0.0f) { output[1] = 0.0f; } else { - tmp = 1.0f - (1.0f - inputColor1[1]) / tmp; + tmp = 1.0f - (1.0f - input_color1[1]) / tmp; if (tmp < 0.0f) { output[1] = 0.0f; } @@ -277,12 +283,12 @@ void MixColorBurnOperation::executePixelSampled(float output[4], } } - tmp = valuem + value * inputColor2[2]; + tmp = valuem + value * input_color2[2]; if (tmp <= 0.0f) { output[2] = 0.0f; } else { - tmp = 1.0f - (1.0f - inputColor1[2]) / tmp; + tmp = 1.0f - (1.0f - input_color1[2]) / tmp; if (tmp < 0.0f) { output[2] = 0.0f; } @@ -294,16 +300,16 @@ void MixColorBurnOperation::executePixelSampled(float output[4], } } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixColorBurnOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -336,56 +342,56 @@ void MixColorBurnOperation::update_memory_buffer_row(PixelCursor &p) } p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Color Operation ******** */ -void MixColorOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixColorOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; float colH, colS, colV; - rgb_to_hsv(inputColor2[0], inputColor2[1], inputColor2[2], &colH, &colS, &colV); + rgb_to_hsv(input_color2[0], input_color2[1], input_color2[2], &colH, &colS, &colV); if (colS != 0.0f) { float rH, rS, rV; float tmpr, tmpg, tmpb; - rgb_to_hsv(inputColor1[0], inputColor1[1], inputColor1[2], &rH, &rS, &rV); + rgb_to_hsv(input_color1[0], input_color1[1], input_color1[2], &rH, &rS, &rV); hsv_to_rgb(colH, colS, rV, &tmpr, &tmpg, &tmpb); - output[0] = (valuem * inputColor1[0]) + (value * tmpr); - output[1] = (valuem * inputColor1[1]) + (value * tmpg); - output[2] = (valuem * inputColor1[2]) + (value * tmpb); + output[0] = (valuem * input_color1[0]) + (value * tmpr); + output[1] = (valuem * input_color1[1]) + (value * tmpg); + output[2] = (valuem * input_color1[2]) + (value * tmpb); } else { - copy_v3_v3(output, inputColor1); + copy_v3_v3(output, input_color1); } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixColorOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -406,44 +412,44 @@ void MixColorOperation::update_memory_buffer_row(PixelCursor &p) } p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Darken Operation ******** */ -void MixDarkenOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixDarkenOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - output[0] = min_ff(inputColor1[0], inputColor2[0]) * value + inputColor1[0] * valuem; - output[1] = min_ff(inputColor1[1], inputColor2[1]) * value + inputColor1[1] * valuem; - output[2] = min_ff(inputColor1[2], inputColor2[2]) * value + inputColor1[2] * valuem; - output[3] = inputColor1[3]; + output[0] = min_ff(input_color1[0], input_color2[0]) * value + input_color1[0] * valuem; + output[1] = min_ff(input_color1[1], input_color2[1]) * value + input_color1[1] * valuem; + output[2] = min_ff(input_color1[2], input_color2[2]) * value + input_color1[2] * valuem; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixDarkenOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } float value_m = 1.0f - value; @@ -452,44 +458,44 @@ void MixDarkenOperation::update_memory_buffer_row(PixelCursor &p) p.out[2] = min_ff(p.color1[2], p.color2[2]) * value + p.color1[2] * value_m; p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Difference Operation ******** */ -void MixDifferenceOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixDifferenceOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - output[0] = valuem * inputColor1[0] + value * fabsf(inputColor1[0] - inputColor2[0]); - output[1] = valuem * inputColor1[1] + value * fabsf(inputColor1[1] - inputColor2[1]); - output[2] = valuem * inputColor1[2] + value * fabsf(inputColor1[2] - inputColor2[2]); - output[3] = inputColor1[3]; + output[0] = valuem * input_color1[0] + value * fabsf(input_color1[0] - input_color2[0]); + output[1] = valuem * input_color1[1] + value * fabsf(input_color1[1] - input_color2[1]); + output[2] = valuem * input_color1[2] + value * fabsf(input_color1[2] - input_color2[2]); + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixDifferenceOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -498,61 +504,61 @@ void MixDifferenceOperation::update_memory_buffer_row(PixelCursor &p) p.out[2] = value_m * p.color1[2] + value * fabsf(p.color1[2] - p.color2[2]); p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Difference Operation ******** */ -void MixDivideOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixDivideOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - if (inputColor2[0] != 0.0f) { - output[0] = valuem * (inputColor1[0]) + value * (inputColor1[0]) / inputColor2[0]; + if (input_color2[0] != 0.0f) { + output[0] = valuem * (input_color1[0]) + value * (input_color1[0]) / input_color2[0]; } else { output[0] = 0.0f; } - if (inputColor2[1] != 0.0f) { - output[1] = valuem * (inputColor1[1]) + value * (inputColor1[1]) / inputColor2[1]; + if (input_color2[1] != 0.0f) { + output[1] = valuem * (input_color1[1]) + value * (input_color1[1]) / input_color2[1]; } else { output[1] = 0.0f; } - if (inputColor2[2] != 0.0f) { - output[2] = valuem * (inputColor1[2]) + value * (inputColor1[2]) / inputColor2[2]; + if (input_color2[2] != 0.0f) { + output[2] = valuem * (input_color1[2]) + value * (input_color1[2]) / input_color2[2]; } else { output[2] = 0.0f; } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixDivideOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -578,39 +584,39 @@ void MixDivideOperation::update_memory_buffer_row(PixelCursor &p) p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Dodge Operation ******** */ -void MixDodgeOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixDodgeOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; float tmp; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } - if (inputColor1[0] != 0.0f) { - tmp = 1.0f - value * inputColor2[0]; + if (input_color1[0] != 0.0f) { + tmp = 1.0f - value * input_color2[0]; if (tmp <= 0.0f) { output[0] = 1.0f; } else { - tmp = inputColor1[0] / tmp; + tmp = input_color1[0] / tmp; if (tmp > 1.0f) { output[0] = 1.0f; } @@ -623,13 +629,13 @@ void MixDodgeOperation::executePixelSampled(float output[4], output[0] = 0.0f; } - if (inputColor1[1] != 0.0f) { - tmp = 1.0f - value * inputColor2[1]; + if (input_color1[1] != 0.0f) { + tmp = 1.0f - value * input_color2[1]; if (tmp <= 0.0f) { output[1] = 1.0f; } else { - tmp = inputColor1[1] / tmp; + tmp = input_color1[1] / tmp; if (tmp > 1.0f) { output[1] = 1.0f; } @@ -642,13 +648,13 @@ void MixDodgeOperation::executePixelSampled(float output[4], output[1] = 0.0f; } - if (inputColor1[2] != 0.0f) { - tmp = 1.0f - value * inputColor2[2]; + if (input_color1[2] != 0.0f) { + tmp = 1.0f - value * input_color2[2]; if (tmp <= 0.0f) { output[2] = 1.0f; } else { - tmp = inputColor1[2] / tmp; + tmp = input_color1[2] / tmp; if (tmp > 1.0f) { output[2] = 1.0f; } @@ -661,16 +667,16 @@ void MixDodgeOperation::executePixelSampled(float output[4], output[2] = 0.0f; } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixDodgeOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } @@ -719,27 +725,27 @@ void MixDodgeOperation::update_memory_buffer_row(PixelCursor &p) p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Glare Operation ******** */ -void MixGlareOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixGlareOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; float value, input_weight, glare_weight; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); - value = inputValue[0]; + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); + value = input_value[0]; /* Linear interpolation between 3 cases: * value=-1:output=input value=0:output=input+glare value=1:output=glare */ @@ -751,12 +757,12 @@ void MixGlareOperation::executePixelSampled(float output[4], input_weight = 1.0f - value; glare_weight = 1.0f; } - output[0] = input_weight * MAX2(inputColor1[0], 0.0f) + glare_weight * inputColor2[0]; - output[1] = input_weight * MAX2(inputColor1[1], 0.0f) + glare_weight * inputColor2[1]; - output[2] = input_weight * MAX2(inputColor1[2], 0.0f) + glare_weight * inputColor2[2]; - output[3] = inputColor1[3]; + output[0] = input_weight * MAX2(input_color1[0], 0.0f) + glare_weight * input_color2[0]; + output[1] = input_weight * MAX2(input_color1[1], 0.0f) + glare_weight * input_color2[1]; + output[2] = input_weight * MAX2(input_color1[2], 0.0f) + glare_weight * input_color2[2]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixGlareOperation::update_memory_buffer_row(PixelCursor &p) @@ -781,53 +787,56 @@ void MixGlareOperation::update_memory_buffer_row(PixelCursor &p) p.out[2] = input_weight * MAX2(p.color1[2], 0.0f) + glare_weight * p.color2[2]; p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Hue Operation ******** */ -void MixHueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void MixHueOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; float colH, colS, colV; - rgb_to_hsv(inputColor2[0], inputColor2[1], inputColor2[2], &colH, &colS, &colV); + rgb_to_hsv(input_color2[0], input_color2[1], input_color2[2], &colH, &colS, &colV); if (colS != 0.0f) { float rH, rS, rV; float tmpr, tmpg, tmpb; - rgb_to_hsv(inputColor1[0], inputColor1[1], inputColor1[2], &rH, &rS, &rV); + rgb_to_hsv(input_color1[0], input_color1[1], input_color1[2], &rH, &rS, &rV); hsv_to_rgb(colH, rS, rV, &tmpr, &tmpg, &tmpb); - output[0] = valuem * (inputColor1[0]) + value * tmpr; - output[1] = valuem * (inputColor1[1]) + value * tmpg; - output[2] = valuem * (inputColor1[2]) + value * tmpb; + output[0] = valuem * (input_color1[0]) + value * tmpr; + output[1] = valuem * (input_color1[1]) + value * tmpg; + output[2] = valuem * (input_color1[2]) + value * tmpb; } else { - copy_v3_v3(output, inputColor1); + copy_v3_v3(output, input_color1); } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixHueOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -848,62 +857,62 @@ void MixHueOperation::update_memory_buffer_row(PixelCursor &p) } p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Lighten Operation ******** */ -void MixLightenOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixLightenOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float tmp; - tmp = value * inputColor2[0]; - if (tmp > inputColor1[0]) { + tmp = value * input_color2[0]; + if (tmp > input_color1[0]) { output[0] = tmp; } else { - output[0] = inputColor1[0]; + output[0] = input_color1[0]; } - tmp = value * inputColor2[1]; - if (tmp > inputColor1[1]) { + tmp = value * input_color2[1]; + if (tmp > input_color1[1]) { output[1] = tmp; } else { - output[1] = inputColor1[1]; + output[1] = input_color1[1]; } - tmp = value * inputColor2[2]; - if (tmp > inputColor1[2]) { + tmp = value * input_color2[2]; + if (tmp > input_color1[2]) { output[2] = tmp; } else { - output[2] = inputColor1[2]; + output[2] = input_color1[2]; } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixLightenOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } @@ -918,59 +927,59 @@ void MixLightenOperation::update_memory_buffer_row(PixelCursor &p) p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Linear Light Operation ******** */ -void MixLinearLightOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixLinearLightOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } - if (inputColor2[0] > 0.5f) { - output[0] = inputColor1[0] + value * (2.0f * (inputColor2[0] - 0.5f)); + if (input_color2[0] > 0.5f) { + output[0] = input_color1[0] + value * (2.0f * (input_color2[0] - 0.5f)); } else { - output[0] = inputColor1[0] + value * (2.0f * (inputColor2[0]) - 1.0f); + output[0] = input_color1[0] + value * (2.0f * (input_color2[0]) - 1.0f); } - if (inputColor2[1] > 0.5f) { - output[1] = inputColor1[1] + value * (2.0f * (inputColor2[1] - 0.5f)); + if (input_color2[1] > 0.5f) { + output[1] = input_color1[1] + value * (2.0f * (input_color2[1] - 0.5f)); } else { - output[1] = inputColor1[1] + value * (2.0f * (inputColor2[1]) - 1.0f); + output[1] = input_color1[1] + value * (2.0f * (input_color2[1]) - 1.0f); } - if (inputColor2[2] > 0.5f) { - output[2] = inputColor1[2] + value * (2.0f * (inputColor2[2] - 0.5f)); + if (input_color2[2] > 0.5f) { + output[2] = input_color1[2] + value * (2.0f * (input_color2[2] - 0.5f)); } else { - output[2] = inputColor1[2] + value * (2.0f * (inputColor2[2]) - 1.0f); + output[2] = input_color1[2] + value * (2.0f * (input_color2[2]) - 1.0f); } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixLinearLightOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } if (p.color2[0] > 0.5f) { @@ -994,44 +1003,44 @@ void MixLinearLightOperation::update_memory_buffer_row(PixelCursor &p) p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Multiply Operation ******** */ -void MixMultiplyOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixMultiplyOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - output[0] = inputColor1[0] * (valuem + value * inputColor2[0]); - output[1] = inputColor1[1] * (valuem + value * inputColor2[1]); - output[2] = inputColor1[2] * (valuem + value * inputColor2[2]); - output[3] = inputColor1[3]; + output[0] = input_color1[0] * (valuem + value * input_color2[0]); + output[1] = input_color1[1] * (valuem + value * input_color2[1]); + output[2] = input_color1[2] * (valuem + value * input_color2[2]); + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixMultiplyOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -1041,61 +1050,64 @@ void MixMultiplyOperation::update_memory_buffer_row(PixelCursor &p) p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Overlay Operation ******** */ -void MixOverlayOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixOverlayOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - if (inputColor1[0] < 0.5f) { - output[0] = inputColor1[0] * (valuem + 2.0f * value * inputColor2[0]); + if (input_color1[0] < 0.5f) { + output[0] = input_color1[0] * (valuem + 2.0f * value * input_color2[0]); } else { - output[0] = 1.0f - (valuem + 2.0f * value * (1.0f - inputColor2[0])) * (1.0f - inputColor1[0]); + output[0] = 1.0f - + (valuem + 2.0f * value * (1.0f - input_color2[0])) * (1.0f - input_color1[0]); } - if (inputColor1[1] < 0.5f) { - output[1] = inputColor1[1] * (valuem + 2.0f * value * inputColor2[1]); + if (input_color1[1] < 0.5f) { + output[1] = input_color1[1] * (valuem + 2.0f * value * input_color2[1]); } else { - output[1] = 1.0f - (valuem + 2.0f * value * (1.0f - inputColor2[1])) * (1.0f - inputColor1[1]); + output[1] = 1.0f - + (valuem + 2.0f * value * (1.0f - input_color2[1])) * (1.0f - input_color1[1]); } - if (inputColor1[2] < 0.5f) { - output[2] = inputColor1[2] * (valuem + 2.0f * value * inputColor2[2]); + if (input_color1[2] < 0.5f) { + output[2] = input_color1[2] * (valuem + 2.0f * value * input_color2[2]); } else { - output[2] = 1.0f - (valuem + 2.0f * value * (1.0f - inputColor2[2])) * (1.0f - inputColor1[2]); + output[2] = 1.0f - + (valuem + 2.0f * value * (1.0f - input_color2[2])) * (1.0f - input_color1[2]); } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixOverlayOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -1120,53 +1132,53 @@ void MixOverlayOperation::update_memory_buffer_row(PixelCursor &p) p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Saturation Operation ******** */ -void MixSaturationOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixSaturationOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; float rH, rS, rV; - rgb_to_hsv(inputColor1[0], inputColor1[1], inputColor1[2], &rH, &rS, &rV); + rgb_to_hsv(input_color1[0], input_color1[1], input_color1[2], &rH, &rS, &rV); if (rS != 0.0f) { float colH, colS, colV; - rgb_to_hsv(inputColor2[0], inputColor2[1], inputColor2[2], &colH, &colS, &colV); + rgb_to_hsv(input_color2[0], input_color2[1], input_color2[2], &colH, &colS, &colV); hsv_to_rgb(rH, (valuem * rS + value * colS), rV, &output[0], &output[1], &output[2]); } else { - copy_v3_v3(output, inputColor1); + copy_v3_v3(output, input_color1); } - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixSaturationOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -1184,45 +1196,45 @@ void MixSaturationOperation::update_memory_buffer_row(PixelCursor &p) p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Screen Operation ******** */ -void MixScreenOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixScreenOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; - output[0] = 1.0f - (valuem + value * (1.0f - inputColor2[0])) * (1.0f - inputColor1[0]); - output[1] = 1.0f - (valuem + value * (1.0f - inputColor2[1])) * (1.0f - inputColor1[1]); - output[2] = 1.0f - (valuem + value * (1.0f - inputColor2[2])) * (1.0f - inputColor1[2]); - output[3] = inputColor1[3]; + output[0] = 1.0f - (valuem + value * (1.0f - input_color2[0])) * (1.0f - input_color1[0]); + output[1] = 1.0f - (valuem + value * (1.0f - input_color2[1])) * (1.0f - input_color1[1]); + output[2] = 1.0f - (valuem + value * (1.0f - input_color2[2])) * (1.0f - input_color1[2]); + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixScreenOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -1232,57 +1244,57 @@ void MixScreenOperation::update_memory_buffer_row(PixelCursor &p) p.out[2] = 1.0f - (value_m + value * (1.0f - p.color2[2])) * (1.0f - p.color1[2]); p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Soft Light Operation ******** */ -void MixSoftLightOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixSoftLightOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; float scr, scg, scb; /* first calculate non-fac based Screen mix */ - scr = 1.0f - (1.0f - inputColor2[0]) * (1.0f - inputColor1[0]); - scg = 1.0f - (1.0f - inputColor2[1]) * (1.0f - inputColor1[1]); - scb = 1.0f - (1.0f - inputColor2[2]) * (1.0f - inputColor1[2]); - - output[0] = valuem * (inputColor1[0]) + - value * (((1.0f - inputColor1[0]) * inputColor2[0] * (inputColor1[0])) + - (inputColor1[0] * scr)); - output[1] = valuem * (inputColor1[1]) + - value * (((1.0f - inputColor1[1]) * inputColor2[1] * (inputColor1[1])) + - (inputColor1[1] * scg)); - output[2] = valuem * (inputColor1[2]) + - value * (((1.0f - inputColor1[2]) * inputColor2[2] * (inputColor1[2])) + - (inputColor1[2] * scb)); - output[3] = inputColor1[3]; - - clampIfNeeded(output); + scr = 1.0f - (1.0f - input_color2[0]) * (1.0f - input_color1[0]); + scg = 1.0f - (1.0f - input_color2[1]) * (1.0f - input_color1[1]); + scb = 1.0f - (1.0f - input_color2[2]) * (1.0f - input_color1[2]); + + output[0] = valuem * (input_color1[0]) + + value * (((1.0f - input_color1[0]) * input_color2[0] * (input_color1[0])) + + (input_color1[0] * scr)); + output[1] = valuem * (input_color1[1]) + + value * (((1.0f - input_color1[1]) * input_color2[1] * (input_color1[1])) + + (input_color1[1] * scg)); + output[2] = valuem * (input_color1[2]) + + value * (((1.0f - input_color1[2]) * input_color2[2] * (input_color1[2])) + + (input_color1[2] * scb)); + output[3] = input_color1[3]; + + clamp_if_needed(output); } void MixSoftLightOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } const float value_m = 1.0f - value; @@ -1301,43 +1313,43 @@ void MixSoftLightOperation::update_memory_buffer_row(PixelCursor &p) value * ((1.0f - p.color1[2]) * p.color2[2] * p.color1[2] + p.color1[2] * scb); p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Subtract Operation ******** */ -void MixSubtractOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixSubtractOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } - output[0] = inputColor1[0] - value * (inputColor2[0]); - output[1] = inputColor1[1] - value * (inputColor2[1]); - output[2] = inputColor1[2] - value * (inputColor2[2]); - output[3] = inputColor1[3]; + output[0] = input_color1[0] - value * (input_color2[0]); + output[1] = input_color1[1] - value * (input_color2[1]); + output[2] = input_color1[2] - value * (input_color2[2]); + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixSubtractOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } p.out[0] = p.color1[0] - value * p.color2[0]; @@ -1345,47 +1357,47 @@ void MixSubtractOperation::update_memory_buffer_row(PixelCursor &p) p.out[2] = p.color1[2] - value * p.color2[2]; p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } /* ******** Mix Value Operation ******** */ -void MixValueOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MixValueOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputColor1[4]; - float inputColor2[4]; - float inputValue[4]; + float input_color1[4]; + float input_color2[4]; + float input_value[4]; - inputValueOperation_->readSampled(inputValue, x, y, sampler); - inputColor1Operation_->readSampled(inputColor1, x, y, sampler); - inputColor2Operation_->readSampled(inputColor2, x, y, sampler); + input_value_operation_->read_sampled(input_value, x, y, sampler); + input_color1_operation_->read_sampled(input_color1, x, y, sampler); + input_color2_operation_->read_sampled(input_color2, x, y, sampler); - float value = inputValue[0]; - if (this->useValueAlphaMultiply()) { - value *= inputColor2[3]; + float value = input_value[0]; + if (this->use_value_alpha_multiply()) { + value *= input_color2[3]; } float valuem = 1.0f - value; float rH, rS, rV; float colH, colS, colV; - rgb_to_hsv(inputColor1[0], inputColor1[1], inputColor1[2], &rH, &rS, &rV); - rgb_to_hsv(inputColor2[0], inputColor2[1], inputColor2[2], &colH, &colS, &colV); + rgb_to_hsv(input_color1[0], input_color1[1], input_color1[2], &rH, &rS, &rV); + rgb_to_hsv(input_color2[0], input_color2[1], input_color2[2], &colH, &colS, &colV); hsv_to_rgb(rH, rS, (valuem * rV + value * colV), &output[0], &output[1], &output[2]); - output[3] = inputColor1[3]; + output[3] = input_color1[3]; - clampIfNeeded(output); + clamp_if_needed(output); } void MixValueOperation::update_memory_buffer_row(PixelCursor &p) { while (p.out < p.row_end) { float value = p.value[0]; - if (this->useValueAlphaMultiply()) { + if (this->use_value_alpha_multiply()) { value *= p.color2[3]; } float value_m = 1.0f - value; @@ -1397,7 +1409,7 @@ void MixValueOperation::update_memory_buffer_row(PixelCursor &p) hsv_to_rgb(rH, rS, (value_m * rV + value * colV), &p.out[0], &p.out[1], &p.out[2]); p.out[3] = p.color1[3]; - clampIfNeeded(p.out); + clamp_if_needed(p.out); p.next(); } } diff --git a/source/blender/compositor/operations/COM_MixOperation.h b/source/blender/compositor/operations/COM_MixOperation.h index 0efc98617a6..bf5639f43a3 100644 --- a/source/blender/compositor/operations/COM_MixOperation.h +++ b/source/blender/compositor/operations/COM_MixOperation.h @@ -51,17 +51,17 @@ class MixBaseOperation : public MultiThreadedOperation { }; /** - * Prefetched reference to the inputProgram + * Prefetched reference to the input_program */ - SocketReader *inputValueOperation_; - SocketReader *inputColor1Operation_; - SocketReader *inputColor2Operation_; - bool valueAlphaMultiply_; - bool useClamp_; + SocketReader *input_value_operation_; + SocketReader *input_color1_operation_; + SocketReader *input_color2_operation_; + bool value_alpha_multiply_; + bool use_clamp_; - inline void clampIfNeeded(float color[4]) + inline void clamp_if_needed(float color[4]) { - if (useClamp_) { + if (use_clamp_) { clamp_v4(color, 0.0f, 1.0f); } } @@ -75,31 +75,31 @@ class MixBaseOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void setUseValueAlphaMultiply(const bool value) + void set_use_value_alpha_multiply(const bool value) { - valueAlphaMultiply_ = value; + value_alpha_multiply_ = value; } - inline bool useValueAlphaMultiply() + inline bool use_value_alpha_multiply() { - return valueAlphaMultiply_; + return value_alpha_multiply_; } - void setUseClamp(bool value) + void set_use_clamp(bool value) { - useClamp_ = value; + use_clamp_ = value; } void update_memory_buffer_partial(MemoryBuffer *output, @@ -112,7 +112,7 @@ class MixBaseOperation : public MultiThreadedOperation { class MixAddOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -120,7 +120,7 @@ class MixAddOperation : public MixBaseOperation { class MixBlendOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -128,7 +128,7 @@ class MixBlendOperation : public MixBaseOperation { class MixColorBurnOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -136,7 +136,7 @@ class MixColorBurnOperation : public MixBaseOperation { class MixColorOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -144,7 +144,7 @@ class MixColorOperation : public MixBaseOperation { class MixDarkenOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -152,7 +152,7 @@ class MixDarkenOperation : public MixBaseOperation { class MixDifferenceOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -160,7 +160,7 @@ class MixDifferenceOperation : public MixBaseOperation { class MixDivideOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -168,7 +168,7 @@ class MixDivideOperation : public MixBaseOperation { class MixDodgeOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -176,7 +176,7 @@ class MixDodgeOperation : public MixBaseOperation { class MixGlareOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -184,7 +184,7 @@ class MixGlareOperation : public MixBaseOperation { class MixHueOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -192,7 +192,7 @@ class MixHueOperation : public MixBaseOperation { class MixLightenOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -200,7 +200,7 @@ class MixLightenOperation : public MixBaseOperation { class MixLinearLightOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -208,7 +208,7 @@ class MixLinearLightOperation : public MixBaseOperation { class MixMultiplyOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -216,7 +216,7 @@ class MixMultiplyOperation : public MixBaseOperation { class MixOverlayOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -224,7 +224,7 @@ class MixOverlayOperation : public MixBaseOperation { class MixSaturationOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -232,7 +232,7 @@ class MixSaturationOperation : public MixBaseOperation { class MixScreenOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -240,7 +240,7 @@ class MixScreenOperation : public MixBaseOperation { class MixSoftLightOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -248,7 +248,7 @@ class MixSoftLightOperation : public MixBaseOperation { class MixSubtractOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; @@ -256,7 +256,7 @@ class MixSubtractOperation : public MixBaseOperation { class MixValueOperation : public MixBaseOperation { public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; protected: void update_memory_buffer_row(PixelCursor &p) override; diff --git a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cc b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cc index c43a552f1ce..1765012d873 100644 --- a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cc +++ b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cc @@ -25,7 +25,7 @@ namespace blender::compositor { MovieClipAttributeOperation::MovieClipAttributeOperation() { - this->addOutputSocket(DataType::Value); + this->add_output_socket(DataType::Value); framenumber_ = 0; attribute_ = MCA_X; invert_ = false; @@ -34,7 +34,7 @@ MovieClipAttributeOperation::MovieClipAttributeOperation() stabilization_resolution_socket_ = nullptr; } -void MovieClipAttributeOperation::initExecution() +void MovieClipAttributeOperation::init_execution() { if (!is_value_calculated_) { calc_value(); @@ -56,12 +56,12 @@ void MovieClipAttributeOperation::calc_value() int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip_, framenumber_); NodeOperation &stabilization_operation = stabilization_resolution_socket_ ? - stabilization_resolution_socket_->getLink()->getOperation() : + stabilization_resolution_socket_->get_link()->get_operation() : *this; BKE_tracking_stabilization_data_get(clip_, clip_framenr, - stabilization_operation.getWidth(), - stabilization_operation.getHeight(), + stabilization_operation.get_width(), + stabilization_operation.get_height(), loc, &scale, &angle); @@ -89,10 +89,10 @@ void MovieClipAttributeOperation::calc_value() } } -void MovieClipAttributeOperation::executePixelSampled(float output[4], - float /*x*/, - float /*y*/, - PixelSampler /*sampler*/) +void MovieClipAttributeOperation::execute_pixel_sampled(float output[4], + float /*x*/, + float /*y*/, + PixelSampler /*sampler*/) { output[0] = value_; } diff --git a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h index 2df2b199107..9f333189811 100644 --- a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h +++ b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h @@ -50,29 +50,29 @@ class MovieClipAttributeOperation : public ConstantOperation { */ MovieClipAttributeOperation(); - void initExecution() override; + void init_execution() override; /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; const float *get_constant_elem() override; - void setMovieClip(MovieClip *clip) + void set_movie_clip(MovieClip *clip) { clip_ = clip; } - void setFramenumber(int framenumber) + void set_framenumber(int framenumber) { framenumber_ = framenumber; } - void setAttribute(MovieClipAttribute attribute) + void set_attribute(MovieClipAttribute attribute) { attribute_ = attribute; } - void setInvert(bool invert) + void set_invert(bool invert) { invert_ = invert; } diff --git a/source/blender/compositor/operations/COM_MovieClipOperation.cc b/source/blender/compositor/operations/COM_MovieClipOperation.cc index 2803c707371..a73b408e3ff 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() { - movieClip_ = nullptr; - movieClipBuffer_ = nullptr; - movieClipUser_ = nullptr; - movieClipwidth_ = 0; - movieClipheight_ = 0; + movie_clip_ = nullptr; + movie_clip_buffer_ = nullptr; + movie_clip_user_ = nullptr; + movie_clipwidth_ = 0; + movie_clipheight_ = 0; framenumber_ = 0; } -void MovieClipBaseOperation::initExecution() +void MovieClipBaseOperation::init_execution() { - if (movieClip_) { - BKE_movieclip_user_set_frame(movieClipUser_, framenumber_); + if (movie_clip_) { + BKE_movieclip_user_set_frame(movie_clip_user_, framenumber_); ImBuf *ibuf; - if (cacheFrame_) { - ibuf = BKE_movieclip_get_ibuf(movieClip_, movieClipUser_); + if (cache_frame_) { + ibuf = BKE_movieclip_get_ibuf(movie_clip_, movie_clip_user_); } else { ibuf = BKE_movieclip_get_ibuf_flag( - movieClip_, movieClipUser_, movieClip_->flag, MOVIECLIP_CACHE_SKIP); + movie_clip_, movie_clip_user_, movie_clip_->flag, MOVIECLIP_CACHE_SKIP); } if (ibuf) { - movieClipBuffer_ = ibuf; + movie_clip_buffer_ = ibuf; if (ibuf->rect_float == nullptr || ibuf->userflags & IB_RECT_INVALID) { IMB_float_from_rect(ibuf); ibuf->userflags &= ~IB_RECT_INVALID; @@ -59,31 +59,31 @@ void MovieClipBaseOperation::initExecution() } } -void MovieClipBaseOperation::deinitExecution() +void MovieClipBaseOperation::deinit_execution() { - if (movieClipBuffer_) { - IMB_freeImBuf(movieClipBuffer_); + if (movie_clip_buffer_) { + IMB_freeImBuf(movie_clip_buffer_); - movieClipBuffer_ = nullptr; + movie_clip_buffer_ = nullptr; } } void MovieClipBaseOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area) { r_area = COM_AREA_NONE; - if (movieClip_) { + if (movie_clip_) { int width, height; - BKE_movieclip_get_size(movieClip_, movieClipUser_, &width, &height); + BKE_movieclip_get_size(movie_clip_, movie_clip_user_, &width, &height); BLI_rcti_init(&r_area, 0, width, 0, height); } } -void MovieClipBaseOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MovieClipBaseOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - ImBuf *ibuf = movieClipBuffer_; + ImBuf *ibuf = movie_clip_buffer_; if (ibuf == nullptr) { zero_v4(output); @@ -111,8 +111,8 @@ void MovieClipBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span UNUSED(inputs)) { - if (movieClipBuffer_) { - output->copy_from(movieClipBuffer_, area); + if (movie_clip_buffer_) { + output->copy_from(movie_clip_buffer_, area); } else { output->fill(area, COM_COLOR_TRANSPARENT); @@ -121,21 +121,21 @@ void MovieClipBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, MovieClipOperation::MovieClipOperation() : MovieClipBaseOperation() { - this->addOutputSocket(DataType::Color); + this->add_output_socket(DataType::Color); } MovieClipAlphaOperation::MovieClipAlphaOperation() : MovieClipBaseOperation() { - this->addOutputSocket(DataType::Value); + this->add_output_socket(DataType::Value); } -void MovieClipAlphaOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MovieClipAlphaOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float result[4]; - MovieClipBaseOperation::executePixelSampled(result, x, y, sampler); + MovieClipBaseOperation::execute_pixel_sampled(result, x, y, sampler); output[0] = result[3]; } @@ -143,8 +143,8 @@ void MovieClipAlphaOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span UNUSED(inputs)) { - if (movieClipBuffer_) { - output->copy_from(movieClipBuffer_, area, 3, COM_DATA_TYPE_VALUE_CHANNELS, 0); + if (movie_clip_buffer_) { + output->copy_from(movie_clip_buffer_, 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 58cebba45d7..e576917df1b 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 *movieClip_; - MovieClipUser *movieClipUser_; - ImBuf *movieClipBuffer_; - int movieClipheight_; - int movieClipwidth_; + MovieClip *movie_clip_; + MovieClipUser *movie_clip_user_; + ImBuf *movie_clip_buffer_; + int movie_clipheight_; + int movie_clipwidth_; int framenumber_; - bool cacheFrame_; + bool cache_frame_; /** * Determine the output resolution. The resolution is retrieved from the Renderer @@ -46,26 +46,26 @@ class MovieClipBaseOperation : public MultiThreadedOperation { public: MovieClipBaseOperation(); - void initExecution() override; - void deinitExecution() override; - void setMovieClip(MovieClip *image) + void init_execution() override; + void deinit_execution() override; + void set_movie_clip(MovieClip *image) { - movieClip_ = image; + movie_clip_ = image; } - void setMovieClipUser(MovieClipUser *imageuser) + void set_movie_clip_user(MovieClipUser *imageuser) { - movieClipUser_ = imageuser; + movie_clip_user_ = imageuser; } - void setCacheFrame(bool value) + void set_cache_frame(bool value) { - cacheFrame_ = value; + cache_frame_ = value; } - void setFramenumber(int framenumber) + void set_framenumber(int framenumber) { framenumber_ = framenumber; } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -80,7 +80,7 @@ class MovieClipOperation : public MovieClipBaseOperation { class MovieClipAlphaOperation : public MovieClipBaseOperation { public: MovieClipAlphaOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_MovieDistortionOperation.cc b/source/blender/compositor/operations/COM_MovieDistortionOperation.cc index 0cb0742dbee..d04a970bc03 100644 --- a/source/blender/compositor/operations/COM_MovieDistortionOperation.cc +++ b/source/blender/compositor/operations/COM_MovieDistortionOperation.cc @@ -24,31 +24,31 @@ namespace blender::compositor { MovieDistortionOperation::MovieDistortionOperation(bool distortion) { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); this->set_canvas_input_index(0); - inputOperation_ = nullptr; - movieClip_ = nullptr; + input_operation_ = nullptr; + movie_clip_ = nullptr; apply_ = distortion; } void MovieDistortionOperation::init_data() { - if (movieClip_) { - MovieTracking *tracking = &movieClip_->tracking; - MovieClipUser clipUser = {0}; + if (movie_clip_) { + MovieTracking *tracking = &movie_clip_->tracking; + MovieClipUser clip_user = {0}; int calibration_width, calibration_height; - BKE_movieclip_user_set_frame(&clipUser, framenumber_); - BKE_movieclip_get_size(movieClip_, &clipUser, &calibration_width, &calibration_height); + BKE_movieclip_user_set_frame(&clip_user, framenumber_); + BKE_movieclip_get_size(movie_clip_, &clip_user, &calibration_width, &calibration_height); float delta[2]; rcti full_frame; full_frame.xmin = full_frame.ymin = 0; - full_frame.xmax = this->getWidth(); - full_frame.ymax = this->getHeight(); + full_frame.xmax = this->get_width(); + full_frame.ymax = this->get_height(); BKE_tracking_max_distortion_delta_across_bound( - tracking, this->getWidth(), this->getHeight(), &full_frame, !apply_, delta); + tracking, this->get_width(), this->get_height(), &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 @@ -65,11 +65,11 @@ void MovieDistortionOperation::init_data() } } -void MovieDistortionOperation::initExecution() +void MovieDistortionOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); - if (movieClip_) { - MovieTracking *tracking = &movieClip_->tracking; + input_operation_ = this->get_input_socket_reader(0); + if (movie_clip_) { + MovieTracking *tracking = &movie_clip_->tracking; distortion_ = BKE_tracking_distortion_new(tracking, calibration_width_, calibration_height_); } else { @@ -77,25 +77,25 @@ void MovieDistortionOperation::initExecution() } } -void MovieDistortionOperation::deinitExecution() +void MovieDistortionOperation::deinit_execution() { - inputOperation_ = nullptr; - movieClip_ = nullptr; + input_operation_ = nullptr; + movie_clip_ = nullptr; if (distortion_ != nullptr) { BKE_tracking_distortion_free(distortion_); } } -void MovieDistortionOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void MovieDistortionOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { if (distortion_ != nullptr) { /* float overscan = 0.0f; */ const float pixel_aspect = pixel_aspect_; - const float w = (float)this->getWidth() /* / (1 + overscan) */; - const float h = (float)this->getHeight() /* / (1 + overscan) */; + const float w = (float)this->get_width() /* / (1 + overscan) */; + const float h = (float)this->get_height() /* / (1 + overscan) */; const float aspx = w / (float)calibration_width_; const float aspy = h / (float)calibration_height_; float in[2]; @@ -114,23 +114,22 @@ void MovieDistortionOperation::executePixelSampled(float output[4], float u = out[0] * aspx /* + 0.5 * overscan * w */, v = (out[1] * aspy /* + 0.5 * overscan * h */) * pixel_aspect; - inputOperation_->readSampled(output, u, v, PixelSampler::Bilinear); + input_operation_->read_sampled(output, u, v, PixelSampler::Bilinear); } else { - inputOperation_->readSampled(output, x, y, PixelSampler::Bilinear); + input_operation_->read_sampled(output, x, y, PixelSampler::Bilinear); } } -bool MovieDistortionOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool MovieDistortionOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; - 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); + rcti new_input; + new_input.xmin = input->xmin - margin_[0]; + new_input.ymin = input->ymin - margin_[1]; + new_input.xmax = input->xmax + margin_[0]; + new_input.ymax = input->ymax + margin_[1]; + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void MovieDistortionOperation::get_area_of_interest(const int input_idx, @@ -157,8 +156,8 @@ void MovieDistortionOperation::update_memory_buffer_partial(MemoryBuffer *output /* `float overscan = 0.0f;` */ const float pixel_aspect = pixel_aspect_; - const float w = (float)this->getWidth() /* `/ (1 + overscan)` */; - const float h = (float)this->getHeight() /* `/ (1 + overscan)` */; + const float w = (float)this->get_width() /* `/ (1 + overscan)` */; + const float h = (float)this->get_height() /* `/ (1 + overscan)` */; const float aspx = w / (float)calibration_width_; const float aspy = h / (float)calibration_height_; float xy[2]; diff --git a/source/blender/compositor/operations/COM_MovieDistortionOperation.h b/source/blender/compositor/operations/COM_MovieDistortionOperation.h index 3e728962bc3..cf430c74f30 100644 --- a/source/blender/compositor/operations/COM_MovieDistortionOperation.h +++ b/source/blender/compositor/operations/COM_MovieDistortionOperation.h @@ -28,8 +28,8 @@ namespace blender::compositor { class MovieDistortionOperation : public MultiThreadedOperation { private: - SocketReader *inputOperation_; - MovieClip *movieClip_; + SocketReader *input_operation_; + MovieClip *movie_clip_; int margin_[2]; protected: @@ -42,23 +42,23 @@ class MovieDistortionOperation : public MultiThreadedOperation { public: MovieDistortionOperation(bool distortion); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void init_data() override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setMovieClip(MovieClip *clip) + void set_movie_clip(MovieClip *clip) { - movieClip_ = clip; + movie_clip_ = clip; } - void setFramenumber(int framenumber) + void set_framenumber(int framenumber) { framenumber_ = framenumber; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.cc b/source/blender/compositor/operations/COM_MultilayerImageOperation.cc index 0209ea0e18c..5549cd1e937 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) { - passId_ = BLI_findindex(&render_layer->passes, render_pass); + pass_id_ = BLI_findindex(&render_layer->passes, render_pass); view_ = view; - renderLayer_ = render_layer; - renderPass_ = render_pass; + render_layer_ = render_layer; + render_pass_ = render_pass; } -ImBuf *MultilayerBaseOperation::getImBuf() +ImBuf *MultilayerBaseOperation::get_im_buf() { /* temporarily changes the view to get the right ImBuf */ - int view = imageUser_->view; + int view = image_user_->view; - imageUser_->view = view_; - imageUser_->pass = passId_; + image_user_->view = view_; + image_user_->pass = pass_id_; - if (BKE_image_multilayer_index(image_->rr, imageUser_)) { - ImBuf *ibuf = BaseImageOperation::getImBuf(); - imageUser_->view = view; + if (BKE_image_multilayer_index(image_->rr, image_user_)) { + ImBuf *ibuf = BaseImageOperation::get_im_buf(); + image_user_->view = view; return ibuf; } - imageUser_->view = view; + image_user_->view = view; return nullptr; } @@ -57,14 +57,14 @@ void MultilayerBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, output->copy_from(buffer_, area); } -std::unique_ptr MultilayerColorOperation::getMetaData() +std::unique_ptr MultilayerColorOperation::get_meta_data() { BLI_assert(buffer_); MetaDataExtractCallbackData callback_data = {nullptr}; RenderResult *render_result = image_->rr; if (render_result && render_result->stamp_data) { - RenderLayer *render_layer = renderLayer_; - RenderPass *render_pass = renderPass_; + RenderLayer *render_layer = render_layer_; + RenderPass *render_pass = render_pass_; std::string full_layer_name = std::string(render_layer->name, BLI_strnlen(render_layer->name, sizeof(render_layer->name))) + @@ -72,7 +72,7 @@ std::unique_ptr MultilayerColorOperation::getMetaData() std::string(render_pass->name, BLI_strnlen(render_pass->name, sizeof(render_pass->name))); blender::StringRef cryptomatte_layer_name = blender::bke::cryptomatte::BKE_cryptomatte_extract_layer_name(full_layer_name); - callback_data.setCryptomatteKeys(cryptomatte_layer_name); + callback_data.set_cryptomatte_keys(cryptomatte_layer_name); BKE_stamp_info_callback(&callback_data, render_result->stamp_data, @@ -83,16 +83,16 @@ std::unique_ptr MultilayerColorOperation::getMetaData() return std::move(callback_data.meta_data); } -void MultilayerColorOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void MultilayerColorOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - if (imageFloatBuffer_ == nullptr) { + if (image_float_buffer_ == nullptr) { zero_v4(output); } else { - if (numberOfChannels_ == 4) { + if (number_of_channels_ == 4) { switch (sampler) { case PixelSampler::Nearest: nearest_interpolation_color(buffer_, nullptr, output, x, y); @@ -108,58 +108,58 @@ void MultilayerColorOperation::executePixelSampled(float output[4], else { int yi = y; int xi = x; - if (xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || - (unsigned int)yi >= this->getHeight()) { + if (xi < 0 || yi < 0 || (unsigned int)xi >= this->get_width() || + (unsigned int)yi >= this->get_height()) { zero_v4(output); } else { - int offset = (yi * this->getWidth() + xi) * 3; - copy_v3_v3(output, &imageFloatBuffer_[offset]); + int offset = (yi * this->get_width() + xi) * 3; + copy_v3_v3(output, &image_float_buffer_[offset]); } } } } -void MultilayerValueOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void MultilayerValueOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { - if (imageFloatBuffer_ == nullptr) { + if (image_float_buffer_ == nullptr) { output[0] = 0.0f; } else { int yi = y; int xi = x; - if (xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || - (unsigned int)yi >= this->getHeight()) { + if (xi < 0 || yi < 0 || (unsigned int)xi >= this->get_width() || + (unsigned int)yi >= this->get_height()) { output[0] = 0.0f; } else { - float result = imageFloatBuffer_[yi * this->getWidth() + xi]; + float result = image_float_buffer_[yi * this->get_width() + xi]; output[0] = result; } } } -void MultilayerVectorOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void MultilayerVectorOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { - if (imageFloatBuffer_ == nullptr) { + if (image_float_buffer_ == nullptr) { output[0] = 0.0f; } else { int yi = y; int xi = x; - if (xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || - (unsigned int)yi >= this->getHeight()) { + if (xi < 0 || yi < 0 || (unsigned int)xi >= this->get_width() || + (unsigned int)yi >= this->get_height()) { output[0] = 0.0f; } else { - int offset = (yi * this->getWidth() + xi) * 3; - copy_v3_v3(output, &imageFloatBuffer_[offset]); + int offset = (yi * this->get_width() + xi) * 3; + copy_v3_v3(output, &image_float_buffer_[offset]); } } } diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.h b/source/blender/compositor/operations/COM_MultilayerImageOperation.h index 77805decc1f..ea5b0fb46ea 100644 --- a/source/blender/compositor/operations/COM_MultilayerImageOperation.h +++ b/source/blender/compositor/operations/COM_MultilayerImageOperation.h @@ -24,13 +24,13 @@ namespace blender::compositor { class MultilayerBaseOperation : public BaseImageOperation { private: - int passId_; + int pass_id_; int view_; protected: - RenderLayer *renderLayer_; - RenderPass *renderPass_; - ImBuf *getImBuf() override; + RenderLayer *render_layer_; + RenderPass *render_pass_; + ImBuf *get_im_buf() override; public: /** @@ -48,10 +48,10 @@ class MultilayerColorOperation : public MultilayerBaseOperation { MultilayerColorOperation(RenderLayer *render_layer, RenderPass *render_pass, int view) : MultilayerBaseOperation(render_layer, render_pass, view) { - this->addOutputSocket(DataType::Color); + this->add_output_socket(DataType::Color); } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; - std::unique_ptr getMetaData() override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; + std::unique_ptr get_meta_data() override; }; class MultilayerValueOperation : public MultilayerBaseOperation { @@ -59,9 +59,9 @@ class MultilayerValueOperation : public MultilayerBaseOperation { MultilayerValueOperation(RenderLayer *render_layer, RenderPass *render_pass, int view) : MultilayerBaseOperation(render_layer, render_pass, view) { - this->addOutputSocket(DataType::Value); + this->add_output_socket(DataType::Value); } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; }; class MultilayerVectorOperation : public MultilayerBaseOperation { @@ -69,9 +69,9 @@ class MultilayerVectorOperation : public MultilayerBaseOperation { MultilayerVectorOperation(RenderLayer *render_layer, RenderPass *render_pass, int view) : MultilayerBaseOperation(render_layer, render_pass, view) { - this->addOutputSocket(DataType::Vector); + this->add_output_socket(DataType::Vector); } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_NormalizeOperation.cc b/source/blender/compositor/operations/COM_NormalizeOperation.cc index 0c2dc309ede..89793897a58 100644 --- a/source/blender/compositor/operations/COM_NormalizeOperation.cc +++ b/source/blender/compositor/operations/COM_NormalizeOperation.cc @@ -22,25 +22,25 @@ namespace blender::compositor { NormalizeOperation::NormalizeOperation() { - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Value); - imageReader_ = nullptr; - cachedInstance_ = nullptr; + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Value); + image_reader_ = nullptr; + cached_instance_ = nullptr; this->flags.complex = true; flags.can_be_constant = true; } -void NormalizeOperation::initExecution() +void NormalizeOperation::init_execution() { - imageReader_ = this->getInputSocketReader(0); - NodeOperation::initMutex(); + image_reader_ = this->get_input_socket_reader(0); + NodeOperation::init_mutex(); } -void NormalizeOperation::executePixel(float output[4], int x, int y, void *data) +void NormalizeOperation::execute_pixel(float output[4], int x, int y, void *data) { /* using generic two floats struct to store `x: min`, `y: multiply` */ NodeTwoFloats *minmult = (NodeTwoFloats *)data; - imageReader_->read(output, x, y, nullptr); + image_reader_->read(output, x, y, nullptr); output[0] = (output[0] - minmult->x) * minmult->y; @@ -53,30 +53,30 @@ void NormalizeOperation::executePixel(float output[4], int x, int y, void *data) } } -void NormalizeOperation::deinitExecution() +void NormalizeOperation::deinit_execution() { - imageReader_ = nullptr; - delete cachedInstance_; - cachedInstance_ = nullptr; - NodeOperation::deinitMutex(); + image_reader_ = nullptr; + delete cached_instance_; + cached_instance_ = nullptr; + NodeOperation::deinit_mutex(); } -bool NormalizeOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool NormalizeOperation::determine_depending_area_of_interest(rcti * /*input*/, + ReadBufferOperation *read_operation, + rcti *output) { - rcti imageInput; - if (cachedInstance_) { + rcti image_input; + if (cached_instance_) { return false; } - NodeOperation *operation = getInputOperation(0); - imageInput.xmax = operation->getWidth(); - imageInput.xmin = 0; - imageInput.ymax = operation->getHeight(); - imageInput.ymin = 0; + NodeOperation *operation = get_input_operation(0); + image_input.xmax = operation->get_width(); + image_input.xmin = 0; + image_input.ymax = operation->get_height(); + image_input.ymin = 0; - if (operation->determineDependingAreaOfInterest(&imageInput, readOperation, output)) { + if (operation->determine_depending_area_of_interest(&image_input, read_operation, output)) { return true; } return false; @@ -86,16 +86,16 @@ bool NormalizeOperation::determineDependingAreaOfInterest(rcti * /*input*/, */ #define BLENDER_ZMAX 10000.0f -void *NormalizeOperation::initializeTileData(rcti *rect) +void *NormalizeOperation::initialize_tile_data(rcti *rect) { - lockMutex(); - if (cachedInstance_ == nullptr) { - MemoryBuffer *tile = (MemoryBuffer *)imageReader_->initializeTileData(rect); + lock_mutex(); + if (cached_instance_ == nullptr) { + MemoryBuffer *tile = (MemoryBuffer *)image_reader_->initialize_tile_data(rect); /* using generic two floats struct to store `x: min`, `y: multiply`. */ NodeTwoFloats *minmult = new NodeTwoFloats(); - float *buffer = tile->getBuffer(); - int p = tile->getWidth() * tile->getHeight(); + float *buffer = tile->get_buffer(); + int p = tile->get_width() * tile->get_height(); float *bc = buffer; float minv = 1.0f + BLENDER_ZMAX; @@ -117,14 +117,14 @@ 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); - cachedInstance_ = minmult; + cached_instance_ = minmult; } - unlockMutex(); - return cachedInstance_; + unlock_mutex(); + return cached_instance_; } -void NormalizeOperation::deinitializeTileData(rcti * /*rect*/, void * /*data*/) +void NormalizeOperation::deinitialize_tile_data(rcti * /*rect*/, void * /*data*/) { /* pass */ } @@ -140,7 +140,7 @@ void NormalizeOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(outpu const rcti &UNUSED(area), Span inputs) { - if (cachedInstance_ == nullptr) { + if (cached_instance_ == 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); - cachedInstance_ = minmult; + cached_instance_ = minmult; } } @@ -170,7 +170,7 @@ void NormalizeOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - NodeTwoFloats *minmult = cachedInstance_; + NodeTwoFloats *minmult = cached_instance_; for (BuffersIterator 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 450155c319a..dd9abcfad26 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 *imageReader_; + SocketReader *image_reader_; /** * \brief temporarily cache of the execution storage * it stores `x->min` and `y->multiply`. */ - NodeTwoFloats *cachedInstance_; + NodeTwoFloats *cached_instance_; public: NormalizeOperation(); @@ -46,24 +46,24 @@ class NormalizeOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; - void deinitializeTileData(rcti *rect, void *data) override; + void *initialize_tile_data(rcti *rect) override; + void deinitialize_tile_data(rcti *rect, void *data) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_started(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_OpenCLKernels.cl b/source/blender/compositor/operations/COM_OpenCLKernels.cl index ebe8a6d08ec..d01e209d3e4 100644 --- a/source/blender/compositor/operations/COM_OpenCLKernels.cl +++ b/source/blender/compositor/operations/COM_OpenCLKernels.cl @@ -29,101 +29,101 @@ const sampler_t SAMPLER_NEAREST_CLAMP = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRES __constant const int2 zero = {0,0}; // KERNEL --- BOKEH BLUR --- -__kernel void bokehBlurKernel(__read_only image2d_t boundingBox, __read_only image2d_t inputImage, - __read_only image2d_t bokehImage, __write_only image2d_t output, - int2 offsetInput, int2 offsetOutput, int radius, int step, int2 dimension, int2 offset) +__kernel void bokeh_blur_kernel(__read_only image2d_t bounding_box, __read_only image2d_t input_image, + __read_only image2d_t bokeh_image, __write_only image2d_t output, + int2 offset_input, int2 offset_output, int radius, int step, int2 dimension, int2 offset) { int2 coords = {get_global_id(0), get_global_id(1)}; coords += offset; - float tempBoundingBox; + float temp_bounding_box; float4 color = {0.0f,0.0f,0.0f,0.0f}; float4 multiplyer = {0.0f,0.0f,0.0f,0.0f}; float4 bokeh; const float radius2 = radius*2.0f; - const int2 realCoordinate = coords + offsetOutput; - int2 imageCoordinates = realCoordinate - offsetInput; + const int2 real_coordinate = coords + offset_output; + int2 image_coordinates = real_coordinate - offset_input; - tempBoundingBox = read_imagef(boundingBox, SAMPLER_NEAREST, coords).s0; + temp_bounding_box = read_imagef(bounding_box, SAMPLER_NEAREST, coords).s0; - if (tempBoundingBox > 0.0f && radius > 0 ) { - const int2 bokehImageDim = get_image_dim(bokehImage); - const int2 bokehImageCenter = bokehImageDim/2; - const int2 minXY = max(realCoordinate - radius, zero); - const int2 maxXY = min(realCoordinate + radius, dimension); + if (temp_bounding_box > 0.0f && radius > 0 ) { + const int2 bokeh_image_dim = get_image_dim(bokeh_image); + const int2 bokeh_image_center = bokeh_image_dim/2; + const int2 minXY = max(real_coordinate - radius, zero); + const int2 maxXY = min(real_coordinate + radius, dimension); int nx, ny; float2 uv; - int2 inputXy; + int2 input_xy; if (radius < 2) { - color = read_imagef(inputImage, SAMPLER_NEAREST, imageCoordinates); + color = read_imagef(input_image, SAMPLER_NEAREST, image_coordinates); multiplyer = (float4)(1.0f, 1.0f, 1.0f, 1.0f); } - for (ny = minXY.y, inputXy.y = ny - offsetInput.y ; ny < maxXY.y ; ny += step, inputXy.y += step) { - uv.y = ((realCoordinate.y-ny)/radius2)*bokehImageDim.y+bokehImageCenter.y; + for (ny = minXY.y, input_xy.y = ny - offset_input.y ; ny < maxXY.y ; ny += step, input_xy.y += step) { + uv.y = ((real_coordinate.y-ny)/radius2)*bokeh_image_dim.y+bokeh_image_center.y; - for (nx = minXY.x, inputXy.x = nx - offsetInput.x; nx < maxXY.x ; nx += step, inputXy.x += step) { - uv.x = ((realCoordinate.x-nx)/radius2)*bokehImageDim.x+bokehImageCenter.x; - bokeh = read_imagef(bokehImage, SAMPLER_NEAREST, uv); - color += bokeh * read_imagef(inputImage, SAMPLER_NEAREST, inputXy); + for (nx = minXY.x, input_xy.x = nx - offset_input.x; nx < maxXY.x ; nx += step, input_xy.x += step) { + uv.x = ((real_coordinate.x-nx)/radius2)*bokeh_image_dim.x+bokeh_image_center.x; + bokeh = read_imagef(bokeh_image, SAMPLER_NEAREST, uv); + color += bokeh * read_imagef(input_image, SAMPLER_NEAREST, input_xy); multiplyer += bokeh; } } color /= multiplyer; } else { - color = read_imagef(inputImage, SAMPLER_NEAREST, imageCoordinates); + color = read_imagef(input_image, SAMPLER_NEAREST, image_coordinates); } write_imagef(output, coords, color); } //KERNEL --- DEFOCUS /VARIABLESIZEBOKEHBLUR --- -__kernel void defocusKernel(__read_only image2d_t inputImage, __read_only image2d_t bokehImage, - __read_only image2d_t inputSize, - __write_only image2d_t output, int2 offsetInput, int2 offsetOutput, - int step, int maxBlurScalar, float threshold, float scalar, int2 dimension, int2 offset) +__kernel void defocus_kernel(__read_only image2d_t input_image, __read_only image2d_t bokeh_image, + __read_only image2d_t input_size, + __write_only image2d_t output, int2 offset_input, int2 offset_output, + int step, int max_blur_scalar, float threshold, float scalar, int2 dimension, int2 offset) { float4 color = {1.0f, 0.0f, 0.0f, 1.0f}; int2 coords = {get_global_id(0), get_global_id(1)}; coords += offset; - const int2 realCoordinate = coords + offsetOutput; + const int2 real_coordinate = coords + offset_output; - float4 readColor; - float4 tempColor; + float4 read_color; + float4 temp_color; float4 bokeh; float size; float4 multiplier_accum = {1.0f, 1.0f, 1.0f, 1.0f}; float4 color_accum; - int minx = max(realCoordinate.s0 - maxBlurScalar, 0); - int miny = max(realCoordinate.s1 - maxBlurScalar, 0); - int maxx = min(realCoordinate.s0 + maxBlurScalar, dimension.s0); - int maxy = min(realCoordinate.s1 + maxBlurScalar, dimension.s1); + int minx = max(real_coordinate.s0 - max_blur_scalar, 0); + int miny = max(real_coordinate.s1 - max_blur_scalar, 0); + int maxx = min(real_coordinate.s0 + max_blur_scalar, dimension.s0); + int maxy = min(real_coordinate.s1 + max_blur_scalar, dimension.s1); { - int2 inputCoordinate = realCoordinate - offsetInput; - float size_center = read_imagef(inputSize, SAMPLER_NEAREST, inputCoordinate).s0 * scalar; - color_accum = read_imagef(inputImage, SAMPLER_NEAREST, inputCoordinate); - readColor = color_accum; + int2 input_coordinate = real_coordinate - offset_input; + float size_center = read_imagef(input_size, SAMPLER_NEAREST, input_coordinate).s0 * scalar; + color_accum = read_imagef(input_image, SAMPLER_NEAREST, input_coordinate); + read_color = color_accum; if (size_center > threshold) { for (int ny = miny; ny < maxy; ny += step) { - inputCoordinate.s1 = ny - offsetInput.s1; - float dy = ny - realCoordinate.s1; + input_coordinate.s1 = ny - offset_input.s1; + float dy = ny - real_coordinate.s1; for (int nx = minx; nx < maxx; nx += step) { - float dx = nx - realCoordinate.s0; + float dx = nx - real_coordinate.s0; if (dx != 0 || dy != 0) { - inputCoordinate.s0 = nx - offsetInput.s0; - size = min(read_imagef(inputSize, SAMPLER_NEAREST, inputCoordinate).s0 * scalar, size_center); + input_coordinate.s0 = nx - offset_input.s0; + size = min(read_imagef(input_size, SAMPLER_NEAREST, input_coordinate).s0 * scalar, size_center); if (size > threshold) { if (size >= fabs(dx) && size >= fabs(dy)) { float2 uv = {256.0f + dx * 255.0f / size, 256.0f + dy * 255.0f / size}; - bokeh = read_imagef(bokehImage, SAMPLER_NEAREST, uv); - tempColor = read_imagef(inputImage, SAMPLER_NEAREST, inputCoordinate); - color_accum += bokeh * tempColor; + bokeh = read_imagef(bokeh_image, SAMPLER_NEAREST, uv); + temp_color = read_imagef(input_image, SAMPLER_NEAREST, input_coordinate); + color_accum += bokeh * temp_color; multiplier_accum += bokeh; } } @@ -140,7 +140,7 @@ __kernel void defocusKernel(__read_only image2d_t inputImage, __read_only image2 { /* factor from 0-1 */ float fac = (size_center - threshold) / threshold; - color = (readColor * (1.0f - fac)) + (color * fac); + color = (read_color * (1.0f - fac)) + (color * fac); } write_imagef(output, coords, color); @@ -149,28 +149,28 @@ __kernel void defocusKernel(__read_only image2d_t inputImage, __read_only image2 // KERNEL --- DILATE --- -__kernel void dilateKernel(__read_only image2d_t inputImage, __write_only image2d_t output, - int2 offsetInput, int2 offsetOutput, int scope, int distanceSquared, int2 dimension, +__kernel void dilate_kernel(__read_only image2d_t input_image, __write_only image2d_t output, + int2 offset_input, int2 offset_output, int scope, int distance_squared, int2 dimension, int2 offset) { int2 coords = {get_global_id(0), get_global_id(1)}; coords += offset; - const int2 realCoordinate = coords + offsetOutput; + const int2 real_coordinate = coords + offset_output; - const int2 minXY = max(realCoordinate - scope, zero); - const int2 maxXY = min(realCoordinate + scope, dimension); + const int2 minXY = max(real_coordinate - scope, zero); + const int2 maxXY = min(real_coordinate + scope, dimension); float value = 0.0f; int nx, ny; - int2 inputXy; + int2 input_xy; - for (ny = minXY.y, inputXy.y = ny - offsetInput.y ; ny < maxXY.y ; ny ++, inputXy.y++) { - const float deltaY = (realCoordinate.y - ny); - for (nx = minXY.x, inputXy.x = nx - offsetInput.x; nx < maxXY.x ; nx ++, inputXy.x++) { - const float deltaX = (realCoordinate.x - nx); - const float measuredDistance = deltaX * deltaX + deltaY * deltaY; - if (measuredDistance <= distanceSquared) { - value = max(value, read_imagef(inputImage, SAMPLER_NEAREST, inputXy).s0); + for (ny = minXY.y, input_xy.y = ny - offset_input.y ; ny < maxXY.y ; ny ++, input_xy.y++) { + const float deltaY = (real_coordinate.y - ny); + for (nx = minXY.x, input_xy.x = nx - offset_input.x; nx < maxXY.x ; nx ++, input_xy.x++) { + const float deltaX = (real_coordinate.x - nx); + const float measured_distance = deltaX * deltaX + deltaY * deltaY; + if (measured_distance <= distance_squared) { + value = max(value, read_imagef(input_image, SAMPLER_NEAREST, input_xy).s0); } } } @@ -180,28 +180,28 @@ __kernel void dilateKernel(__read_only image2d_t inputImage, __write_only image } // KERNEL --- DILATE --- -__kernel void erodeKernel(__read_only image2d_t inputImage, __write_only image2d_t output, - int2 offsetInput, int2 offsetOutput, int scope, int distanceSquared, int2 dimension, +__kernel void erode_kernel(__read_only image2d_t input_image, __write_only image2d_t output, + int2 offset_input, int2 offset_output, int scope, int distance_squared, int2 dimension, int2 offset) { int2 coords = {get_global_id(0), get_global_id(1)}; coords += offset; - const int2 realCoordinate = coords + offsetOutput; + const int2 real_coordinate = coords + offset_output; - const int2 minXY = max(realCoordinate - scope, zero); - const int2 maxXY = min(realCoordinate + scope, dimension); + const int2 minXY = max(real_coordinate - scope, zero); + const int2 maxXY = min(real_coordinate + scope, dimension); float value = 1.0f; int nx, ny; - int2 inputXy; + int2 input_xy; - for (ny = minXY.y, inputXy.y = ny - offsetInput.y ; ny < maxXY.y ; ny ++, inputXy.y++) { - for (nx = minXY.x, inputXy.x = nx - offsetInput.x; nx < maxXY.x ; nx ++, inputXy.x++) { - const float deltaX = (realCoordinate.x - nx); - const float deltaY = (realCoordinate.y - ny); - const float measuredDistance = deltaX * deltaX+deltaY * deltaY; - if (measuredDistance <= distanceSquared) { - value = min(value, read_imagef(inputImage, SAMPLER_NEAREST, inputXy).s0); + for (ny = minXY.y, input_xy.y = ny - offset_input.y ; ny < maxXY.y ; ny ++, input_xy.y++) { + for (nx = minXY.x, input_xy.x = nx - offset_input.x; nx < maxXY.x ; nx ++, input_xy.x++) { + const float deltaX = (real_coordinate.x - nx); + const float deltaY = (real_coordinate.y - ny); + const float measured_distance = deltaX * deltaX+deltaY * deltaY; + if (measured_distance <= distance_squared) { + value = min(value, read_imagef(input_image, SAMPLER_NEAREST, input_xy).s0); } } } @@ -211,34 +211,34 @@ __kernel void erodeKernel(__read_only image2d_t inputImage, __write_only image2 } // KERNEL --- DIRECTIONAL BLUR --- -__kernel void directionalBlurKernel(__read_only image2d_t inputImage, __write_only image2d_t output, - int2 offsetOutput, int iterations, float scale, float rotation, float2 translate, +__kernel void directional_blur_kernel(__read_only image2d_t input_image, __write_only image2d_t output, + int2 offset_output, int iterations, float scale, float rotation, float2 translate, float2 center, int2 offset) { int2 coords = {get_global_id(0), get_global_id(1)}; coords += offset; - const int2 realCoordinate = coords + offsetOutput; + const int2 real_coordinate = coords + offset_output; float4 col; float2 ltxy = translate; float lsc = scale; float lrot = rotation; - col = read_imagef(inputImage, SAMPLER_NEAREST, realCoordinate); + col = read_imagef(input_image, SAMPLER_NEAREST, real_coordinate); /* blur the image */ for (int i = 0; i < iterations; ++i) { const float cs = cos(lrot), ss = sin(lrot); const float isc = 1.0f / (1.0f + lsc); - const float v = isc * (realCoordinate.s1 - center.s1) + ltxy.s1; - const float u = isc * (realCoordinate.s0 - center.s0) + ltxy.s0; + const float v = isc * (real_coordinate.s1 - center.s1) + ltxy.s1; + const float u = isc * (real_coordinate.s0 - center.s0) + ltxy.s0; float2 uv = { cs * u + ss * v + center.s0, cs * v - ss * u + center.s1 }; - col += read_imagef(inputImage, SAMPLER_NEAREST_CLAMP, uv); + col += read_imagef(input_image, SAMPLER_NEAREST_CLAMP, uv); /* double transformations */ ltxy += translate; @@ -252,10 +252,10 @@ __kernel void directionalBlurKernel(__read_only image2d_t inputImage, __write_o } // KERNEL --- GAUSSIAN BLUR --- -__kernel void gaussianXBlurOperationKernel(__read_only image2d_t inputImage, - int2 offsetInput, +__kernel void gaussian_xblur_operation_kernel(__read_only image2d_t input_image, + int2 offset_input, __write_only image2d_t output, - int2 offsetOutput, + int2 offset_output, int filter_size, int2 dimension, __global float *gausstab, @@ -264,17 +264,17 @@ __kernel void gaussianXBlurOperationKernel(__read_only image2d_t inputImage, float4 color = {0.0f, 0.0f, 0.0f, 0.0f}; int2 coords = {get_global_id(0), get_global_id(1)}; coords += offset; - const int2 realCoordinate = coords + offsetOutput; - int2 inputCoordinate = realCoordinate - offsetInput; + const int2 real_coordinate = coords + offset_output; + int2 input_coordinate = real_coordinate - offset_input; float weight = 0.0f; - int xmin = max(realCoordinate.x - filter_size, 0) - offsetInput.x; - int xmax = min(realCoordinate.x + filter_size + 1, dimension.x) - offsetInput.x; + int xmin = max(real_coordinate.x - filter_size, 0) - offset_input.x; + int xmax = min(real_coordinate.x + filter_size + 1, dimension.x) - offset_input.x; - for (int nx = xmin, i = max(filter_size - realCoordinate.x, 0); nx < xmax; ++nx, ++i) { + for (int nx = xmin, i = max(filter_size - real_coordinate.x, 0); nx < xmax; ++nx, ++i) { float w = gausstab[i]; - inputCoordinate.x = nx; - color += read_imagef(inputImage, SAMPLER_NEAREST, inputCoordinate) * w; + input_coordinate.x = nx; + color += read_imagef(input_image, SAMPLER_NEAREST, input_coordinate) * w; weight += w; } @@ -283,10 +283,10 @@ __kernel void gaussianXBlurOperationKernel(__read_only image2d_t inputImage, write_imagef(output, coords, color); } -__kernel void gaussianYBlurOperationKernel(__read_only image2d_t inputImage, - int2 offsetInput, +__kernel void gaussian_yblur_operation_kernel(__read_only image2d_t input_image, + int2 offset_input, __write_only image2d_t output, - int2 offsetOutput, + int2 offset_output, int filter_size, int2 dimension, __global float *gausstab, @@ -295,17 +295,17 @@ __kernel void gaussianYBlurOperationKernel(__read_only image2d_t inputImage, float4 color = {0.0f, 0.0f, 0.0f, 0.0f}; int2 coords = {get_global_id(0), get_global_id(1)}; coords += offset; - const int2 realCoordinate = coords + offsetOutput; - int2 inputCoordinate = realCoordinate - offsetInput; + const int2 real_coordinate = coords + offset_output; + int2 input_coordinate = real_coordinate - offset_input; float weight = 0.0f; - int ymin = max(realCoordinate.y - filter_size, 0) - offsetInput.y; - int ymax = min(realCoordinate.y + filter_size + 1, dimension.y) - offsetInput.y; + int ymin = max(real_coordinate.y - filter_size, 0) - offset_input.y; + int ymax = min(real_coordinate.y + filter_size + 1, dimension.y) - offset_input.y; - for (int ny = ymin, i = max(filter_size - realCoordinate.y, 0); ny < ymax; ++ny, ++i) { + for (int ny = ymin, i = max(filter_size - real_coordinate.y, 0); ny < ymax; ++ny, ++i) { float w = gausstab[i]; - inputCoordinate.y = ny; - color += read_imagef(inputImage, SAMPLER_NEAREST, inputCoordinate) * w; + input_coordinate.y = ny; + color += read_imagef(input_image, SAMPLER_NEAREST, input_coordinate) * w; weight += w; } diff --git a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cc b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cc index e652a0be3e6..7f2968a4719 100644 --- a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cc +++ b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cc @@ -36,19 +36,26 @@ OutputOpenExrSingleLayerMultiViewOperation::OutputOpenExrSingleLayerMultiViewOpe DataType datatype, ImageFormatData *format, const char *path, - const ColorManagedViewSettings *viewSettings, - const ColorManagedDisplaySettings *displaySettings, - const char *viewName, - const bool saveAsRender) - : OutputSingleLayerOperation( - rd, tree, datatype, format, path, viewSettings, displaySettings, viewName, saveAsRender) + const ColorManagedViewSettings *view_settings, + const ColorManagedDisplaySettings *display_settings, + const char *view_name, + const bool save_as_render) + : OutputSingleLayerOperation(rd, + tree, + datatype, + format, + path, + view_settings, + display_settings, + view_name, + save_as_render) { } void *OutputOpenExrSingleLayerMultiViewOperation::get_handle(const char *filename) { - size_t width = this->getWidth(); - size_t height = this->getHeight(); + size_t width = this->get_width(); + size_t height = this->get_height(); SceneRenderView *srv; if (width != 0 && height != 0) { @@ -56,7 +63,7 @@ void *OutputOpenExrSingleLayerMultiViewOperation::get_handle(const char *filenam exrhandle = IMB_exr_get_handle_name(filename); - if (!BKE_scene_multiview_is_render_view_first(rd_, viewName_)) { + if (!BKE_scene_multiview_is_render_view_first(rd_, view_name_)) { return exrhandle; } @@ -87,10 +94,10 @@ void *OutputOpenExrSingleLayerMultiViewOperation::get_handle(const char *filenam return nullptr; } -void OutputOpenExrSingleLayerMultiViewOperation::deinitExecution() +void OutputOpenExrSingleLayerMultiViewOperation::deinit_execution() { - unsigned int width = this->getWidth(); - unsigned int height = this->getHeight(); + unsigned int width = this->get_width(); + unsigned int height = this->get_height(); if (width != 0 && height != 0) { void *exrhandle; @@ -109,17 +116,17 @@ void OutputOpenExrSingleLayerMultiViewOperation::deinitExecution() add_exr_channels(exrhandle, nullptr, datatype_, - viewName_, + view_name_, width, format_->depth == R_IMF_CHAN_DEPTH_16, - outputBuffer_); + output_buffer_); /* memory can only be freed after we write all views to the file */ - outputBuffer_ = nullptr; - imageInput_ = nullptr; + output_buffer_ = nullptr; + image_input_ = nullptr; /* ready to close the file */ - if (BKE_scene_multiview_is_render_view_last(rd_, viewName_)) { + if (BKE_scene_multiview_is_render_view_last(rd_, view_name_)) { IMB_exr_write_channels(exrhandle); /* free buffer memory for all the views */ @@ -140,15 +147,15 @@ OutputOpenExrMultiLayerMultiViewOperation::OutputOpenExrMultiLayerMultiViewOpera const char *path, char exr_codec, bool exr_half_float, - const char *viewName) - : OutputOpenExrMultiLayerOperation(scene, rd, tree, path, exr_codec, exr_half_float, viewName) + const char *view_name) + : OutputOpenExrMultiLayerOperation(scene, rd, tree, path, exr_codec, exr_half_float, view_name) { } void *OutputOpenExrMultiLayerMultiViewOperation::get_handle(const char *filename) { - unsigned int width = this->getWidth(); - unsigned int height = this->getHeight(); + unsigned int width = this->get_width(); + unsigned int height = this->get_height(); if (width != 0 && height != 0) { @@ -158,7 +165,7 @@ 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(rd_, viewName_)) { + if (!BKE_scene_multiview_is_render_view_first(rd_, view_name_)) { return exrhandle; } @@ -187,7 +194,7 @@ void *OutputOpenExrMultiLayerMultiViewOperation::get_handle(const char *filename BLI_make_existing_file(filename); /* prepare the file with all the channels for the header */ - StampData *stamp_data = createStampData(); + StampData *stamp_data = create_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); @@ -202,10 +209,10 @@ void *OutputOpenExrMultiLayerMultiViewOperation::get_handle(const char *filename return nullptr; } -void OutputOpenExrMultiLayerMultiViewOperation::deinitExecution() +void OutputOpenExrMultiLayerMultiViewOperation::deinit_execution() { - unsigned int width = this->getWidth(); - unsigned int height = this->getHeight(); + unsigned int width = this->get_width(); + unsigned int height = this->get_height(); if (width != 0 && height != 0) { void *exrhandle; @@ -226,20 +233,20 @@ void OutputOpenExrMultiLayerMultiViewOperation::deinitExecution() add_exr_channels(exrhandle, layers_[i].name, layers_[i].datatype, - viewName_, + view_name_, width, exr_half_float_, - layers_[i].outputBuffer); + layers_[i].output_buffer); } for (unsigned int i = 0; i < layers_.size(); i++) { /* memory can only be freed after we write all views to the file */ - layers_[i].outputBuffer = nullptr; - layers_[i].imageInput = nullptr; + layers_[i].output_buffer = nullptr; + layers_[i].image_input = nullptr; } /* ready to close the file */ - if (BKE_scene_multiview_is_render_view_last(rd_, viewName_)) { + if (BKE_scene_multiview_is_render_view_last(rd_, view_name_)) { IMB_exr_write_channels(exrhandle); /* free buffer memory for all the views */ @@ -260,12 +267,19 @@ OutputStereoOperation::OutputStereoOperation(const RenderData *rd, ImageFormatData *format, const char *path, const char *name, - const ColorManagedViewSettings *viewSettings, - const ColorManagedDisplaySettings *displaySettings, - const char *viewName, - const bool saveAsRender) - : OutputSingleLayerOperation( - rd, tree, datatype, format, path, viewSettings, displaySettings, viewName, saveAsRender) + const ColorManagedViewSettings *view_settings, + const ColorManagedDisplaySettings *display_settings, + const char *view_name, + const bool save_as_render) + : OutputSingleLayerOperation(rd, + tree, + datatype, + format, + path, + view_settings, + display_settings, + view_name, + save_as_render) { BLI_strncpy(name_, name, sizeof(name_)); channels_ = get_datatype_size(datatype); @@ -273,8 +287,8 @@ OutputStereoOperation::OutputStereoOperation(const RenderData *rd, void *OutputStereoOperation::get_handle(const char *filename) { - size_t width = this->getWidth(); - size_t height = this->getHeight(); + size_t width = this->get_width(); + size_t height = this->get_height(); const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME}; size_t i; @@ -283,7 +297,7 @@ void *OutputStereoOperation::get_handle(const char *filename) exrhandle = IMB_exr_get_handle_name(filename); - if (!BKE_scene_multiview_is_render_view_first(rd_, viewName_)) { + if (!BKE_scene_multiview_is_render_view_first(rd_, view_name_)) { return exrhandle; } @@ -298,32 +312,32 @@ void *OutputStereoOperation::get_handle(const char *filename) return nullptr; } -void OutputStereoOperation::deinitExecution() +void OutputStereoOperation::deinit_execution() { - unsigned int width = this->getWidth(); - unsigned int height = this->getHeight(); + unsigned int width = this->get_width(); + unsigned int height = this->get_height(); if (width != 0 && height != 0) { void *exrhandle; exrhandle = this->get_handle(path_); - float *buf = outputBuffer_; + float *buf = output_buffer_; /* populate single EXR channel with view data */ IMB_exr_add_channel(exrhandle, nullptr, name_, - viewName_, + view_name_, 1, channels_ * width * height, buf, format_->depth == R_IMF_CHAN_DEPTH_16); - imageInput_ = nullptr; - outputBuffer_ = nullptr; + image_input_ = nullptr; + output_buffer_ = nullptr; /* create stereo ibuf */ - if (BKE_scene_multiview_is_render_view_last(rd_, viewName_)) { + if (BKE_scene_multiview_is_render_view_last(rd_, view_name_)) { ImBuf *ibuf[3] = {nullptr}; const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME}; char filename[FILE_MAX]; @@ -341,7 +355,7 @@ void OutputStereoOperation::deinitExecution() /* 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, viewSettings_, displaySettings_, format_); + ibuf[i], true, false, view_settings_, display_settings_, format_); IMB_prepare_write_ImBuf(IMB_isfloat(ibuf[i]), ibuf[i]); } diff --git a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h index a6e76e6190e..9f8bf2ed127 100644 --- a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h +++ b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h @@ -38,13 +38,13 @@ class OutputOpenExrSingleLayerMultiViewOperation : public OutputSingleLayerOpera DataType datatype, ImageFormatData *format, const char *path, - const ColorManagedViewSettings *viewSettings, - const ColorManagedDisplaySettings *displaySettings, - const char *viewName, - const bool saveAsRender); + const ColorManagedViewSettings *view_settings, + const ColorManagedDisplaySettings *display_settings, + const char *view_name, + const bool save_as_render); void *get_handle(const char *filename); - void deinitExecution() override; + void deinit_execution() override; }; /* Writes inputs into OpenEXR multilayer channels. */ @@ -57,10 +57,10 @@ class OutputOpenExrMultiLayerMultiViewOperation : public OutputOpenExrMultiLayer const char *path, char exr_codec, bool exr_half_float, - const char *viewName); + const char *view_name); void *get_handle(const char *filename); - void deinitExecution() override; + void deinit_execution() override; }; class OutputStereoOperation : public OutputSingleLayerOperation { @@ -75,12 +75,12 @@ class OutputStereoOperation : public OutputSingleLayerOperation { struct ImageFormatData *format, const char *path, const char *name, - const ColorManagedViewSettings *viewSettings, - const ColorManagedDisplaySettings *displaySettings, - const char *viewName, - const bool saveAsRender); + const ColorManagedViewSettings *view_settings, + const ColorManagedDisplaySettings *display_settings, + const char *view_name, + const bool save_as_render); void *get_handle(const char *filename); - void deinitExecution() override; + void deinit_execution() override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_OutputFileOperation.cc b/source/blender/compositor/operations/COM_OutputFileOperation.cc index 6a5ddd969b4..77e291e9dc4 100644 --- a/source/blender/compositor/operations/COM_OutputFileOperation.cc +++ b/source/blender/compositor/operations/COM_OutputFileOperation.cc @@ -37,9 +37,9 @@ namespace blender::compositor { void add_exr_channels(void *exrhandle, - const char *layerName, + const char *layer_name, const DataType datatype, - const char *viewName, + const char *view_name, const size_t width, bool use_half_float, float *buf) @@ -48,51 +48,63 @@ void add_exr_channels(void *exrhandle, switch (datatype) { case DataType::Value: IMB_exr_add_channel( - exrhandle, layerName, "V", viewName, 1, width, buf ? buf : nullptr, use_half_float); + exrhandle, layer_name, "V", view_name, 1, width, buf ? buf : nullptr, use_half_float); break; case DataType::Vector: - IMB_exr_add_channel( - exrhandle, layerName, "X", viewName, 3, 3 * width, buf ? buf : nullptr, use_half_float); IMB_exr_add_channel(exrhandle, - layerName, + layer_name, + "X", + view_name, + 3, + 3 * width, + buf ? buf : nullptr, + use_half_float); + IMB_exr_add_channel(exrhandle, + layer_name, "Y", - viewName, + view_name, 3, 3 * width, buf ? buf + 1 : nullptr, use_half_float); IMB_exr_add_channel(exrhandle, - layerName, + layer_name, "Z", - viewName, + view_name, 3, 3 * width, buf ? buf + 2 : nullptr, use_half_float); break; case DataType::Color: - IMB_exr_add_channel( - exrhandle, layerName, "R", viewName, 4, 4 * width, buf ? buf : nullptr, use_half_float); IMB_exr_add_channel(exrhandle, - layerName, + layer_name, + "R", + view_name, + 4, + 4 * width, + buf ? buf : nullptr, + use_half_float); + IMB_exr_add_channel(exrhandle, + layer_name, "G", - viewName, + view_name, 4, 4 * width, buf ? buf + 1 : nullptr, use_half_float); IMB_exr_add_channel(exrhandle, - layerName, + layer_name, "B", - viewName, + view_name, 4, 4 * width, buf ? buf + 2 : nullptr, use_half_float); IMB_exr_add_channel(exrhandle, - layerName, + layer_name, "A", - viewName, + view_name, 4, 4 * width, buf ? buf + 3 : nullptr, @@ -105,7 +117,7 @@ void add_exr_channels(void *exrhandle, void free_exr_channels(void *exrhandle, const RenderData *rd, - const char *layerName, + const char *layer_name, const DataType datatype) { SceneRenderView *srv; @@ -121,13 +133,13 @@ void free_exr_channels(void *exrhandle, /* the pointer is stored in the first channel of each datatype */ switch (datatype) { case DataType::Value: - rect = IMB_exr_channel_rect(exrhandle, layerName, "V", srv->name); + rect = IMB_exr_channel_rect(exrhandle, layer_name, "V", srv->name); break; case DataType::Vector: - rect = IMB_exr_channel_rect(exrhandle, layerName, "X", srv->name); + rect = IMB_exr_channel_rect(exrhandle, layer_name, "X", srv->name); break; case DataType::Color: - rect = IMB_exr_channel_rect(exrhandle, layerName, "R", srv->name); + rect = IMB_exr_channel_rect(exrhandle, layer_name, "R", srv->name); break; default: break; @@ -187,7 +199,7 @@ static void write_buffer_rect(rcti *rect, for (y = y1; y < y2 && (!breaked); y++) { for (x = x1; x < x2 && (!breaked); x++) { - reader->readSampled(color, x, y, PixelSampler::Nearest); + reader->read_sampled(color, x, y, PixelSampler::Nearest); for (i = 0; i < size; i++) { buffer[offset + i] = color[i]; @@ -208,58 +220,58 @@ OutputSingleLayerOperation::OutputSingleLayerOperation( DataType datatype, ImageFormatData *format, const char *path, - const ColorManagedViewSettings *viewSettings, - const ColorManagedDisplaySettings *displaySettings, - const char *viewName, - const bool saveAsRender) + const ColorManagedViewSettings *view_settings, + const ColorManagedDisplaySettings *display_settings, + const char *view_name, + const bool save_as_render) { rd_ = rd; tree_ = tree; - this->addInputSocket(datatype); + this->add_input_socket(datatype); - outputBuffer_ = nullptr; + output_buffer_ = nullptr; datatype_ = datatype; - imageInput_ = nullptr; + image_input_ = nullptr; format_ = format; BLI_strncpy(path_, path, sizeof(path_)); - viewSettings_ = viewSettings; - displaySettings_ = displaySettings; - viewName_ = viewName; - saveAsRender_ = saveAsRender; + view_settings_ = view_settings; + display_settings_ = display_settings; + view_name_ = view_name; + save_as_render_ = save_as_render; } -void OutputSingleLayerOperation::initExecution() +void OutputSingleLayerOperation::init_execution() { - imageInput_ = getInputSocketReader(0); - outputBuffer_ = init_buffer(this->getWidth(), this->getHeight(), datatype_); + image_input_ = get_input_socket_reader(0); + output_buffer_ = init_buffer(this->get_width(), this->get_height(), datatype_); } -void OutputSingleLayerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) +void OutputSingleLayerOperation::execute_region(rcti *rect, unsigned int /*tile_number*/) { - write_buffer_rect(rect, tree_, imageInput_, outputBuffer_, this->getWidth(), datatype_); + write_buffer_rect(rect, tree_, image_input_, output_buffer_, this->get_width(), datatype_); } -void OutputSingleLayerOperation::deinitExecution() +void OutputSingleLayerOperation::deinit_execution() { - if (this->getWidth() * this->getHeight() != 0) { + if (this->get_width() * this->get_height() != 0) { int size = get_datatype_size(datatype_); - ImBuf *ibuf = IMB_allocImBuf(this->getWidth(), this->getHeight(), format_->planes, 0); + ImBuf *ibuf = IMB_allocImBuf(this->get_width(), this->get_height(), format_->planes, 0); char filename[FILE_MAX]; const char *suffix; ibuf->channels = size; - ibuf->rect_float = outputBuffer_; + ibuf->rect_float = output_buffer_; ibuf->mall |= IB_rectfloat; ibuf->dither = rd_->dither_intensity; IMB_colormanagement_imbuf_for_write( - ibuf, saveAsRender_, false, viewSettings_, displaySettings_, format_); + ibuf, save_as_render_, false, view_settings_, display_settings_, format_); - suffix = BKE_scene_multiview_view_suffix_get(rd_, viewName_); + suffix = BKE_scene_multiview_view_suffix_get(rd_, view_name_); BKE_image_path_from_imformat(filename, path_, @@ -279,20 +291,22 @@ void OutputSingleLayerOperation::deinitExecution() IMB_freeImBuf(ibuf); } - outputBuffer_ = nullptr; - imageInput_ = nullptr; + output_buffer_ = nullptr; + image_input_ = nullptr; } void OutputSingleLayerOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output), const rcti &area, Span inputs) { - if (!outputBuffer_) { + if (!output_buffer_) { return; } - MemoryBuffer output_buf( - outputBuffer_, COM_data_type_num_channels(datatype_), this->getWidth(), this->getHeight()); + MemoryBuffer output_buf(output_buffer_, + COM_data_type_num_channels(datatype_), + this->get_width(), + this->get_height()); const MemoryBuffer *input_image = inputs[0]; output_buf.copy_from(input_image, area); } @@ -305,9 +319,9 @@ OutputOpenExrLayer::OutputOpenExrLayer(const char *name_, DataType datatype_, bo this->datatype = datatype_; this->use_layer = use_layer_; - /* these are created in initExecution */ - this->outputBuffer = nullptr; - this->imageInput = nullptr; + /* these are created in init_execution */ + this->output_buffer = nullptr; + this->image_input = nullptr; } OutputOpenExrMultiLayerOperation::OutputOpenExrMultiLayerOperation(const Scene *scene, @@ -316,7 +330,7 @@ OutputOpenExrMultiLayerOperation::OutputOpenExrMultiLayerOperation(const Scene * const char *path, char exr_codec, bool exr_half_float, - const char *viewName) + const char *view_name) { scene_ = scene; rd_ = rd; @@ -325,7 +339,7 @@ OutputOpenExrMultiLayerOperation::OutputOpenExrMultiLayerOperation(const Scene * BLI_strncpy(path_, path, sizeof(path_)); exr_codec_ = exr_codec; exr_half_float_ = exr_half_float; - viewName_ = viewName; + view_name_ = view_name; this->set_canvas_input_index(RESOLUTION_INPUT_ANY); } @@ -333,11 +347,11 @@ void OutputOpenExrMultiLayerOperation::add_layer(const char *name, DataType datatype, bool use_layer) { - this->addInputSocket(datatype); + this->add_input_socket(datatype); layers_.append(OutputOpenExrLayer(name, datatype, use_layer)); } -StampData *OutputOpenExrMultiLayerOperation::createStampData() const +StampData *OutputOpenExrMultiLayerOperation::create_stamp_data() const { /* StampData API doesn't provide functions to modify an instance without having a RenderResult. */ @@ -346,54 +360,54 @@ StampData *OutputOpenExrMultiLayerOperation::createStampData() const render_result.stamp_data = stamp_data; for (const OutputOpenExrLayer &layer : layers_) { /* Skip unconnected sockets. */ - if (layer.imageInput == nullptr) { + if (layer.image_input == nullptr) { continue; } - std::unique_ptr meta_data = layer.imageInput->getMetaData(); + std::unique_ptr meta_data = layer.image_input->get_meta_data(); if (meta_data) { blender::StringRef layer_name = blender::bke::cryptomatte::BKE_cryptomatte_extract_layer_name( blender::StringRef(layer.name, BLI_strnlen(layer.name, sizeof(layer.name)))); - meta_data->replaceHashNeutralCryptomatteKeys(layer_name); - meta_data->addToRenderResult(&render_result); + meta_data->replace_hash_neutral_cryptomatte_keys(layer_name); + meta_data->add_to_render_result(&render_result); } } return stamp_data; } -void OutputOpenExrMultiLayerOperation::initExecution() +void OutputOpenExrMultiLayerOperation::init_execution() { for (unsigned int i = 0; i < layers_.size(); i++) { if (layers_[i].use_layer) { - SocketReader *reader = getInputSocketReader(i); - layers_[i].imageInput = reader; - layers_[i].outputBuffer = init_buffer( - this->getWidth(), this->getHeight(), layers_[i].datatype); + SocketReader *reader = get_input_socket_reader(i); + layers_[i].image_input = reader; + layers_[i].output_buffer = init_buffer( + this->get_width(), this->get_height(), layers_[i].datatype); } } } -void OutputOpenExrMultiLayerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) +void OutputOpenExrMultiLayerOperation::execute_region(rcti *rect, unsigned int /*tile_number*/) { for (unsigned int i = 0; i < layers_.size(); i++) { OutputOpenExrLayer &layer = layers_[i]; - if (layer.imageInput) { + if (layer.image_input) { write_buffer_rect( - rect, tree_, layer.imageInput, layer.outputBuffer, this->getWidth(), layer.datatype); + rect, tree_, layer.image_input, layer.output_buffer, this->get_width(), layer.datatype); } } } -void OutputOpenExrMultiLayerOperation::deinitExecution() +void OutputOpenExrMultiLayerOperation::deinit_execution() { - unsigned int width = this->getWidth(); - unsigned int height = this->getHeight(); + unsigned int width = this->get_width(); + unsigned int height = this->get_height(); if (width != 0 && height != 0) { char filename[FILE_MAX]; const char *suffix; void *exrhandle = IMB_exr_get_handle(); - suffix = BKE_scene_multiview_view_suffix_get(rd_, viewName_); + suffix = BKE_scene_multiview_view_suffix_get(rd_, view_name_); BKE_image_path_from_imtype(filename, path_, BKE_main_blendfile_path_from_global(), @@ -406,7 +420,7 @@ void OutputOpenExrMultiLayerOperation::deinitExecution() for (unsigned int i = 0; i < layers_.size(); i++) { OutputOpenExrLayer &layer = layers_[i]; - if (!layer.imageInput) { + if (!layer.image_input) { continue; /* skip unconnected sockets */ } @@ -416,11 +430,11 @@ void OutputOpenExrMultiLayerOperation::deinitExecution() "", width, exr_half_float_, - layers_[i].outputBuffer); + layers_[i].output_buffer); } /* when the filename has no permissions, this can fail */ - StampData *stamp_data = createStampData(); + StampData *stamp_data = create_stamp_data(); if (IMB_exr_begin_write(exrhandle, filename, width, height, exr_codec_, stamp_data)) { IMB_exr_write_channels(exrhandle); } @@ -432,12 +446,12 @@ void OutputOpenExrMultiLayerOperation::deinitExecution() IMB_exr_close(exrhandle); for (unsigned int i = 0; i < layers_.size(); i++) { - if (layers_[i].outputBuffer) { - MEM_freeN(layers_[i].outputBuffer); - layers_[i].outputBuffer = nullptr; + if (layers_[i].output_buffer) { + MEM_freeN(layers_[i].output_buffer); + layers_[i].output_buffer = nullptr; } - layers_[i].imageInput = nullptr; + layers_[i].image_input = nullptr; } BKE_stamp_data_free(stamp_data); } @@ -450,11 +464,11 @@ void OutputOpenExrMultiLayerOperation::update_memory_buffer_partial(MemoryBuffer const MemoryBuffer *input_image = inputs[0]; for (int i = 0; i < layers_.size(); i++) { OutputOpenExrLayer &layer = layers_[i]; - if (layer.outputBuffer) { - MemoryBuffer output_buf(layer.outputBuffer, + if (layer.output_buffer) { + MemoryBuffer output_buf(layer.output_buffer, COM_data_type_num_channels(layer.datatype), - this->getWidth(), - this->getHeight()); + this->get_width(), + this->get_height()); output_buf.copy_from(input_image, area); } } diff --git a/source/blender/compositor/operations/COM_OutputFileOperation.h b/source/blender/compositor/operations/COM_OutputFileOperation.h index e862b964431..2a18b056c12 100644 --- a/source/blender/compositor/operations/COM_OutputFileOperation.h +++ b/source/blender/compositor/operations/COM_OutputFileOperation.h @@ -38,15 +38,15 @@ class OutputSingleLayerOperation : public MultiThreadedOperation { ImageFormatData *format_; char path_[FILE_MAX]; - float *outputBuffer_; + float *output_buffer_; DataType datatype_; - SocketReader *imageInput_; + SocketReader *image_input_; - const ColorManagedViewSettings *viewSettings_; - const ColorManagedDisplaySettings *displaySettings_; + const ColorManagedViewSettings *view_settings_; + const ColorManagedDisplaySettings *display_settings_; - const char *viewName_; - bool saveAsRender_; + const char *view_name_; + bool save_as_render_; public: OutputSingleLayerOperation(const RenderData *rd, @@ -54,19 +54,19 @@ class OutputSingleLayerOperation : public MultiThreadedOperation { DataType datatype, ImageFormatData *format, const char *path, - const ColorManagedViewSettings *viewSettings, - const ColorManagedDisplaySettings *displaySettings, - const char *viewName, - const bool saveAsRender); + const ColorManagedViewSettings *view_settings, + const ColorManagedDisplaySettings *display_settings, + const char *view_name, + const bool save_as_render); - void executeRegion(rcti *rect, unsigned int tileNumber) override; - bool isOutputOperation(bool /*rendering*/) const override + void execute_region(rcti *rect, unsigned int tile_number) override; + bool is_output_operation(bool /*rendering*/) const override { return true; } - void initExecution() override; - void deinitExecution() override; - eCompositorPriority getRenderPriority() const override + void init_execution() override; + void deinit_execution() override; + eCompositorPriority get_render_priority() const override { return eCompositorPriority::Low; } @@ -85,8 +85,8 @@ struct OutputOpenExrLayer { bool use_layer; /* internals */ - float *outputBuffer; - SocketReader *imageInput; + float *output_buffer; + SocketReader *image_input; }; /* Writes inputs into OpenEXR multilayer channels. */ @@ -100,9 +100,9 @@ class OutputOpenExrMultiLayerOperation : public MultiThreadedOperation { char exr_codec_; bool exr_half_float_; Vector layers_; - const char *viewName_; + const char *view_name_; - StampData *createStampData() const; + StampData *create_stamp_data() const; public: OutputOpenExrMultiLayerOperation(const Scene *scene, @@ -111,18 +111,18 @@ class OutputOpenExrMultiLayerOperation : public MultiThreadedOperation { const char *path, char exr_codec, bool exr_half_float, - const char *viewName); + const char *view_name); void add_layer(const char *name, DataType datatype, bool use_layer); - void executeRegion(rcti *rect, unsigned int tileNumber) override; - bool isOutputOperation(bool /*rendering*/) const override + void execute_region(rcti *rect, unsigned int tile_number) override; + bool is_output_operation(bool /*rendering*/) const override { return true; } - void initExecution() override; - void deinitExecution() override; - eCompositorPriority getRenderPriority() const override + void init_execution() override; + void deinit_execution() override; + eCompositorPriority get_render_priority() const override { return eCompositorPriority::Low; } @@ -133,15 +133,15 @@ class OutputOpenExrMultiLayerOperation : public MultiThreadedOperation { }; void add_exr_channels(void *exrhandle, - const char *layerName, + const char *layer_name, const DataType datatype, - const char *viewName, + const char *view_name, const size_t width, bool use_half_float, float *buf); void free_exr_channels(void *exrhandle, const RenderData *rd, - const char *layerName, + const char *layer_name, const DataType datatype); int get_datatype_size(DataType datatype); diff --git a/source/blender/compositor/operations/COM_PixelateOperation.cc b/source/blender/compositor/operations/COM_PixelateOperation.cc index 0d6e906a4c3..869e2357126 100644 --- a/source/blender/compositor/operations/COM_PixelateOperation.cc +++ b/source/blender/compositor/operations/COM_PixelateOperation.cc @@ -20,32 +20,32 @@ namespace blender::compositor { -PixelateOperation::PixelateOperation(DataType datatype) +PixelateOperation::PixelateOperation(DataType data_type) { - this->addInputSocket(datatype); - this->addOutputSocket(datatype); + this->add_input_socket(data_type); + this->add_output_socket(data_type); this->set_canvas_input_index(0); - inputOperation_ = nullptr; + input_operation_ = nullptr; } -void PixelateOperation::initExecution() +void PixelateOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); + input_operation_ = this->get_input_socket_reader(0); } -void PixelateOperation::deinitExecution() +void PixelateOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = nullptr; } -void PixelateOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void PixelateOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float nx = round(x); float ny = round(y); - inputOperation_->readSampled(output, nx, ny, sampler); + input_operation_->read_sampled(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 f8155e54f75..51a480b98e9 100644 --- a/source/blender/compositor/operations/COM_PixelateOperation.h +++ b/source/blender/compositor/operations/COM_PixelateOperation.h @@ -34,33 +34,33 @@ class PixelateOperation : public NodeOperation { /** * \brief cached reference to the input operation */ - SocketReader *inputOperation_; + SocketReader *input_operation_; public: /** * \brief PixelateOperation - * \param dataType: the datatype to create this operator for (saves datatype conversions) + * \param data_type: the datatype to create this operator for (saves datatype conversions) */ - PixelateOperation(DataType dataType); + PixelateOperation(DataType data_type); /** * \brief initialization of the execution */ - void initExecution() override; + void init_execution() override; /** * \brief de-initialization of the execution */ - void deinitExecution() override; + void deinit_execution() override; /** - * \brief executePixel + * \brief execute_pixel * \param output: result * \param x: x-coordinate * \param y: y-coordinate * \param sampler: sampler */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cc b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cc index fbaab16efc2..6a6692c977d 100644 --- a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cc +++ b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cc @@ -56,11 +56,11 @@ static bool check_corners(float corners[4][2]) } /* TODO(manzanilla): to be removed with tiled implementation. */ -static void readCornersFromSockets(rcti *rect, SocketReader *readers[4], float corners[4][2]) +static void read_corners_from_sockets(rcti *rect, SocketReader *readers[4], float corners[4][2]) { for (int i = 0; i < 4; i++) { float result[4] = {0.0f, 0.0f, 0.0f, 0.0f}; - readers[i]->readSampled(result, rect->xmin, rect->ymin, PixelSampler::Nearest); + readers[i]->read_sampled(result, rect->xmin, rect->ymin, PixelSampler::Nearest); corners[i][0] = result[0]; corners[i][1] = result[1]; } @@ -136,13 +136,13 @@ static void read_input_corners(NodeOperation *op, const int first_input_idx, flo PlaneCornerPinMaskOperation::PlaneCornerPinMaskOperation() : corners_ready_(false) { - addInputSocket(DataType::Vector); - addInputSocket(DataType::Vector); - addInputSocket(DataType::Vector); - addInputSocket(DataType::Vector); + add_input_socket(DataType::Vector); + add_input_socket(DataType::Vector); + add_input_socket(DataType::Vector); + add_input_socket(DataType::Vector); /* XXX this is stupid: we need to make this "complex", - * so we can use the initializeTileData function + * so we can use the initialize_tile_data function * to read corners from input sockets ... */ flags.complex = true; @@ -153,49 +153,49 @@ void PlaneCornerPinMaskOperation::init_data() if (execution_model_ == eExecutionModel::FullFrame) { float corners[4][2]; read_input_corners(this, 0, corners); - calculateCorners(corners, true, 0); + calculate_corners(corners, true, 0); } } -/* TODO(manzanilla): to be removed with tiled implementation. Same for #deinitExecution and do the +/* TODO(manzanilla): to be removed with tiled implementation. Same for #deinit_execution and do the * same on #PlaneCornerPinWarpImageOperation. */ -void PlaneCornerPinMaskOperation::initExecution() +void PlaneCornerPinMaskOperation::init_execution() { - PlaneDistortMaskOperation::initExecution(); + PlaneDistortMaskOperation::init_execution(); - initMutex(); + init_mutex(); } -void PlaneCornerPinMaskOperation::deinitExecution() +void PlaneCornerPinMaskOperation::deinit_execution() { - PlaneDistortMaskOperation::deinitExecution(); + PlaneDistortMaskOperation::deinit_execution(); - deinitMutex(); + deinit_mutex(); } -void *PlaneCornerPinMaskOperation::initializeTileData(rcti *rect) +void *PlaneCornerPinMaskOperation::initialize_tile_data(rcti *rect) { - void *data = PlaneDistortMaskOperation::initializeTileData(rect); + void *data = PlaneDistortMaskOperation::initialize_tile_data(rect); /* get corner 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 */ - lockMutex(); + lock_mutex(); if (!corners_ready_) { SocketReader *readers[4] = { - getInputSocketReader(0), - getInputSocketReader(1), - getInputSocketReader(2), - getInputSocketReader(3), + get_input_socket_reader(0), + get_input_socket_reader(1), + get_input_socket_reader(2), + get_input_socket_reader(3), }; float corners[4][2]; - readCornersFromSockets(rect, readers, corners); - calculateCorners(corners, true, 0); + read_corners_from_sockets(rect, readers, corners); + calculate_corners(corners, true, 0); corners_ready_ = true; } - unlockMutex(); + unlock_mutex(); return data; } @@ -221,10 +221,10 @@ void PlaneCornerPinMaskOperation::get_area_of_interest(const int UNUSED(input_id PlaneCornerPinWarpImageOperation::PlaneCornerPinWarpImageOperation() : corners_ready_(false) { - addInputSocket(DataType::Vector); - addInputSocket(DataType::Vector); - addInputSocket(DataType::Vector); - addInputSocket(DataType::Vector); + add_input_socket(DataType::Vector); + add_input_socket(DataType::Vector); + add_input_socket(DataType::Vector); + add_input_socket(DataType::Vector); } void PlaneCornerPinWarpImageOperation::init_data() @@ -232,57 +232,58 @@ void PlaneCornerPinWarpImageOperation::init_data() if (execution_model_ == eExecutionModel::FullFrame) { float corners[4][2]; read_input_corners(this, 1, corners); - calculateCorners(corners, true, 0); + calculate_corners(corners, true, 0); } } -void PlaneCornerPinWarpImageOperation::initExecution() +void PlaneCornerPinWarpImageOperation::init_execution() { - PlaneDistortWarpImageOperation::initExecution(); + PlaneDistortWarpImageOperation::init_execution(); - initMutex(); + init_mutex(); } -void PlaneCornerPinWarpImageOperation::deinitExecution() +void PlaneCornerPinWarpImageOperation::deinit_execution() { - PlaneDistortWarpImageOperation::deinitExecution(); + PlaneDistortWarpImageOperation::deinit_execution(); - deinitMutex(); + deinit_mutex(); } -void *PlaneCornerPinWarpImageOperation::initializeTileData(rcti *rect) +void *PlaneCornerPinWarpImageOperation::initialize_tile_data(rcti *rect) { - void *data = PlaneDistortWarpImageOperation::initializeTileData(rect); + void *data = PlaneDistortWarpImageOperation::initialize_tile_data(rect); /* get corner 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 */ - lockMutex(); + lock_mutex(); if (!corners_ready_) { /* corner sockets start at index 1 */ SocketReader *readers[4] = { - getInputSocketReader(1), - getInputSocketReader(2), - getInputSocketReader(3), - getInputSocketReader(4), + get_input_socket_reader(1), + get_input_socket_reader(2), + get_input_socket_reader(3), + get_input_socket_reader(4), }; float corners[4][2]; - readCornersFromSockets(rect, readers, corners); - calculateCorners(corners, true, 0); + read_corners_from_sockets(rect, readers, corners); + calculate_corners(corners, true, 0); corners_ready_ = true; } - unlockMutex(); + unlock_mutex(); return data; } -bool PlaneCornerPinWarpImageOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool PlaneCornerPinWarpImageOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { for (int i = 0; i < 4; i++) { - if (getInputOperation(i + 1)->determineDependingAreaOfInterest(input, readOperation, output)) { + if (get_input_operation(i + 1)->determine_depending_area_of_interest( + input, read_operation, output)) { return true; } } @@ -293,12 +294,12 @@ bool PlaneCornerPinWarpImageOperation::determineDependingAreaOfInterest( */ output->xmin = 0; output->ymin = 0; - output->xmax = getInputOperation(0)->getWidth(); - output->ymax = getInputOperation(0)->getHeight(); + output->xmax = get_input_operation(0)->get_width(); + output->ymax = get_input_operation(0)->get_height(); return true; #if 0 - return PlaneDistortWarpImageOperation::determineDependingAreaOfInterest( - input, readOperation, output); + return PlaneDistortWarpImageOperation::determine_depending_area_of_interest( + input, read_operation, output); #endif } diff --git a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.h b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.h index 211dcee5132..bb2166bf8b8 100644 --- a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.h +++ b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.h @@ -38,10 +38,10 @@ class PlaneCornerPinMaskOperation : public PlaneDistortMaskOperation { PlaneCornerPinMaskOperation(); void init_data() override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; @@ -56,14 +56,14 @@ class PlaneCornerPinWarpImageOperation : public PlaneDistortWarpImageOperation { PlaneCornerPinWarpImageOperation(); void init_data() override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; 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_PlaneDistortCommonOperation.cc b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cc index 8cfa8715cc2..21757e4c97d 100644 --- a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cc +++ b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cc @@ -29,29 +29,29 @@ PlaneDistortBaseOperation::PlaneDistortBaseOperation() { } -void PlaneDistortBaseOperation::calculateCorners(const float corners[4][2], - bool normalized, - int sample) +void PlaneDistortBaseOperation::calculate_corners(const float corners[4][2], + bool normalized, + int 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(); - sample_data->frameSpaceCorners[i][1] = corners[i][1] * this->getHeight(); + sample_data->frame_space_corners[i][0] = corners[i][0] * this->get_width(); + sample_data->frame_space_corners[i][1] = corners[i][1] * this->get_height(); } } else { for (int i = 0; i < 4; i++) { - sample_data->frameSpaceCorners[i][0] = corners[i][0]; - sample_data->frameSpaceCorners[i][1] = corners[i][1]; + sample_data->frame_space_corners[i][0] = corners[i][0]; + sample_data->frame_space_corners[i][1] = corners[i][1]; } } } /* ******** PlaneDistort WarpImage ******** */ -BLI_INLINE void warpCoord(float x, float y, float matrix[3][3], float uv[2], float deriv[2][2]) +BLI_INLINE void warp_coord(float x, float y, float matrix[3][3], float uv[2], float deriv[2][2]) { float vec[3] = {x, y, 1.0f}; mul_m3_v3(matrix, vec); @@ -66,55 +66,55 @@ BLI_INLINE void warpCoord(float x, float y, float matrix[3][3], float uv[2], flo PlaneDistortWarpImageOperation::PlaneDistortWarpImageOperation() : PlaneDistortBaseOperation() { - this->addInputSocket(DataType::Color, ResizeMode::Align); - this->addOutputSocket(DataType::Color); - pixelReader_ = nullptr; + this->add_input_socket(DataType::Color, ResizeMode::Align); + this->add_output_socket(DataType::Color); + pixel_reader_ = nullptr; this->flags.complex = true; } -void PlaneDistortWarpImageOperation::calculateCorners(const float corners[4][2], - bool normalized, - int sample) +void PlaneDistortWarpImageOperation::calculate_corners(const float corners[4][2], + bool normalized, + int sample) { - PlaneDistortBaseOperation::calculateCorners(corners, normalized, sample); + PlaneDistortBaseOperation::calculate_corners(corners, normalized, sample); const NodeOperation *image = get_input_operation(0); - const int width = image->getWidth(); - const int height = image->getHeight(); + const int width = image->get_width(); + const int height = image->get_height(); float frame_corners[4][2] = { {0.0f, 0.0f}, {(float)width, 0.0f}, {(float)width, (float)height}, {0.0f, (float)height}}; MotionSample *sample_data = &samples_[sample]; BKE_tracking_homography_between_two_quads( - sample_data->frameSpaceCorners, frame_corners, sample_data->perspectiveMatrix); + sample_data->frame_space_corners, frame_corners, sample_data->perspective_matrix); } -void PlaneDistortWarpImageOperation::initExecution() +void PlaneDistortWarpImageOperation::init_execution() { - pixelReader_ = this->getInputSocketReader(0); + pixel_reader_ = this->get_input_socket_reader(0); } -void PlaneDistortWarpImageOperation::deinitExecution() +void PlaneDistortWarpImageOperation::deinit_execution() { - pixelReader_ = nullptr; + pixel_reader_ = nullptr; } -void PlaneDistortWarpImageOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void PlaneDistortWarpImageOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { float uv[2]; float deriv[2][2]; if (motion_blur_samples_ == 1) { - warpCoord(x, y, samples_[0].perspectiveMatrix, uv, deriv); - pixelReader_->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1]); + warp_coord(x, y, samples_[0].perspective_matrix, uv, deriv); + pixel_reader_->read_filtered(output, uv[0], uv[1], deriv[0], deriv[1]); } else { zero_v4(output); for (int sample = 0; sample < motion_blur_samples_; sample++) { float color[4]; - warpCoord(x, y, samples_[sample].perspectiveMatrix, uv, deriv); - pixelReader_->readFiltered(color, uv[0], uv[1], deriv[0], deriv[1]); + warp_coord(x, y, samples_[sample].perspective_matrix, uv, deriv); + pixel_reader_->read_filtered(color, uv[0], uv[1], deriv[0], deriv[1]); add_v4_v4(output, color); } mul_v4_fl(output, 1.0f / (float)motion_blur_samples_); @@ -131,7 +131,7 @@ void PlaneDistortWarpImageOperation::update_memory_buffer_partial(MemoryBuffer * BuffersIterator it = output->iterate_with({}, area); if (motion_blur_samples_ == 1) { for (; !it.is_end(); ++it) { - warpCoord(it.x, it.y, samples_[0].perspectiveMatrix, uv, deriv); + warp_coord(it.x, it.y, samples_[0].perspective_matrix, uv, deriv); input_img->read_elem_filtered(uv[0], uv[1], deriv[0], deriv[1], it.out); } } @@ -140,7 +140,7 @@ void PlaneDistortWarpImageOperation::update_memory_buffer_partial(MemoryBuffer * zero_v4(it.out); for (const int sample : IndexRange(motion_blur_samples_)) { float color[4]; - warpCoord(it.x, it.y, samples_[sample].perspectiveMatrix, uv, deriv); + warp_coord(it.x, it.y, samples_[sample].perspective_matrix, uv, deriv); input_img->read_elem_filtered(uv[0], uv[1], deriv[0], deriv[1], color); add_v4_v4(it.out, color); } @@ -149,8 +149,8 @@ void PlaneDistortWarpImageOperation::update_memory_buffer_partial(MemoryBuffer * } } -bool PlaneDistortWarpImageOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool PlaneDistortWarpImageOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { float min[2], max[2]; INIT_MINMAX2(min, max); @@ -160,23 +160,23 @@ bool PlaneDistortWarpImageOperation::determineDependingAreaOfInterest( float deriv[2][2]; 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); - warpCoord(input->xmax + 2, input->ymax + 2, sample_data->perspectiveMatrix, UVs[2], deriv); - warpCoord(input->xmin - 2, input->ymax + 2, sample_data->perspectiveMatrix, UVs[3], deriv); + warp_coord(input->xmin - 2, input->ymin - 2, sample_data->perspective_matrix, UVs[0], deriv); + warp_coord(input->xmax + 2, input->ymin - 2, sample_data->perspective_matrix, UVs[1], deriv); + warp_coord(input->xmax + 2, input->ymax + 2, sample_data->perspective_matrix, UVs[2], deriv); + warp_coord(input->xmin - 2, input->ymax + 2, sample_data->perspective_matrix, UVs[3], deriv); for (int i = 0; i < 4; i++) { minmax_v2v2_v2(min, max, UVs[i]); } } - rcti newInput; + rcti new_input; - newInput.xmin = min[0] - 1; - newInput.ymin = min[1] - 1; - newInput.xmax = max[0] + 1; - newInput.ymax = max[1] + 1; + new_input.xmin = min[0] - 1; + new_input.ymin = min[1] - 1; + new_input.xmax = max[0] + 1; + new_input.ymax = max[1] + 1; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void PlaneDistortWarpImageOperation::get_area_of_interest(const int input_idx, @@ -201,14 +201,14 @@ void PlaneDistortWarpImageOperation::get_area_of_interest(const int input_idx, float deriv[2][2]; 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); - warpCoord( - output_area.xmax + 2, output_area.ymin - 2, sample_data->perspectiveMatrix, UVs[1], deriv); - warpCoord( - output_area.xmax + 2, output_area.ymax + 2, sample_data->perspectiveMatrix, UVs[2], deriv); - warpCoord( - output_area.xmin - 2, output_area.ymax + 2, sample_data->perspectiveMatrix, UVs[3], deriv); + warp_coord( + output_area.xmin - 2, output_area.ymin - 2, sample_data->perspective_matrix, UVs[0], deriv); + warp_coord( + output_area.xmax + 2, output_area.ymin - 2, sample_data->perspective_matrix, UVs[1], deriv); + warp_coord( + output_area.xmax + 2, output_area.ymax + 2, sample_data->perspective_matrix, UVs[2], deriv); + warp_coord( + output_area.xmin - 2, output_area.ymax + 2, sample_data->perspective_matrix, UVs[3], deriv); for (int i = 0; i < 4; i++) { minmax_v2v2_v2(min, max, UVs[i]); } @@ -225,21 +225,21 @@ void PlaneDistortWarpImageOperation::get_area_of_interest(const int input_idx, PlaneDistortMaskOperation::PlaneDistortMaskOperation() : PlaneDistortBaseOperation() { - addOutputSocket(DataType::Value); + add_output_socket(DataType::Value); /* Currently hardcoded to 8 samples. */ osa_ = 8; } -void PlaneDistortMaskOperation::initExecution() +void PlaneDistortMaskOperation::init_execution() { BLI_jitter_init(jitter_, osa_); } -void PlaneDistortMaskOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void PlaneDistortMaskOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { float point[2]; int inside_counter = 0; @@ -249,13 +249,13 @@ void PlaneDistortMaskOperation::executePixelSampled(float output[4], 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], - sample_data->frameSpaceCorners[2]) || + sample_data->frame_space_corners[0], + sample_data->frame_space_corners[1], + sample_data->frame_space_corners[2]) || isect_point_tri_v2(point, - sample_data->frameSpaceCorners[0], - sample_data->frameSpaceCorners[2], - sample_data->frameSpaceCorners[3])) { + sample_data->frame_space_corners[0], + sample_data->frame_space_corners[2], + sample_data->frame_space_corners[3])) { inside_counter++; } } @@ -268,13 +268,13 @@ void PlaneDistortMaskOperation::executePixelSampled(float output[4], 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], - sample_data->frameSpaceCorners[2]) || + sample_data->frame_space_corners[0], + sample_data->frame_space_corners[1], + sample_data->frame_space_corners[2]) || isect_point_tri_v2(point, - sample_data->frameSpaceCorners[0], - sample_data->frameSpaceCorners[2], - sample_data->frameSpaceCorners[3])) { + sample_data->frame_space_corners[0], + sample_data->frame_space_corners[2], + sample_data->frame_space_corners[3])) { inside_counter++; } } @@ -307,13 +307,13 @@ int PlaneDistortMaskOperation::get_jitter_samples_inside_count(int x, 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], - sample_data.frameSpaceCorners[2]) || + sample_data.frame_space_corners[0], + sample_data.frame_space_corners[1], + sample_data.frame_space_corners[2]) || isect_point_tri_v2(point, - sample_data.frameSpaceCorners[0], - sample_data.frameSpaceCorners[2], - sample_data.frameSpaceCorners[3])) { + sample_data.frame_space_corners[0], + sample_data.frame_space_corners[2], + sample_data.frame_space_corners[3])) { inside_count++; } } diff --git a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h index e9880624ebf..bf330ed7230 100644 --- a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h +++ b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h @@ -35,8 +35,8 @@ namespace blender::compositor { class PlaneDistortBaseOperation : public MultiThreadedOperation { protected: struct MotionSample { - float frameSpaceCorners[4][2]; /* Corners coordinates in pixel space. */ - float perspectiveMatrix[3][3]; + float frame_space_corners[4][2]; /* Corners coordinates in pixel space. */ + float perspective_matrix[3][3]; }; MotionSample samples_[PLANE_DISTORT_MAX_SAMPLES]; int motion_blur_samples_; @@ -45,17 +45,17 @@ class PlaneDistortBaseOperation : public MultiThreadedOperation { public: PlaneDistortBaseOperation(); - void setMotionBlurSamples(int samples) + void set_motion_blur_samples(int samples) { BLI_assert(samples <= PLANE_DISTORT_MAX_SAMPLES); motion_blur_samples_ = samples; } - void setMotionBlurShutter(float shutter) + void set_motion_blur_shutter(float shutter) { motion_blur_shutter_ = shutter; } - virtual void calculateCorners(const float corners[4][2], bool normalized, int sample); + virtual void calculate_corners(const float corners[4][2], bool normalized, int sample); private: friend class PlaneTrackCommon; @@ -63,21 +63,21 @@ class PlaneDistortBaseOperation : public MultiThreadedOperation { class PlaneDistortWarpImageOperation : public PlaneDistortBaseOperation { protected: - SocketReader *pixelReader_; + SocketReader *pixel_reader_; public: PlaneDistortWarpImageOperation(); - void calculateCorners(const float corners[4][2], bool normalized, int sample) override; + void calculate_corners(const float corners[4][2], bool normalized, int sample) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, @@ -93,9 +93,9 @@ class PlaneDistortMaskOperation : public PlaneDistortBaseOperation { public: PlaneDistortMaskOperation(); - void initExecution() override; + void init_execution() override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_PlaneTrackOperation.cc b/source/blender/compositor/operations/COM_PlaneTrackOperation.cc index 1f40556a935..28da200c615 100644 --- a/source/blender/compositor/operations/COM_PlaneTrackOperation.cc +++ b/source/blender/compositor/operations/COM_PlaneTrackOperation.cc @@ -27,18 +27,18 @@ namespace blender::compositor { PlaneTrackCommon::PlaneTrackCommon() { - movieClip_ = nullptr; + movie_clip_ = nullptr; framenumber_ = 0; - trackingObjectName_[0] = '\0'; - planeTrackName_[0] = '\0'; + tracking_object_name_[0] = '\0'; + plane_track_name_[0] = '\0'; } void PlaneTrackCommon::read_and_calculate_corners(PlaneDistortBaseOperation *distort_op) { float corners[4][2]; if (distort_op->motion_blur_samples_ == 1) { - readCornersFromTrack(corners, framenumber_); - distort_op->calculateCorners(corners, true, 0); + read_corners_from_track(corners, framenumber_); + distort_op->calculate_corners(corners, true, 0); } else { const float frame = (float)framenumber_ - distort_op->motion_blur_shutter_; @@ -46,30 +46,30 @@ void PlaneTrackCommon::read_and_calculate_corners(PlaneDistortBaseOperation *dis distort_op->motion_blur_samples_; float frame_iter = frame; for (int sample = 0; sample < distort_op->motion_blur_samples_; sample++) { - readCornersFromTrack(corners, frame_iter); - distort_op->calculateCorners(corners, true, sample); + read_corners_from_track(corners, frame_iter); + distort_op->calculate_corners(corners, true, sample); frame_iter += frame_step; } } } -void PlaneTrackCommon::readCornersFromTrack(float corners[4][2], float frame) +void PlaneTrackCommon::read_corners_from_track(float corners[4][2], float frame) { MovieTracking *tracking; MovieTrackingObject *object; - if (!movieClip_) { + if (!movie_clip_) { return; } - tracking = &movieClip_->tracking; + tracking = &movie_clip_->tracking; - object = BKE_tracking_object_get_named(tracking, trackingObjectName_); + object = BKE_tracking_object_get_named(tracking, tracking_object_name_); if (object) { MovieTrackingPlaneTrack *plane_track; - plane_track = BKE_tracking_plane_track_get_named(tracking, object, planeTrackName_); + plane_track = BKE_tracking_plane_track_get_named(tracking, object, plane_track_name_); if (plane_track) { - float clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, frame); + float clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, 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 (movieClip_) { + if (movie_clip_) { int width, height; MovieClipUser user = {0}; BKE_movieclip_user_set_frame(&user, framenumber_); - BKE_movieclip_get_size(movieClip_, &user, &width, &height); + BKE_movieclip_get_size(movie_clip_, &user, &width, &height); r_area = preferred_area; r_area.xmax = r_area.xmin + width; r_area.ymax = r_area.ymin + height; @@ -100,9 +100,9 @@ void PlaneTrackMaskOperation::init_data() } /* TODO(manzanilla): to be removed with tiled implementation. */ -void PlaneTrackMaskOperation::initExecution() +void PlaneTrackMaskOperation::init_execution() { - PlaneDistortMaskOperation::initExecution(); + PlaneDistortMaskOperation::init_execution(); if (execution_model_ == eExecutionModel::Tiled) { PlaneTrackCommon::read_and_calculate_corners(this); } @@ -119,9 +119,9 @@ void PlaneTrackWarpImageOperation::init_data() } /* TODO(manzanilla): to be removed with tiled implementation. */ -void PlaneTrackWarpImageOperation::initExecution() +void PlaneTrackWarpImageOperation::init_execution() { - PlaneDistortWarpImageOperation::initExecution(); + PlaneDistortWarpImageOperation::init_execution(); if (execution_model_ == eExecutionModel::Tiled) { PlaneTrackCommon::read_and_calculate_corners(this); } diff --git a/source/blender/compositor/operations/COM_PlaneTrackOperation.h b/source/blender/compositor/operations/COM_PlaneTrackOperation.h index d3dbd092024..4c584ca43f4 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 *movieClip_; + MovieClip *movie_clip_; int framenumber_; - char trackingObjectName_[64]; - char planeTrackName_[64]; + char tracking_object_name_[64]; + char plane_track_name_[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. @@ -46,25 +46,25 @@ class PlaneTrackCommon { public: PlaneTrackCommon(); - void setMovieClip(MovieClip *clip) + void set_movie_clip(MovieClip *clip) { - movieClip_ = clip; + movie_clip_ = clip; } - void setTrackingObject(char *object) + void set_tracking_object(char *object) { - BLI_strncpy(trackingObjectName_, object, sizeof(trackingObjectName_)); + BLI_strncpy(tracking_object_name_, object, sizeof(tracking_object_name_)); } - void setPlaneTrackName(char *plane_track) + void set_plane_track_name(char *plane_track) { - BLI_strncpy(planeTrackName_, plane_track, sizeof(planeTrackName_)); + BLI_strncpy(plane_track_name_, plane_track, sizeof(plane_track_name_)); } - void setFramenumber(int framenumber) + void set_framenumber(int framenumber) { framenumber_ = framenumber; } private: - void readCornersFromTrack(float corners[4][2], float frame); + void read_corners_from_track(float corners[4][2], float frame); }; class PlaneTrackMaskOperation : public PlaneDistortMaskOperation, public PlaneTrackCommon { @@ -75,7 +75,7 @@ class PlaneTrackMaskOperation : public PlaneDistortMaskOperation, public PlaneTr void init_data() override; - void initExecution() override; + void init_execution() override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override { @@ -96,7 +96,7 @@ class PlaneTrackWarpImageOperation : public PlaneDistortWarpImageOperation, void init_data() override; - void initExecution() override; + void init_execution() override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override { diff --git a/source/blender/compositor/operations/COM_PosterizeOperation.cc b/source/blender/compositor/operations/COM_PosterizeOperation.cc index 44a86f1d9de..c43520d103c 100644 --- a/source/blender/compositor/operations/COM_PosterizeOperation.cc +++ b/source/blender/compositor/operations/COM_PosterizeOperation.cc @@ -22,37 +22,37 @@ namespace blender::compositor { PosterizeOperation::PosterizeOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); - inputProgram_ = nullptr; - inputStepsProgram_ = nullptr; + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); + input_program_ = nullptr; + input_steps_program_ = nullptr; flags.can_be_constant = true; } -void PosterizeOperation::initExecution() +void PosterizeOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); - inputStepsProgram_ = this->getInputSocketReader(1); + input_program_ = this->get_input_socket_reader(0); + input_steps_program_ = this->get_input_socket_reader(1); } -void PosterizeOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void PosterizeOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float inputValue[4]; - float inputSteps[4]; + float input_value[4]; + float input_steps[4]; - 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]; + input_program_->read_sampled(input_value, x, y, sampler); + input_steps_program_->read_sampled(input_steps, x, y, sampler); + CLAMP(input_steps[0], 2.0f, 1024.0f); + const float steps_inv = 1.0f / input_steps[0]; - output[0] = floor(inputValue[0] / steps_inv) * steps_inv; - output[1] = floor(inputValue[1] / steps_inv) * steps_inv; - output[2] = floor(inputValue[2] / steps_inv) * steps_inv; - output[3] = inputValue[3]; + output[0] = floor(input_value[0] / steps_inv) * steps_inv; + output[1] = floor(input_value[1] / steps_inv) * steps_inv; + output[2] = floor(input_value[2] / steps_inv) * steps_inv; + output[3] = input_value[3]; } void PosterizeOperation::update_memory_buffer_partial(MemoryBuffer *output, @@ -73,10 +73,10 @@ void PosterizeOperation::update_memory_buffer_partial(MemoryBuffer *output, } } -void PosterizeOperation::deinitExecution() +void PosterizeOperation::deinit_execution() { - inputProgram_ = nullptr; - inputStepsProgram_ = nullptr; + input_program_ = nullptr; + input_steps_program_ = nullptr; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_PosterizeOperation.h b/source/blender/compositor/operations/COM_PosterizeOperation.h index 58ce599c6fe..70e516bccf8 100644 --- a/source/blender/compositor/operations/COM_PosterizeOperation.h +++ b/source/blender/compositor/operations/COM_PosterizeOperation.h @@ -25,10 +25,10 @@ namespace blender::compositor { class PosterizeOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; - SocketReader *inputStepsProgram_; + SocketReader *input_program_; + SocketReader *input_steps_program_; public: PosterizeOperation(); @@ -36,17 +36,17 @@ class PosterizeOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_PreviewOperation.cc b/source/blender/compositor/operations/COM_PreviewOperation.cc index 960cfda9ec0..f46f0f5b13f 100644 --- a/source/blender/compositor/operations/COM_PreviewOperation.cc +++ b/source/blender/compositor/operations/COM_PreviewOperation.cc @@ -23,70 +23,70 @@ namespace blender::compositor { -PreviewOperation::PreviewOperation(const ColorManagedViewSettings *viewSettings, - const ColorManagedDisplaySettings *displaySettings, - const unsigned int defaultWidth, - const unsigned int defaultHeight) +PreviewOperation::PreviewOperation(const ColorManagedViewSettings *view_settings, + const ColorManagedDisplaySettings *display_settings, + const unsigned int default_width, + const unsigned int default_height) { - this->addInputSocket(DataType::Color, ResizeMode::Align); + this->add_input_socket(DataType::Color, ResizeMode::Align); preview_ = nullptr; - outputBuffer_ = nullptr; + output_buffer_ = nullptr; input_ = nullptr; divider_ = 1.0f; - viewSettings_ = viewSettings; - displaySettings_ = displaySettings; - defaultWidth_ = defaultWidth; - defaultHeight_ = defaultHeight; + view_settings_ = view_settings; + display_settings_ = display_settings; + default_width_ = default_width; + default_height_ = default_height; flags.use_viewer_border = true; flags.is_preview_operation = true; } -void PreviewOperation::verifyPreview(bNodeInstanceHash *previews, bNodeInstanceKey key) +void PreviewOperation::verify_preview(bNodeInstanceHash *previews, bNodeInstanceKey key) { /* Size (0, 0) ensures the preview rect is not allocated in advance, - * this is set later in initExecution once the resolution is determined. + * this is set later in init_execution once the resolution is determined. */ preview_ = BKE_node_preview_verify(previews, key, 0, 0, true); } -void PreviewOperation::initExecution() +void PreviewOperation::init_execution() { - input_ = getInputSocketReader(0); + input_ = get_input_socket_reader(0); - if (this->getWidth() == (unsigned int)preview_->xsize && - this->getHeight() == (unsigned int)preview_->ysize) { - outputBuffer_ = preview_->rect; + if (this->get_width() == (unsigned int)preview_->xsize && + this->get_height() == (unsigned int)preview_->ysize) { + output_buffer_ = preview_->rect; } - if (outputBuffer_ == nullptr) { - outputBuffer_ = (unsigned char *)MEM_callocN( - sizeof(unsigned char) * 4 * getWidth() * getHeight(), "PreviewOperation"); + if (output_buffer_ == nullptr) { + output_buffer_ = (unsigned char *)MEM_callocN( + sizeof(unsigned char) * 4 * get_width() * get_height(), "PreviewOperation"); if (preview_->rect) { MEM_freeN(preview_->rect); } - preview_->xsize = getWidth(); - preview_->ysize = getHeight(); - preview_->rect = outputBuffer_; + preview_->xsize = get_width(); + preview_->ysize = get_height(); + preview_->rect = output_buffer_; } } -void PreviewOperation::deinitExecution() +void PreviewOperation::deinit_execution() { - outputBuffer_ = nullptr; + output_buffer_ = nullptr; input_ = nullptr; } -void PreviewOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) +void PreviewOperation::execute_region(rcti *rect, unsigned int /*tile_number*/) { int offset; float color[4]; struct ColormanageProcessor *cm_processor; - cm_processor = IMB_colormanagement_display_processor_new(viewSettings_, displaySettings_); + cm_processor = IMB_colormanagement_display_processor_new(view_settings_, display_settings_); for (int y = rect->ymin; y < rect->ymax; y++) { - offset = (y * getWidth() + rect->xmin) * 4; + offset = (y * get_width() + rect->xmin) * 4; for (int x = rect->xmin; x < rect->xmax; x++) { float rx = floor(x / divider_); float ry = floor(y / divider_); @@ -95,35 +95,35 @@ void PreviewOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) color[1] = 0.0f; color[2] = 0.0f; color[3] = 1.0f; - input_->readSampled(color, rx, ry, PixelSampler::Nearest); + input_->read_sampled(color, rx, ry, PixelSampler::Nearest); IMB_colormanagement_processor_apply_v4(cm_processor, color); - rgba_float_to_uchar(outputBuffer_ + offset, color); + rgba_float_to_uchar(output_buffer_ + offset, color); offset += 4; } } IMB_colormanagement_processor_free(cm_processor); } -bool PreviewOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool PreviewOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; + rcti new_input; - newInput.xmin = input->xmin / divider_; - newInput.xmax = input->xmax / divider_; - newInput.ymin = input->ymin / divider_; - newInput.ymax = input->ymax / divider_; + new_input.xmin = input->xmin / divider_; + new_input.xmax = input->xmax / divider_; + new_input.ymin = input->ymin / divider_; + new_input.ymax = input->ymax / divider_; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void PreviewOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area) { /* 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(defaultWidth_ > 0 && defaultHeight_ > 0); + BLI_assert(default_width_ > 0 && default_height_ > 0); rcti local_preferred; - BLI_rcti_init(&local_preferred, 0, defaultWidth_, 0, defaultHeight_); + BLI_rcti_init(&local_preferred, 0, default_width_, 0, default_height_); NodeOperation::determine_canvas(local_preferred, r_area); /* If resolution is 0 there are two possible scenarios: @@ -152,7 +152,7 @@ void PreviewOperation::determine_canvas(const rcti &UNUSED(preferred_area), rcti BLI_rcti_init(&r_area, r_area.xmin, r_area.xmin + width, r_area.ymin, r_area.ymin + height); } -eCompositorPriority PreviewOperation::getRenderPriority() const +eCompositorPriority PreviewOperation::get_render_priority() const { return eCompositorPriority::Low; } @@ -176,12 +176,12 @@ void PreviewOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output) { MemoryBuffer *input = inputs[0]; struct ColormanageProcessor *cm_processor = IMB_colormanagement_display_processor_new( - viewSettings_, displaySettings_); + view_settings_, display_settings_); rcti buffer_area; - BLI_rcti_init(&buffer_area, 0, this->getWidth(), 0, this->getHeight()); + BLI_rcti_init(&buffer_area, 0, this->get_width(), 0, this->get_height()); BuffersIteratorBuilder it_builder( - outputBuffer_, buffer_area, area, COM_data_type_num_channels(DataType::Color)); + output_buffer_, buffer_area, area, COM_data_type_num_channels(DataType::Color)); for (BuffersIterator it = it_builder.build(); !it.is_end(); ++it) { const float rx = it.x / divider_; diff --git a/source/blender/compositor/operations/COM_PreviewOperation.h b/source/blender/compositor/operations/COM_PreviewOperation.h index 1df8815d62b..97d1884c9a7 100644 --- a/source/blender/compositor/operations/COM_PreviewOperation.h +++ b/source/blender/compositor/operations/COM_PreviewOperation.h @@ -28,7 +28,7 @@ namespace blender::compositor { class PreviewOperation : public MultiThreadedOperation { protected: - unsigned char *outputBuffer_; + unsigned char *output_buffer_; /** * \brief holds reference to the SDNA bNode, where this nodes will render the preview image for @@ -36,32 +36,32 @@ class PreviewOperation : public MultiThreadedOperation { bNodePreview *preview_; SocketReader *input_; float divider_; - unsigned int defaultWidth_; - unsigned int defaultHeight_; + unsigned int default_width_; + unsigned int default_height_; - const ColorManagedViewSettings *viewSettings_; - const ColorManagedDisplaySettings *displaySettings_; + const ColorManagedViewSettings *view_settings_; + const ColorManagedDisplaySettings *display_settings_; public: - PreviewOperation(const ColorManagedViewSettings *viewSettings, - const ColorManagedDisplaySettings *displaySettings, - unsigned int defaultWidth, - unsigned int defaultHeight); - void verifyPreview(bNodeInstanceHash *previews, bNodeInstanceKey key); + PreviewOperation(const ColorManagedViewSettings *view_settings, + const ColorManagedDisplaySettings *display_settings, + unsigned int default_width, + unsigned int default_height); + void verify_preview(bNodeInstanceHash *previews, bNodeInstanceKey key); - bool isOutputOperation(bool /*rendering*/) const override + bool is_output_operation(bool /*rendering*/) const override { return !G.background; } - void initExecution() override; - void deinitExecution() override; - eCompositorPriority getRenderPriority() const override; + void init_execution() override; + void deinit_execution() override; + eCompositorPriority get_render_priority() const override; - void executeRegion(rcti *rect, unsigned int tileNumber) override; + void execute_region(rcti *rect, unsigned int tile_number) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc index 8e6aa7e8db8..436fdb16e8d 100644 --- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc +++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cc @@ -23,12 +23,12 @@ namespace blender::compositor { ProjectorLensDistortionOperation::ProjectorLensDistortionOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); this->flags.complex = true; - inputProgram_ = nullptr; - dispersionAvailable_ = false; + input_program_ = nullptr; + dispersion_available_ = false; dispersion_ = 0.0f; } @@ -44,87 +44,87 @@ void ProjectorLensDistortionOperation::init_data() } } -void ProjectorLensDistortionOperation::initExecution() +void ProjectorLensDistortionOperation::init_execution() { - this->initMutex(); - inputProgram_ = this->getInputSocketReader(0); + this->init_mutex(); + input_program_ = this->get_input_socket_reader(0); } -void *ProjectorLensDistortionOperation::initializeTileData(rcti * /*rect*/) +void *ProjectorLensDistortionOperation::initialize_tile_data(rcti * /*rect*/) { - updateDispersion(); - void *buffer = inputProgram_->initializeTileData(nullptr); + update_dispersion(); + void *buffer = input_program_->initialize_tile_data(nullptr); return buffer; } -void ProjectorLensDistortionOperation::executePixel(float output[4], int x, int y, void *data) +void ProjectorLensDistortionOperation::execute_pixel(float output[4], int x, int y, void *data) { - float inputValue[4]; - const float height = this->getHeight(); - const float width = this->getWidth(); + float input_value[4]; + const float height = this->get_height(); + const float width = this->get_width(); const float v = (y + 0.5f) / height; const float u = (x + 0.5f) / width; - MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - 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 - kr2_) - 0.5f, v * height - 0.5f); - output[2] = inputValue[2]; + MemoryBuffer *input_buffer = (MemoryBuffer *)data; + input_buffer->read_bilinear(input_value, (u * width + kr2_) - 0.5f, v * height - 0.5f); + output[0] = input_value[0]; + input_buffer->read(input_value, x, y); + output[1] = input_value[1]; + input_buffer->read_bilinear(input_value, (u * width - kr2_) - 0.5f, v * height - 0.5f); + output[2] = input_value[2]; output[3] = 1.0f; } -void ProjectorLensDistortionOperation::deinitExecution() +void ProjectorLensDistortionOperation::deinit_execution() { - this->deinitMutex(); - inputProgram_ = nullptr; + this->deinit_mutex(); + input_program_ = nullptr; } -bool ProjectorLensDistortionOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool ProjectorLensDistortionOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; - if (dispersionAvailable_) { - newInput.ymax = input->ymax; - newInput.ymin = input->ymin; - newInput.xmin = input->xmin - kr2_ - 2; - newInput.xmax = input->xmax + kr2_ + 2; + rcti new_input; + if (dispersion_available_) { + new_input.ymax = input->ymax; + new_input.ymin = input->ymin; + new_input.xmin = input->xmin - kr2_ - 2; + new_input.xmax = input->xmax + kr2_ + 2; } else { - rcti dispInput; - BLI_rcti_init(&dispInput, 0, 5, 0, 5); - if (this->getInputOperation(1)->determineDependingAreaOfInterest( - &dispInput, readOperation, output)) { + rcti disp_input; + BLI_rcti_init(&disp_input, 0, 5, 0, 5); + if (this->get_input_operation(1)->determine_depending_area_of_interest( + &disp_input, read_operation, output)) { return true; } - newInput.xmin = input->xmin - 7; /* (0.25f * 20 * 1) + 2 == worse case dispersion */ - newInput.ymin = input->ymin; - newInput.ymax = input->ymax; - newInput.xmax = input->xmax + 7; /* (0.25f * 20 * 1) + 2 == worse case dispersion */ + new_input.xmin = input->xmin - 7; /* (0.25f * 20 * 1) + 2 == worse case dispersion */ + new_input.ymin = input->ymin; + new_input.ymax = input->ymax; + new_input.xmax = input->xmax + 7; /* (0.25f * 20 * 1) + 2 == worse case dispersion */ } - if (this->getInputOperation(0)->determineDependingAreaOfInterest( - &newInput, readOperation, output)) { + if (this->get_input_operation(0)->determine_depending_area_of_interest( + &new_input, read_operation, output)) { return true; } return false; } /* TODO(manzanilla): to be removed with tiled implementation. */ -void ProjectorLensDistortionOperation::updateDispersion() +void ProjectorLensDistortionOperation::update_dispersion() { - if (dispersionAvailable_) { + if (dispersion_available_) { return; } - this->lockMutex(); - if (!dispersionAvailable_) { + this->lock_mutex(); + if (!dispersion_available_) { float result[4]; - this->getInputSocketReader(1)->readSampled(result, 1, 1, PixelSampler::Nearest); + this->get_input_socket_reader(1)->read_sampled(result, 1, 1, PixelSampler::Nearest); dispersion_ = result[0]; kr_ = 0.25f * max_ff(min_ff(dispersion_, 1.0f), 0.0f); kr2_ = kr_ * 20; - dispersionAvailable_ = true; + dispersion_available_ = true; } - this->unlockMutex(); + this->unlock_mutex(); } void ProjectorLensDistortionOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -165,8 +165,8 @@ void ProjectorLensDistortionOperation::update_memory_buffer_partial(MemoryBuffer Span inputs) { const MemoryBuffer *input_image = inputs[0]; - const float height = this->getHeight(); - const float width = this->getWidth(); + const float height = this->get_height(); + const float width = this->get_width(); float color[4]; for (BuffersIterator it = output->iterate_with({}, area); !it.is_end(); ++it) { const float v = (it.y + 0.5f) / height; diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h index af9b216db07..ea90840e61c 100644 --- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h +++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h @@ -26,13 +26,13 @@ namespace blender::compositor { class ProjectorLensDistortionOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; float dispersion_; /* TODO(manzanilla): to be removed with tiled implementation. */ - bool dispersionAvailable_; + bool dispersion_available_; float kr_, kr2_; @@ -42,25 +42,25 @@ class ProjectorLensDistortionOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; void init_data() override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void updateDispersion(); + void update_dispersion(); void determine_canvas(const rcti &preferred_area, rcti &r_area) override; 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_QualityStepHelper.cc b/source/blender/compositor/operations/COM_QualityStepHelper.cc index a45c7ab552c..895e341d550 100644 --- a/source/blender/compositor/operations/COM_QualityStepHelper.cc +++ b/source/blender/compositor/operations/COM_QualityStepHelper.cc @@ -27,7 +27,7 @@ QualityStepHelper::QualityStepHelper() offsetadd_ = 4; } -void QualityStepHelper::initExecution(QualityHelper helper) +void QualityStepHelper::init_execution(QualityHelper helper) { switch (helper) { case COM_QH_INCREASE: diff --git a/source/blender/compositor/operations/COM_QualityStepHelper.h b/source/blender/compositor/operations/COM_QualityStepHelper.h index 5c59f4d2a37..6f168babeae 100644 --- a/source/blender/compositor/operations/COM_QualityStepHelper.h +++ b/source/blender/compositor/operations/COM_QualityStepHelper.h @@ -37,13 +37,13 @@ class QualityStepHelper { /** * Initialize the execution */ - void initExecution(QualityHelper helper); + void init_execution(QualityHelper helper); - inline int getStep() const + inline int get_step() const { return step_; } - inline int getOffsetAdd() const + inline int get_offset_add() const { return offsetadd_; } @@ -51,7 +51,7 @@ class QualityStepHelper { public: QualityStepHelper(); - void setQuality(eCompositorQuality quality) + void set_quality(eCompositorQuality quality) { quality_ = quality; } diff --git a/source/blender/compositor/operations/COM_ReadBufferOperation.cc b/source/blender/compositor/operations/COM_ReadBufferOperation.cc index 9fe800021e7..75b4c61a376 100644 --- a/source/blender/compositor/operations/COM_ReadBufferOperation.cc +++ b/source/blender/compositor/operations/COM_ReadBufferOperation.cc @@ -25,39 +25,39 @@ namespace blender::compositor { ReadBufferOperation::ReadBufferOperation(DataType datatype) { - this->addOutputSocket(datatype); + this->add_output_socket(datatype); single_value_ = false; offset_ = 0; buffer_ = nullptr; flags.is_read_buffer_operation = true; } -void *ReadBufferOperation::initializeTileData(rcti * /*rect*/) +void *ReadBufferOperation::initialize_tile_data(rcti * /*rect*/) { return buffer_; } void ReadBufferOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { - if (memoryProxy_ != nullptr) { - WriteBufferOperation *operation = memoryProxy_->getWriteBufferOperation(); + if (memory_proxy_ != nullptr) { + WriteBufferOperation *operation = memory_proxy_->get_write_buffer_operation(); operation->determine_canvas(preferred_area, r_area); operation->set_canvas(r_area); /** \todo may not occur! But does with blur node. */ - if (memoryProxy_->getExecutor()) { + if (memory_proxy_->get_executor()) { uint resolution[2] = {static_cast(BLI_rcti_size_x(&r_area)), static_cast(BLI_rcti_size_y(&r_area))}; - memoryProxy_->getExecutor()->setResolution(resolution); + memory_proxy_->get_executor()->set_resolution(resolution); } - single_value_ = operation->isSingleValue(); + single_value_ = operation->is_single_value(); } } -void ReadBufferOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ReadBufferOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { if (single_value_) { /* write buffer has a single value stored at (0,0) */ @@ -70,21 +70,21 @@ void ReadBufferOperation::executePixelSampled(float output[4], break; case PixelSampler::Bilinear: default: - buffer_->readBilinear(output, x, y); + buffer_->read_bilinear(output, x, y); break; case PixelSampler::Bicubic: - buffer_->readBilinear(output, x, y); + buffer_->read_bilinear(output, x, y); break; } } } -void ReadBufferOperation::executePixelExtend(float output[4], - float x, - float y, - PixelSampler sampler, - MemoryBufferExtend extend_x, - MemoryBufferExtend extend_y) +void ReadBufferOperation::execute_pixel_extend(float output[4], + float x, + float y, + PixelSampler sampler, + MemoryBufferExtend extend_x, + MemoryBufferExtend extend_y) { if (single_value_) { /* write buffer has a single value stored at (0,0) */ @@ -94,11 +94,11 @@ void ReadBufferOperation::executePixelExtend(float output[4], buffer_->read(output, x, y, extend_x, extend_y); } else { - buffer_->readBilinear(output, x, y, extend_x, extend_y); + buffer_->read_bilinear(output, x, y, extend_x, extend_y); } } -void ReadBufferOperation::executePixelFiltered( +void ReadBufferOperation::execute_pixel_filtered( float output[4], float x, float y, float dx[2], float dy[2]) { if (single_value_) { @@ -112,29 +112,29 @@ void ReadBufferOperation::executePixelFiltered( } } -bool ReadBufferOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool ReadBufferOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - if (this == readOperation) { + if (this == read_operation) { BLI_rcti_init(output, input->xmin, input->xmax, input->ymin, input->ymax); return true; } return false; } -void ReadBufferOperation::readResolutionFromWriteBuffer() +void ReadBufferOperation::read_resolution_from_write_buffer() { - if (memoryProxy_ != nullptr) { - WriteBufferOperation *operation = memoryProxy_->getWriteBufferOperation(); - this->setWidth(operation->getWidth()); - this->setHeight(operation->getHeight()); + if (memory_proxy_ != nullptr) { + WriteBufferOperation *operation = memory_proxy_->get_write_buffer_operation(); + this->set_width(operation->get_width()); + this->set_height(operation->get_height()); } } -void ReadBufferOperation::updateMemoryBuffer() +void ReadBufferOperation::update_memory_buffer() { - buffer_ = this->getMemoryProxy()->getBuffer(); + buffer_ = this->get_memory_proxy()->get_buffer(); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_ReadBufferOperation.h b/source/blender/compositor/operations/COM_ReadBufferOperation.h index f4504e11f48..7f461d1c925 100644 --- a/source/blender/compositor/operations/COM_ReadBufferOperation.h +++ b/source/blender/compositor/operations/COM_ReadBufferOperation.h @@ -26,51 +26,52 @@ namespace blender::compositor { class ReadBufferOperation : public NodeOperation { private: - MemoryProxy *memoryProxy_; + MemoryProxy *memory_proxy_; 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) + void set_memory_proxy(MemoryProxy *memory_proxy) { - memoryProxy_ = memoryProxy; + memory_proxy_ = memory_proxy; } - MemoryProxy *getMemoryProxy() const + MemoryProxy *get_memory_proxy() const { - return memoryProxy_; + return memory_proxy_; } void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void *initializeTileData(rcti *rect) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; - void executePixelExtend(float output[4], - float x, - float y, - PixelSampler sampler, - MemoryBufferExtend extend_x, - MemoryBufferExtend extend_y); - void executePixelFiltered(float output[4], float x, float y, float dx[2], float dy[2]) override; - void setOffset(unsigned int offset) + void *initialize_tile_data(rcti *rect) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_extend(float output[4], + float x, + float y, + PixelSampler sampler, + MemoryBufferExtend extend_x, + MemoryBufferExtend extend_y); + void execute_pixel_filtered( + float output[4], float x, float y, float dx[2], float dy[2]) override; + void set_offset(unsigned int offset) { offset_ = offset; } - unsigned int getOffset() const + unsigned int get_offset() const { return offset_; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - MemoryBuffer *getInputMemoryBuffer(MemoryBuffer **memoryBuffers) override + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + MemoryBuffer *get_input_memory_buffer(MemoryBuffer **memory_buffers) override { - return memoryBuffers[offset_]; + return memory_buffers[offset_]; } - void readResolutionFromWriteBuffer(); - void updateMemoryBuffer(); + void read_resolution_from_write_buffer(); + void update_memory_buffer(); }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_RenderLayersProg.cc b/source/blender/compositor/operations/COM_RenderLayersProg.cc index 02a278899bb..7650def2c87 100644 --- a/source/blender/compositor/operations/COM_RenderLayersProg.cc +++ b/source/blender/compositor/operations/COM_RenderLayersProg.cc @@ -24,21 +24,21 @@ namespace blender::compositor { /* ******** Render Layers Base Prog ******** */ -RenderLayersProg::RenderLayersProg(const char *passName, DataType type, int elementsize) - : passName_(passName) +RenderLayersProg::RenderLayersProg(const char *pass_name, DataType type, int elementsize) + : pass_name_(pass_name) { - this->setScene(nullptr); - inputBuffer_ = nullptr; + this->set_scene(nullptr); + input_buffer_ = nullptr; elementsize_ = elementsize; rd_ = nullptr; layer_buffer_ = nullptr; - this->addOutputSocket(type); + this->add_output_socket(type); } -void RenderLayersProg::initExecution() +void RenderLayersProg::init_execution() { - Scene *scene = this->getScene(); + Scene *scene = this->get_scene(); Render *re = (scene) ? RE_GetSceneRender(scene) : nullptr; RenderResult *rr = nullptr; @@ -47,14 +47,14 @@ void RenderLayersProg::initExecution() } if (rr) { - ViewLayer *view_layer = (ViewLayer *)BLI_findlink(&scene->view_layers, getLayerId()); + ViewLayer *view_layer = (ViewLayer *)BLI_findlink(&scene->view_layers, get_layer_id()); if (view_layer) { RenderLayer *rl = RE_GetRenderLayer(rr, view_layer->name); if (rl) { - inputBuffer_ = RE_RenderLayerGetPass(rl, passName_.c_str(), viewName_); - if (inputBuffer_) { - layer_buffer_ = new MemoryBuffer(inputBuffer_, elementsize_, getWidth(), getHeight()); + input_buffer_ = RE_RenderLayerGetPass(rl, pass_name_.c_str(), view_name_); + if (input_buffer_) { + layer_buffer_ = new MemoryBuffer(input_buffer_, elementsize_, get_width(), get_height()); } } } @@ -65,10 +65,10 @@ void RenderLayersProg::initExecution() } } -void RenderLayersProg::doInterpolation(float output[4], float x, float y, PixelSampler sampler) +void RenderLayersProg::do_interpolation(float output[4], float x, float y, PixelSampler sampler) { unsigned int offset; - int width = this->getWidth(), height = this->getHeight(); + int width = this->get_width(), height = this->get_height(); int ix = x, iy = y; if (ix < 0 || iy < 0 || ix >= width || iy >= height) { @@ -89,28 +89,31 @@ void RenderLayersProg::doInterpolation(float output[4], float x, float y, PixelS offset = (iy * width + ix) * elementsize_; if (elementsize_ == 1) { - output[0] = inputBuffer_[offset]; + output[0] = input_buffer_[offset]; } else if (elementsize_ == 3) { - copy_v3_v3(output, &inputBuffer_[offset]); + copy_v3_v3(output, &input_buffer_[offset]); } else { - copy_v4_v4(output, &inputBuffer_[offset]); + copy_v4_v4(output, &input_buffer_[offset]); } break; } case PixelSampler::Bilinear: - BLI_bilinear_interpolation_fl(inputBuffer_, output, width, height, elementsize_, x, y); + BLI_bilinear_interpolation_fl(input_buffer_, output, width, height, elementsize_, x, y); break; case PixelSampler::Bicubic: - BLI_bicubic_interpolation_fl(inputBuffer_, output, width, height, elementsize_, x, y); + BLI_bicubic_interpolation_fl(input_buffer_, output, width, height, elementsize_, x, y); break; } } -void RenderLayersProg::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void RenderLayersProg::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { #if 0 const RenderData *rd = rd_; @@ -118,14 +121,14 @@ void RenderLayersProg::executePixelSampled(float output[4], float x, float y, Pi int dx = 0, dy = 0; if (rd->mode & R_BORDER && rd->mode & R_CROP) { - /* see comment in executeRegion describing coordinate mapping, + /* see comment in execute_region describing coordinate mapping, * here it simply goes other way around */ int full_width = rd->xsch * rd->size / 100; int full_height = rd->ysch * rd->size / 100; - dx = rd->border.xmin * full_width - (full_width - this->getWidth()) / 2.0f; - dy = rd->border.ymin * full_height - (full_height - this->getHeight()) / 2.0f; + dx = rd->border.xmin * full_width - (full_width - this->get_width()) / 2.0f; + dy = rd->border.ymin * full_height - (full_height - this->get_height()) / 2.0f; } int ix = x - dx; @@ -134,7 +137,7 @@ void RenderLayersProg::executePixelSampled(float output[4], float x, float y, Pi #ifndef NDEBUG { - const DataType data_type = this->getOutputSocket()->getDataType(); + const DataType data_type = this->get_output_socket()->get_data_type(); int actual_element_size = elementsize_; int expected_element_size; if (data_type == DataType::Value) { @@ -154,7 +157,7 @@ void RenderLayersProg::executePixelSampled(float output[4], float x, float y, Pi } #endif - if (inputBuffer_ == nullptr) { + if (input_buffer_ == nullptr) { int elemsize = elementsize_; if (elemsize == 1) { output[0] = 0.0f; @@ -168,13 +171,13 @@ void RenderLayersProg::executePixelSampled(float output[4], float x, float y, Pi } } else { - doInterpolation(output, x, y, sampler); + do_interpolation(output, x, y, sampler); } } -void RenderLayersProg::deinitExecution() +void RenderLayersProg::deinit_execution() { - inputBuffer_ = nullptr; + input_buffer_ = nullptr; if (layer_buffer_) { delete layer_buffer_; layer_buffer_ = nullptr; @@ -183,7 +186,7 @@ void RenderLayersProg::deinitExecution() void RenderLayersProg::determine_canvas(const rcti &UNUSED(preferred_area), rcti &r_area) { - Scene *sce = this->getScene(); + Scene *sce = this->get_scene(); Render *re = (sce) ? RE_GetSceneRender(sce) : nullptr; RenderResult *rr = nullptr; @@ -194,7 +197,7 @@ void RenderLayersProg::determine_canvas(const rcti &UNUSED(preferred_area), rcti } if (rr) { - ViewLayer *view_layer = (ViewLayer *)BLI_findlink(&sce->view_layers, getLayerId()); + ViewLayer *view_layer = (ViewLayer *)BLI_findlink(&sce->view_layers, get_layer_id()); if (view_layer) { RenderLayer *rl = RE_GetRenderLayer(rr, view_layer->name); if (rl) { @@ -208,9 +211,9 @@ void RenderLayersProg::determine_canvas(const rcti &UNUSED(preferred_area), rcti } } -std::unique_ptr RenderLayersProg::getMetaData() +std::unique_ptr RenderLayersProg::get_meta_data() { - Scene *scene = this->getScene(); + Scene *scene = this->get_scene(); Render *re = (scene) ? RE_GetSceneRender(scene) : nullptr; RenderResult *render_result = nullptr; MetaDataExtractCallbackData callback_data = {nullptr}; @@ -220,15 +223,15 @@ std::unique_ptr RenderLayersProg::getMetaData() } if (render_result && render_result->stamp_data) { - ViewLayer *view_layer = (ViewLayer *)BLI_findlink(&scene->view_layers, getLayerId()); + ViewLayer *view_layer = (ViewLayer *)BLI_findlink(&scene->view_layers, get_layer_id()); if (view_layer) { std::string full_layer_name = std::string( view_layer->name, BLI_strnlen(view_layer->name, sizeof(view_layer->name))) + - "." + passName_; + "." + pass_name_; blender::StringRef cryptomatte_layer_name = blender::bke::cryptomatte::BKE_cryptomatte_extract_layer_name(full_layer_name); - callback_data.setCryptomatteKeys(cryptomatte_layer_name); + callback_data.set_cryptomatte_keys(cryptomatte_layer_name); BKE_stamp_info_callback(&callback_data, render_result->stamp_data, @@ -260,17 +263,17 @@ void RenderLayersProg::update_memory_buffer_partial(MemoryBuffer *output, } /* ******** Render Layers AO Operation ******** */ -void RenderLayersAOOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void RenderLayersAOOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float *inputBuffer = this->getInputBuffer(); - if (inputBuffer == nullptr) { + float *input_buffer = this->get_input_buffer(); + if (input_buffer == nullptr) { zero_v3(output); } else { - doInterpolation(output, x, y, sampler); + do_interpolation(output, x, y, sampler); } output[3] = 1.0f; } @@ -291,19 +294,19 @@ void RenderLayersAOOperation::update_memory_buffer_partial(MemoryBuffer *output, } /* ******** Render Layers Alpha Operation ******** */ -void RenderLayersAlphaProg::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void RenderLayersAlphaProg::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - float *inputBuffer = this->getInputBuffer(); + float *input_buffer = this->get_input_buffer(); - if (inputBuffer == nullptr) { + if (input_buffer == nullptr) { output[0] = 0.0f; } else { float temp[4]; - doInterpolation(temp, x, y, sampler); + do_interpolation(temp, x, y, sampler); output[0] = temp[3]; } } @@ -323,22 +326,22 @@ void RenderLayersAlphaProg::update_memory_buffer_partial(MemoryBuffer *output, } /* ******** Render Layers Depth Operation ******** */ -void RenderLayersDepthProg::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void RenderLayersDepthProg::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { int ix = x; int iy = y; - float *inputBuffer = this->getInputBuffer(); + float *input_buffer = this->get_input_buffer(); - if (inputBuffer == nullptr || ix < 0 || iy < 0 || ix >= (int)this->getWidth() || - iy >= (int)this->getHeight()) { + if (input_buffer == nullptr || ix < 0 || iy < 0 || ix >= (int)this->get_width() || + iy >= (int)this->get_height()) { output[0] = 10e10f; } else { - unsigned int offset = (iy * this->getWidth() + ix); - output[0] = inputBuffer[offset]; + unsigned int offset = (iy * this->get_width() + ix); + output[0] = input_buffer[offset]; } } diff --git a/source/blender/compositor/operations/COM_RenderLayersProg.h b/source/blender/compositor/operations/COM_RenderLayersProg.h index 14fc3babe32..79afe3c2a8c 100644 --- a/source/blender/compositor/operations/COM_RenderLayersProg.h +++ b/source/blender/compositor/operations/COM_RenderLayersProg.h @@ -41,14 +41,14 @@ class RenderLayersProg : public MultiThreadedOperation { Scene *scene_; /** - * layerId of the layer where this operation needs to get its data from + * layer_id of the layer where this operation needs to get its data from */ - short layerId_; + short layer_id_; /** - * viewName of the view to use (unless another view is specified by the node + * view_name of the view to use (unless another view is specified by the node */ - const char *viewName_; + const char *view_name_; const MemoryBuffer *layer_buffer_; @@ -56,12 +56,12 @@ class RenderLayersProg : public MultiThreadedOperation { * Cached instance to the float buffer inside the layer. * TODO: To be removed with tiled implementation. */ - float *inputBuffer_; + float *input_buffer_; /** * Render-pass where this operation needs to get its data from. */ - std::string passName_; + std::string pass_name_; int elementsize_; @@ -78,56 +78,56 @@ class RenderLayersProg : public MultiThreadedOperation { /** * retrieve the reference to the float buffer of the renderer. */ - inline float *getInputBuffer() + inline float *get_input_buffer() { - return inputBuffer_; + return input_buffer_; } - void doInterpolation(float output[4], float x, float y, PixelSampler sampler); + void do_interpolation(float output[4], float x, float y, PixelSampler sampler); public: /** * Constructor */ - RenderLayersProg(const char *passName, DataType type, int elementsize); + RenderLayersProg(const char *pass_name, DataType type, int elementsize); /** * setter for the scene field. Will be called from * \see RenderLayerNode to set the actual scene where * the data will be retrieved from. */ - void setScene(Scene *scene) + void set_scene(Scene *scene) { scene_ = scene; } - Scene *getScene() const + Scene *get_scene() const { return scene_; } - void setRenderData(const RenderData *rd) + void set_render_data(const RenderData *rd) { rd_ = rd; } - void setLayerId(short layerId) + void set_layer_id(short layer_id) { - layerId_ = layerId; + layer_id_ = layer_id; } - short getLayerId() const + short get_layer_id() const { - return layerId_; + return layer_id_; } - void setViewName(const char *viewName) + void set_view_name(const char *view_name) { - viewName_ = viewName; + view_name_ = view_name; } - const char *getViewName() + const char *get_view_name() { - return viewName_; + return view_name_; } - void initExecution() override; - void deinitExecution() override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void init_execution() override; + void deinit_execution() override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - std::unique_ptr getMetaData() override; + std::unique_ptr get_meta_data() override; virtual void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -136,11 +136,11 @@ class RenderLayersProg : public MultiThreadedOperation { class RenderLayersAOOperation : public RenderLayersProg { public: - RenderLayersAOOperation(const char *passName, DataType type, int elementsize) - : RenderLayersProg(passName, type, elementsize) + RenderLayersAOOperation(const char *pass_name, DataType type, int elementsize) + : RenderLayersProg(pass_name, type, elementsize) { } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -149,11 +149,11 @@ class RenderLayersAOOperation : public RenderLayersProg { class RenderLayersAlphaProg : public RenderLayersProg { public: - RenderLayersAlphaProg(const char *passName, DataType type, int elementsize) - : RenderLayersProg(passName, type, elementsize) + RenderLayersAlphaProg(const char *pass_name, DataType type, int elementsize) + : RenderLayersProg(pass_name, type, elementsize) { } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -162,11 +162,11 @@ class RenderLayersAlphaProg : public RenderLayersProg { class RenderLayersDepthProg : public RenderLayersProg { public: - RenderLayersDepthProg(const char *passName, DataType type, int elementsize) - : RenderLayersProg(passName, type, elementsize) + RenderLayersDepthProg(const char *pass_name, DataType type, int elementsize) + : RenderLayersProg(pass_name, type, elementsize) { } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_RotateOperation.cc b/source/blender/compositor/operations/COM_RotateOperation.cc index 9cef80c14b9..8129516f81c 100644 --- a/source/blender/compositor/operations/COM_RotateOperation.cc +++ b/source/blender/compositor/operations/COM_RotateOperation.cc @@ -22,14 +22,14 @@ namespace blender::compositor { RotateOperation::RotateOperation() { - this->addInputSocket(DataType::Color, ResizeMode::None); - this->addInputSocket(DataType::Value, ResizeMode::None); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color, ResizeMode::None); + this->add_input_socket(DataType::Value, ResizeMode::None); + this->add_output_socket(DataType::Color); this->set_canvas_input_index(0); - imageSocket_ = nullptr; - degreeSocket_ = nullptr; - doDegree2RadConversion_ = false; - isDegreeSet_ = false; + image_socket_ = nullptr; + degree_socket_ = nullptr; + do_degree2_rad_conversion_ = false; + is_degree_set_ = 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(), centerX_, centerY_); + get_rotation_center(get_canvas(), center_x_, center_y_); } } -void RotateOperation::initExecution() +void RotateOperation::init_execution() { - imageSocket_ = this->getInputSocketReader(0); - degreeSocket_ = this->getInputSocketReader(1); + image_socket_ = this->get_input_socket_reader(0); + degree_socket_ = this->get_input_socket_reader(1); } -void RotateOperation::deinitExecution() +void RotateOperation::deinit_execution() { - imageSocket_ = nullptr; - degreeSocket_ = nullptr; + image_socket_ = nullptr; + degree_socket_ = nullptr; } -inline void RotateOperation::ensureDegree() +inline void RotateOperation::ensure_degree() { - if (!isDegreeSet_) { + if (!is_degree_set_) { float degree[4]; switch (execution_model_) { case eExecutionModel::Tiled: - degreeSocket_->readSampled(degree, 0, 0, PixelSampler::Nearest); + degree_socket_->read_sampled(degree, 0, 0, PixelSampler::Nearest); break; case eExecutionModel::FullFrame: degree[0] = get_input_operation(DEGREE_INPUT_INDEX)->get_constant_value_default(0.0f); @@ -157,7 +157,7 @@ inline void RotateOperation::ensureDegree() } double rad; - if (doDegree2RadConversion_) { + if (do_degree2_rad_conversion_) { rad = DEG2RAD((double)degree[0]); } else { @@ -166,51 +166,54 @@ inline void RotateOperation::ensureDegree() cosine_ = cos(rad); sine_ = sin(rad); - isDegreeSet_ = true; + is_degree_set_ = true; } } -void RotateOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void RotateOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - ensureDegree(); - 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); + ensure_degree(); + const float dy = y - center_y_; + const float dx = x - center_x_; + const float nx = center_x_ + (cosine_ * dx + sine_ * dy); + const float ny = center_y_ + (-sine_ * dx + cosine_ * dy); + image_socket_->read_sampled(output, nx, ny, sampler); } -bool RotateOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool RotateOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - ensureDegree(); - rcti newInput; - - 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); + ensure_degree(); + rcti new_input; + + const float dxmin = input->xmin - center_x_; + const float dymin = input->ymin - center_y_; + const float dxmax = input->xmax - center_x_; + const float dymax = input->ymax - center_y_; + + const float x1 = center_x_ + (cosine_ * dxmin + sine_ * dymin); + const float x2 = center_x_ + (cosine_ * dxmax + sine_ * dymin); + const float x3 = center_x_ + (cosine_ * dxmin + sine_ * dymax); + const float x4 = center_x_ + (cosine_ * dxmax + sine_ * dymax); + const float y1 = center_y_ + (-sine_ * dxmin + cosine_ * dymin); + const float y2 = center_y_ + (-sine_ * dxmax + cosine_ * dymin); + const float y3 = center_y_ + (-sine_ * dxmin + cosine_ * dymax); + const float y4 = center_y_ + (-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))); const float maxy = MAX2(y1, MAX2(y2, MAX2(y3, y4))); - newInput.xmax = ceil(maxx) + 1; - newInput.xmin = floor(minx) - 1; - newInput.ymax = ceil(maxy) + 1; - newInput.ymin = floor(miny) - 1; + new_input.xmax = ceil(maxx) + 1; + new_input.xmin = floor(minx) - 1; + new_input.ymax = ceil(maxy) + 1; + new_input.ymin = floor(miny) - 1; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void RotateOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -221,13 +224,13 @@ void RotateOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) } const bool image_determined = - getInputSocket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area); + get_input_socket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area); if (image_determined) { rcti input_canvas = r_area; rcti unused; - getInputSocket(DEGREE_INPUT_INDEX)->determine_canvas(input_canvas, unused); + get_input_socket(DEGREE_INPUT_INDEX)->determine_canvas(input_canvas, unused); - ensureDegree(); + ensure_degree(); get_rotation_canvas(input_canvas, sine_, cosine_, r_area); } @@ -242,7 +245,7 @@ void RotateOperation::get_area_of_interest(const int input_idx, return; } - ensureDegree(); + ensure_degree(); const rcti &input_image_canvas = get_input_operation(IMAGE_INPUT_INDEX)->get_canvas(); get_rotation_area_of_interest( diff --git a/source/blender/compositor/operations/COM_RotateOperation.h b/source/blender/compositor/operations/COM_RotateOperation.h index d99c914bed7..3970d3a2776 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 *imageSocket_; - SocketReader *degreeSocket_; + SocketReader *image_socket_; + SocketReader *degree_socket_; /* TODO(manzanilla): to be removed with tiled implementation. */ - float centerX_; - float centerY_; + float center_x_; + float center_y_; float cosine_; float sine_; - bool doDegree2RadConversion_; - bool isDegreeSet_; + bool do_degree2_rad_conversion_; + bool is_degree_set_; PixelSampler sampler_; public: @@ -79,17 +79,17 @@ class RotateOperation : public MultiThreadedOperation { const float cosine, rcti &r_canvas); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void init_data() override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; - void setDoDegree2RadConversion(bool abool) + void set_do_degree2_rad_conversion(bool abool) { - doDegree2RadConversion_ = abool; + do_degree2_rad_conversion_ = abool; } void set_sampler(PixelSampler sampler) @@ -97,7 +97,7 @@ class RotateOperation : public MultiThreadedOperation { sampler_ = sampler; } - void ensureDegree(); + void ensure_degree(); void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_SMAAOperation.cc b/source/blender/compositor/operations/COM_SMAAOperation.cc index 40af7389d7f..c73462d2e6d 100644 --- a/source/blender/compositor/operations/COM_SMAAOperation.cc +++ b/source/blender/compositor/operations/COM_SMAAOperation.cc @@ -38,7 +38,7 @@ namespace blender::compositor { * * This file is based on SMAA-CPP: * - * https://github.com/iRi-E/smaa-cpp + * https://github.com/i_ri-E/smaa-cpp * * Currently only SMAA 1x mode is provided, so the operation will be done * with no spatial multi-sampling nor temporal super-sampling. @@ -64,7 +64,7 @@ namespace blender::compositor { * #buffer->read_elem_checked. */ static inline void sample(SocketReader *reader, int x, int y, float color[4]) { - if (x < 0 || x >= reader->getWidth() || y < 0 || y >= reader->getHeight()) { + if (x < 0 || x >= reader->get_width() || y < 0 || y >= reader->get_height()) { color[0] = color[1] = color[2] = color[3] = 0.0; return; } @@ -167,50 +167,50 @@ static void area_diag(int d1, int d2, int e1, int e2, float weights[2]) SMAAEdgeDetectionOperation::SMAAEdgeDetectionOperation() { - this->addInputSocket(DataType::Color); /* image */ - this->addInputSocket(DataType::Value); /* Depth, material ID, etc. TODO: currently unused. */ - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); /* image */ + this->add_input_socket(DataType::Value); /* Depth, material ID, etc. TODO: currently unused. */ + this->add_output_socket(DataType::Color); this->flags.complex = true; - imageReader_ = nullptr; - valueReader_ = nullptr; - this->setThreshold(CMP_DEFAULT_SMAA_THRESHOLD); - this->setLocalContrastAdaptationFactor(CMP_DEFAULT_SMAA_CONTRAST_LIMIT); + image_reader_ = nullptr; + value_reader_ = nullptr; + this->set_threshold(CMP_DEFAULT_SMAA_THRESHOLD); + this->set_local_contrast_adaptation_factor(CMP_DEFAULT_SMAA_CONTRAST_LIMIT); } -void SMAAEdgeDetectionOperation::initExecution() +void SMAAEdgeDetectionOperation::init_execution() { - imageReader_ = this->getInputSocketReader(0); - valueReader_ = this->getInputSocketReader(1); + image_reader_ = this->get_input_socket_reader(0); + value_reader_ = this->get_input_socket_reader(1); } -void SMAAEdgeDetectionOperation::deinitExecution() +void SMAAEdgeDetectionOperation::deinit_execution() { - imageReader_ = nullptr; - valueReader_ = nullptr; + image_reader_ = nullptr; + value_reader_ = nullptr; } -void SMAAEdgeDetectionOperation::setThreshold(float threshold) +void SMAAEdgeDetectionOperation::set_threshold(float threshold) { /* UI values are between 0 and 1 for simplicity but algorithm expects values between 0 and 0.5 */ threshold_ = scalenorm(0, 0.5, threshold); } -void SMAAEdgeDetectionOperation::setLocalContrastAdaptationFactor(float factor) +void SMAAEdgeDetectionOperation::set_local_contrast_adaptation_factor(float factor) { /* UI values are between 0 and 1 for simplicity but algorithm expects values between 1 and 10 */ contrast_limit_ = scalenorm(1, 10, factor); } -bool SMAAEdgeDetectionOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool SMAAEdgeDetectionOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; - newInput.xmax = input->xmax + 1; - newInput.xmin = input->xmin - 2; - newInput.ymax = input->ymax + 1; - newInput.ymin = input->ymin - 2; + rcti new_input; + new_input.xmax = input->xmax + 1; + new_input.xmin = input->xmin - 2; + new_input.ymax = input->ymax + 1; + new_input.ymin = input->ymin - 2; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void SMAAEdgeDetectionOperation::get_area_of_interest(const int UNUSED(input_idx), @@ -223,16 +223,16 @@ void SMAAEdgeDetectionOperation::get_area_of_interest(const int UNUSED(input_idx r_input_area.ymin = output_area.ymin - 2; } -void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, void * /*data*/) +void SMAAEdgeDetectionOperation::execute_pixel(float output[4], int x, int y, void * /*data*/) { float color[4]; /* Calculate luma deltas: */ - sample(imageReader_, x, y, color); + sample(image_reader_, x, y, color); float L = IMB_colormanagement_get_luminance(color); - sample(imageReader_, x - 1, y, color); + sample(image_reader_, x - 1, y, color); float Lleft = IMB_colormanagement_get_luminance(color); - sample(imageReader_, x, y - 1, color); + sample(image_reader_, x, y - 1, color); float Ltop = IMB_colormanagement_get_luminance(color); float Dleft = fabsf(L - Lleft); float Dtop = fabsf(L - Ltop); @@ -249,36 +249,36 @@ void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, voi } /* Calculate right and bottom deltas: */ - sample(imageReader_, x + 1, y, color); + sample(image_reader_, x + 1, y, color); float Lright = IMB_colormanagement_get_luminance(color); - sample(imageReader_, x, y + 1, color); + sample(image_reader_, x, y + 1, color); float Lbottom = IMB_colormanagement_get_luminance(color); float Dright = fabsf(L - Lright); float Dbottom = fabsf(L - Lbottom); /* Calculate the maximum delta in the direct neighborhood: */ - float maxDelta = fmaxf(fmaxf(Dleft, Dright), fmaxf(Dtop, Dbottom)); + float max_delta = fmaxf(fmaxf(Dleft, Dright), fmaxf(Dtop, Dbottom)); /* Calculate luma used for both left and top edges: */ - sample(imageReader_, x - 1, y - 1, color); + sample(image_reader_, 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(imageReader_, x - 2, y, color); + sample(image_reader_, x - 2, y, color); float Lleftleft = IMB_colormanagement_get_luminance(color); - sample(imageReader_, x - 1, y + 1, color); + sample(image_reader_, x - 1, y + 1, color); float Lleftbottom = IMB_colormanagement_get_luminance(color); float Dleftleft = fabsf(Lleft - Lleftleft); float Dlefttop = fabsf(Lleft - Llefttop); float Dleftbottom = fabsf(Lleft - Lleftbottom); /* Calculate the final maximum delta: */ - maxDelta = fmaxf(maxDelta, fmaxf(Dleftleft, fmaxf(Dlefttop, Dleftbottom))); + max_delta = fmaxf(max_delta, fmaxf(Dleftleft, fmaxf(Dlefttop, Dleftbottom))); /* Local contrast adaptation: */ - if (maxDelta > contrast_limit_ * Dleft) { + if (max_delta > contrast_limit_ * Dleft) { output[0] = 0.0f; } } @@ -286,19 +286,19 @@ void SMAAEdgeDetectionOperation::executePixel(float output[4], int x, int y, voi /* Top edge */ if (output[1] != 0.0f) { /* Calculate top-top delta: */ - sample(imageReader_, x, y - 2, color); + sample(image_reader_, x, y - 2, color); float Ltoptop = IMB_colormanagement_get_luminance(color); - sample(imageReader_, x + 1, y - 1, color); + sample(image_reader_, x + 1, y - 1, color); float Ltopright = IMB_colormanagement_get_luminance(color); float Dtoptop = fabsf(Ltop - Ltoptop); float Dtopleft = fabsf(Ltop - Llefttop); float Dtopright = fabsf(Ltop - Ltopright); /* Calculate the final maximum delta: */ - maxDelta = fmaxf(maxDelta, fmaxf(Dtoptop, fmaxf(Dtopleft, Dtopright))); + max_delta = fmaxf(max_delta, fmaxf(Dtoptop, fmaxf(Dtopleft, Dtopright))); /* Local contrast adaptation: */ - if (maxDelta > contrast_limit_ * Dtop) { + if (max_delta > contrast_limit_ * Dtop) { output[1] = 0.0f; } } @@ -344,7 +344,7 @@ void SMAAEdgeDetectionOperation::update_memory_buffer_partial(MemoryBuffer *outp const float Dbottom = fabsf(L - Lbottom); /* Calculate the maximum delta in the direct neighborhood: */ - float maxDelta = fmaxf(fmaxf(Dleft, Dright), fmaxf(Dtop, Dbottom)); + float max_delta = fmaxf(fmaxf(Dleft, Dright), fmaxf(Dtop, Dbottom)); /* Calculate luma used for both left and top edges: */ image->read_elem_checked(x - 1, y - 1, color); @@ -362,10 +362,10 @@ void SMAAEdgeDetectionOperation::update_memory_buffer_partial(MemoryBuffer *outp const float Dleftbottom = fabsf(Lleft - Lleftbottom); /* Calculate the final maximum delta: */ - maxDelta = fmaxf(maxDelta, fmaxf(Dleftleft, fmaxf(Dlefttop, Dleftbottom))); + max_delta = fmaxf(max_delta, fmaxf(Dleftleft, fmaxf(Dlefttop, Dleftbottom))); /* Local contrast adaptation: */ - if (maxDelta > contrast_limit_ * Dleft) { + if (max_delta > contrast_limit_ * Dleft) { it.out[0] = 0.0f; } } @@ -382,10 +382,10 @@ void SMAAEdgeDetectionOperation::update_memory_buffer_partial(MemoryBuffer *outp const float Dtopright = fabsf(Ltop - Ltopright); /* Calculate the final maximum delta: */ - maxDelta = fmaxf(maxDelta, fmaxf(Dtoptop, fmaxf(Dtopleft, Dtopright))); + max_delta = fmaxf(max_delta, fmaxf(Dtoptop, fmaxf(Dtopleft, Dtopright))); /* Local contrast adaptation: */ - if (maxDelta > contrast_limit_ * Dtop) { + if (max_delta > contrast_limit_ * Dtop) { it.out[1] = 0.0f; } } @@ -398,47 +398,47 @@ void SMAAEdgeDetectionOperation::update_memory_buffer_partial(MemoryBuffer *outp SMAABlendingWeightCalculationOperation::SMAABlendingWeightCalculationOperation() { - this->addInputSocket(DataType::Color); /* edges */ - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); /* edges */ + this->add_output_socket(DataType::Color); this->flags.complex = true; - imageReader_ = nullptr; - this->setCornerRounding(CMP_DEFAULT_SMAA_CORNER_ROUNDING); + image_reader_ = nullptr; + this->set_corner_rounding(CMP_DEFAULT_SMAA_CORNER_ROUNDING); } -void *SMAABlendingWeightCalculationOperation::initializeTileData(rcti *rect) +void *SMAABlendingWeightCalculationOperation::initialize_tile_data(rcti *rect) { - return getInputOperation(0)->initializeTileData(rect); + return get_input_operation(0)->initialize_tile_data(rect); } -void SMAABlendingWeightCalculationOperation::initExecution() +void SMAABlendingWeightCalculationOperation::init_execution() { - imageReader_ = this->getInputSocketReader(0); + image_reader_ = this->get_input_socket_reader(0); if (execution_model_ == eExecutionModel::Tiled) { - sample_image_fn_ = [=](int x, int y, float *out) { sample(imageReader_, x, y, out); }; + sample_image_fn_ = [=](int x, int y, float *out) { sample(image_reader_, x, y, out); }; } } -void SMAABlendingWeightCalculationOperation::setCornerRounding(float rounding) +void SMAABlendingWeightCalculationOperation::set_corner_rounding(float rounding) { /* UI values are between 0 and 1 for simplicity but algorithm expects values between 0 and 100 */ corner_rounding_ = static_cast(scalenorm(0, 100, rounding)); } -void SMAABlendingWeightCalculationOperation::executePixel(float output[4], - int x, - int y, - void * /*data*/) +void SMAABlendingWeightCalculationOperation::execute_pixel(float output[4], + int x, + int y, + void * /*data*/) { float edges[4], c[4]; zero_v4(output); - sample(imageReader_, x, y, edges); + sample(image_reader_, x, y, edges); /* Edge at north */ if (edges[1] > 0.0f) { /* Diagonals have both north and west edges, so calculating weights for them */ /* in one of the boundaries is enough. */ - calculateDiagWeights(x, y, edges, output); + calculate_diag_weights(x, y, edges, output); /* We give priority to diagonals, so if we find a diagonal we skip. */ /* horizontal/vertical processing. */ @@ -447,25 +447,25 @@ void SMAABlendingWeightCalculationOperation::executePixel(float output[4], } /* Find the distance to the left and the right: */ - int left = searchXLeft(x, y); - int right = searchXRight(x, y); + int left = search_xleft(x, y); + int right = search_xright(x, y); int d1 = x - left, d2 = right - x; /* Fetch the left and right crossing edges: */ int e1 = 0, e2 = 0; - sample(imageReader_, left, y - 1, c); + sample(image_reader_, left, y - 1, c); if (c[0] > 0.0) { e1 += 1; } - sample(imageReader_, left, y, c); + sample(image_reader_, left, y, c); if (c[0] > 0.0) { e1 += 2; } - sample(imageReader_, right + 1, y - 1, c); + sample(image_reader_, right + 1, y - 1, c); if (c[0] > 0.0) { e2 += 1; } - sample(imageReader_, right + 1, y, c); + sample(image_reader_, right + 1, y, c); if (c[0] > 0.0) { e2 += 2; } @@ -476,37 +476,37 @@ void SMAABlendingWeightCalculationOperation::executePixel(float output[4], /* Fix corners: */ if (corner_rounding_) { - detectHorizontalCornerPattern(output, left, right, y, d1, d2); + detect_horizontal_corner_pattern(output, left, right, y, d1, d2); } } /* Edge at west */ if (edges[0] > 0.0f) { /* Did we already do diagonal search for this west edge from the left neighboring pixel? */ - if (isVerticalSearchUnneeded(x, y)) { + if (is_vertical_search_unneeded(x, y)) { return; } /* Find the distance to the top and the bottom: */ - int top = searchYUp(x, y); - int bottom = searchYDown(x, y); + int top = search_yup(x, y); + int bottom = search_ydown(x, y); int d1 = y - top, d2 = bottom - y; /* Fetch the top and bottom crossing edges: */ int e1 = 0, e2 = 0; - sample(imageReader_, x - 1, top, c); + sample(image_reader_, x - 1, top, c); if (c[1] > 0.0) { e1 += 1; } - sample(imageReader_, x, top, c); + sample(image_reader_, x, top, c); if (c[1] > 0.0) { e1 += 2; } - sample(imageReader_, x - 1, bottom + 1, c); + sample(image_reader_, x - 1, bottom + 1, c); if (c[1] > 0.0) { e2 += 1; } - sample(imageReader_, x, bottom + 1, c); + sample(image_reader_, x, bottom + 1, c); if (c[1] > 0.0) { e2 += 2; } @@ -516,7 +516,7 @@ void SMAABlendingWeightCalculationOperation::executePixel(float output[4], /* Fix corners: */ if (corner_rounding_) { - detectVerticalCornerPattern(output + 2, x, top, bottom, d1, d2); + detect_vertical_corner_pattern(output + 2, x, top, bottom, d1, d2); } } } @@ -544,7 +544,7 @@ void SMAABlendingWeightCalculationOperation::update_memory_buffer_partial( if (edges[1] > 0.0f) { /* Diagonals have both north and west edges, so calculating weights for them */ /* in one of the boundaries is enough. */ - calculateDiagWeights(x, y, edges, it.out); + calculate_diag_weights(x, y, edges, it.out); /* We give priority to diagonals, so if we find a diagonal we skip. */ /* horizontal/vertical processing. */ @@ -553,8 +553,8 @@ void SMAABlendingWeightCalculationOperation::update_memory_buffer_partial( } /* Find the distance to the left and the right: */ - int left = searchXLeft(x, y); - int right = searchXRight(x, y); + int left = search_xleft(x, y); + int right = search_xright(x, y); int d1 = x - left, d2 = right - x; /* Fetch the left and right crossing edges: */ @@ -582,20 +582,20 @@ void SMAABlendingWeightCalculationOperation::update_memory_buffer_partial( /* Fix corners: */ if (corner_rounding_) { - detectHorizontalCornerPattern(it.out, left, right, y, d1, d2); + detect_horizontal_corner_pattern(it.out, left, right, y, d1, d2); } } /* Edge at west */ if (edges[0] > 0.0f) { /* Did we already do diagonal search for this west edge from the left neighboring pixel? */ - if (isVerticalSearchUnneeded(x, y)) { + if (is_vertical_search_unneeded(x, y)) { continue; } /* Find the distance to the top and the bottom: */ - int top = searchYUp(x, y); - int bottom = searchYDown(x, y); + int top = search_yup(x, y); + int bottom = search_ydown(x, y); int d1 = y - top, d2 = bottom - y; /* Fetch the top and bottom crossing edges: */ @@ -622,30 +622,30 @@ void SMAABlendingWeightCalculationOperation::update_memory_buffer_partial( /* Fix corners: */ if (corner_rounding_) { - detectVerticalCornerPattern(it.out + 2, x, top, bottom, d1, d2); + detect_vertical_corner_pattern(it.out + 2, x, top, bottom, d1, d2); } } } } -void SMAABlendingWeightCalculationOperation::deinitExecution() +void SMAABlendingWeightCalculationOperation::deinit_execution() { - imageReader_ = nullptr; + image_reader_ = nullptr; } -bool SMAABlendingWeightCalculationOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool SMAABlendingWeightCalculationOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; - newInput.xmax = input->xmax + fmax(SMAA_MAX_SEARCH_STEPS, SMAA_MAX_SEARCH_STEPS_DIAG + 1); - newInput.xmin = input->xmin - - fmax(fmax(SMAA_MAX_SEARCH_STEPS - 1, 1), SMAA_MAX_SEARCH_STEPS_DIAG + 1); - newInput.ymax = input->ymax + fmax(SMAA_MAX_SEARCH_STEPS, SMAA_MAX_SEARCH_STEPS_DIAG); - newInput.ymin = input->ymin - - fmax(fmax(SMAA_MAX_SEARCH_STEPS - 1, 1), SMAA_MAX_SEARCH_STEPS_DIAG); + new_input.xmax = input->xmax + fmax(SMAA_MAX_SEARCH_STEPS, SMAA_MAX_SEARCH_STEPS_DIAG + 1); + new_input.xmin = input->xmin - + fmax(fmax(SMAA_MAX_SEARCH_STEPS - 1, 1), SMAA_MAX_SEARCH_STEPS_DIAG + 1); + new_input.ymax = input->ymax + fmax(SMAA_MAX_SEARCH_STEPS, SMAA_MAX_SEARCH_STEPS_DIAG); + new_input.ymin = input->ymin - + fmax(fmax(SMAA_MAX_SEARCH_STEPS - 1, 1), SMAA_MAX_SEARCH_STEPS_DIAG); - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void SMAABlendingWeightCalculationOperation::get_area_of_interest(const int UNUSED(input_idx), @@ -667,7 +667,7 @@ void SMAABlendingWeightCalculationOperation::get_area_of_interest(const int UNUS /** * These functions allows to perform diagonal pattern searches. */ -int SMAABlendingWeightCalculationOperation::searchDiag1(int x, int y, int dir, bool *found) +int SMAABlendingWeightCalculationOperation::search_diag1(int x, int y, int dir, bool *found) { float e[4]; int end = x + SMAA_MAX_SEARCH_STEPS_DIAG * dir; @@ -690,7 +690,7 @@ int SMAABlendingWeightCalculationOperation::searchDiag1(int x, int y, int dir, b return x - dir; } -int SMAABlendingWeightCalculationOperation::searchDiag2(int x, int y, int dir, bool *found) +int SMAABlendingWeightCalculationOperation::search_diag2(int x, int y, int dir, bool *found) { float e[4]; int end = x + SMAA_MAX_SEARCH_STEPS_DIAG * dir; @@ -717,10 +717,10 @@ int SMAABlendingWeightCalculationOperation::searchDiag2(int x, int y, int dir, b /** * This searches for diagonal patterns and returns the corresponding weights. */ -void SMAABlendingWeightCalculationOperation::calculateDiagWeights(int x, - int y, - const float edges[2], - float weights[2]) +void SMAABlendingWeightCalculationOperation::calculate_diag_weights(int x, + int y, + const float edges[2], + float weights[2]) { int d1, d2; bool d1_found, d2_found; @@ -734,13 +734,13 @@ void SMAABlendingWeightCalculationOperation::calculateDiagWeights(int x, /* Search for the line ends: */ if (edges[0] > 0.0f) { - d1 = x - searchDiag1(x, y, -1, &d1_found); + d1 = x - search_diag1(x, y, -1, &d1_found); } else { d1 = 0; d1_found = true; } - d2 = searchDiag1(x, y, 1, &d2_found) - x; + d2 = search_diag1(x, y, 1, &d2_found) - x; if (d1 + d2 > 2) { /* d1 + d2 + 1 > 3 */ int e1 = 0, e2 = 0; @@ -778,10 +778,10 @@ void SMAABlendingWeightCalculationOperation::calculateDiagWeights(int x, } /* Search for the line ends: */ - d1 = x - searchDiag2(x, y, -1, &d1_found); + d1 = x - search_diag2(x, y, -1, &d1_found); sample_image_fn_(x + 1, y, e); if (e[0] > 0.0f) { - d2 = searchDiag2(x, y, 1, &d2_found) - x; + d2 = search_diag2(x, y, 1, &d2_found) - x; } else { d2 = 0; @@ -826,7 +826,7 @@ void SMAABlendingWeightCalculationOperation::calculateDiagWeights(int x, } } -bool SMAABlendingWeightCalculationOperation::isVerticalSearchUnneeded(int x, int y) +bool SMAABlendingWeightCalculationOperation::is_vertical_search_unneeded(int x, int y) { int d1, d2; bool found; @@ -839,12 +839,12 @@ bool SMAABlendingWeightCalculationOperation::isVerticalSearchUnneeded(int x, int /* Search for the line ends: */ sample_image_fn_(x - 1, y, e); if (e[1] > 0.0f) { - d1 = x - searchDiag2(x - 1, y, -1, &found); + d1 = x - search_diag2(x - 1, y, -1, &found); } else { d1 = 0; } - d2 = searchDiag2(x - 1, y, 1, &found) - x; + d2 = search_diag2(x - 1, y, 1, &found) - x; return (d1 + d2 > 2); /* d1 + d2 + 1 > 3 */ } @@ -852,7 +852,7 @@ bool SMAABlendingWeightCalculationOperation::isVerticalSearchUnneeded(int x, int /*-----------------------------------------------------------------------------*/ /* Horizontal/Vertical Search Functions */ -int SMAABlendingWeightCalculationOperation::searchXLeft(int x, int y) +int SMAABlendingWeightCalculationOperation::search_xleft(int x, int y) { int end = x - SMAA_MAX_SEARCH_STEPS; float e[4]; @@ -875,7 +875,7 @@ int SMAABlendingWeightCalculationOperation::searchXLeft(int x, int y) return x + 1; } -int SMAABlendingWeightCalculationOperation::searchXRight(int x, int y) +int SMAABlendingWeightCalculationOperation::search_xright(int x, int y) { int end = x + SMAA_MAX_SEARCH_STEPS; float e[4]; @@ -896,7 +896,7 @@ int SMAABlendingWeightCalculationOperation::searchXRight(int x, int y) return x - 1; } -int SMAABlendingWeightCalculationOperation::searchYUp(int x, int y) +int SMAABlendingWeightCalculationOperation::search_yup(int x, int y) { int end = y - SMAA_MAX_SEARCH_STEPS; float e[4]; @@ -919,7 +919,7 @@ int SMAABlendingWeightCalculationOperation::searchYUp(int x, int y) return y + 1; } -int SMAABlendingWeightCalculationOperation::searchYDown(int x, int y) +int SMAABlendingWeightCalculationOperation::search_ydown(int x, int y) { int end = y + SMAA_MAX_SEARCH_STEPS; float e[4]; @@ -943,7 +943,7 @@ int SMAABlendingWeightCalculationOperation::searchYDown(int x, int y) /*-----------------------------------------------------------------------------*/ /* Corner Detection Functions */ -void SMAABlendingWeightCalculationOperation::detectHorizontalCornerPattern( +void SMAABlendingWeightCalculationOperation::detect_horizontal_corner_pattern( float weights[2], int left, int right, int y, int d1, int d2) { float factor[2] = {1.0f, 1.0f}; @@ -972,7 +972,7 @@ void SMAABlendingWeightCalculationOperation::detectHorizontalCornerPattern( weights[1] *= CLAMPIS(factor[1], 0.0f, 1.0f); } -void SMAABlendingWeightCalculationOperation::detectVerticalCornerPattern( +void SMAABlendingWeightCalculationOperation::detect_vertical_corner_pattern( float weights[2], int x, int top, int bottom, int d1, int d2) { float factor[2] = {1.0f, 1.0f}; @@ -1007,29 +1007,29 @@ void SMAABlendingWeightCalculationOperation::detectVerticalCornerPattern( SMAANeighborhoodBlendingOperation::SMAANeighborhoodBlendingOperation() { - this->addInputSocket(DataType::Color); /* image */ - this->addInputSocket(DataType::Color); /* blend */ - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); /* image */ + this->add_input_socket(DataType::Color); /* blend */ + this->add_output_socket(DataType::Color); this->flags.complex = true; image1Reader_ = nullptr; image2Reader_ = nullptr; } -void *SMAANeighborhoodBlendingOperation::initializeTileData(rcti *rect) +void *SMAANeighborhoodBlendingOperation::initialize_tile_data(rcti *rect) { - return getInputOperation(0)->initializeTileData(rect); + return get_input_operation(0)->initialize_tile_data(rect); } -void SMAANeighborhoodBlendingOperation::initExecution() +void SMAANeighborhoodBlendingOperation::init_execution() { - image1Reader_ = this->getInputSocketReader(0); - image2Reader_ = this->getInputSocketReader(1); + image1Reader_ = this->get_input_socket_reader(0); + image2Reader_ = this->get_input_socket_reader(1); } -void SMAANeighborhoodBlendingOperation::executePixel(float output[4], - int x, - int y, - void * /*data*/) +void SMAANeighborhoodBlendingOperation::execute_pixel(float output[4], + int x, + int y, + void * /*data*/) { float w[4]; @@ -1127,23 +1127,23 @@ void SMAANeighborhoodBlendingOperation::update_memory_buffer_partial(MemoryBuffe } } -void SMAANeighborhoodBlendingOperation::deinitExecution() +void SMAANeighborhoodBlendingOperation::deinit_execution() { image1Reader_ = nullptr; image2Reader_ = nullptr; } -bool SMAANeighborhoodBlendingOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool SMAANeighborhoodBlendingOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; - newInput.xmax = input->xmax + 1; - newInput.xmin = input->xmin - 1; - newInput.ymax = input->ymax + 1; - newInput.ymin = input->ymin - 1; + new_input.xmax = input->xmax + 1; + new_input.xmin = input->xmin - 1; + new_input.ymax = input->ymax + 1; + new_input.ymin = input->ymin - 1; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void SMAANeighborhoodBlendingOperation::get_area_of_interest(const int UNUSED(input_idx), diff --git a/source/blender/compositor/operations/COM_SMAAOperation.h b/source/blender/compositor/operations/COM_SMAAOperation.h index d4c9e128dca..65a88d43fdf 100644 --- a/source/blender/compositor/operations/COM_SMAAOperation.h +++ b/source/blender/compositor/operations/COM_SMAAOperation.h @@ -29,8 +29,8 @@ namespace blender::compositor { class SMAAEdgeDetectionOperation : public MultiThreadedOperation { protected: - SocketReader *imageReader_; - SocketReader *valueReader_; + SocketReader *image_reader_; + SocketReader *value_reader_; float threshold_; float contrast_limit_; @@ -41,25 +41,25 @@ class SMAAEdgeDetectionOperation : public MultiThreadedOperation { /** * the inner loop of this program */ - virtual void executePixel(float output[4], int x, int y, void *data) override; + virtual void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setThreshold(float threshold); + void set_threshold(float threshold); - void setLocalContrastAdaptationFactor(float factor); + void set_local_contrast_adaptation_factor(float factor); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, @@ -72,7 +72,7 @@ class SMAAEdgeDetectionOperation : public MultiThreadedOperation { class SMAABlendingWeightCalculationOperation : public MultiThreadedOperation { private: - SocketReader *imageReader_; + SocketReader *image_reader_; std::function sample_image_fn_; int corner_rounding_; @@ -82,24 +82,24 @@ class SMAABlendingWeightCalculationOperation : public MultiThreadedOperation { /** * the inner loop of this program */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; - void *initializeTileData(rcti *rect) override; + void init_execution() override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setCornerRounding(float rounding); + void set_corner_rounding(float rounding); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_started(MemoryBuffer *output, @@ -111,20 +111,22 @@ class SMAABlendingWeightCalculationOperation : public MultiThreadedOperation { private: /* Diagonal Search Functions */ - int searchDiag1(int x, int y, int dir, bool *found); - int searchDiag2(int x, int y, int dir, bool *found); - void calculateDiagWeights(int x, int y, const float edges[2], float weights[2]); - bool isVerticalSearchUnneeded(int x, int y); + int search_diag1(int x, int y, int dir, bool *found); + int search_diag2(int x, int y, int dir, bool *found); + void calculate_diag_weights(int x, int y, const float edges[2], float weights[2]); + bool is_vertical_search_unneeded(int x, int y); /* Horizontal/Vertical Search Functions */ - int searchXLeft(int x, int y); - int searchXRight(int x, int y); - int searchYUp(int x, int y); - int searchYDown(int x, int y); + int search_xleft(int x, int y); + int search_xright(int x, int y); + int search_yup(int x, int y); + int search_ydown(int x, int y); /* Corner Detection Functions */ - void detectHorizontalCornerPattern(float weights[2], int left, int right, int y, int d1, int d2); - void detectVerticalCornerPattern(float weights[2], int x, int top, int bottom, int d1, int d2); + void detect_horizontal_corner_pattern( + float weights[2], int left, int right, int y, int d1, int d2); + void detect_vertical_corner_pattern( + float weights[2], int x, int top, int bottom, int d1, int d2); }; /*-----------------------------------------------------------------------------*/ @@ -141,22 +143,22 @@ class SMAANeighborhoodBlendingOperation : public MultiThreadedOperation { /** * the inner loop of this program */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; - void *initializeTileData(rcti *rect) override; + void init_execution() override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, diff --git a/source/blender/compositor/operations/COM_ScaleOperation.cc b/source/blender/compositor/operations/COM_ScaleOperation.cc index 82878c1276f..350934b0d3b 100644 --- a/source/blender/compositor/operations/COM_ScaleOperation.cc +++ b/source/blender/compositor/operations/COM_ScaleOperation.cc @@ -49,20 +49,21 @@ ScaleOperation::ScaleOperation() : ScaleOperation(DataType::Color) ScaleOperation::ScaleOperation(DataType data_type) : BaseScaleOperation() { - this->addInputSocket(data_type, ResizeMode::None); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(data_type); - inputOperation_ = nullptr; - inputXOperation_ = nullptr; - inputYOperation_ = nullptr; + this->add_input_socket(data_type, ResizeMode::None); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(data_type); + input_operation_ = nullptr; + input_xoperation_ = nullptr; + input_yoperation_ = nullptr; } float ScaleOperation::get_constant_scale(const int input_op_idx, const float factor) { - const bool is_constant = getInputOperation(input_op_idx)->get_flags().is_constant_operation; + const bool is_constant = get_input_operation(input_op_idx)->get_flags().is_constant_operation; if (is_constant) { - return ((ConstantOperation *)getInputOperation(input_op_idx))->get_constant_elem()[0] * factor; + return ((ConstantOperation *)get_input_operation(input_op_idx))->get_constant_elem()[0] * + factor; } return 1.0f; @@ -112,22 +113,22 @@ void ScaleOperation::clamp_area_size_max(rcti &area, Size2f max_size) void ScaleOperation::init_data() { - canvas_center_x_ = canvas_.xmin + getWidth() / 2.0f; - canvas_center_y_ = canvas_.ymin + getHeight() / 2.0f; + canvas_center_x_ = canvas_.xmin + get_width() / 2.0f; + canvas_center_y_ = canvas_.ymin + get_height() / 2.0f; } -void ScaleOperation::initExecution() +void ScaleOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); - inputXOperation_ = this->getInputSocketReader(1); - inputYOperation_ = this->getInputSocketReader(2); + input_operation_ = this->get_input_socket_reader(0); + input_xoperation_ = this->get_input_socket_reader(1); + input_yoperation_ = this->get_input_socket_reader(2); } -void ScaleOperation::deinitExecution() +void ScaleOperation::deinit_execution() { - inputOperation_ = nullptr; - inputXOperation_ = nullptr; - inputYOperation_ = nullptr; + input_operation_ = nullptr; + input_xoperation_ = nullptr; + input_yoperation_ = nullptr; } void ScaleOperation::get_scale_offset(const rcti &input_canvas, @@ -171,8 +172,8 @@ void ScaleOperation::get_area_of_interest(const int input_idx, } NodeOperation *image_op = get_input_operation(IMAGE_INPUT_INDEX); - const float scale_x = get_constant_scale_x(image_op->getWidth()); - const float scale_y = get_constant_scale_y(image_op->getHeight()); + const float scale_x = get_constant_scale_x(image_op->get_width()); + const float scale_y = get_constant_scale_y(image_op->get_height()); get_scale_area_of_interest( image_op->get_canvas(), this->get_canvas(), scale_x, scale_y, output_area, r_input_area); @@ -184,8 +185,8 @@ void ScaleOperation::update_memory_buffer_partial(MemoryBuffer *output, Span inputs) { NodeOperation *input_image_op = get_input_operation(IMAGE_INPUT_INDEX); - const int input_image_width = input_image_op->getWidth(); - const int input_image_height = input_image_op->getHeight(); + const int input_image_width = input_image_op->get_width(); + const int input_image_height = input_image_op->get_height(); const float scale_x_factor = get_relative_scale_x_factor(input_image_width); const float scale_y_factor = get_relative_scale_y_factor(input_image_height); const float scale_center_x = input_image_width / 2.0f; @@ -219,12 +220,12 @@ void ScaleOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) } const bool image_determined = - getInputSocket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area); + get_input_socket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area); if (image_determined) { rcti image_canvas = r_area; rcti unused; - NodeOperationInput *x_socket = getInputSocket(X_INPUT_INDEX); - NodeOperationInput *y_socket = getInputSocket(Y_INPUT_INDEX); + NodeOperationInput *x_socket = get_input_socket(X_INPUT_INDEX); + NodeOperationInput *y_socket = get_input_socket(Y_INPUT_INDEX); x_socket->determine_canvas(image_canvas, unused); y_socket->determine_canvas(image_canvas, unused); if (is_scaling_variable()) { @@ -258,129 +259,128 @@ ScaleRelativeOperation::ScaleRelativeOperation(DataType data_type) : ScaleOperat { } -void ScaleRelativeOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ScaleRelativeOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - PixelSampler effective_sampler = getEffectiveSampler(sampler); + PixelSampler effective_sampler = get_effective_sampler(sampler); float scaleX[4]; float scaleY[4]; - inputXOperation_->readSampled(scaleX, x, y, effective_sampler); - inputYOperation_->readSampled(scaleY, x, y, effective_sampler); + input_xoperation_->read_sampled(scaleX, x, y, effective_sampler); + input_yoperation_->read_sampled(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; - inputOperation_->readSampled(output, nx, ny, effective_sampler); + input_operation_->read_sampled(output, nx, ny, effective_sampler); } -bool ScaleRelativeOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool ScaleRelativeOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; if (!variable_size_) { float scaleX[4]; float scaleY[4]; - inputXOperation_->readSampled(scaleX, 0, 0, PixelSampler::Nearest); - inputYOperation_->readSampled(scaleY, 0, 0, PixelSampler::Nearest); + input_xoperation_->read_sampled(scaleX, 0, 0, PixelSampler::Nearest); + input_yoperation_->read_sampled(scaleY, 0, 0, PixelSampler::Nearest); const float scx = scaleX[0]; const float scy = scaleY[0]; - newInput.xmax = this->canvas_center_x_ + (input->xmax - this->canvas_center_x_) / scx + 1; - newInput.xmin = this->canvas_center_x_ + (input->xmin - this->canvas_center_x_) / scx - 1; - newInput.ymax = this->canvas_center_y_ + (input->ymax - this->canvas_center_y_) / scy + 1; - newInput.ymin = this->canvas_center_y_ + (input->ymin - this->canvas_center_y_) / scy - 1; + new_input.xmax = this->canvas_center_x_ + (input->xmax - this->canvas_center_x_) / scx + 1; + new_input.xmin = this->canvas_center_x_ + (input->xmin - this->canvas_center_x_) / scx - 1; + new_input.ymax = this->canvas_center_y_ + (input->ymax - this->canvas_center_y_) / scy + 1; + new_input.ymin = this->canvas_center_y_ + (input->ymin - this->canvas_center_y_) / scy - 1; } else { - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; } - return BaseScaleOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return BaseScaleOperation::determine_depending_area_of_interest( + &new_input, read_operation, output); } -void ScaleAbsoluteOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ScaleAbsoluteOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - PixelSampler effective_sampler = getEffectiveSampler(sampler); + PixelSampler effective_sampler = get_effective_sampler(sampler); float scaleX[4]; float scaleY[4]; - inputXOperation_->readSampled(scaleX, x, y, effective_sampler); - inputYOperation_->readSampled(scaleY, x, y, effective_sampler); + input_xoperation_->read_sampled(scaleX, x, y, effective_sampler); + input_yoperation_->read_sampled(scaleY, x, y, effective_sampler); const float scx = scaleX[0]; /* Target absolute scale. */ const float scy = scaleY[0]; /* Target absolute scale. */ - const float width = this->getWidth(); - const float height = this->getHeight(); + const float width = this->get_width(); + const float height = this->get_height(); /* Divide. */ - float relativeXScale = scx / width; - float relativeYScale = scy / height; + float relative_xscale = scx / width; + float relative_yscale = scy / height; - float nx = this->canvas_center_x_ + (x - this->canvas_center_x_) / relativeXScale; - float ny = this->canvas_center_y_ + (y - this->canvas_center_y_) / relativeYScale; + float nx = this->canvas_center_x_ + (x - this->canvas_center_x_) / relative_xscale; + float ny = this->canvas_center_y_ + (y - this->canvas_center_y_) / relative_yscale; - inputOperation_->readSampled(output, nx, ny, effective_sampler); + input_operation_->read_sampled(output, nx, ny, effective_sampler); } -bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool ScaleAbsoluteOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; if (!variable_size_) { float scaleX[4]; float scaleY[4]; - inputXOperation_->readSampled(scaleX, 0, 0, PixelSampler::Nearest); - inputYOperation_->readSampled(scaleY, 0, 0, PixelSampler::Nearest); + input_xoperation_->read_sampled(scaleX, 0, 0, PixelSampler::Nearest); + input_yoperation_->read_sampled(scaleY, 0, 0, PixelSampler::Nearest); const float scx = scaleX[0]; const float scy = scaleY[0]; - const float width = this->getWidth(); - const float height = this->getHeight(); + const float width = this->get_width(); + const float height = this->get_height(); /* Divide. */ - float relateveXScale = scx / width; - float relateveYScale = scy / height; - - newInput.xmax = this->canvas_center_x_ + - (input->xmax - this->canvas_center_x_) / relateveXScale; - newInput.xmin = this->canvas_center_x_ + - (input->xmin - this->canvas_center_x_) / relateveXScale; - newInput.ymax = this->canvas_center_y_ + - (input->ymax - this->canvas_center_y_) / relateveYScale; - newInput.ymin = this->canvas_center_y_ + - (input->ymin - this->canvas_center_y_) / relateveYScale; + float relateve_xscale = scx / width; + float relateve_yscale = scy / height; + + new_input.xmax = this->canvas_center_x_ + + (input->xmax - this->canvas_center_x_) / relateve_xscale; + new_input.xmin = this->canvas_center_x_ + + (input->xmin - this->canvas_center_x_) / relateve_xscale; + new_input.ymax = this->canvas_center_y_ + + (input->ymax - this->canvas_center_y_) / relateve_yscale; + new_input.ymin = this->canvas_center_y_ + + (input->ymin - this->canvas_center_y_) / relateve_yscale; } else { - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; } - return ScaleOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return ScaleOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } /* Absolute fixed size. */ ScaleFixedSizeOperation::ScaleFixedSizeOperation() : BaseScaleOperation() { - this->addInputSocket(DataType::Color, ResizeMode::None); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color, ResizeMode::None); + this->add_output_socket(DataType::Color); this->set_canvas_input_index(0); - inputOperation_ = nullptr; + input_operation_ = nullptr; is_offset_ = false; } @@ -388,20 +388,20 @@ 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); - relX_ = input_width / (float)newWidth_; - relY_ = input_height / (float)newHeight_; + rel_x_ = input_width / (float)new_width_; + rel_y_ = input_height / (float)new_height_; /* *** all the options below are for a fairly special case - camera framing *** */ - if (offsetX_ != 0.0f || offsetY_ != 0.0f) { + if (offset_x_ != 0.0f || offset_y_ != 0.0f) { is_offset_ = true; - if (newWidth_ > newHeight_) { - offsetX_ *= newWidth_; - offsetY_ *= newWidth_; + if (new_width_ > new_height_) { + offset_x_ *= new_width_; + offset_y_ *= new_width_; } else { - offsetX_ *= newHeight_; - offsetY_ *= newHeight_; + offset_x_ *= new_height_; + offset_y_ *= new_height_; } } @@ -411,8 +411,8 @@ void ScaleFixedSizeOperation::init_data(const rcti &input_canvas) const float h_src = input_height; /* destination aspect is already applied from the camera frame */ - const float w_dst = newWidth_; - const float h_dst = newHeight_; + const float w_dst = new_width_; + const float h_dst = new_height_; const float asp_src = w_src / h_src; const float asp_dst = w_dst / h_dst; @@ -421,33 +421,33 @@ void ScaleFixedSizeOperation::init_data(const rcti &input_canvas) if ((asp_src > asp_dst) == (is_crop_ == true)) { /* fit X */ const float div = asp_src / asp_dst; - relX_ /= div; - offsetX_ += ((w_src - (w_src * div)) / (w_src / w_dst)) / 2.0f; + rel_x_ /= div; + offset_x_ += ((w_src - (w_src * div)) / (w_src / w_dst)) / 2.0f; if (is_crop_ && execution_model_ == eExecutionModel::FullFrame) { - int fit_width = newWidth_ * div; + int fit_width = new_width_ * div; if (fit_width > max_scale_canvas_size_.x) { fit_width = max_scale_canvas_size_.x; } - const int added_width = fit_width - newWidth_; - newWidth_ += added_width; - offsetX_ += added_width / 2.0f; + const int added_width = fit_width - new_width_; + new_width_ += added_width; + offset_x_ += added_width / 2.0f; } } else { /* fit Y */ const float div = asp_dst / asp_src; - relY_ /= div; - offsetY_ += ((h_src - (h_src * div)) / (h_src / h_dst)) / 2.0f; + rel_y_ /= div; + offset_y_ += ((h_src - (h_src * div)) / (h_src / h_dst)) / 2.0f; if (is_crop_ && execution_model_ == eExecutionModel::FullFrame) { - int fit_height = newHeight_ * div; + int fit_height = new_height_ * div; if (fit_height > max_scale_canvas_size_.y) { fit_height = max_scale_canvas_size_.y; } - const int added_height = fit_height - newHeight_; - newHeight_ += added_height; - offsetY_ += added_height / 2.0f; + const int added_height = fit_height - new_height_; + new_height_ += added_height; + offset_y_ += added_height / 2.0f; } } @@ -457,66 +457,67 @@ void ScaleFixedSizeOperation::init_data(const rcti &input_canvas) /* *** end framing options *** */ } -void ScaleFixedSizeOperation::initExecution() +void ScaleFixedSizeOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); + input_operation_ = this->get_input_socket_reader(0); } -void ScaleFixedSizeOperation::deinitExecution() +void ScaleFixedSizeOperation::deinit_execution() { - inputOperation_ = nullptr; + input_operation_ = nullptr; } -void ScaleFixedSizeOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ScaleFixedSizeOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - PixelSampler effective_sampler = getEffectiveSampler(sampler); + PixelSampler effective_sampler = get_effective_sampler(sampler); if (is_offset_) { - float nx = ((x - offsetX_) * relX_); - float ny = ((y - offsetY_) * relY_); - inputOperation_->readSampled(output, nx, ny, effective_sampler); + float nx = ((x - offset_x_) * rel_x_); + float ny = ((y - offset_y_) * rel_y_); + input_operation_->read_sampled(output, nx, ny, effective_sampler); } else { - inputOperation_->readSampled(output, x * relX_, y * relY_, effective_sampler); + input_operation_->read_sampled(output, x * rel_x_, y * rel_y_, effective_sampler); } } -bool ScaleFixedSizeOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool ScaleFixedSizeOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; + rcti new_input; - 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_; + new_input.xmax = (input->xmax - offset_x_) * rel_x_ + 1; + new_input.xmin = (input->xmin - offset_x_) * rel_x_; + new_input.ymax = (input->ymax - offset_y_) * rel_y_ + 1; + new_input.ymin = (input->ymin - offset_y_) * rel_y_; - return BaseScaleOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return BaseScaleOperation::determine_depending_area_of_interest( + &new_input, read_operation, output); } void ScaleFixedSizeOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { rcti local_preferred = preferred_area; - local_preferred.xmax = local_preferred.xmin + newWidth_; - local_preferred.ymax = local_preferred.ymin + newHeight_; + local_preferred.xmax = local_preferred.xmin + new_width_; + local_preferred.ymax = local_preferred.ymin + new_height_; rcti input_canvas; - const bool input_determined = getInputSocket(0)->determine_canvas(local_preferred, input_canvas); + const bool input_determined = get_input_socket(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 /= relX_; - r_area.ymin /= relY_; - r_area.xmin += offsetX_; - r_area.ymin += offsetY_; + r_area.xmin /= rel_x_; + r_area.ymin /= rel_y_; + r_area.xmin += offset_x_; + r_area.ymin += offset_y_; } - r_area.xmax = r_area.xmin + newWidth_; - r_area.ymax = r_area.ymin + newHeight_; + r_area.xmax = r_area.xmin + new_width_; + r_area.ymax = r_area.ymin + new_height_; } } @@ -527,10 +528,10 @@ 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 - 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_); + r_input_area.xmax = ceilf((output_area.xmax - offset_x_) * rel_x_); + r_input_area.xmin = floorf((output_area.xmin - offset_x_) * rel_x_); + r_input_area.ymax = ceilf((output_area.ymax - offset_y_) * rel_y_); + r_input_area.ymin = floorf((output_area.ymin - offset_y_) * rel_y_); expand_area_for_sampler(r_input_area, (PixelSampler)sampler_); } @@ -543,15 +544,15 @@ void ScaleFixedSizeOperation::update_memory_buffer_partial(MemoryBuffer *output, BuffersIterator it = output->iterate_with({}, area); if (is_offset_) { for (; !it.is_end(); ++it) { - const float nx = (canvas_.xmin + it.x - offsetX_) * relX_; - const float ny = (canvas_.ymin + it.y - offsetY_) * relY_; + const float nx = (canvas_.xmin + it.x - offset_x_) * rel_x_; + const float ny = (canvas_.ymin + it.y - offset_y_) * rel_y_; 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) * relX_ - canvas_.xmin, - (canvas_.ymin + it.y) * relY_ - canvas_.ymin, + input_img->read_elem_sampled((canvas_.xmin + it.x) * rel_x_ - canvas_.xmin, + (canvas_.ymin + it.y) * rel_y_ - canvas_.ymin, sampler, it.out); } diff --git a/source/blender/compositor/operations/COM_ScaleOperation.h b/source/blender/compositor/operations/COM_ScaleOperation.h index 868a17bc394..7710aa34c54 100644 --- a/source/blender/compositor/operations/COM_ScaleOperation.h +++ b/source/blender/compositor/operations/COM_ScaleOperation.h @@ -27,11 +27,11 @@ class BaseScaleOperation : public MultiThreadedOperation { static constexpr float DEFAULT_MAX_SCALE_CANVAS_SIZE = 12000; public: - void setSampler(PixelSampler sampler) + void set_sampler(PixelSampler sampler) { sampler_ = (int)sampler; } - void setVariableSize(bool variable_size) + void set_variable_size(bool variable_size) { variable_size_ = variable_size; }; @@ -41,7 +41,7 @@ class BaseScaleOperation : public MultiThreadedOperation { protected: BaseScaleOperation(); - PixelSampler getEffectiveSampler(PixelSampler sampler) + PixelSampler get_effective_sampler(PixelSampler sampler) { return (sampler_ == -1) ? sampler : (PixelSampler)sampler_; } @@ -61,9 +61,9 @@ class ScaleOperation : public BaseScaleOperation { static constexpr int X_INPUT_INDEX = 1; static constexpr int Y_INPUT_INDEX = 2; - SocketReader *inputOperation_; - SocketReader *inputXOperation_; - SocketReader *inputYOperation_; + SocketReader *input_operation_; + SocketReader *input_xoperation_; + SocketReader *input_yoperation_; float canvas_center_x_; float canvas_center_y_; @@ -97,8 +97,8 @@ class ScaleOperation : public BaseScaleOperation { static void clamp_area_size_max(rcti &area, Size2f max_size); void init_data() override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, @@ -122,10 +122,10 @@ class ScaleRelativeOperation : public ScaleOperation { public: ScaleRelativeOperation(); ScaleRelativeOperation(DataType data_type); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; float get_relative_scale_x_factor(float UNUSED(width)) override { @@ -140,10 +140,10 @@ class ScaleRelativeOperation : public ScaleOperation { class ScaleAbsoluteOperation : public ScaleOperation { public: - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; float get_relative_scale_x_factor(float width) override { @@ -157,15 +157,15 @@ class ScaleAbsoluteOperation : public ScaleOperation { }; class ScaleFixedSizeOperation : public BaseScaleOperation { - SocketReader *inputOperation_; - int newWidth_; - int newHeight_; - float relX_; - float relY_; + SocketReader *input_operation_; + int new_width_; + int new_height_; + float rel_x_; + float rel_y_; /* center is only used for aspect correction */ - float offsetX_; - float offsetY_; + float offset_x_; + float offset_y_; bool is_aspect_; bool is_crop_; /* set from other properties on initialization, @@ -174,34 +174,34 @@ class ScaleFixedSizeOperation : public BaseScaleOperation { public: ScaleFixedSizeOperation(); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; - void setNewWidth(int width) + void init_execution() override; + void deinit_execution() override; + void set_new_width(int width) { - newWidth_ = width; + new_width_ = width; } - void setNewHeight(int height) + void set_new_height(int height) { - newHeight_ = height; + new_height_ = height; } - void setIsAspect(bool is_aspect) + void set_is_aspect(bool is_aspect) { is_aspect_ = is_aspect; } - void setIsCrop(bool is_crop) + void set_is_crop(bool is_crop) { is_crop_ = is_crop; } - void setOffset(float x, float y) + void set_offset(float x, float y) { - offsetX_ = x; - offsetY_ = y; + offset_x_ = x; + offset_y_ = 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 3892d76874c..1ce0378c335 100644 --- a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cc +++ b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cc @@ -28,12 +28,12 @@ namespace blender::compositor { ScreenLensDistortionOperation::ScreenLensDistortionOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); this->flags.complex = true; - inputProgram_ = nullptr; + input_program_ = nullptr; distortion_ = 0.0f; dispersion_ = 0.0f; distortion_const_ = false; @@ -41,13 +41,13 @@ ScreenLensDistortionOperation::ScreenLensDistortionOperation() variables_ready_ = false; } -void ScreenLensDistortionOperation::setDistortion(float distortion) +void ScreenLensDistortionOperation::set_distortion(float distortion) { distortion_ = distortion; distortion_const_ = true; } -void ScreenLensDistortionOperation::setDispersion(float dispersion) +void ScreenLensDistortionOperation::set_dispersion(float dispersion) { dispersion_ = dispersion; dispersion_const_ = true; @@ -55,8 +55,8 @@ void ScreenLensDistortionOperation::setDispersion(float dispersion) void ScreenLensDistortionOperation::init_data() { - cx_ = 0.5f * (float)getWidth(); - cy_ = 0.5f * (float)getHeight(); + cx_ = 0.5f * (float)get_width(); + cy_ = 0.5f * (float)get_height(); switch (execution_model_) { case eExecutionModel::FullFrame: { @@ -68,13 +68,13 @@ void ScreenLensDistortionOperation::init_data() if (!dispersion_const_ && distortion_op->get_flags().is_constant_operation) { dispersion_ = static_cast(dispersion_op)->get_constant_elem()[0]; } - updateVariables(distortion_, dispersion_); + update_variables(distortion_, dispersion_); break; } case eExecutionModel::Tiled: { /* If both are constant, init variables once. */ if (distortion_const_ && dispersion_const_) { - updateVariables(distortion_, dispersion_); + update_variables(distortion_, dispersion_); variables_ready_ = true; } break; @@ -82,42 +82,42 @@ void ScreenLensDistortionOperation::init_data() } } -void ScreenLensDistortionOperation::initExecution() +void ScreenLensDistortionOperation::init_execution() { - inputProgram_ = this->getInputSocketReader(0); - this->initMutex(); + input_program_ = this->get_input_socket_reader(0); + this->init_mutex(); uint rng_seed = (uint)(PIL_check_seconds_timer_i() & UINT_MAX); - rng_seed ^= (uint)POINTER_AS_INT(inputProgram_); + rng_seed ^= (uint)POINTER_AS_INT(input_program_); rng_ = BLI_rng_new(rng_seed); } -void *ScreenLensDistortionOperation::initializeTileData(rcti * /*rect*/) +void *ScreenLensDistortionOperation::initialize_tile_data(rcti * /*rect*/) { - void *buffer = inputProgram_->initializeTileData(nullptr); + void *buffer = input_program_->initialize_tile_data(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 (!variables_ready_) { - this->lockMutex(); + this->lock_mutex(); if (!distortion_const_) { float result[4]; - getInputSocketReader(1)->readSampled(result, 0, 0, PixelSampler::Nearest); + get_input_socket_reader(1)->read_sampled(result, 0, 0, PixelSampler::Nearest); distortion_ = result[0]; } if (!dispersion_const_) { float result[4]; - getInputSocketReader(2)->readSampled(result, 0, 0, PixelSampler::Nearest); + get_input_socket_reader(2)->read_sampled(result, 0, 0, PixelSampler::Nearest); dispersion_ = result[0]; } - updateVariables(distortion_, dispersion_); + update_variables(distortion_, dispersion_); variables_ready_ = true; - this->unlockMutex(); + this->unlock_mutex(); } return buffer; @@ -132,8 +132,8 @@ void ScreenLensDistortionOperation::get_uv(const float xy[2], float uv[2]) const void ScreenLensDistortionOperation::distort_uv(const float uv[2], float t, float xy[2]) const { float d = 1.0f / (1.0f + sqrtf(t)); - xy[0] = (uv[0] * d + 0.5f) * getWidth() - 0.5f; - xy[1] = (uv[1] * d + 0.5f) * getHeight() - 0.5f; + xy[0] = (uv[0] * d + 0.5f) * get_width() - 0.5f; + xy[1] = (uv[1] * d + 0.5f) * get_height() - 0.5f; } bool ScreenLensDistortionOperation::get_delta(float r_sq, @@ -176,7 +176,7 @@ void ScreenLensDistortionOperation::accumulate(const MemoryBuffer *buffer, distort_uv(uv, t, xy); switch (execution_model_) { case eExecutionModel::Tiled: - buffer->readBilinear(color, xy[0], xy[1]); + buffer->read_bilinear(color, xy[0], xy[1]); break; case eExecutionModel::FullFrame: buffer->read_elem_bilinear(xy[0], xy[1], color); @@ -190,7 +190,7 @@ void ScreenLensDistortionOperation::accumulate(const MemoryBuffer *buffer, } } -void ScreenLensDistortionOperation::executePixel(float output[4], int x, int y, void *data) +void ScreenLensDistortionOperation::execute_pixel(float output[4], int x, int y, void *data) { MemoryBuffer *buffer = (MemoryBuffer *)data; float xy[2] = {(float)x, (float)y}; @@ -228,10 +228,10 @@ void ScreenLensDistortionOperation::executePixel(float output[4], int x, int y, } } -void ScreenLensDistortionOperation::deinitExecution() +void ScreenLensDistortionOperation::deinit_execution() { - this->deinitMutex(); - inputProgram_ = nullptr; + this->deinit_mutex(); + input_program_ = nullptr; BLI_rng_free(rng_); } @@ -250,22 +250,22 @@ void ScreenLensDistortionOperation::determineUV(float result[6], float x, float get_delta(uv_dot, k4_[2], uv, result + 4); } -bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( - rcti * /*input*/, ReadBufferOperation *readOperation, rcti *output) +bool ScreenLensDistortionOperation::determine_depending_area_of_interest( + rcti * /*input*/, ReadBufferOperation *read_operation, rcti *output) { - rcti newInputValue; - newInputValue.xmin = 0; - newInputValue.ymin = 0; - newInputValue.xmax = 2; - newInputValue.ymax = 2; - - NodeOperation *operation = getInputOperation(1); - if (operation->determineDependingAreaOfInterest(&newInputValue, readOperation, output)) { + rcti new_input_value; + new_input_value.xmin = 0; + new_input_value.ymin = 0; + new_input_value.xmax = 2; + new_input_value.ymax = 2; + + NodeOperation *operation = get_input_operation(1); + if (operation->determine_depending_area_of_interest(&new_input_value, read_operation, output)) { return true; } - operation = getInputOperation(2); - if (operation->determineDependingAreaOfInterest(&newInputValue, readOperation, output)) { + operation = get_input_operation(2); + if (operation->determine_depending_area_of_interest(&new_input_value, read_operation, output)) { return true; } @@ -275,23 +275,23 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( * So now just use the full image area, which may not be as efficient but works at least ... */ #if 1 - rcti imageInput; + rcti image_input; - operation = getInputOperation(0); - imageInput.xmax = operation->getWidth(); - imageInput.xmin = 0; - imageInput.ymax = operation->getHeight(); - imageInput.ymin = 0; + operation = get_input_operation(0); + image_input.xmax = operation->get_width(); + image_input.xmin = 0; + image_input.ymax = operation->get_height(); + image_input.ymin = 0; - if (operation->determineDependingAreaOfInterest(&imageInput, readOperation, output)) { + if (operation->determine_depending_area_of_interest(&image_input, read_operation, output)) { return true; } return false; #else - rcti newInput; + rcti new_input; const float margin = 2; - BLI_rcti_init_minmax(&newInput); + BLI_rcti_init_minmax(&new_input); if (dispersion_const_ && distortion_const_) { /* update from fixed distortion/dispersion */ @@ -299,10 +299,10 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( { \ float coords[6]; \ determineUV(coords, x, y); \ - newInput.xmin = min_ffff(newInput.xmin, coords[0], coords[2], coords[4]); \ - newInput.ymin = min_ffff(newInput.ymin, coords[1], coords[3], coords[5]); \ - newInput.xmax = max_ffff(newInput.xmax, coords[0], coords[2], coords[4]); \ - newInput.ymax = max_ffff(newInput.ymax, coords[1], coords[3], coords[5]); \ + new_input.xmin = min_ffff(new_input.xmin, coords[0], coords[2], coords[4]); \ + new_input.ymin = min_ffff(new_input.ymin, coords[1], coords[3], coords[5]); \ + new_input.xmax = max_ffff(new_input.xmax, coords[0], coords[2], coords[4]); \ + new_input.ymax = max_ffff(new_input.ymax, coords[1], coords[3], coords[5]); \ } \ (void)0 @@ -320,12 +320,12 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( # define UPDATE_INPUT(x, y, distortion) \ { \ float coords[6]; \ - updateVariables(distortion, dispersion); \ + update_variables(distortion, dispersion); \ determineUV(coords, x, y); \ - newInput.xmin = min_ffff(newInput.xmin, coords[0], coords[2], coords[4]); \ - newInput.ymin = min_ffff(newInput.ymin, coords[1], coords[3], coords[5]); \ - newInput.xmax = max_ffff(newInput.xmax, coords[0], coords[2], coords[4]); \ - newInput.ymax = max_ffff(newInput.ymax, coords[1], coords[3], coords[5]); \ + new_input.xmin = min_ffff(new_input.xmin, coords[0], coords[2], coords[4]); \ + new_input.ymin = min_ffff(new_input.ymin, coords[1], coords[3], coords[5]); \ + new_input.xmax = max_ffff(new_input.xmax, coords[0], coords[2], coords[4]); \ + new_input.ymax = max_ffff(new_input.ymax, coords[1], coords[3], coords[5]); \ } \ (void)0 @@ -352,20 +352,20 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest( } } - newInput.xmin -= margin; - newInput.ymin -= margin; - newInput.xmax += margin; - newInput.ymax += margin; + new_input.xmin -= margin; + new_input.ymin -= margin; + new_input.xmax += margin; + new_input.ymax += margin; - operation = getInputOperation(0); - if (operation->determineDependingAreaOfInterest(&newInput, readOperation, output)) { + operation = get_input_operation(0); + if (operation->determine_depending_area_of_interest(&new_input, read_operation, output)) { return true; } return false; #endif } -void ScreenLensDistortionOperation::updateVariables(float distortion, float dispersion) +void ScreenLensDistortionOperation::update_variables(float distortion, float dispersion) { k_[1] = max_ff(min_ff(distortion, 1.0f), -0.999f); /* Smaller dispersion range for somewhat more control. */ @@ -413,14 +413,14 @@ void ScreenLensDistortionOperation::get_area_of_interest(const int input_idx, * So now just use the full image area, which may not be as efficient but works at least ... */ #if 1 - NodeOperation *image = getInputOperation(0); + NodeOperation *image = get_input_operation(0); r_input_area = image->get_canvas(); #else /* Original method in tiled implementation. */ - rcti newInput; + rcti new_input; const float margin = 2; - BLI_rcti_init_minmax(&newInput); + BLI_rcti_init_minmax(&new_input); if (dispersion_const_ && distortion_const_) { /* update from fixed distortion/dispersion */ @@ -428,10 +428,10 @@ void ScreenLensDistortionOperation::get_area_of_interest(const int input_idx, { \ float coords[6]; \ determineUV(coords, x, y); \ - newInput.xmin = min_ffff(newInput.xmin, coords[0], coords[2], coords[4]); \ - newInput.ymin = min_ffff(newInput.ymin, coords[1], coords[3], coords[5]); \ - newInput.xmax = max_ffff(newInput.xmax, coords[0], coords[2], coords[4]); \ - newInput.ymax = max_ffff(newInput.ymax, coords[1], coords[3], coords[5]); \ + new_input.xmin = min_ffff(new_input.xmin, coords[0], coords[2], coords[4]); \ + new_input.ymin = min_ffff(new_input.ymin, coords[1], coords[3], coords[5]); \ + new_input.xmax = max_ffff(new_input.xmax, coords[0], coords[2], coords[4]); \ + new_input.ymax = max_ffff(new_input.ymax, coords[1], coords[3], coords[5]); \ } \ (void)0 @@ -449,12 +449,12 @@ void ScreenLensDistortionOperation::get_area_of_interest(const int input_idx, # define UPDATE_INPUT(x, y, distortion) \ { \ float coords[6]; \ - updateVariables(distortion, dispersion); \ + update_variables(distortion, dispersion); \ determineUV(coords, x, y); \ - newInput.xmin = min_ffff(newInput.xmin, coords[0], coords[2], coords[4]); \ - newInput.ymin = min_ffff(newInput.ymin, coords[1], coords[3], coords[5]); \ - newInput.xmax = max_ffff(newInput.xmax, coords[0], coords[2], coords[4]); \ - newInput.ymax = max_ffff(newInput.ymax, coords[1], coords[3], coords[5]); \ + new_input.xmin = min_ffff(new_input.xmin, coords[0], coords[2], coords[4]); \ + new_input.ymin = min_ffff(new_input.ymin, coords[1], coords[3], coords[5]); \ + new_input.xmax = max_ffff(new_input.xmax, coords[0], coords[2], coords[4]); \ + new_input.ymax = max_ffff(new_input.ymax, coords[1], coords[3], coords[5]); \ } \ (void)0 @@ -481,13 +481,13 @@ void ScreenLensDistortionOperation::get_area_of_interest(const int input_idx, } } - newInput.xmin -= margin; - newInput.ymin -= margin; - newInput.xmax += margin; - newInput.ymax += margin; + new_input.xmin -= margin; + new_input.ymin -= margin; + new_input.xmax += margin; + new_input.ymax += margin; - operation = getInputOperation(0); - if (operation->determineDependingAreaOfInterest(&newInput, readOperation, output)) { + operation = get_input_operation(0); + if (operation->determine_depending_area_of_interest(&new_input, read_operation, output)) { return true; } return false; diff --git a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h index 8962ee09290..fb610b90466 100644 --- a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h +++ b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h @@ -28,9 +28,9 @@ namespace blender::compositor { class ScreenLensDistortionOperation : public MultiThreadedOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; struct RNG *rng_; bool fit_; @@ -55,36 +55,36 @@ class ScreenLensDistortionOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setFit(bool fit) + void set_fit(bool fit) { fit_ = fit; } - void setJitter(bool jitter) + void set_jitter(bool jitter) { jitter_ = jitter; } /** Set constant distortion value */ - void setDistortion(float distortion); + void set_distortion(float distortion); /** Set constant dispersion value */ - void setDispersion(float dispersion); + void set_dispersion(float dispersion); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; @@ -94,7 +94,7 @@ class ScreenLensDistortionOperation : public MultiThreadedOperation { private: void determineUV(float result[6], float x, float y) const; - void updateVariables(float distortion, float dispersion); + void update_variables(float distortion, float dispersion); void get_uv(const float xy[2], float uv[2]) const; void distort_uv(const float uv[2], float t, float xy[2]) const; diff --git a/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.cc b/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.cc index 2f11e1dbb18..a1ea5758a83 100644 --- a/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.cc +++ b/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.cc @@ -22,39 +22,39 @@ namespace blender::compositor { SetAlphaMultiplyOperation::SetAlphaMultiplyOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); - inputColor_ = nullptr; - inputAlpha_ = nullptr; + input_color_ = nullptr; + input_alpha_ = nullptr; this->flags.can_be_constant = true; } -void SetAlphaMultiplyOperation::initExecution() +void SetAlphaMultiplyOperation::init_execution() { - inputColor_ = getInputSocketReader(0); - inputAlpha_ = getInputSocketReader(1); + input_color_ = get_input_socket_reader(0); + input_alpha_ = get_input_socket_reader(1); } -void SetAlphaMultiplyOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void SetAlphaMultiplyOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float color_input[4]; float alpha_input[4]; - inputColor_->readSampled(color_input, x, y, sampler); - inputAlpha_->readSampled(alpha_input, x, y, sampler); + input_color_->read_sampled(color_input, x, y, sampler); + input_alpha_->read_sampled(alpha_input, x, y, sampler); mul_v4_v4fl(output, color_input, alpha_input[0]); } -void SetAlphaMultiplyOperation::deinitExecution() +void SetAlphaMultiplyOperation::deinit_execution() { - inputColor_ = nullptr; - inputAlpha_ = nullptr; + input_color_ = nullptr; + input_alpha_ = 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 77f61e976e1..2aa56800ff7 100644 --- a/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.h +++ b/source/blender/compositor/operations/COM_SetAlphaMultiplyOperation.h @@ -29,16 +29,16 @@ namespace blender::compositor { */ class SetAlphaMultiplyOperation : public MultiThreadedOperation { private: - SocketReader *inputColor_; - SocketReader *inputAlpha_; + SocketReader *input_color_; + SocketReader *input_alpha_; public: SetAlphaMultiplyOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.cc b/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.cc index 09539d2fe57..649e6ce0a4e 100644 --- a/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.cc +++ b/source/blender/compositor/operations/COM_SetAlphaReplaceOperation.cc @@ -22,37 +22,37 @@ namespace blender::compositor { SetAlphaReplaceOperation::SetAlphaReplaceOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); - inputColor_ = nullptr; - inputAlpha_ = nullptr; + input_color_ = nullptr; + input_alpha_ = nullptr; this->flags.can_be_constant = true; } -void SetAlphaReplaceOperation::initExecution() +void SetAlphaReplaceOperation::init_execution() { - inputColor_ = getInputSocketReader(0); - inputAlpha_ = getInputSocketReader(1); + input_color_ = get_input_socket_reader(0); + input_alpha_ = get_input_socket_reader(1); } -void SetAlphaReplaceOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void SetAlphaReplaceOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float alpha_input[4]; - inputColor_->readSampled(output, x, y, sampler); - inputAlpha_->readSampled(alpha_input, x, y, sampler); + input_color_->read_sampled(output, x, y, sampler); + input_alpha_->read_sampled(alpha_input, x, y, sampler); output[3] = alpha_input[0]; } -void SetAlphaReplaceOperation::deinitExecution() +void SetAlphaReplaceOperation::deinit_execution() { - inputColor_ = nullptr; - inputAlpha_ = nullptr; + input_color_ = nullptr; + input_alpha_ = 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 9c295eec3bd..ea27e6af672 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 *inputColor_; - SocketReader *inputAlpha_; + SocketReader *input_color_; + SocketReader *input_alpha_; public: /** @@ -40,10 +40,10 @@ class SetAlphaReplaceOperation : public MultiThreadedOperation { /** * the inner loop of this program */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_SetColorOperation.cc b/source/blender/compositor/operations/COM_SetColorOperation.cc index 8700ba7496b..2f89e6722fa 100644 --- a/source/blender/compositor/operations/COM_SetColorOperation.cc +++ b/source/blender/compositor/operations/COM_SetColorOperation.cc @@ -22,14 +22,14 @@ namespace blender::compositor { SetColorOperation::SetColorOperation() { - this->addOutputSocket(DataType::Color); + this->add_output_socket(DataType::Color); flags.is_set_operation = true; } -void SetColorOperation::executePixelSampled(float output[4], - float /*x*/, - float /*y*/, - PixelSampler /*sampler*/) +void SetColorOperation::execute_pixel_sampled(float output[4], + float /*x*/, + float /*y*/, + PixelSampler /*sampler*/) { copy_v4_v4(output, color_); } diff --git a/source/blender/compositor/operations/COM_SetColorOperation.h b/source/blender/compositor/operations/COM_SetColorOperation.h index ad30c1d820d..0e04c0324b8 100644 --- a/source/blender/compositor/operations/COM_SetColorOperation.h +++ b/source/blender/compositor/operations/COM_SetColorOperation.h @@ -41,39 +41,39 @@ class SetColorOperation : public ConstantOperation { return color_; } - float getChannel1() + float get_channel1() { return color_[0]; } - void setChannel1(float value) + void set_channel1(float value) { color_[0] = value; } - float getChannel2() + float get_channel2() { return color_[1]; } - void setChannel2(float value) + void set_channel2(float value) { color_[1] = value; } - float getChannel3() + float get_channel3() { return color_[2]; } - void setChannel3(float value) + void set_channel3(float value) { color_[2] = value; } - float getChannel4() + float get_channel4() { return color_[3]; } - void setChannel4(const float value) + void set_channel4(const float value) { color_[3] = value; } - void setChannels(const float value[4]) + void set_channels(const float value[4]) { copy_v4_v4(color_, value); } @@ -81,7 +81,7 @@ class SetColorOperation : public ConstantOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; }; diff --git a/source/blender/compositor/operations/COM_SetSamplerOperation.cc b/source/blender/compositor/operations/COM_SetSamplerOperation.cc index 7919b885556..6f5ac63317b 100644 --- a/source/blender/compositor/operations/COM_SetSamplerOperation.cc +++ b/source/blender/compositor/operations/COM_SetSamplerOperation.cc @@ -22,25 +22,25 @@ namespace blender::compositor { SetSamplerOperation::SetSamplerOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); } -void SetSamplerOperation::initExecution() +void SetSamplerOperation::init_execution() { - reader_ = this->getInputSocketReader(0); + reader_ = this->get_input_socket_reader(0); } -void SetSamplerOperation::deinitExecution() +void SetSamplerOperation::deinit_execution() { reader_ = nullptr; } -void SetSamplerOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void SetSamplerOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { - reader_->readSampled(output, x, y, sampler_); + reader_->read_sampled(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 87b232cbfa7..27ef6603ae4 100644 --- a/source/blender/compositor/operations/COM_SetSamplerOperation.h +++ b/source/blender/compositor/operations/COM_SetSamplerOperation.h @@ -37,7 +37,7 @@ class SetSamplerOperation : public NodeOperation { */ SetSamplerOperation(); - void setSampler(PixelSampler sampler) + void set_sampler(PixelSampler sampler) { sampler_ = sampler; } @@ -45,9 +45,9 @@ class SetSamplerOperation : public NodeOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; + void init_execution() override; + void deinit_execution() override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_SetValueOperation.cc b/source/blender/compositor/operations/COM_SetValueOperation.cc index b5e2f50338f..9cd4bed0750 100644 --- a/source/blender/compositor/operations/COM_SetValueOperation.cc +++ b/source/blender/compositor/operations/COM_SetValueOperation.cc @@ -22,14 +22,14 @@ namespace blender::compositor { SetValueOperation::SetValueOperation() { - this->addOutputSocket(DataType::Value); + this->add_output_socket(DataType::Value); flags.is_set_operation = true; } -void SetValueOperation::executePixelSampled(float output[4], - float /*x*/, - float /*y*/, - PixelSampler /*sampler*/) +void SetValueOperation::execute_pixel_sampled(float output[4], + float /*x*/, + float /*y*/, + PixelSampler /*sampler*/) { output[0] = value_; } diff --git a/source/blender/compositor/operations/COM_SetValueOperation.h b/source/blender/compositor/operations/COM_SetValueOperation.h index bf914d2f918..4c824d00294 100644 --- a/source/blender/compositor/operations/COM_SetValueOperation.h +++ b/source/blender/compositor/operations/COM_SetValueOperation.h @@ -41,11 +41,11 @@ class SetValueOperation : public ConstantOperation { return &value_; } - float getValue() + float get_value() { return value_; } - void setValue(float value) + void set_value(float value) { value_ = value; } @@ -53,7 +53,7 @@ class SetValueOperation : public ConstantOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; }; diff --git a/source/blender/compositor/operations/COM_SetVectorOperation.cc b/source/blender/compositor/operations/COM_SetVectorOperation.cc index 6f0a947c52d..47f13f10fee 100644 --- a/source/blender/compositor/operations/COM_SetVectorOperation.cc +++ b/source/blender/compositor/operations/COM_SetVectorOperation.cc @@ -22,14 +22,14 @@ namespace blender::compositor { SetVectorOperation::SetVectorOperation() { - this->addOutputSocket(DataType::Vector); + this->add_output_socket(DataType::Vector); flags.is_set_operation = true; } -void SetVectorOperation::executePixelSampled(float output[4], - float /*x*/, - float /*y*/, - PixelSampler /*sampler*/) +void SetVectorOperation::execute_pixel_sampled(float output[4], + float /*x*/, + float /*y*/, + PixelSampler /*sampler*/) { output[0] = vector_.x; output[1] = vector_.y; diff --git a/source/blender/compositor/operations/COM_SetVectorOperation.h b/source/blender/compositor/operations/COM_SetVectorOperation.h index 920ea8051e4..291fef37817 100644 --- a/source/blender/compositor/operations/COM_SetVectorOperation.h +++ b/source/blender/compositor/operations/COM_SetVectorOperation.h @@ -82,11 +82,11 @@ class SetVectorOperation : public ConstantOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void setVector(const float vector[3]) + void set_vector(const float vector[3]) { setX(vector[0]); setY(vector[1]); diff --git a/source/blender/compositor/operations/COM_SocketProxyOperation.cc b/source/blender/compositor/operations/COM_SocketProxyOperation.cc index 39876439b7b..18a09362591 100644 --- a/source/blender/compositor/operations/COM_SocketProxyOperation.cc +++ b/source/blender/compositor/operations/COM_SocketProxyOperation.cc @@ -22,15 +22,15 @@ namespace blender::compositor { SocketProxyOperation::SocketProxyOperation(DataType type, bool use_conversion) { - this->addInputSocket(type); - this->addOutputSocket(type); + this->add_input_socket(type); + this->add_output_socket(type); flags.is_proxy_operation = true; flags.use_datatype_conversion = use_conversion; } -std::unique_ptr SocketProxyOperation::getMetaData() +std::unique_ptr SocketProxyOperation::get_meta_data() { - return this->getInputSocket(0)->getReader()->getMetaData(); + return this->get_input_socket(0)->get_reader()->get_meta_data(); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_SocketProxyOperation.h b/source/blender/compositor/operations/COM_SocketProxyOperation.h index 1d3b76055bd..e9740cf43bc 100644 --- a/source/blender/compositor/operations/COM_SocketProxyOperation.h +++ b/source/blender/compositor/operations/COM_SocketProxyOperation.h @@ -26,7 +26,7 @@ class SocketProxyOperation : public NodeOperation { public: SocketProxyOperation(DataType type, bool use_conversion); - std::unique_ptr getMetaData() override; + std::unique_ptr get_meta_data() override; }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_SplitOperation.cc b/source/blender/compositor/operations/COM_SplitOperation.cc index 99db558343d..e98c5c986f5 100644 --- a/source/blender/compositor/operations/COM_SplitOperation.cc +++ b/source/blender/compositor/operations/COM_SplitOperation.cc @@ -22,39 +22,39 @@ namespace blender::compositor { SplitOperation::SplitOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); image1Input_ = nullptr; image2Input_ = nullptr; } -void SplitOperation::initExecution() +void SplitOperation::init_execution() { /* When initializing the tree during initial load the width and height can be zero. */ - image1Input_ = getInputSocketReader(0); - image2Input_ = getInputSocketReader(1); + image1Input_ = get_input_socket_reader(0); + image2Input_ = get_input_socket_reader(1); } -void SplitOperation::deinitExecution() +void SplitOperation::deinit_execution() { image1Input_ = nullptr; image2Input_ = nullptr; } -void SplitOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void SplitOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { - int perc = xSplit_ ? splitPercentage_ * this->getWidth() / 100.0f : - splitPercentage_ * this->getHeight() / 100.0f; - bool image1 = xSplit_ ? x > perc : y > perc; + int perc = x_split_ ? split_percentage_ * this->get_width() / 100.0f : + split_percentage_ * this->get_height() / 100.0f; + bool image1 = x_split_ ? x > perc : y > perc; if (image1) { - image1Input_->readSampled(output, x, y, PixelSampler::Nearest); + image1Input_->read_sampled(output, x, y, PixelSampler::Nearest); } else { - image2Input_->readSampled(output, x, y, PixelSampler::Nearest); + image2Input_->read_sampled(output, x, y, PixelSampler::Nearest); } } @@ -62,7 +62,7 @@ void SplitOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { rcti unused_area; - const bool determined = this->getInputSocket(0)->determine_canvas(COM_AREA_NONE, unused_area); + const bool determined = this->get_input_socket(0)->determine_canvas(COM_AREA_NONE, unused_area); this->set_canvas_input_index(determined ? 0 : 1); NodeOperation::determine_canvas(preferred_area, r_area); @@ -72,11 +72,11 @@ void SplitOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - 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()); + const int percent = x_split_ ? split_percentage_ * this->get_width() / 100.0f : + split_percentage_ * this->get_height() / 100.0f; + const size_t elem_bytes = COM_data_type_bytes_len(get_output_socket()->get_data_type()); for (BuffersIterator it = output->iterate_with(inputs, area); !it.is_end(); ++it) { - const bool is_image1 = xSplit_ ? it.x > percent : it.y > percent; + const bool is_image1 = x_split_ ? 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 9f594793be5..2d2b2e89cca 100644 --- a/source/blender/compositor/operations/COM_SplitOperation.h +++ b/source/blender/compositor/operations/COM_SplitOperation.h @@ -27,22 +27,22 @@ class SplitOperation : public MultiThreadedOperation { SocketReader *image1Input_; SocketReader *image2Input_; - float splitPercentage_; - bool xSplit_; + float split_percentage_; + bool x_split_; public: SplitOperation(); - void initExecution() override; - void deinitExecution() override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void init_execution() override; + void deinit_execution() override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void setSplitPercentage(float splitPercentage) + void set_split_percentage(float split_percentage) { - splitPercentage_ = splitPercentage; + split_percentage_ = split_percentage; } - void setXSplit(bool xsplit) + void set_xsplit(bool xsplit) { - xSplit_ = xsplit; + x_split_ = 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 b055d0a7644..5842fcc2278 100644 --- a/source/blender/compositor/operations/COM_SunBeamsOperation.cc +++ b/source/blender/compositor/operations/COM_SunBeamsOperation.cc @@ -23,8 +23,8 @@ namespace blender::compositor { SunBeamsOperation::SunBeamsOperation() { - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); this->set_canvas_input_index(0); this->flags.complex = true; @@ -33,12 +33,12 @@ SunBeamsOperation::SunBeamsOperation() void SunBeamsOperation::calc_rays_common_data() { /* convert to pixels */ - 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()); + source_px_[0] = data_.source[0] * this->get_width(); + source_px_[1] = data_.source[1] * this->get_height(); + ray_length_px_ = data_.ray_length * MAX2(this->get_width(), this->get_height()); } -void SunBeamsOperation::initExecution() +void SunBeamsOperation::init_execution() { calc_rays_common_data(); } @@ -145,7 +145,7 @@ template struct BufferLineAccumulator { falloff_factor = dist_max > dist_min ? dr / (float)(dist_max - dist_min) : 0.0f; - float *iter = input->getBuffer() + input->get_coords_offset(x, y); + float *iter = input->get_buffer() + input->get_coords_offset(x, y); return iter; } @@ -312,13 +312,13 @@ static void accumulate_line(MemoryBuffer *input, } } -void *SunBeamsOperation::initializeTileData(rcti * /*rect*/) +void *SunBeamsOperation::initialize_tile_data(rcti * /*rect*/) { - void *buffer = getInputOperation(0)->initializeTileData(nullptr); + void *buffer = get_input_operation(0)->initialize_tile_data(nullptr); return buffer; } -void SunBeamsOperation::executePixel(float output[4], int x, int y, void *data) +void SunBeamsOperation::execute_pixel(float output[4], int x, int y, void *data) { const float co[2] = {(float)x, (float)y}; @@ -340,9 +340,9 @@ static void calc_ray_shift(rcti *rect, float x, float y, const float source[2], BLI_rcti_do_minmax_v(rect, ico); } -bool SunBeamsOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool SunBeamsOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { /* Enlarges the rect by moving each corner toward the source. * This is the maximum distance that pixels can influence each other @@ -354,7 +354,7 @@ bool SunBeamsOperation::determineDependingAreaOfInterest(rcti *input, 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); + return NodeOperation::determine_depending_area_of_interest(&rect, read_operation, output); } void SunBeamsOperation::get_area_of_interest(const int input_idx, diff --git a/source/blender/compositor/operations/COM_SunBeamsOperation.h b/source/blender/compositor/operations/COM_SunBeamsOperation.h index 2a62be065a4..c40d540996e 100644 --- a/source/blender/compositor/operations/COM_SunBeamsOperation.h +++ b/source/blender/compositor/operations/COM_SunBeamsOperation.h @@ -25,17 +25,17 @@ class SunBeamsOperation : public MultiThreadedOperation { public: SunBeamsOperation(); - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void setData(const NodeSunBeams &data) + void set_data(const NodeSunBeams &data) { data_ = data; } diff --git a/source/blender/compositor/operations/COM_TextureOperation.cc b/source/blender/compositor/operations/COM_TextureOperation.cc index 7c18b8214de..da1c90cd1c5 100644 --- a/source/blender/compositor/operations/COM_TextureOperation.cc +++ b/source/blender/compositor/operations/COM_TextureOperation.cc @@ -26,46 +26,46 @@ namespace blender::compositor { TextureBaseOperation::TextureBaseOperation() { - this->addInputSocket(DataType::Vector); // offset - this->addInputSocket(DataType::Vector); // size + this->add_input_socket(DataType::Vector); // offset + this->add_input_socket(DataType::Vector); // size texture_ = nullptr; - inputSize_ = nullptr; - inputOffset_ = nullptr; + input_size_ = nullptr; + input_offset_ = nullptr; rd_ = nullptr; pool_ = nullptr; - sceneColorManage_ = false; + scene_color_manage_ = false; flags.complex = true; } TextureOperation::TextureOperation() : TextureBaseOperation() { - this->addOutputSocket(DataType::Color); + this->add_output_socket(DataType::Color); } TextureAlphaOperation::TextureAlphaOperation() : TextureBaseOperation() { - this->addOutputSocket(DataType::Value); + this->add_output_socket(DataType::Value); } -void TextureBaseOperation::initExecution() +void TextureBaseOperation::init_execution() { - inputOffset_ = getInputSocketReader(0); - inputSize_ = getInputSocketReader(1); + input_offset_ = get_input_socket_reader(0); + input_size_ = get_input_socket_reader(1); pool_ = BKE_image_pool_new(); if (texture_ != nullptr && texture_->nodetree != nullptr && texture_->use_nodes) { ntreeTexBeginExecTree(texture_->nodetree); } - NodeOperation::initExecution(); + NodeOperation::init_execution(); } -void TextureBaseOperation::deinitExecution() +void TextureBaseOperation::deinit_execution() { - inputSize_ = nullptr; - inputOffset_ = nullptr; + input_size_ = nullptr; + input_offset_ = 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(); + NodeOperation::deinit_execution(); } void TextureBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -85,30 +85,30 @@ void TextureBaseOperation::determine_canvas(const rcti &preferred_area, rcti &r_ } } -void TextureAlphaOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void TextureAlphaOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float color[4]; - TextureBaseOperation::executePixelSampled(color, x, y, sampler); + TextureBaseOperation::execute_pixel_sampled(color, x, y, sampler); output[0] = color[3]; } -void TextureBaseOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void TextureBaseOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { TexResult texres = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0, nullptr}; - float textureSize[4]; - float textureOffset[4]; + float texture_size[4]; + float texture_offset[4]; float vec[3]; int retval; - const float cx = this->getWidth() / 2; - const float cy = this->getHeight() / 2; - float u = (x - cx) / this->getWidth() * 2; - float v = (y - cy) / this->getHeight() * 2; + const float cx = this->get_width() / 2; + const float cy = this->get_height() / 2; + float u = (x - cx) / this->get_width() * 2; + float v = (y - cy) / this->get_height() * 2; /* When no interpolation/filtering happens in multitex() force nearest interpolation. * We do it here because (a) we can't easily say multitex() that we want nearest @@ -120,16 +120,16 @@ void TextureBaseOperation::executePixelSampled(float output[4], v += 0.5f / cy; } - inputSize_->readSampled(textureSize, x, y, sampler); - inputOffset_->readSampled(textureOffset, x, y, sampler); + input_size_->read_sampled(texture_size, x, y, sampler); + input_offset_->read_sampled(texture_offset, x, y, sampler); - vec[0] = textureSize[0] * (u + textureOffset[0]); - vec[1] = textureSize[1] * (v + textureOffset[1]); - vec[2] = textureSize[2] * textureOffset[2]; + vec[0] = texture_size[0] * (u + texture_offset[0]); + vec[1] = texture_size[1] * (v + texture_offset[1]); + vec[2] = texture_size[2] * texture_offset[2]; const int thread_id = WorkScheduler::current_thread_id(); retval = multitex_ext( - texture_, vec, nullptr, nullptr, 0, &texres, thread_id, pool_, sceneColorManage_, false); + texture_, vec, nullptr, nullptr, 0, &texres, thread_id, pool_, scene_color_manage_, false); output[3] = texres.talpha ? texres.ta : texres.tin; if (retval & TEX_RGB) { @@ -146,8 +146,8 @@ void TextureBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - const int op_width = this->getWidth(); - const int op_height = this->getHeight(); + const int op_width = this->get_width(); + const int op_height = this->get_height(); const float center_x = op_width / 2; const float center_y = op_height / 2; TexResult tex_result = {0}; @@ -181,7 +181,7 @@ void TextureBaseOperation::update_memory_buffer_partial(MemoryBuffer *output, &tex_result, thread_id, pool_, - sceneColorManage_, + scene_color_manage_, 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 3916f82c77b..bf1bb1affb8 100644 --- a/source/blender/compositor/operations/COM_TextureOperation.h +++ b/source/blender/compositor/operations/COM_TextureOperation.h @@ -37,10 +37,10 @@ class TextureBaseOperation : public MultiThreadedOperation { private: Tex *texture_; const RenderData *rd_; - SocketReader *inputSize_; - SocketReader *inputOffset_; + SocketReader *input_size_; + SocketReader *input_offset_; struct ImagePool *pool_; - bool sceneColorManage_; + bool scene_color_manage_; protected: /** @@ -54,21 +54,21 @@ class TextureBaseOperation : public MultiThreadedOperation { TextureBaseOperation(); public: - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void setTexture(Tex *texture) + void set_texture(Tex *texture) { texture_ = texture; } - void initExecution() override; - void deinitExecution() override; - void setRenderData(const RenderData *rd) + void init_execution() override; + void deinit_execution() override; + void set_render_data(const RenderData *rd) { rd_ = rd; } - void setSceneColorManage(bool sceneColorManage) + void set_scene_color_manage(bool scene_color_manage) { - sceneColorManage_ = sceneColorManage; + scene_color_manage_ = scene_color_manage; } void update_memory_buffer_partial(MemoryBuffer *output, @@ -83,7 +83,7 @@ class TextureOperation : public TextureBaseOperation { class TextureAlphaOperation : public TextureBaseOperation { public: TextureAlphaOperation(); - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_TonemapOperation.cc b/source/blender/compositor/operations/COM_TonemapOperation.cc index b9d67ec8be3..6d3fc9380c1 100644 --- a/source/blender/compositor/operations/COM_TonemapOperation.cc +++ b/source/blender/compositor/operations/COM_TonemapOperation.cc @@ -26,24 +26,24 @@ namespace blender::compositor { TonemapOperation::TonemapOperation() { - this->addInputSocket(DataType::Color, ResizeMode::Align); - this->addOutputSocket(DataType::Color); - imageReader_ = nullptr; + this->add_input_socket(DataType::Color, ResizeMode::Align); + this->add_output_socket(DataType::Color); + image_reader_ = nullptr; data_ = nullptr; - cachedInstance_ = nullptr; + cached_instance_ = nullptr; this->flags.complex = true; } -void TonemapOperation::initExecution() +void TonemapOperation::init_execution() { - imageReader_ = this->getInputSocketReader(0); - NodeOperation::initMutex(); + image_reader_ = this->get_input_socket_reader(0); + NodeOperation::init_mutex(); } -void TonemapOperation::executePixel(float output[4], int x, int y, void *data) +void TonemapOperation::execute_pixel(float output[4], int x, int y, void *data) { AvgLogLum *avg = (AvgLogLum *)data; - imageReader_->read(output, x, y, nullptr); + image_reader_->read(output, x, y, nullptr); mul_v3_fl(output, avg->al); float dr = output[0] + data_->offset; float dg = output[1] + data_->offset; @@ -58,7 +58,7 @@ void TonemapOperation::executePixel(float output[4], int x, int y, void *data) output[2] = powf(MAX2(output[2], 0.0f), igm); } } -void PhotoreceptorTonemapOperation::executePixel(float output[4], int x, int y, void *data) +void PhotoreceptorTonemapOperation::execute_pixel(float output[4], int x, int y, void *data) { AvgLogLum *avg = (AvgLogLum *)data; NodeTonemap *ntm = data_; @@ -67,7 +67,7 @@ void PhotoreceptorTonemapOperation::executePixel(float output[4], int x, int y, 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; - imageReader_->read(output, x, y, nullptr); + image_reader_->read(output, x, y, nullptr); const float L = IMB_colormanagement_get_luminance(output); float I_l = output[0] + ic * (L - output[0]); @@ -84,41 +84,41 @@ void PhotoreceptorTonemapOperation::executePixel(float output[4], int x, int y, output[2] /= (output[2] + powf(f * I_a, m)); } -void TonemapOperation::deinitExecution() +void TonemapOperation::deinit_execution() { - imageReader_ = nullptr; - delete cachedInstance_; - NodeOperation::deinitMutex(); + image_reader_ = nullptr; + delete cached_instance_; + NodeOperation::deinit_mutex(); } -bool TonemapOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool TonemapOperation::determine_depending_area_of_interest(rcti * /*input*/, + ReadBufferOperation *read_operation, + rcti *output) { - rcti imageInput; + rcti image_input; - NodeOperation *operation = getInputOperation(0); - imageInput.xmax = operation->getWidth(); - imageInput.xmin = 0; - imageInput.ymax = operation->getHeight(); - imageInput.ymin = 0; - if (operation->determineDependingAreaOfInterest(&imageInput, readOperation, output)) { + NodeOperation *operation = get_input_operation(0); + image_input.xmax = operation->get_width(); + image_input.xmin = 0; + image_input.ymax = operation->get_height(); + image_input.ymin = 0; + if (operation->determine_depending_area_of_interest(&image_input, read_operation, output)) { return true; } return false; } -void *TonemapOperation::initializeTileData(rcti *rect) +void *TonemapOperation::initialize_tile_data(rcti *rect) { - lockMutex(); - if (cachedInstance_ == nullptr) { - MemoryBuffer *tile = (MemoryBuffer *)imageReader_->initializeTileData(rect); + lock_mutex(); + if (cached_instance_ == nullptr) { + MemoryBuffer *tile = (MemoryBuffer *)image_reader_->initialize_tile_data(rect); AvgLogLum *data = new AvgLogLum(); - float *buffer = tile->getBuffer(); + float *buffer = tile->get_buffer(); float lsum = 0.0f; - int p = tile->getWidth() * tile->getHeight(); + int p = tile->get_width() * tile->get_height(); float *bc = buffer; float avl, maxl = -1e10f, minl = 1e10f; const float sc = 1.0f / p; @@ -142,13 +142,13 @@ void *TonemapOperation::initializeTileData(rcti *rect) float al = exp((double)avl); data->al = (al == 0.0f) ? 0.0f : (data_->key / al); data->igm = (data_->gamma == 0.0f) ? 1 : (1.0f / data_->gamma); - cachedInstance_ = data; + cached_instance_ = data; } - unlockMutex(); - return cachedInstance_; + unlock_mutex(); + return cached_instance_; } -void TonemapOperation::deinitializeTileData(rcti * /*rect*/, void * /*data*/) +void TonemapOperation::deinitialize_tile_data(rcti * /*rect*/, void * /*data*/) { /* pass */ } @@ -189,7 +189,7 @@ void TonemapOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output) const rcti &UNUSED(area), Span inputs) { - if (cachedInstance_ == nullptr) { + if (cached_instance_ == nullptr) { Luminance lum = {0}; const MemoryBuffer *input = inputs[0]; exec_system_->execute_work( @@ -215,7 +215,7 @@ void TonemapOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output) const float al = exp((double)avg_log); avg->al = (al == 0.0f) ? 0.0f : (data_->key / al); avg->igm = (data_->gamma == 0.0f) ? 1 : (1.0f / data_->gamma); - cachedInstance_ = avg; + cached_instance_ = avg; } } @@ -223,7 +223,7 @@ void TonemapOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - AvgLogLum *avg = cachedInstance_; + AvgLogLum *avg = cached_instance_; const float igm = avg->igm; const float offset = data_->offset; for (BuffersIterator it = output->iterate_with(inputs, area); !it.is_end(); ++it) { @@ -247,7 +247,7 @@ void PhotoreceptorTonemapOperation::update_memory_buffer_partial(MemoryBuffer *o const rcti &area, Span inputs) { - AvgLogLum *avg = cachedInstance_; + AvgLogLum *avg = cached_instance_; 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)); diff --git a/source/blender/compositor/operations/COM_TonemapOperation.h b/source/blender/compositor/operations/COM_TonemapOperation.h index c04ee4fcbe9..a20c061965e 100644 --- a/source/blender/compositor/operations/COM_TonemapOperation.h +++ b/source/blender/compositor/operations/COM_TonemapOperation.h @@ -44,7 +44,7 @@ class TonemapOperation : public MultiThreadedOperation { /** * \brief Cached reference to the reader */ - SocketReader *imageReader_; + SocketReader *image_reader_; /** * \brief settings of the Tonemap @@ -54,7 +54,7 @@ class TonemapOperation : public MultiThreadedOperation { /** * \brief temporarily cache of the execution storage */ - AvgLogLum *cachedInstance_; + AvgLogLum *cached_instance_; public: TonemapOperation(); @@ -62,29 +62,29 @@ class TonemapOperation : public MultiThreadedOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; - void deinitializeTileData(rcti *rect, void *data) override; + void *initialize_tile_data(rcti *rect) override; + void deinitialize_tile_data(rcti *rect, void *data) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void setData(NodeTonemap *data) + void set_data(NodeTonemap *data) { data_ = data; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_started(MemoryBuffer *output, @@ -106,7 +106,7 @@ class PhotoreceptorTonemapOperation : public TonemapOperation { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_TrackPositionOperation.cc b/source/blender/compositor/operations/COM_TrackPositionOperation.cc index d9e55011d16..f329bfb0656 100644 --- a/source/blender/compositor/operations/COM_TrackPositionOperation.cc +++ b/source/blender/compositor/operations/COM_TrackPositionOperation.cc @@ -26,20 +26,20 @@ namespace blender::compositor { TrackPositionOperation::TrackPositionOperation() { - this->addOutputSocket(DataType::Value); - movieClip_ = nullptr; + this->add_output_socket(DataType::Value); + movie_clip_ = nullptr; framenumber_ = 0; - trackingObjectName_[0] = 0; - trackName_[0] = 0; + tracking_object_name_[0] = 0; + track_name_[0] = 0; axis_ = 0; position_ = CMP_TRACKPOS_ABSOLUTE; - relativeFrame_ = 0; + relative_frame_ = 0; speed_output_ = false; flags.is_set_operation = true; is_track_position_calculated_ = false; } -void TrackPositionOperation::initExecution() +void TrackPositionOperation::init_execution() { if (!is_track_position_calculated_) { calc_track_position(); @@ -54,45 +54,45 @@ void TrackPositionOperation::calc_track_position() MovieTrackingObject *object; track_position_ = 0; - zero_v2(markerPos_); - zero_v2(relativePos_); + zero_v2(marker_pos_); + zero_v2(relative_pos_); - if (!movieClip_) { + if (!movie_clip_) { return; } - tracking = &movieClip_->tracking; + tracking = &movie_clip_->tracking; BKE_movieclip_user_set_frame(&user, framenumber_); - BKE_movieclip_get_size(movieClip_, &user, &width_, &height_); + BKE_movieclip_get_size(movie_clip_, &user, &width_, &height_); - object = BKE_tracking_object_get_named(tracking, trackingObjectName_); + object = BKE_tracking_object_get_named(tracking, tracking_object_name_); if (object) { MovieTrackingTrack *track; - track = BKE_tracking_track_get_named(tracking, object, trackName_); + track = BKE_tracking_track_get_named(tracking, object, track_name_); if (track) { MovieTrackingMarker *marker; - int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, framenumber_); + int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, framenumber_); marker = BKE_tracking_marker_get(track, clip_framenr); - copy_v2_v2(markerPos_, marker->pos); + copy_v2_v2(marker_pos_, marker->pos); if (speed_output_) { - int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, - relativeFrame_); + int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, + relative_frame_); marker = BKE_tracking_marker_get_exact(track, relative_clip_framenr); if (marker != nullptr && (marker->flag & MARKER_DISABLED) == 0) { - copy_v2_v2(relativePos_, marker->pos); + copy_v2_v2(relative_pos_, marker->pos); } else { - copy_v2_v2(relativePos_, markerPos_); + copy_v2_v2(relative_pos_, marker_pos_); } - if (relativeFrame_ < framenumber_) { - swap_v2_v2(relativePos_, markerPos_); + if (relative_frame_ < framenumber_) { + swap_v2_v2(relative_pos_, marker_pos_); } } else if (position_ == CMP_TRACKPOS_RELATIVE_START) { @@ -102,23 +102,23 @@ void TrackPositionOperation::calc_track_position() marker = &track->markers[i]; if ((marker->flag & MARKER_DISABLED) == 0) { - copy_v2_v2(relativePos_, marker->pos); + copy_v2_v2(relative_pos_, marker->pos); break; } } } else if (position_ == CMP_TRACKPOS_RELATIVE_FRAME) { - int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip_, - relativeFrame_); + int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, + relative_frame_); marker = BKE_tracking_marker_get(track, relative_clip_framenr); - copy_v2_v2(relativePos_, marker->pos); + copy_v2_v2(relative_pos_, marker->pos); } } } - track_position_ = markerPos_[axis_] - relativePos_[axis_]; + track_position_ = marker_pos_[axis_] - relative_pos_[axis_]; if (axis_ == 0) { track_position_ *= width_; } @@ -127,12 +127,12 @@ void TrackPositionOperation::calc_track_position() } } -void TrackPositionOperation::executePixelSampled(float output[4], - float /*x*/, - float /*y*/, - PixelSampler /*sampler*/) +void TrackPositionOperation::execute_pixel_sampled(float output[4], + float /*x*/, + float /*y*/, + PixelSampler /*sampler*/) { - output[0] = markerPos_[axis_] - relativePos_[axis_]; + output[0] = marker_pos_[axis_] - relative_pos_[axis_]; if (axis_ == 0) { output[0] *= width_; diff --git a/source/blender/compositor/operations/COM_TrackPositionOperation.h b/source/blender/compositor/operations/COM_TrackPositionOperation.h index 25e5a144228..1de8b72f783 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 *movieClip_; + MovieClip *movie_clip_; int framenumber_; - char trackingObjectName_[64]; - char trackName_[64]; + char tracking_object_name_[64]; + char track_name_[64]; int axis_; int position_; - int relativeFrame_; + int relative_frame_; bool speed_output_; int width_, height_; - float markerPos_[2]; - float relativePos_[2]; + float marker_pos_[2]; + float relative_pos_[2]; float track_position_; bool is_track_position_calculated_; @@ -58,42 +58,42 @@ class TrackPositionOperation : public ConstantOperation { public: TrackPositionOperation(); - void setMovieClip(MovieClip *clip) + void set_movie_clip(MovieClip *clip) { - movieClip_ = clip; + movie_clip_ = clip; } - void setTrackingObject(char *object) + void set_tracking_object(char *object) { - BLI_strncpy(trackingObjectName_, object, sizeof(trackingObjectName_)); + BLI_strncpy(tracking_object_name_, object, sizeof(tracking_object_name_)); } - void setTrackName(char *track) + void set_track_name(char *track) { - BLI_strncpy(trackName_, track, sizeof(trackName_)); + BLI_strncpy(track_name_, track, sizeof(track_name_)); } - void setFramenumber(int framenumber) + void set_framenumber(int framenumber) { framenumber_ = framenumber; } - void setAxis(int value) + void set_axis(int value) { axis_ = value; } - void setPosition(int value) + void set_position(int value) { position_ = value; } - void setRelativeFrame(int value) + void set_relative_frame(int value) { - relativeFrame_ = value; + relative_frame_ = value; } - void setSpeedOutput(bool speed_output) + void set_speed_output(bool speed_output) { speed_output_ = speed_output; } - void initExecution() override; + void init_execution() override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; const float *get_constant_elem() override; diff --git a/source/blender/compositor/operations/COM_TransformOperation.cc b/source/blender/compositor/operations/COM_TransformOperation.cc index 38bb443bdea..be9bb32e7f0 100644 --- a/source/blender/compositor/operations/COM_TransformOperation.cc +++ b/source/blender/compositor/operations/COM_TransformOperation.cc @@ -24,12 +24,12 @@ namespace blender::compositor { TransformOperation::TransformOperation() { - addInputSocket(DataType::Color, ResizeMode::None); - addInputSocket(DataType::Value, ResizeMode::None); - addInputSocket(DataType::Value, ResizeMode::None); - addInputSocket(DataType::Value, ResizeMode::None); - addInputSocket(DataType::Value, ResizeMode::None); - addOutputSocket(DataType::Color); + add_input_socket(DataType::Color, ResizeMode::None); + add_input_socket(DataType::Value, ResizeMode::None); + add_input_socket(DataType::Value, ResizeMode::None); + add_input_socket(DataType::Value, ResizeMode::None); + add_input_socket(DataType::Value, ResizeMode::None); + add_output_socket(DataType::Color); translate_factor_x_ = 1.0f; translate_factor_y_ = 1.0f; convert_degree_to_rad_ = false; @@ -123,14 +123,14 @@ void TransformOperation::update_memory_buffer_partial(MemoryBuffer *output, void TransformOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { const bool image_determined = - getInputSocket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area); + get_input_socket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area); if (image_determined) { rcti image_canvas = r_area; rcti unused; - getInputSocket(X_INPUT_INDEX)->determine_canvas(image_canvas, unused); - getInputSocket(Y_INPUT_INDEX)->determine_canvas(image_canvas, unused); - getInputSocket(DEGREE_INPUT_INDEX)->determine_canvas(image_canvas, unused); - getInputSocket(SCALE_INPUT_INDEX)->determine_canvas(image_canvas, unused); + get_input_socket(X_INPUT_INDEX)->determine_canvas(image_canvas, unused); + get_input_socket(Y_INPUT_INDEX)->determine_canvas(image_canvas, unused); + get_input_socket(DEGREE_INPUT_INDEX)->determine_canvas(image_canvas, unused); + get_input_socket(SCALE_INPUT_INDEX)->determine_canvas(image_canvas, unused); init_data(); if (invert_) { diff --git a/source/blender/compositor/operations/COM_TranslateOperation.cc b/source/blender/compositor/operations/COM_TranslateOperation.cc index 1ec5029385e..89c7468a67c 100644 --- a/source/blender/compositor/operations/COM_TranslateOperation.cc +++ b/source/blender/compositor/operations/COM_TranslateOperation.cc @@ -25,68 +25,68 @@ TranslateOperation::TranslateOperation() : TranslateOperation(DataType::Color) } TranslateOperation::TranslateOperation(DataType data_type, ResizeMode resize_mode) { - this->addInputSocket(data_type, resize_mode); - this->addInputSocket(DataType::Value, ResizeMode::None); - this->addInputSocket(DataType::Value, ResizeMode::None); - this->addOutputSocket(data_type); + this->add_input_socket(data_type, resize_mode); + this->add_input_socket(DataType::Value, ResizeMode::None); + this->add_input_socket(DataType::Value, ResizeMode::None); + this->add_output_socket(data_type); this->set_canvas_input_index(0); - inputOperation_ = nullptr; - inputXOperation_ = nullptr; - inputYOperation_ = nullptr; - isDeltaSet_ = false; - factorX_ = 1.0f; - factorY_ = 1.0f; + input_operation_ = nullptr; + input_xoperation_ = nullptr; + input_yoperation_ = nullptr; + is_delta_set_ = false; + factor_x_ = 1.0f; + factor_y_ = 1.0f; this->x_extend_mode_ = MemoryBufferExtend::Clip; this->y_extend_mode_ = MemoryBufferExtend::Clip; } -void TranslateOperation::initExecution() +void TranslateOperation::init_execution() { - inputOperation_ = this->getInputSocketReader(0); - inputXOperation_ = this->getInputSocketReader(1); - inputYOperation_ = this->getInputSocketReader(2); + input_operation_ = this->get_input_socket_reader(0); + input_xoperation_ = this->get_input_socket_reader(1); + input_yoperation_ = this->get_input_socket_reader(2); } -void TranslateOperation::deinitExecution() +void TranslateOperation::deinit_execution() { - inputOperation_ = nullptr; - inputXOperation_ = nullptr; - inputYOperation_ = nullptr; + input_operation_ = nullptr; + input_xoperation_ = nullptr; + input_yoperation_ = nullptr; } -void TranslateOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler /*sampler*/) +void TranslateOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler /*sampler*/) { - ensureDelta(); + ensure_delta(); - float originalXPos = x - this->getDeltaX(); - float originalYPos = y - this->getDeltaY(); + float original_xpos = x - this->getDeltaX(); + float original_ypos = y - this->getDeltaY(); - inputOperation_->readSampled(output, originalXPos, originalYPos, PixelSampler::Bilinear); + input_operation_->read_sampled(output, original_xpos, original_ypos, PixelSampler::Bilinear); } -bool TranslateOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool TranslateOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; + rcti new_input; - ensureDelta(); + ensure_delta(); - newInput.xmin = input->xmin - this->getDeltaX(); - newInput.xmax = input->xmax - this->getDeltaX(); - newInput.ymin = input->ymin - this->getDeltaY(); - newInput.ymax = input->ymax - this->getDeltaY(); + new_input.xmin = input->xmin - this->getDeltaX(); + new_input.xmax = input->xmax - this->getDeltaX(); + new_input.ymin = input->ymin - this->getDeltaY(); + new_input.ymax = input->ymax - this->getDeltaY(); - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } void TranslateOperation::setFactorXY(float factorX, float factorY) { - factorX_ = factorX; - factorY_ = factorY; + factor_x_ = factorX; + factor_y_ = factorY; } void TranslateOperation::set_wrapping(int wrapping_type) @@ -112,7 +112,7 @@ void TranslateOperation::get_area_of_interest(const int input_idx, rcti &r_input_area) { if (input_idx == 0) { - ensureDelta(); + ensure_delta(); r_input_area = output_area; if (x_extend_mode_ == MemoryBufferExtend::Clip) { const int delta_x = this->getDeltaX(); @@ -154,15 +154,15 @@ TranslateCanvasOperation::TranslateCanvasOperation() void TranslateCanvasOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { const bool determined = - getInputSocket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area); + get_input_socket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area); if (determined) { - NodeOperationInput *x_socket = getInputSocket(X_INPUT_INDEX); - NodeOperationInput *y_socket = getInputSocket(Y_INPUT_INDEX); + NodeOperationInput *x_socket = get_input_socket(X_INPUT_INDEX); + NodeOperationInput *y_socket = get_input_socket(Y_INPUT_INDEX); rcti unused; x_socket->determine_canvas(r_area, unused); y_socket->determine_canvas(r_area, unused); - ensureDelta(); + ensure_delta(); const float delta_x = x_extend_mode_ == MemoryBufferExtend::Clip ? getDeltaX() : 0.0f; const float delta_y = y_extend_mode_ == MemoryBufferExtend::Clip ? getDeltaY() : 0.0f; BLI_rcti_translate(&r_area, delta_x, delta_y); diff --git a/source/blender/compositor/operations/COM_TranslateOperation.h b/source/blender/compositor/operations/COM_TranslateOperation.h index 25251ff1d9e..30e489bf395 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 *inputOperation_; - SocketReader *inputXOperation_; - SocketReader *inputYOperation_; - float deltaX_; - float deltaY_; - bool isDeltaSet_; - float factorX_; - float factorY_; + SocketReader *input_operation_; + SocketReader *input_xoperation_; + SocketReader *input_yoperation_; + float delta_x_; + float delta_y_; + bool is_delta_set_; + float factor_x_; + float factor_y_; protected: MemoryBufferExtend x_extend_mode_; @@ -46,39 +46,39 @@ class TranslateOperation : public MultiThreadedOperation { public: TranslateOperation(); TranslateOperation(DataType data_type, ResizeMode mode = ResizeMode::Center); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; float getDeltaX() { - return deltaX_ * factorX_; + return delta_x_ * factor_x_; } float getDeltaY() { - return deltaY_ * factorY_; + return delta_y_ * factor_y_; } - inline void ensureDelta() + inline void ensure_delta() { - if (!isDeltaSet_) { + if (!is_delta_set_) { if (execution_model_ == eExecutionModel::Tiled) { - float tempDelta[4]; - inputXOperation_->readSampled(tempDelta, 0, 0, PixelSampler::Nearest); - deltaX_ = tempDelta[0]; - inputYOperation_->readSampled(tempDelta, 0, 0, PixelSampler::Nearest); - deltaY_ = tempDelta[0]; + float temp_delta[4]; + input_xoperation_->read_sampled(temp_delta, 0, 0, PixelSampler::Nearest); + delta_x_ = temp_delta[0]; + input_yoperation_->read_sampled(temp_delta, 0, 0, PixelSampler::Nearest); + delta_y_ = temp_delta[0]; } else { - 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); + delta_x_ = get_input_operation(X_INPUT_INDEX)->get_constant_value_default(0.0f); + delta_y_ = get_input_operation(Y_INPUT_INDEX)->get_constant_value_default(0.0f); } - isDeltaSet_ = true; + is_delta_set_ = true; } } diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cc b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cc index a0013ae1061..07baf370d1d 100644 --- a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cc +++ b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cc @@ -23,127 +23,128 @@ namespace blender::compositor { VariableSizeBokehBlurOperation::VariableSizeBokehBlurOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color, ResizeMode::Align); /* Do not resize the bokeh image. */ - this->addInputSocket(DataType::Value); /* Radius. */ + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color, ResizeMode::Align); /* Do not resize the bokeh image. */ + this->add_input_socket(DataType::Value); /* Radius. */ #ifdef COM_DEFOCUS_SEARCH /* Inverse search radius optimization structure. */ - this->addInputSocket(DataType::Color, ResizeMode::None); + this->add_input_socket(DataType::Color, ResizeMode::None); #endif - this->addOutputSocket(DataType::Color); + this->add_output_socket(DataType::Color); flags.complex = true; flags.open_cl = true; - inputProgram_ = nullptr; - inputBokehProgram_ = nullptr; - inputSizeProgram_ = nullptr; - maxBlur_ = 32.0f; + input_program_ = nullptr; + input_bokeh_program_ = nullptr; + input_size_program_ = nullptr; + max_blur_ = 32.0f; threshold_ = 1.0f; do_size_scale_ = false; #ifdef COM_DEFOCUS_SEARCH - inputSearchProgram_ = nullptr; + input_search_program_ = nullptr; #endif } -void VariableSizeBokehBlurOperation::initExecution() +void VariableSizeBokehBlurOperation::init_execution() { - inputProgram_ = getInputSocketReader(0); - inputBokehProgram_ = getInputSocketReader(1); - inputSizeProgram_ = getInputSocketReader(2); + input_program_ = get_input_socket_reader(0); + input_bokeh_program_ = get_input_socket_reader(1); + input_size_program_ = get_input_socket_reader(2); #ifdef COM_DEFOCUS_SEARCH - inputSearchProgram_ = getInputSocketReader(3); + input_search_program_ = get_input_socket_reader(3); #endif - QualityStepHelper::initExecution(COM_QH_INCREASE); + QualityStepHelper::init_execution(COM_QH_INCREASE); } struct VariableSizeBokehBlurTileData { MemoryBuffer *color; MemoryBuffer *bokeh; MemoryBuffer *size; - int maxBlurScalar; + int max_blur_scalar; }; -void *VariableSizeBokehBlurOperation::initializeTileData(rcti *rect) +void *VariableSizeBokehBlurOperation::initialize_tile_data(rcti *rect) { VariableSizeBokehBlurTileData *data = new VariableSizeBokehBlurTileData(); - data->color = (MemoryBuffer *)inputProgram_->initializeTileData(rect); - data->bokeh = (MemoryBuffer *)inputBokehProgram_->initializeTileData(rect); - data->size = (MemoryBuffer *)inputSizeProgram_->initializeTileData(rect); + data->color = (MemoryBuffer *)input_program_->initialize_tile_data(rect); + data->bokeh = (MemoryBuffer *)input_bokeh_program_->initialize_tile_data(rect); + data->size = (MemoryBuffer *)input_size_program_->initialize_tile_data(rect); rcti rect2; - this->determineDependingAreaOfInterest(rect, (ReadBufferOperation *)inputSizeProgram_, &rect2); + this->determine_depending_area_of_interest( + rect, (ReadBufferOperation *)input_size_program_, &rect2); - const float max_dim = MAX2(this->getWidth(), this->getHeight()); + const float max_dim = MAX2(this->get_width(), this->get_height()); 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, maxBlur_); + data->max_blur_scalar = (int)(data->size->get_max_value(rect2) * scalar); + CLAMP(data->max_blur_scalar, 1.0f, max_blur_); return data; } -void VariableSizeBokehBlurOperation::deinitializeTileData(rcti * /*rect*/, void *data) +void VariableSizeBokehBlurOperation::deinitialize_tile_data(rcti * /*rect*/, void *data) { VariableSizeBokehBlurTileData *result = (VariableSizeBokehBlurTileData *)data; delete result; } -void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, void *data) +void VariableSizeBokehBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { - VariableSizeBokehBlurTileData *tileData = (VariableSizeBokehBlurTileData *)data; - MemoryBuffer *inputProgramBuffer = tileData->color; - MemoryBuffer *inputBokehBuffer = tileData->bokeh; - MemoryBuffer *inputSizeBuffer = tileData->size; - float *inputSizeFloatBuffer = inputSizeBuffer->getBuffer(); - float *inputProgramFloatBuffer = inputProgramBuffer->getBuffer(); - float readColor[4]; + VariableSizeBokehBlurTileData *tile_data = (VariableSizeBokehBlurTileData *)data; + MemoryBuffer *input_program_buffer = tile_data->color; + MemoryBuffer *input_bokeh_buffer = tile_data->bokeh; + MemoryBuffer *input_size_buffer = tile_data->size; + float *input_size_float_buffer = input_size_buffer->get_buffer(); + float *input_program_float_buffer = input_program_buffer->get_buffer(); + float read_color[4]; float bokeh[4]; - float tempSize[4]; + float temp_size[4]; float multiplier_accum[4]; float color_accum[4]; - const float max_dim = MAX2(getWidth(), getHeight()); + const float max_dim = MAX2(get_width(), get_height()); const float scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; - int maxBlurScalar = tileData->maxBlurScalar; + int max_blur_scalar = tile_data->max_blur_scalar; - BLI_assert(inputBokehBuffer->getWidth() == COM_BLUR_BOKEH_PIXELS); - BLI_assert(inputBokehBuffer->getHeight() == COM_BLUR_BOKEH_PIXELS); + BLI_assert(input_bokeh_buffer->get_width() == COM_BLUR_BOKEH_PIXELS); + BLI_assert(input_bokeh_buffer->get_height() == COM_BLUR_BOKEH_PIXELS); #ifdef COM_DEFOCUS_SEARCH float search[4]; - inputSearchProgram_->read(search, - x / InverseSearchRadiusOperation::DIVIDER, - y / InverseSearchRadiusOperation::DIVIDER, - nullptr); + input_search_program_->read(search, + x / InverseSearchRadiusOperation::DIVIDER, + y / InverseSearchRadiusOperation::DIVIDER, + nullptr); int minx = search[0]; int miny = search[1]; int maxx = search[2]; int maxy = search[3]; #else - int minx = MAX2(x - maxBlurScalar, 0); - int miny = MAX2(y - maxBlurScalar, 0); - int maxx = MIN2(x + maxBlurScalar, (int)getWidth()); - int maxy = MIN2(y + maxBlurScalar, (int)getHeight()); + int minx = MAX2(x - max_blur_scalar, 0); + int miny = MAX2(y - max_blur_scalar, 0); + int maxx = MIN2(x + max_blur_scalar, (int)get_width()); + int maxy = MIN2(y + max_blur_scalar, (int)get_height()); #endif { - inputSizeBuffer->readNoCheck(tempSize, x, y); - inputProgramBuffer->readNoCheck(readColor, x, y); + input_size_buffer->read_no_check(temp_size, x, y); + input_program_buffer->read_no_check(read_color, x, y); - copy_v4_v4(color_accum, readColor); + copy_v4_v4(color_accum, read_color); copy_v4_fl(multiplier_accum, 1.0f); - float size_center = tempSize[0] * scalar; + float size_center = temp_size[0] * scalar; - const int addXStepValue = QualityStepHelper::getStep(); - const int addYStepValue = addXStepValue; - const int addXStepColor = addXStepValue * COM_DATA_TYPE_COLOR_CHANNELS; + const int add_xstep_value = QualityStepHelper::get_step(); + const int add_ystep_value = add_xstep_value; + const int add_xstep_color = add_xstep_value * COM_DATA_TYPE_COLOR_CHANNELS; if (size_center > threshold_) { - for (int ny = miny; ny < maxy; ny += addYStepValue) { + for (int ny = miny; ny < maxy; ny += add_ystep_value) { float dy = ny - y; - int offsetValueNy = ny * inputSizeBuffer->getWidth(); - int offsetValueNxNy = offsetValueNy + (minx); - int offsetColorNxNy = offsetValueNxNy * COM_DATA_TYPE_COLOR_CHANNELS; - for (int nx = minx; nx < maxx; nx += addXStepValue) { + int offset_value_ny = ny * input_size_buffer->get_width(); + int offset_value_nx_ny = offset_value_ny + (minx); + int offset_color_nx_ny = offset_value_nx_ny * COM_DATA_TYPE_COLOR_CHANNELS; + for (int nx = minx; nx < maxx; nx += add_xstep_value) { if (nx != x || ny != y) { - float size = MIN2(inputSizeFloatBuffer[offsetValueNxNy] * scalar, size_center); + float size = MIN2(input_size_float_buffer[offset_value_nx_ny] * scalar, size_center); if (size > threshold_) { float dx = nx - x; if (size > fabsf(dx) && size > fabsf(dy)) { @@ -153,14 +154,14 @@ void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, (float)(COM_BLUR_BOKEH_PIXELS / 2) + (dy / size) * (float)((COM_BLUR_BOKEH_PIXELS / 2) - 1), }; - inputBokehBuffer->read(bokeh, uv[0], uv[1]); - madd_v4_v4v4(color_accum, bokeh, &inputProgramFloatBuffer[offsetColorNxNy]); + input_bokeh_buffer->read(bokeh, uv[0], uv[1]); + madd_v4_v4v4(color_accum, bokeh, &input_program_float_buffer[offset_color_nx_ny]); add_v4_v4(multiplier_accum, bokeh); } } } - offsetColorNxNy += addXStepColor; - offsetValueNxNy += addXStepValue; + offset_color_nx_ny += add_xstep_color; + offset_value_nx_ny += add_xstep_value; } } } @@ -174,98 +175,102 @@ void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, if ((size_center > threshold_) && (size_center < threshold_ * 2.0f)) { /* factor from 0-1 */ float fac = (size_center - threshold_) / threshold_; - interp_v4_v4v4(output, readColor, output, fac); + interp_v4_v4v4(output, read_color, output, fac); } } } -void VariableSizeBokehBlurOperation::executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list * /*clKernelsToCleanUp*/) +void VariableSizeBokehBlurOperation::execute_opencl( + OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list * /*cl_kernels_to_clean_up*/) { - cl_kernel defocusKernel = device->COM_clCreateKernel("defocusKernel", nullptr); + cl_kernel defocus_kernel = device->COM_cl_create_kernel("defocus_kernel", nullptr); - cl_int step = this->getStep(); - cl_int maxBlur; + cl_int step = this->get_step(); + cl_int max_blur; cl_float threshold = threshold_; - MemoryBuffer *sizeMemoryBuffer = inputSizeProgram_->getInputMemoryBuffer(inputMemoryBuffers); + MemoryBuffer *size_memory_buffer = input_size_program_->get_input_memory_buffer( + input_memory_buffers); - const float max_dim = MAX2(getWidth(), getHeight()); + const float max_dim = MAX2(get_width(), get_height()); cl_float scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; - maxBlur = (cl_int)min_ff(sizeMemoryBuffer->get_max_value() * scalar, (float)maxBlur_); - - device->COM_clAttachMemoryBufferToKernelParameter( - defocusKernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, inputProgram_); - device->COM_clAttachMemoryBufferToKernelParameter( - defocusKernel, 1, -1, clMemToCleanUp, inputMemoryBuffers, inputBokehProgram_); - device->COM_clAttachMemoryBufferToKernelParameter( - 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); - clSetKernelArg(defocusKernel, 7, sizeof(cl_int), &maxBlur); - clSetKernelArg(defocusKernel, 8, sizeof(cl_float), &threshold); - clSetKernelArg(defocusKernel, 9, sizeof(cl_float), &scalar); - device->COM_clAttachSizeToKernelParameter(defocusKernel, 10, this); - - device->COM_clEnqueueRange(defocusKernel, outputMemoryBuffer, 11, this); + max_blur = (cl_int)min_ff(size_memory_buffer->get_max_value() * scalar, (float)max_blur_); + + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + defocus_kernel, 0, -1, cl_mem_to_clean_up, input_memory_buffers, input_program_); + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + defocus_kernel, 1, -1, cl_mem_to_clean_up, input_memory_buffers, input_bokeh_program_); + device->COM_cl_attach_memory_buffer_to_kernel_parameter( + defocus_kernel, 2, 4, cl_mem_to_clean_up, input_memory_buffers, input_size_program_); + device->COM_cl_attach_output_memory_buffer_to_kernel_parameter( + defocus_kernel, 3, cl_output_buffer); + device->COM_cl_attach_memory_buffer_offset_to_kernel_parameter( + defocus_kernel, 5, output_memory_buffer); + clSetKernelArg(defocus_kernel, 6, sizeof(cl_int), &step); + clSetKernelArg(defocus_kernel, 7, sizeof(cl_int), &max_blur); + clSetKernelArg(defocus_kernel, 8, sizeof(cl_float), &threshold); + clSetKernelArg(defocus_kernel, 9, sizeof(cl_float), &scalar); + device->COM_cl_attach_size_to_kernel_parameter(defocus_kernel, 10, this); + + device->COM_cl_enqueue_range(defocus_kernel, output_memory_buffer, 11, this); } -void VariableSizeBokehBlurOperation::deinitExecution() +void VariableSizeBokehBlurOperation::deinit_execution() { - inputProgram_ = nullptr; - inputBokehProgram_ = nullptr; - inputSizeProgram_ = nullptr; + input_program_ = nullptr; + input_bokeh_program_ = nullptr; + input_size_program_ = nullptr; #ifdef COM_DEFOCUS_SEARCH - inputSearchProgram_ = nullptr; + input_search_program_ = nullptr; #endif } -bool VariableSizeBokehBlurOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool VariableSizeBokehBlurOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newInput; - rcti bokehInput; + rcti new_input; + rcti bokeh_input; - const float max_dim = MAX2(getWidth(), getHeight()); + const float max_dim = MAX2(get_width(), get_height()); 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; - newInput.ymax = input->ymax + maxBlurScalar - 2; - newInput.ymin = input->ymin - maxBlurScalar - 2; - bokehInput.xmax = COM_BLUR_BOKEH_PIXELS; - bokehInput.xmin = 0; - bokehInput.ymax = COM_BLUR_BOKEH_PIXELS; - bokehInput.ymin = 0; - - NodeOperation *operation = getInputOperation(2); - if (operation->determineDependingAreaOfInterest(&newInput, readOperation, output)) { + int max_blur_scalar = max_blur_ * scalar; + + new_input.xmax = input->xmax + max_blur_scalar + 2; + new_input.xmin = input->xmin - max_blur_scalar + 2; + new_input.ymax = input->ymax + max_blur_scalar - 2; + new_input.ymin = input->ymin - max_blur_scalar - 2; + bokeh_input.xmax = COM_BLUR_BOKEH_PIXELS; + bokeh_input.xmin = 0; + bokeh_input.ymax = COM_BLUR_BOKEH_PIXELS; + bokeh_input.ymin = 0; + + NodeOperation *operation = get_input_operation(2); + if (operation->determine_depending_area_of_interest(&new_input, read_operation, output)) { return true; } - operation = getInputOperation(1); - if (operation->determineDependingAreaOfInterest(&bokehInput, readOperation, output)) { + operation = get_input_operation(1); + if (operation->determine_depending_area_of_interest(&bokeh_input, read_operation, output)) { return true; } #ifdef COM_DEFOCUS_SEARCH - rcti searchInput; - searchInput.xmax = (input->xmax / InverseSearchRadiusOperation::DIVIDER) + 1; - searchInput.xmin = (input->xmin / InverseSearchRadiusOperation::DIVIDER) - 1; - searchInput.ymax = (input->ymax / InverseSearchRadiusOperation::DIVIDER) + 1; - searchInput.ymin = (input->ymin / InverseSearchRadiusOperation::DIVIDER) - 1; - operation = getInputOperation(3); - if (operation->determineDependingAreaOfInterest(&searchInput, readOperation, output)) { + rcti search_input; + search_input.xmax = (input->xmax / InverseSearchRadiusOperation::DIVIDER) + 1; + search_input.xmin = (input->xmin / InverseSearchRadiusOperation::DIVIDER) - 1; + search_input.ymax = (input->ymax / InverseSearchRadiusOperation::DIVIDER) + 1; + search_input.ymin = (input->ymin / InverseSearchRadiusOperation::DIVIDER) - 1; + operation = get_input_operation(3); + if (operation->determine_depending_area_of_interest(&search_input, read_operation, output)) { return true; } #endif - operation = getInputOperation(0); - if (operation->determineDependingAreaOfInterest(&newInput, readOperation, output)) { + operation = get_input_operation(0); + if (operation->determine_depending_area_of_interest(&new_input, read_operation, output)) { return true; } return false; @@ -278,9 +283,9 @@ void VariableSizeBokehBlurOperation::get_area_of_interest(const int input_idx, switch (input_idx) { case IMAGE_INPUT_INDEX: case SIZE_INPUT_INDEX: { - const float max_dim = MAX2(getWidth(), getHeight()); + const float max_dim = MAX2(get_width(), get_height()); const float scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; - const int max_blur_scalar = maxBlur_ * scalar; + const int max_blur_scalar = max_blur_ * 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; @@ -322,8 +327,8 @@ struct PixelData { static void blur_pixel(int x, int y, PixelData &p) { - BLI_assert(p.bokeh_input->getWidth() == COM_BLUR_BOKEH_PIXELS); - BLI_assert(p.bokeh_input->getHeight() == COM_BLUR_BOKEH_PIXELS); + BLI_assert(p.bokeh_input->get_width() == COM_BLUR_BOKEH_PIXELS); + BLI_assert(p.bokeh_input->get_height() == COM_BLUR_BOKEH_PIXELS); #ifdef COM_DEFOCUS_SEARCH float search[4]; @@ -388,20 +393,20 @@ void VariableSizeBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer * p.bokeh_input = inputs[BOKEH_INPUT_INDEX]; p.size_input = inputs[SIZE_INPUT_INDEX]; p.image_input = inputs[IMAGE_INPUT_INDEX]; - p.step = QualityStepHelper::getStep(); + p.step = QualityStepHelper::get_step(); p.threshold = threshold_; - p.image_width = this->getWidth(); - p.image_height = this->getHeight(); + p.image_width = this->get_width(); + p.image_height = this->get_height(); rcti scalar_area; this->get_area_of_interest(SIZE_INPUT_INDEX, area, scalar_area); BLI_rcti_isect(&scalar_area, &p.size_input->get_rect(), &scalar_area); const float max_size = p.size_input->get_max_value(scalar_area); - const float max_dim = MAX2(this->getWidth(), this->getHeight()); + const float max_dim = MAX2(this->get_width(), this->get_height()); p.scalar = do_size_scale_ ? (max_dim / 100.0f) : 1.0f; p.max_blur_scalar = static_cast(max_size * p.scalar); - CLAMP(p.max_blur_scalar, 1, maxBlur_); + CLAMP(p.max_blur_scalar, 1, max_blur_); for (BuffersIterator it = output->iterate_with({p.image_input, p.size_input}, area); !it.is_end(); @@ -434,34 +439,34 @@ void VariableSizeBokehBlurOperation::update_memory_buffer_partial(MemoryBuffer * /* #InverseSearchRadiusOperation. */ InverseSearchRadiusOperation::InverseSearchRadiusOperation() { - this->addInputSocket(DataType::Value, ResizeMode::Align); /* Radius. */ - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Value, ResizeMode::Align); /* Radius. */ + this->add_output_socket(DataType::Color); this->flags.complex = true; - inputRadius_ = nullptr; + input_radius_ = nullptr; } -void InverseSearchRadiusOperation::initExecution() +void InverseSearchRadiusOperation::init_execution() { - inputRadius_ = this->getInputSocketReader(0); + input_radius_ = this->get_input_socket_reader(0); } -void *InverseSearchRadiusOperation::initializeTileData(rcti *rect) +void *InverseSearchRadiusOperation::initialize_tile_data(rcti *rect) { MemoryBuffer *data = new MemoryBuffer(DataType::Color, rect); - float *buffer = data->getBuffer(); + float *buffer = data->get_buffer(); int x, y; - int width = inputRadius_->getWidth(); - int height = inputRadius_->getHeight(); + int width = input_radius_->get_width(); + int height = input_radius_->get_height(); 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 - 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); + buffer[offset] = MAX2(rx - max_blur_, 0); + buffer[offset + 1] = MAX2(ry - max_blur_, 0); + buffer[offset + 2] = MIN2(rx + DIVIDER + max_blur_, width); + buffer[offset + 3] = MIN2(ry + DIVIDER + max_blur_, height); offset += 4; } } @@ -476,7 +481,7 @@ void *InverseSearchRadiusOperation::initializeTileData(rcti *rect) for (int x2 = 0; x2 < DIVIDER; x2++) { for (int y2 = 0; y2 < DIVIDER; y2++) { - inputRadius_->read(temp, rx + x2, ry + y2, PixelSampler::Nearest); + input_radius_->read(temp, rx + x2, ry + y2, PixelSampler::Nearest); if (radius < temp[0]) { radius = temp[0]; maxx = x2; @@ -484,15 +489,15 @@ void *InverseSearchRadiusOperation::initializeTileData(rcti *rect) } } } - int impactRadius = ceil(radius / DIVIDER); - for (int x2 = x - impactRadius; x2 < x + impactRadius; x2++) { - for (int y2 = y - impactRadius; y2 < y + impactRadius; y2++) { + int impact_radius = ceil(radius / DIVIDER); + for (int x2 = x - impact_radius; x2 < x + impact_radius; x2++) { + for (int y2 = y - impact_radius; y2 < y + impact_radius; y2++) { data->read(temp, x2, y2); temp[0] = MIN2(temp[0], maxx); temp[1] = MIN2(temp[1], maxy); temp[2] = MAX2(temp[2], maxx); temp[3] = MAX2(temp[3], maxy); - data->writePixel(x2, y2, temp); + data->write_pixel(x2, y2, temp); } } } @@ -501,13 +506,13 @@ void *InverseSearchRadiusOperation::initializeTileData(rcti *rect) return data; } -void InverseSearchRadiusOperation::executePixelChunk(float output[4], int x, int y, void *data) +void InverseSearchRadiusOperation::execute_pixel_chunk(float output[4], int x, int y, void *data) { MemoryBuffer *buffer = (MemoryBuffer *)data; - buffer->readNoCheck(output, x, y); + buffer->read_no_check(output, x, y); } -void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, void *data) +void InverseSearchRadiusOperation::deinitialize_tile_data(rcti *rect, void *data) { if (data) { MemoryBuffer *mb = (MemoryBuffer *)data; @@ -515,28 +520,28 @@ void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, void *data) } } -void InverseSearchRadiusOperation::deinitExecution() +void InverseSearchRadiusOperation::deinit_execution() { - inputRadius_ = nullptr; + input_radius_ = nullptr; } -void InverseSearchRadiusOperation::determineResolution(unsigned int resolution[2], - unsigned int preferredResolution[2]) +void InverseSearchRadiusOperation::determine_resolution(unsigned int resolution[2], + unsigned int preferred_resolution[2]) { - NodeOperation::determineResolution(resolution, preferredResolution); + NodeOperation::determine_resolution(resolution, preferred_resolution); resolution[0] = resolution[0] / DIVIDER; resolution[1] = resolution[1] / DIVIDER; } -bool InverseSearchRadiusOperation::determineDependingAreaOfInterest( - rcti *input, ReadBufferOperation *readOperation, rcti *output) +bool InverseSearchRadiusOperation::determine_depending_area_of_interest( + rcti *input, ReadBufferOperation *read_operation, rcti *output) { - rcti newRect; - 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); + rcti new_rect; + new_rect.ymin = input->ymin * DIVIDER - max_blur_; + new_rect.ymax = input->ymax * DIVIDER + max_blur_; + new_rect.xmin = input->xmin * DIVIDER - max_blur_; + new_rect.xmax = input->xmax * DIVIDER + max_blur_; + return NodeOperation::determine_depending_area_of_interest(&new_rect, read_operation, output); } #endif diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h index c32d10ae3b9..7e53ed8a979 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 maxBlur_; + int max_blur_; float threshold_; bool do_size_scale_; /* scale size, matching 'BokehBlurNode' */ - SocketReader *inputProgram_; - SocketReader *inputBokehProgram_; - SocketReader *inputSizeProgram_; + SocketReader *input_program_; + SocketReader *input_bokeh_program_; + SocketReader *input_size_program_; #ifdef COM_DEFOCUS_SEARCH - SocketReader *inputSearchProgram_; + SocketReader *input_search_program_; #endif public: @@ -50,47 +50,47 @@ class VariableSizeBokehBlurOperation : public MultiThreadedOperation, public Qua /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; - void deinitializeTileData(rcti *rect, void *data) override; + void deinitialize_tile_data(rcti *rect, void *data) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; - void setMaxBlur(int maxRadius) + void set_max_blur(int max_radius) { - maxBlur_ = maxRadius; + max_blur_ = max_radius; } - void setThreshold(float threshold) + void set_threshold(float threshold) { threshold_ = threshold; } - void setDoScaleSize(bool scale_size) + void set_do_scale_size(bool scale_size) { do_size_scale_ = scale_size; } - void executeOpenCL(OpenCLDevice *device, - MemoryBuffer *outputMemoryBuffer, - cl_mem clOutputBuffer, - MemoryBuffer **inputMemoryBuffers, - std::list *clMemToCleanUp, - std::list *clKernelsToCleanUp) override; + void execute_opencl(OpenCLDevice *device, + MemoryBuffer *output_memory_buffer, + cl_mem cl_output_buffer, + MemoryBuffer **input_memory_buffers, + std::list *cl_mem_to_clean_up, + std::list *cl_kernels_to_clean_up) override; void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override; void update_memory_buffer_partial(MemoryBuffer *output, @@ -102,8 +102,8 @@ class VariableSizeBokehBlurOperation : public MultiThreadedOperation, public Qua #ifdef COM_DEFOCUS_SEARCH class InverseSearchRadiusOperation : public NodeOperation { private: - int maxBlur_; - SocketReader *inputRadius_; + int max_blur_; + SocketReader *input_radius_; public: static const int DIVIDER = 4; @@ -113,28 +113,28 @@ class InverseSearchRadiusOperation : public NodeOperation { /** * The inner loop of this operation. */ - void executePixelChunk(float output[4], int x, int y, void *data); + void execute_pixel_chunk(float output[4], int x, int y, void *data); /** * Initialize the execution */ - void initExecution() override; - void *initializeTileData(rcti *rect) override; - void deinitializeTileData(rcti *rect, void *data) override; + void init_execution() override; + void *initialize_tile_data(rcti *rect) override; + void deinitialize_tile_data(rcti *rect, void *data) override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void setMaxBlur(int maxRadius) + void set_max_blur(int max_radius) { - maxBlur_ = maxRadius; + max_blur_ = max_radius; } }; #endif diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.cc b/source/blender/compositor/operations/COM_VectorBlurOperation.cc index 6ebd8e27d76..8fd074749cd 100644 --- a/source/blender/compositor/operations/COM_VectorBlurOperation.cc +++ b/source/blender/compositor/operations/COM_VectorBlurOperation.cc @@ -42,76 +42,76 @@ void antialias_tagbuf(int xsize, int ysize, char *rectmove); /* VectorBlurOperation */ VectorBlurOperation::VectorBlurOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); /* ZBUF */ - this->addInputSocket(DataType::Color); /* SPEED */ - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); /* ZBUF */ + this->add_input_socket(DataType::Color); /* SPEED */ + this->add_output_socket(DataType::Color); settings_ = nullptr; - cachedInstance_ = nullptr; - inputImageProgram_ = nullptr; - inputSpeedProgram_ = nullptr; - inputZProgram_ = nullptr; + cached_instance_ = nullptr; + input_image_program_ = nullptr; + input_speed_program_ = nullptr; + input_zprogram_ = nullptr; flags.complex = true; flags.is_fullframe_operation = true; } -void VectorBlurOperation::initExecution() +void VectorBlurOperation::init_execution() { - initMutex(); - inputImageProgram_ = getInputSocketReader(0); - inputZProgram_ = getInputSocketReader(1); - inputSpeedProgram_ = getInputSocketReader(2); - cachedInstance_ = nullptr; - QualityStepHelper::initExecution(COM_QH_INCREASE); + init_mutex(); + input_image_program_ = get_input_socket_reader(0); + input_zprogram_ = get_input_socket_reader(1); + input_speed_program_ = get_input_socket_reader(2); + cached_instance_ = nullptr; + QualityStepHelper::init_execution(COM_QH_INCREASE); } -void VectorBlurOperation::executePixel(float output[4], int x, int y, void *data) +void VectorBlurOperation::execute_pixel(float output[4], int x, int y, void *data) { float *buffer = (float *)data; - int index = (y * this->getWidth() + x) * COM_DATA_TYPE_COLOR_CHANNELS; + int index = (y * this->get_width() + x) * COM_DATA_TYPE_COLOR_CHANNELS; copy_v4_v4(output, &buffer[index]); } -void VectorBlurOperation::deinitExecution() +void VectorBlurOperation::deinit_execution() { - deinitMutex(); - inputImageProgram_ = nullptr; - inputSpeedProgram_ = nullptr; - inputZProgram_ = nullptr; - if (cachedInstance_) { - MEM_freeN(cachedInstance_); - cachedInstance_ = nullptr; + deinit_mutex(); + input_image_program_ = nullptr; + input_speed_program_ = nullptr; + input_zprogram_ = nullptr; + if (cached_instance_) { + MEM_freeN(cached_instance_); + cached_instance_ = nullptr; } } -void *VectorBlurOperation::initializeTileData(rcti *rect) +void *VectorBlurOperation::initialize_tile_data(rcti *rect) { - if (cachedInstance_) { - return cachedInstance_; + if (cached_instance_) { + return cached_instance_; } - lockMutex(); - 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); - cachedInstance_ = data; + lock_mutex(); + if (cached_instance_ == nullptr) { + MemoryBuffer *tile = (MemoryBuffer *)input_image_program_->initialize_tile_data(rect); + MemoryBuffer *speed = (MemoryBuffer *)input_speed_program_->initialize_tile_data(rect); + MemoryBuffer *z = (MemoryBuffer *)input_zprogram_->initialize_tile_data(rect); + float *data = (float *)MEM_dupallocN(tile->get_buffer()); + this->generate_vector_blur(data, tile, speed, z); + cached_instance_ = data; } - unlockMutex(); - return cachedInstance_; + unlock_mutex(); + return cached_instance_; } -bool VectorBlurOperation::determineDependingAreaOfInterest(rcti * /*input*/, - ReadBufferOperation *readOperation, - rcti *output) +bool VectorBlurOperation::determine_depending_area_of_interest(rcti * /*input*/, + ReadBufferOperation *read_operation, + rcti *output) { - if (cachedInstance_ == nullptr) { - rcti newInput; - newInput.xmax = this->getWidth(); - newInput.xmin = 0; - newInput.ymax = this->getHeight(); - newInput.ymin = 0; - return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + if (cached_instance_ == nullptr) { + rcti new_input; + new_input.xmax = this->get_width(); + new_input.xmin = 0; + new_input.ymax = this->get_height(); + new_input.ymin = 0; + return NodeOperation::determine_depending_area_of_interest(&new_input, read_operation, output); } return false; @@ -129,12 +129,12 @@ void VectorBlurOperation::update_memory_buffer(MemoryBuffer *output, Span inputs) { /* TODO(manzanilla): once tiled implementation is removed, run multi-threaded where possible. */ - if (!cachedInstance_) { + if (!cached_instance_) { MemoryBuffer *image = inputs[IMAGE_INPUT_INDEX]; const bool is_image_inflated = image->is_a_single_elem(); image = is_image_inflated ? image->inflate() : image; - /* Must be a copy because it's modified in #generateVectorBlur. */ + /* Must be a copy because it's modified in #generate_vector_blur. */ MemoryBuffer *speed = inputs[SPEED_INPUT_INDEX]; speed = speed->is_a_single_elem() ? speed->inflate() : new MemoryBuffer(*speed); @@ -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; - cachedInstance_ = (float *)MEM_dupallocN(image->getBuffer()); - this->generateVectorBlur(cachedInstance_, image, speed, z); + cached_instance_ = (float *)MEM_dupallocN(image->get_buffer()); + this->generate_vector_blur(cached_instance_, image, speed, z); if (is_image_inflated) { delete image; @@ -154,29 +154,29 @@ void VectorBlurOperation::update_memory_buffer(MemoryBuffer *output, } } - const int num_channels = COM_data_type_num_channels(getOutputSocket()->getDataType()); - MemoryBuffer buf(cachedInstance_, num_channels, this->getWidth(), this->getHeight()); + const int num_channels = COM_data_type_num_channels(get_output_socket()->get_data_type()); + MemoryBuffer buf(cached_instance_, num_channels, this->get_width(), this->get_height()); output->copy_from(&buf, area); } -void VectorBlurOperation::generateVectorBlur(float *data, - MemoryBuffer *inputImage, - MemoryBuffer *inputSpeed, - MemoryBuffer *inputZ) +void VectorBlurOperation::generate_vector_blur(float *data, + MemoryBuffer *input_image, + MemoryBuffer *input_speed, + MemoryBuffer *inputZ) { NodeBlurData blurdata; - blurdata.samples = settings_->samples / QualityStepHelper::getStep(); + blurdata.samples = settings_->samples / QualityStepHelper::get_step(); blurdata.maxspeed = settings_->maxspeed; blurdata.minspeed = settings_->minspeed; blurdata.curved = settings_->curved; blurdata.fac = settings_->fac; zbuf_accumulate_vecblur(&blurdata, - this->getWidth(), - this->getHeight(), + this->get_width(), + this->get_height(), data, - inputImage->getBuffer(), - inputSpeed->getBuffer(), - inputZ->getBuffer()); + input_image->get_buffer(), + input_speed->get_buffer(), + inputZ->get_buffer()); } /* ****************** Spans ******************************* */ diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.h b/source/blender/compositor/operations/COM_VectorBlurOperation.h index cb384283c79..efcb5001fd4 100644 --- a/source/blender/compositor/operations/COM_VectorBlurOperation.h +++ b/source/blender/compositor/operations/COM_VectorBlurOperation.h @@ -31,18 +31,18 @@ class VectorBlurOperation : public NodeOperation, public QualityStepHelper { static constexpr int SPEED_INPUT_INDEX = 2; /** - * \brief Cached reference to the inputProgram + * \brief Cached reference to the input_program */ - SocketReader *inputImageProgram_; - SocketReader *inputSpeedProgram_; - SocketReader *inputZProgram_; + SocketReader *input_image_program_; + SocketReader *input_speed_program_; + SocketReader *input_zprogram_; /** * \brief settings of the glare node. */ NodeBlurData *settings_; - float *cachedInstance_; + float *cached_instance_; public: VectorBlurOperation(); @@ -50,27 +50,27 @@ class VectorBlurOperation : public NodeOperation, public QualityStepHelper { /** * The inner loop of this operation. */ - void executePixel(float output[4], int x, int y, void *data) override; + void execute_pixel(float output[4], int x, int y, void *data) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; - void *initializeTileData(rcti *rect) override; + void *initialize_tile_data(rcti *rect) override; - void setVectorBlurSettings(NodeBlurData *settings) + void set_vector_blur_settings(NodeBlurData *settings) { settings_ = settings; } - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; void get_area_of_interest(const int input_idx, const rcti &output_area, @@ -80,10 +80,10 @@ class VectorBlurOperation : public NodeOperation, public QualityStepHelper { Span inputs) override; protected: - void generateVectorBlur(float *data, - MemoryBuffer *inputImage, - MemoryBuffer *inputSpeed, - MemoryBuffer *inputZ); + void generate_vector_blur(float *data, + MemoryBuffer *input_image, + MemoryBuffer *input_speed, + MemoryBuffer *inputZ); }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_VectorCurveOperation.cc b/source/blender/compositor/operations/COM_VectorCurveOperation.cc index ade0c5ee788..c7cd8dc5684 100644 --- a/source/blender/compositor/operations/COM_VectorCurveOperation.cc +++ b/source/blender/compositor/operations/COM_VectorCurveOperation.cc @@ -24,40 +24,40 @@ namespace blender::compositor { VectorCurveOperation::VectorCurveOperation() { - this->addInputSocket(DataType::Vector); - this->addOutputSocket(DataType::Vector); + this->add_input_socket(DataType::Vector); + this->add_output_socket(DataType::Vector); - inputProgram_ = nullptr; + input_program_ = nullptr; } -void VectorCurveOperation::initExecution() +void VectorCurveOperation::init_execution() { - CurveBaseOperation::initExecution(); - inputProgram_ = this->getInputSocketReader(0); + CurveBaseOperation::init_execution(); + input_program_ = this->get_input_socket_reader(0); } -void VectorCurveOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void VectorCurveOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float input[4]; - inputProgram_->readSampled(input, x, y, sampler); + input_program_->read_sampled(input, x, y, sampler); - BKE_curvemapping_evaluate_premulRGBF(curveMapping_, output, input); + BKE_curvemapping_evaluate_premulRGBF(curve_mapping_, output, input); } -void VectorCurveOperation::deinitExecution() +void VectorCurveOperation::deinit_execution() { - CurveBaseOperation::deinitExecution(); - inputProgram_ = nullptr; + CurveBaseOperation::deinit_execution(); + input_program_ = nullptr; } void VectorCurveOperation::update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) { - CurveMapping *curve_map = curveMapping_; + CurveMapping *curve_map = curve_mapping_; for (BuffersIterator 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 0f819628935..87864e08e25 100644 --- a/source/blender/compositor/operations/COM_VectorCurveOperation.h +++ b/source/blender/compositor/operations/COM_VectorCurveOperation.h @@ -26,9 +26,9 @@ namespace blender::compositor { class VectorCurveOperation : public CurveBaseOperation { private: /** - * Cached reference to the inputProgram + * Cached reference to the input_program */ - SocketReader *inputProgram_; + SocketReader *input_program_; public: VectorCurveOperation(); @@ -36,17 +36,17 @@ class VectorCurveOperation : public CurveBaseOperation { /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; /** * Initialize the execution */ - void initExecution() override; + void init_execution() override; /** * Deinitialize the execution */ - void deinitExecution() override; + void deinit_execution() override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, diff --git a/source/blender/compositor/operations/COM_ViewerOperation.cc b/source/blender/compositor/operations/COM_ViewerOperation.cc index 5360b118dee..440deea7796 100644 --- a/source/blender/compositor/operations/COM_ViewerOperation.cc +++ b/source/blender/compositor/operations/COM_ViewerOperation.cc @@ -31,54 +31,54 @@ static int MAX_VIEWER_TRANSLATION_PADDING = 12000; ViewerOperation::ViewerOperation() { - this->setImage(nullptr); - this->setImageUser(nullptr); - outputBuffer_ = nullptr; - depthBuffer_ = nullptr; + this->set_image(nullptr); + this->set_image_user(nullptr); + output_buffer_ = nullptr; + depth_buffer_ = nullptr; active_ = false; - doDepthBuffer_ = false; - viewSettings_ = nullptr; - displaySettings_ = nullptr; - useAlphaInput_ = false; - - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Value); - - imageInput_ = nullptr; - alphaInput_ = nullptr; - depthInput_ = nullptr; + do_depth_buffer_ = false; + view_settings_ = nullptr; + display_settings_ = nullptr; + use_alpha_input_ = false; + + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Value); + + image_input_ = nullptr; + alpha_input_ = nullptr; + depth_input_ = nullptr; rd_ = nullptr; - viewName_ = nullptr; + view_name_ = nullptr; flags.use_viewer_border = true; flags.is_viewer_operation = true; } -void ViewerOperation::initExecution() +void ViewerOperation::init_execution() { /* When initializing the tree during initial load the width and height can be zero. */ - imageInput_ = getInputSocketReader(0); - alphaInput_ = getInputSocketReader(1); - depthInput_ = getInputSocketReader(2); - doDepthBuffer_ = (depthInput_ != nullptr); + image_input_ = get_input_socket_reader(0); + alpha_input_ = get_input_socket_reader(1); + depth_input_ = get_input_socket_reader(2); + do_depth_buffer_ = (depth_input_ != nullptr); - if (isActiveViewerOutput() && !exec_system_->is_breaked()) { - initImage(); + if (is_active_viewer_output() && !exec_system_->is_breaked()) { + init_image(); } } -void ViewerOperation::deinitExecution() +void ViewerOperation::deinit_execution() { - imageInput_ = nullptr; - alphaInput_ = nullptr; - depthInput_ = nullptr; - outputBuffer_ = nullptr; + image_input_ = nullptr; + alpha_input_ = nullptr; + depth_input_ = nullptr; + output_buffer_ = nullptr; } -void ViewerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) +void ViewerOperation::execute_region(rcti *rect, unsigned int /*tile_number*/) { - float *buffer = outputBuffer_; - float *depthbuffer = depthBuffer_; + float *buffer = output_buffer_; + float *depthbuffer = depth_buffer_; if (!buffer) { return; } @@ -86,9 +86,9 @@ void ViewerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) const int y1 = rect->ymin; const int x2 = rect->xmax; const int y2 = rect->ymax; - const int offsetadd = (this->getWidth() - (x2 - x1)); + const int offsetadd = (this->get_width() - (x2 - x1)); const int offsetadd4 = offsetadd * 4; - int offset = (y1 * this->getWidth() + x1); + int offset = (y1 * this->get_width() + x1); int offset4 = offset * 4; float alpha[4], depth[4]; int x; @@ -97,54 +97,54 @@ void ViewerOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) for (y = y1; y < y2 && (!breaked); y++) { for (x = x1; x < x2; x++) { - imageInput_->readSampled(&(buffer[offset4]), x, y, PixelSampler::Nearest); - if (useAlphaInput_) { - alphaInput_->readSampled(alpha, x, y, PixelSampler::Nearest); + image_input_->read_sampled(&(buffer[offset4]), x, y, PixelSampler::Nearest); + if (use_alpha_input_) { + alpha_input_->read_sampled(alpha, x, y, PixelSampler::Nearest); buffer[offset4 + 3] = alpha[0]; } - depthInput_->readSampled(depth, x, y, PixelSampler::Nearest); + depth_input_->read_sampled(depth, x, y, PixelSampler::Nearest); depthbuffer[offset] = depth[0]; offset++; offset4 += 4; } - if (isBraked()) { + if (is_braked()) { breaked = true; } offset += offsetadd; offset4 += offsetadd4; } - updateImage(rect); + update_image(rect); } void ViewerOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) { - const int sceneRenderWidth = rd_->xsch * rd_->size / 100; - const int sceneRenderHeight = rd_->ysch * rd_->size / 100; + const int scene_render_width = rd_->xsch * rd_->size / 100; + const int scene_render_height = rd_->ysch * rd_->size / 100; rcti local_preferred = preferred_area; - local_preferred.xmax = local_preferred.xmin + sceneRenderWidth; - local_preferred.ymax = local_preferred.ymin + sceneRenderHeight; + local_preferred.xmax = local_preferred.xmin + scene_render_width; + local_preferred.ymax = local_preferred.ymin + scene_render_height; NodeOperation::determine_canvas(local_preferred, r_area); } -void ViewerOperation::initImage() +void ViewerOperation::init_image() { Image *ima = image_; - ImageUser iuser = *imageUser_; + ImageUser iuser = *image_user_; void *lock; ImBuf *ibuf; /* make sure the image has the correct number of views */ - if (ima && BKE_scene_multiview_is_render_view_first(rd_, viewName_)) { - BKE_image_ensure_viewer_views(rd_, ima, imageUser_); + if (ima && BKE_scene_multiview_is_render_view_first(rd_, view_name_)) { + BKE_image_ensure_viewer_views(rd_, ima, image_user_); } BLI_thread_lock(LOCK_DRAW_IMAGE); /* local changes to the original ImageUser */ - iuser.multi_index = BKE_scene_multiview_view_id_get(rd_, viewName_); + iuser.multi_index = BKE_scene_multiview_view_id_get(rd_, view_name_); ibuf = BKE_image_acquire_ibuf(ima, &iuser, &lock); if (!ibuf) { @@ -161,8 +161,8 @@ void ViewerOperation::initImage() padding_y = MAX_VIEWER_TRANSLATION_PADDING; } - display_width_ = getWidth() + padding_x; - display_height_ = getHeight() + padding_y; + display_width_ = get_width() + padding_x; + display_height_ = get_height() + padding_y; if (ibuf->x != display_width_ || ibuf->y != display_height_) { imb_freerectImBuf(ibuf); imb_freerectfloatImBuf(ibuf); @@ -179,18 +179,18 @@ void ViewerOperation::initImage() ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID; } - if (doDepthBuffer_) { + if (do_depth_buffer_) { addzbuffloatImBuf(ibuf); } /* now we combine the input with ibuf */ - outputBuffer_ = ibuf->rect_float; + output_buffer_ = ibuf->rect_float; /* needed for display buffer update */ ibuf_ = ibuf; - if (doDepthBuffer_) { - depthBuffer_ = ibuf->zbuf_float; + if (do_depth_buffer_) { + depth_buffer_ = ibuf->zbuf_float; } BKE_image_release_ibuf(image_, ibuf_, lock); @@ -198,32 +198,32 @@ void ViewerOperation::initImage() BLI_thread_unlock(LOCK_DRAW_IMAGE); } -void ViewerOperation::updateImage(const rcti *rect) +void ViewerOperation::update_image(const rcti *rect) { if (exec_system_->is_breaked()) { return; } - float *buffer = outputBuffer_; + float *buffer = output_buffer_; IMB_partial_display_buffer_update(ibuf_, buffer, nullptr, display_width_, 0, 0, - viewSettings_, - displaySettings_, + view_settings_, + display_settings_, rect->xmin, rect->ymin, rect->xmax, rect->ymax); image_->gpuflag |= IMA_GPU_REFRESH; - this->updateDraw(); + this->update_draw(); } -eCompositorPriority ViewerOperation::getRenderPriority() const +eCompositorPriority ViewerOperation::get_render_priority() const { - if (this->isActiveViewerOutput()) { + if (this->is_active_viewer_output()) { return eCompositorPriority::High; } @@ -234,25 +234,25 @@ void ViewerOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output), const rcti &area, Span inputs) { - if (!outputBuffer_) { + if (!output_buffer_) { 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( - outputBuffer_, COM_DATA_TYPE_COLOR_CHANNELS, display_width_, display_height_); + output_buffer_, 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 (useAlphaInput_) { + if (use_alpha_input_) { 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 (depthBuffer_) { + if (depth_buffer_) { MemoryBuffer depth_buffer( - depthBuffer_, COM_DATA_TYPE_VALUE_CHANNELS, display_width_, display_height_); + depth_buffer_, 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); } @@ -263,27 +263,27 @@ void ViewerOperation::update_memory_buffer_partial(MemoryBuffer *UNUSED(output), offset_x + BLI_rcti_size_x(&area), offset_y, offset_y + BLI_rcti_size_y(&area)); - updateImage(&display_area); + update_image(&display_area); } void ViewerOperation::clear_display_buffer() { - BLI_assert(isActiveViewerOutput()); + BLI_assert(is_active_viewer_output()); if (exec_system_->is_breaked()) { return; } - initImage(); - if (outputBuffer_ == nullptr) { + init_image(); + if (output_buffer_ == nullptr) { return; } size_t buf_bytes = (size_t)ibuf_->y * ibuf_->x * COM_DATA_TYPE_COLOR_CHANNELS * sizeof(float); if (buf_bytes > 0) { - memset(outputBuffer_, 0, buf_bytes); + memset(output_buffer_, 0, buf_bytes); rcti display_area; BLI_rcti_init(&display_area, 0, ibuf_->x, 0, ibuf_->y); - updateImage(&display_area); + update_image(&display_area); } } diff --git a/source/blender/compositor/operations/COM_ViewerOperation.h b/source/blender/compositor/operations/COM_ViewerOperation.h index 9a812c8d87d..7fc5ae36ad9 100644 --- a/source/blender/compositor/operations/COM_ViewerOperation.h +++ b/source/blender/compositor/operations/COM_ViewerOperation.h @@ -28,105 +28,105 @@ namespace blender::compositor { class ViewerOperation : public MultiThreadedOperation { private: /* TODO(manzanilla): To be removed together with tiled implementation. */ - float *outputBuffer_; - float *depthBuffer_; + float *output_buffer_; + float *depth_buffer_; Image *image_; - ImageUser *imageUser_; + ImageUser *image_user_; bool active_; - float centerX_; - float centerY_; - ChunkOrdering chunkOrder_; - bool doDepthBuffer_; + float center_x_; + float center_y_; + ChunkOrdering chunk_order_; + bool do_depth_buffer_; ImBuf *ibuf_; - bool useAlphaInput_; + bool use_alpha_input_; const RenderData *rd_; - const char *viewName_; + const char *view_name_; - const ColorManagedViewSettings *viewSettings_; - const ColorManagedDisplaySettings *displaySettings_; + const ColorManagedViewSettings *view_settings_; + const ColorManagedDisplaySettings *display_settings_; - SocketReader *imageInput_; - SocketReader *alphaInput_; - SocketReader *depthInput_; + SocketReader *image_input_; + SocketReader *alpha_input_; + SocketReader *depth_input_; int display_width_; int display_height_; public: ViewerOperation(); - void initExecution() override; - void deinitExecution() override; - void executeRegion(rcti *rect, unsigned int tileNumber) override; + void init_execution() override; + void deinit_execution() override; + void execute_region(rcti *rect, unsigned int tile_number) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - bool isOutputOperation(bool /*rendering*/) const override + bool is_output_operation(bool /*rendering*/) const override { if (G.background) { return false; } - return isActiveViewerOutput(); + return is_active_viewer_output(); } - void setImage(Image *image) + void set_image(Image *image) { image_ = image; } - void setImageUser(ImageUser *imageUser) + void set_image_user(ImageUser *image_user) { - imageUser_ = imageUser; + image_user_ = image_user; } - bool isActiveViewerOutput() const override + bool is_active_viewer_output() const override { return active_; } - void setActive(bool active) + void set_active(bool active) { active_ = active; } void setCenterX(float centerX) { - centerX_ = centerX; + center_x_ = centerX; } void setCenterY(float centerY) { - centerY_ = centerY; + center_y_ = centerY; } - void setChunkOrder(ChunkOrdering tileOrder) + void set_chunk_order(ChunkOrdering tile_order) { - chunkOrder_ = tileOrder; + chunk_order_ = tile_order; } float getCenterX() const { - return centerX_; + return center_x_; } float getCenterY() const { - return centerY_; + return center_y_; } - ChunkOrdering getChunkOrder() const + ChunkOrdering get_chunk_order() const { - return chunkOrder_; + return chunk_order_; } - eCompositorPriority getRenderPriority() const override; - void setUseAlphaInput(bool value) + eCompositorPriority get_render_priority() const override; + void set_use_alpha_input(bool value) { - useAlphaInput_ = value; + use_alpha_input_ = value; } - void setRenderData(const RenderData *rd) + void set_render_data(const RenderData *rd) { rd_ = rd; } - void setViewName(const char *viewName) + void set_view_name(const char *view_name) { - viewName_ = viewName; + view_name_ = view_name; } - void setViewSettings(const ColorManagedViewSettings *viewSettings) + void set_view_settings(const ColorManagedViewSettings *view_settings) { - viewSettings_ = viewSettings; + view_settings_ = view_settings; } - void setDisplaySettings(const ColorManagedDisplaySettings *displaySettings) + void set_display_settings(const ColorManagedDisplaySettings *display_settings) { - displaySettings_ = displaySettings; + display_settings_ = display_settings; } void update_memory_buffer_partial(MemoryBuffer *output, @@ -136,8 +136,8 @@ class ViewerOperation : public MultiThreadedOperation { void clear_display_buffer(); private: - void updateImage(const rcti *rect); - void initImage(); + void update_image(const rcti *rect); + void init_image(); }; } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_WrapOperation.cc b/source/blender/compositor/operations/COM_WrapOperation.cc index be4798c605f..336e1b72520 100644 --- a/source/blender/compositor/operations/COM_WrapOperation.cc +++ b/source/blender/compositor/operations/COM_WrapOperation.cc @@ -24,98 +24,99 @@ namespace blender::compositor { WrapOperation::WrapOperation(DataType datatype) : ReadBufferOperation(datatype) { - wrappingType_ = CMP_NODE_WRAP_NONE; + wrapping_type_ = CMP_NODE_WRAP_NONE; } -inline float WrapOperation::getWrappedOriginalXPos(float x) +inline float WrapOperation::get_wrapped_original_xpos(float x) { - if (this->getWidth() == 0) { + if (this->get_width() == 0) { return 0; } while (x < 0) { - x += this->getWidth(); + x += this->get_width(); } - return fmodf(x, this->getWidth()); + return fmodf(x, this->get_width()); } -inline float WrapOperation::getWrappedOriginalYPos(float y) +inline float WrapOperation::get_wrapped_original_ypos(float y) { - if (this->getHeight() == 0) { + if (this->get_height() == 0) { return 0; } while (y < 0) { - y += this->getHeight(); + y += this->get_height(); } - return fmodf(y, this->getHeight()); + return fmodf(y, this->get_height()); } -void WrapOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) +void WrapOperation::execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) { float nx, ny; nx = x; ny = y; MemoryBufferExtend extend_x = MemoryBufferExtend::Clip, extend_y = MemoryBufferExtend::Clip; - switch (wrappingType_) { + switch (wrapping_type_) { case CMP_NODE_WRAP_NONE: - /* Intentionally empty, originalXPos and originalYPos have been set before. */ + /* Intentionally empty, original_xpos and original_ypos have been set before. */ break; case CMP_NODE_WRAP_X: /* Wrap only on the x-axis. */ - nx = this->getWrappedOriginalXPos(x); + nx = this->get_wrapped_original_xpos(x); extend_x = MemoryBufferExtend::Repeat; break; case CMP_NODE_WRAP_Y: /* Wrap only on the y-axis. */ - ny = this->getWrappedOriginalYPos(y); + ny = this->get_wrapped_original_ypos(y); extend_y = MemoryBufferExtend::Repeat; break; case CMP_NODE_WRAP_XY: /* Wrap on both. */ - nx = this->getWrappedOriginalXPos(x); - ny = this->getWrappedOriginalYPos(y); + nx = this->get_wrapped_original_xpos(x); + ny = this->get_wrapped_original_ypos(y); extend_x = MemoryBufferExtend::Repeat; extend_y = MemoryBufferExtend::Repeat; break; } - executePixelExtend(output, nx, ny, sampler, extend_x, extend_y); + execute_pixel_extend(output, nx, ny, sampler, extend_x, extend_y); } -bool WrapOperation::determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) +bool WrapOperation::determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) { - rcti newInput; - newInput.xmin = input->xmin; - newInput.xmax = input->xmax; - newInput.ymin = input->ymin; - newInput.ymax = input->ymax; + rcti new_input; + new_input.xmin = input->xmin; + new_input.xmax = input->xmax; + new_input.ymin = input->ymin; + new_input.ymax = input->ymax; - if (ELEM(wrappingType_, CMP_NODE_WRAP_X, CMP_NODE_WRAP_XY)) { + if (ELEM(wrapping_type_, 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)); - if (newInput.xmin >= newInput.xmax) { - newInput.xmin = 0; - newInput.xmax = this->getWidth(); + new_input.xmin = get_wrapped_original_xpos(input->xmin); + new_input.xmax = roundf(get_wrapped_original_xpos(input->xmax)); + if (new_input.xmin >= new_input.xmax) { + new_input.xmin = 0; + new_input.xmax = this->get_width(); } } - if (ELEM(wrappingType_, CMP_NODE_WRAP_Y, CMP_NODE_WRAP_XY)) { + if (ELEM(wrapping_type_, 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)); - if (newInput.ymin >= newInput.ymax) { - newInput.ymin = 0; - newInput.ymax = this->getHeight(); + new_input.ymin = get_wrapped_original_ypos(input->ymin); + new_input.ymax = roundf(get_wrapped_original_ypos(input->ymax)); + if (new_input.ymin >= new_input.ymax) { + new_input.ymin = 0; + new_input.ymax = this->get_height(); } } - return ReadBufferOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + return ReadBufferOperation::determine_depending_area_of_interest( + &new_input, read_operation, output); } -void WrapOperation::setWrapping(int wrapping_type) +void WrapOperation::set_wrapping(int wrapping_type) { - wrappingType_ = wrapping_type; + wrapping_type_ = wrapping_type; } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_WrapOperation.h b/source/blender/compositor/operations/COM_WrapOperation.h index 15fc43cc65a..e8ec97fa5f2 100644 --- a/source/blender/compositor/operations/COM_WrapOperation.h +++ b/source/blender/compositor/operations/COM_WrapOperation.h @@ -24,18 +24,18 @@ namespace blender::compositor { class WrapOperation : public ReadBufferOperation { private: - int wrappingType_; + int wrapping_type_; public: WrapOperation(DataType datatype); - bool determineDependingAreaOfInterest(rcti *input, - ReadBufferOperation *readOperation, - rcti *output) override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; - - void setWrapping(int wrapping_type); - float getWrappedOriginalXPos(float x); - float getWrappedOriginalYPos(float y); + bool determine_depending_area_of_interest(rcti *input, + ReadBufferOperation *read_operation, + rcti *output) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; + + void set_wrapping(int wrapping_type); + float get_wrapped_original_xpos(float x); + float get_wrapped_original_ypos(float y); void setFactorXY(float factorX, float factorY); }; diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.cc b/source/blender/compositor/operations/COM_WriteBufferOperation.cc index 26c1d71c9da..1c728772fdd 100644 --- a/source/blender/compositor/operations/COM_WriteBufferOperation.cc +++ b/source/blender/compositor/operations/COM_WriteBufferOperation.cc @@ -23,47 +23,47 @@ namespace blender::compositor { WriteBufferOperation::WriteBufferOperation(DataType datatype) { - this->addInputSocket(datatype); - memoryProxy_ = new MemoryProxy(datatype); - memoryProxy_->setWriteBufferOperation(this); - memoryProxy_->setExecutor(nullptr); + this->add_input_socket(datatype); + memory_proxy_ = new MemoryProxy(datatype); + memory_proxy_->set_write_buffer_operation(this); + memory_proxy_->set_executor(nullptr); flags.is_write_buffer_operation = true; } WriteBufferOperation::~WriteBufferOperation() { - if (memoryProxy_) { - delete memoryProxy_; - memoryProxy_ = nullptr; + if (memory_proxy_) { + delete memory_proxy_; + memory_proxy_ = nullptr; } } -void WriteBufferOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void WriteBufferOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { - input_->readSampled(output, x, y, sampler); + input_->read_sampled(output, x, y, sampler); } -void WriteBufferOperation::initExecution() +void WriteBufferOperation::init_execution() { - input_ = this->getInputOperation(0); - memoryProxy_->allocate(this->getWidth(), this->getHeight()); + input_ = this->get_input_operation(0); + memory_proxy_->allocate(this->get_width(), this->get_height()); } -void WriteBufferOperation::deinitExecution() +void WriteBufferOperation::deinit_execution() { input_ = nullptr; - memoryProxy_->free(); + memory_proxy_->free(); } -void WriteBufferOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/) +void WriteBufferOperation::execute_region(rcti *rect, unsigned int /*tile_number*/) { - MemoryBuffer *memoryBuffer = memoryProxy_->getBuffer(); - float *buffer = memoryBuffer->getBuffer(); - const uint8_t num_channels = memoryBuffer->get_num_channels(); + MemoryBuffer *memory_buffer = memory_proxy_->get_buffer(); + float *buffer = memory_buffer->get_buffer(); + const uint8_t num_channels = memory_buffer->get_num_channels(); if (input_->get_flags().complex) { - void *data = input_->initializeTileData(rect); + void *data = input_->initialize_tile_data(rect); int x1 = rect->xmin; int y1 = rect->ymin; int x2 = rect->xmax; @@ -72,17 +72,17 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/ int y; bool breaked = false; for (y = y1; y < y2 && (!breaked); y++) { - int offset4 = (y * memoryBuffer->getWidth() + x1) * num_channels; + int offset4 = (y * memory_buffer->get_width() + x1) * num_channels; for (x = x1; x < x2; x++) { input_->read(&(buffer[offset4]), x, y, data); offset4 += num_channels; } - if (isBraked()) { + if (is_braked()) { breaked = true; } } if (data) { - input_->deinitializeTileData(rect, data); + input_->deinitialize_tile_data(rect, data); data = nullptr; } } @@ -96,25 +96,25 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/ int y; bool breaked = false; for (y = y1; y < y2 && (!breaked); y++) { - int offset4 = (y * memoryBuffer->getWidth() + x1) * num_channels; + int offset4 = (y * memory_buffer->get_width() + x1) * num_channels; for (x = x1; x < x2; x++) { - input_->readSampled(&(buffer[offset4]), x, y, PixelSampler::Nearest); + input_->read_sampled(&(buffer[offset4]), x, y, PixelSampler::Nearest); offset4 += num_channels; } - if (isBraked()) { + if (is_braked()) { breaked = true; } } } } -void WriteBufferOperation::executeOpenCLRegion(OpenCLDevice *device, - rcti * /*rect*/, - unsigned int /*chunkNumber*/, - MemoryBuffer **inputMemoryBuffers, - MemoryBuffer *outputBuffer) +void WriteBufferOperation::execute_opencl_region(OpenCLDevice *device, + rcti * /*rect*/, + unsigned int /*chunk_number*/, + MemoryBuffer **input_memory_buffers, + MemoryBuffer *output_buffer) { - float *outputFloatBuffer = outputBuffer->getBuffer(); + float *output_float_buffer = output_buffer->get_buffer(); cl_int error; /* * 1. create cl_mem from outputbuffer @@ -125,55 +125,55 @@ void WriteBufferOperation::executeOpenCLRegion(OpenCLDevice *device, * NOTE: list of cl_mem will be filled by 2, and needs to be cleaned up by 4 */ /* STEP 1 */ - const unsigned int outputBufferWidth = outputBuffer->getWidth(); - const unsigned int outputBufferHeight = outputBuffer->getHeight(); - - const cl_image_format *imageFormat = OpenCLDevice::determineImageFormat(outputBuffer); - - cl_mem clOutputBuffer = clCreateImage2D(device->getContext(), - CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR, - imageFormat, - outputBufferWidth, - outputBufferHeight, - 0, - outputFloatBuffer, - &error); + const unsigned int output_buffer_width = output_buffer->get_width(); + const unsigned int output_buffer_height = output_buffer->get_height(); + + const cl_image_format *image_format = OpenCLDevice::determine_image_format(output_buffer); + + cl_mem cl_output_buffer = clCreateImage2D(device->get_context(), + CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR, + image_format, + output_buffer_width, + output_buffer_height, + 0, + output_float_buffer, + &error); if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); } /* STEP 2 */ - std::list *clMemToCleanUp = new std::list(); - clMemToCleanUp->push_back(clOutputBuffer); - std::list *clKernelsToCleanUp = new std::list(); + std::list *cl_mem_to_clean_up = new std::list(); + cl_mem_to_clean_up->push_back(cl_output_buffer); + std::list *cl_kernels_to_clean_up = new std::list(); - input_->executeOpenCL(device, - outputBuffer, - clOutputBuffer, - inputMemoryBuffers, - clMemToCleanUp, - clKernelsToCleanUp); + input_->execute_opencl(device, + output_buffer, + cl_output_buffer, + input_memory_buffers, + cl_mem_to_clean_up, + cl_kernels_to_clean_up); /* STEP 3 */ size_t origin[3] = {0, 0, 0}; - size_t region[3] = {outputBufferWidth, outputBufferHeight, 1}; + size_t region[3] = {output_buffer_width, output_buffer_height, 1}; // clFlush(queue); // clFinish(queue); - error = clEnqueueBarrier(device->getQueue()); + error = clEnqueueBarrier(device->get_queue()); if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); } - error = clEnqueueReadImage(device->getQueue(), - clOutputBuffer, + error = clEnqueueReadImage(device->get_queue(), + cl_output_buffer, CL_TRUE, origin, region, 0, 0, - outputFloatBuffer, + output_float_buffer, 0, nullptr, nullptr); @@ -181,27 +181,27 @@ void WriteBufferOperation::executeOpenCLRegion(OpenCLDevice *device, printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); } - this->getMemoryProxy()->getBuffer()->fill_from(*outputBuffer); + this->get_memory_proxy()->get_buffer()->fill_from(*output_buffer); /* STEP 4 */ - while (!clMemToCleanUp->empty()) { - cl_mem mem = clMemToCleanUp->front(); + while (!cl_mem_to_clean_up->empty()) { + cl_mem mem = cl_mem_to_clean_up->front(); error = clReleaseMemObject(mem); if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); } - clMemToCleanUp->pop_front(); + cl_mem_to_clean_up->pop_front(); } - while (!clKernelsToCleanUp->empty()) { - cl_kernel kernel = clKernelsToCleanUp->front(); + while (!cl_kernels_to_clean_up->empty()) { + cl_kernel kernel = cl_kernels_to_clean_up->front(); error = clReleaseKernel(kernel); if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); } - clKernelsToCleanUp->pop_front(); + cl_kernels_to_clean_up->pop_front(); } - delete clKernelsToCleanUp; + delete cl_kernels_to_clean_up; } void WriteBufferOperation::determine_canvas(const rcti &preferred_area, rcti &r_area) @@ -219,11 +219,11 @@ void WriteBufferOperation::determine_canvas(const rcti &preferred_area, rcti &r_ } } -void WriteBufferOperation::readResolutionFromInputSocket() +void WriteBufferOperation::read_resolution_from_input_socket() { - NodeOperation *inputOperation = this->getInputOperation(0); - this->setWidth(inputOperation->getWidth()); - this->setHeight(inputOperation->getHeight()); + NodeOperation *input_operation = this->get_input_operation(0); + this->set_width(input_operation->get_width()); + this->set_height(input_operation->get_height()); } } // namespace blender::compositor diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.h b/source/blender/compositor/operations/COM_WriteBufferOperation.h index bd8a2876a42..cf6b7f655ce 100644 --- a/source/blender/compositor/operations/COM_WriteBufferOperation.h +++ b/source/blender/compositor/operations/COM_WriteBufferOperation.h @@ -31,34 +31,34 @@ class MemoryProxy; * \ingroup Operation */ class WriteBufferOperation : public NodeOperation { - MemoryProxy *memoryProxy_; + MemoryProxy *memory_proxy_; bool single_value_; /* single value stored in buffer */ NodeOperation *input_; public: WriteBufferOperation(DataType datatype); ~WriteBufferOperation(); - MemoryProxy *getMemoryProxy() + MemoryProxy *get_memory_proxy() { - return memoryProxy_; + return memory_proxy_; } - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; - bool isSingleValue() const + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; + bool is_single_value() const { return single_value_; } - void executeRegion(rcti *rect, unsigned int tileNumber) override; - void initExecution() override; - void deinitExecution() override; - void executeOpenCLRegion(OpenCLDevice *device, - rcti *rect, - unsigned int chunkNumber, - MemoryBuffer **memoryBuffers, - MemoryBuffer *outputBuffer) override; + void execute_region(rcti *rect, unsigned int tile_number) override; + void init_execution() override; + void deinit_execution() override; + void execute_opencl_region(OpenCLDevice *device, + rcti *rect, + unsigned int chunk_number, + MemoryBuffer **memory_buffers, + MemoryBuffer *output_buffer) override; void determine_canvas(const rcti &preferred_area, rcti &r_area) override; - void readResolutionFromInputSocket(); - inline NodeOperation *getInput() + void read_resolution_from_input_socket(); + inline NodeOperation *get_input() { return input_; } diff --git a/source/blender/compositor/operations/COM_ZCombineOperation.cc b/source/blender/compositor/operations/COM_ZCombineOperation.cc index 3a0126a12d4..9593e909d5a 100644 --- a/source/blender/compositor/operations/COM_ZCombineOperation.cc +++ b/source/blender/compositor/operations/COM_ZCombineOperation.cc @@ -22,11 +22,11 @@ namespace blender::compositor { ZCombineOperation::ZCombineOperation() { - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Value); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Value); + this->add_output_socket(DataType::Color); image1Reader_ = nullptr; depth1Reader_ = nullptr; @@ -35,29 +35,29 @@ ZCombineOperation::ZCombineOperation() this->flags.can_be_constant = true; } -void ZCombineOperation::initExecution() +void ZCombineOperation::init_execution() { - image1Reader_ = this->getInputSocketReader(0); - depth1Reader_ = this->getInputSocketReader(1); - image2Reader_ = this->getInputSocketReader(2); - depth2Reader_ = this->getInputSocketReader(3); + image1Reader_ = this->get_input_socket_reader(0); + depth1Reader_ = this->get_input_socket_reader(1); + image2Reader_ = this->get_input_socket_reader(2); + depth2Reader_ = this->get_input_socket_reader(3); } -void ZCombineOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ZCombineOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float depth1[4]; float depth2[4]; - depth1Reader_->readSampled(depth1, x, y, sampler); - depth2Reader_->readSampled(depth2, x, y, sampler); + depth1Reader_->read_sampled(depth1, x, y, sampler); + depth2Reader_->read_sampled(depth2, x, y, sampler); if (depth1[0] < depth2[0]) { - image1Reader_->readSampled(output, x, y, sampler); + image1Reader_->read_sampled(output, x, y, sampler); } else { - image2Reader_->readSampled(output, x, y, sampler); + image2Reader_->read_sampled(output, x, y, sampler); } } @@ -73,25 +73,25 @@ void ZCombineOperation::update_memory_buffer_partial(MemoryBuffer *output, } } -void ZCombineAlphaOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ZCombineAlphaOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float depth1[4]; float depth2[4]; float color1[4]; float color2[4]; - depth1Reader_->readSampled(depth1, x, y, sampler); - depth2Reader_->readSampled(depth2, x, y, sampler); + depth1Reader_->read_sampled(depth1, x, y, sampler); + depth2Reader_->read_sampled(depth2, x, y, sampler); if (depth1[0] <= depth2[0]) { - image1Reader_->readSampled(color1, x, y, sampler); - image2Reader_->readSampled(color2, x, y, sampler); + image1Reader_->read_sampled(color1, x, y, sampler); + image2Reader_->read_sampled(color2, x, y, sampler); } else { - image1Reader_->readSampled(color2, x, y, sampler); - image2Reader_->readSampled(color1, x, y, sampler); + image1Reader_->read_sampled(color2, x, y, sampler); + image2Reader_->read_sampled(color1, x, y, sampler); } float fac = color1[3]; float ifac = 1.0f - fac; @@ -127,7 +127,7 @@ void ZCombineAlphaOperation::update_memory_buffer_partial(MemoryBuffer *output, } } -void ZCombineOperation::deinitExecution() +void ZCombineOperation::deinit_execution() { image1Reader_ = nullptr; depth1Reader_ = nullptr; @@ -138,35 +138,35 @@ void ZCombineOperation::deinitExecution() // MASK combine ZCombineMaskOperation::ZCombineMaskOperation() { - this->addInputSocket(DataType::Value); // mask - this->addInputSocket(DataType::Color); - this->addInputSocket(DataType::Color); - this->addOutputSocket(DataType::Color); + this->add_input_socket(DataType::Value); // mask + this->add_input_socket(DataType::Color); + this->add_input_socket(DataType::Color); + this->add_output_socket(DataType::Color); - maskReader_ = nullptr; + mask_reader_ = nullptr; image1Reader_ = nullptr; image2Reader_ = nullptr; } -void ZCombineMaskOperation::initExecution() +void ZCombineMaskOperation::init_execution() { - maskReader_ = this->getInputSocketReader(0); - image1Reader_ = this->getInputSocketReader(1); - image2Reader_ = this->getInputSocketReader(2); + mask_reader_ = this->get_input_socket_reader(0); + image1Reader_ = this->get_input_socket_reader(1); + image2Reader_ = this->get_input_socket_reader(2); } -void ZCombineMaskOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ZCombineMaskOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float mask[4]; float color1[4]; float color2[4]; - maskReader_->readSampled(mask, x, y, sampler); - image1Reader_->readSampled(color1, x, y, sampler); - image2Reader_->readSampled(color2, x, y, sampler); + mask_reader_->read_sampled(mask, x, y, sampler); + image1Reader_->read_sampled(color1, x, y, sampler); + image2Reader_->read_sampled(color2, x, y, sampler); interp_v4_v4v4(output, color1, color2, 1.0f - mask[0]); } @@ -183,18 +183,18 @@ void ZCombineMaskOperation::update_memory_buffer_partial(MemoryBuffer *output, } } -void ZCombineMaskAlphaOperation::executePixelSampled(float output[4], - float x, - float y, - PixelSampler sampler) +void ZCombineMaskAlphaOperation::execute_pixel_sampled(float output[4], + float x, + float y, + PixelSampler sampler) { float mask[4]; float color1[4]; float color2[4]; - maskReader_->readSampled(mask, x, y, sampler); - image1Reader_->readSampled(color1, x, y, sampler); - image2Reader_->readSampled(color2, x, y, sampler); + mask_reader_->read_sampled(mask, x, y, sampler); + image1Reader_->read_sampled(color1, x, y, sampler); + image2Reader_->read_sampled(color2, x, y, sampler); float fac = (1.0f - mask[0]) * (1.0f - color1[3]) + mask[0] * color2[3]; float mfac = 1.0f - fac; @@ -223,10 +223,10 @@ void ZCombineMaskAlphaOperation::update_memory_buffer_partial(MemoryBuffer *outp } } -void ZCombineMaskOperation::deinitExecution() +void ZCombineMaskOperation::deinit_execution() { image1Reader_ = nullptr; - maskReader_ = nullptr; + mask_reader_ = nullptr; image2Reader_ = nullptr; } diff --git a/source/blender/compositor/operations/COM_ZCombineOperation.h b/source/blender/compositor/operations/COM_ZCombineOperation.h index 612107e3c77..ffc1bdd93b4 100644 --- a/source/blender/compositor/operations/COM_ZCombineOperation.h +++ b/source/blender/compositor/operations/COM_ZCombineOperation.h @@ -39,13 +39,13 @@ class ZCombineOperation : public MultiThreadedOperation { */ ZCombineOperation(); - void initExecution() override; - void deinitExecution() override; + void init_execution() override; + void deinit_execution() override; /** * The inner loop of this operation. */ - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -53,7 +53,7 @@ class ZCombineOperation : public MultiThreadedOperation { }; class ZCombineAlphaOperation : public ZCombineOperation { - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, @@ -62,23 +62,23 @@ class ZCombineAlphaOperation : public ZCombineOperation { class ZCombineMaskOperation : public MultiThreadedOperation { protected: - SocketReader *maskReader_; + SocketReader *mask_reader_; SocketReader *image1Reader_; SocketReader *image2Reader_; public: ZCombineMaskOperation(); - void initExecution() override; - void deinitExecution() override; - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void init_execution() override; + void deinit_execution() override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, Span inputs) override; }; class ZCombineMaskAlphaOperation : public ZCombineMaskOperation { - void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) override; + void execute_pixel_sampled(float output[4], float x, float y, PixelSampler sampler) override; void update_memory_buffer_partial(MemoryBuffer *output, const rcti &area, -- cgit v1.2.3