From 6a1d82490e49d1f5d73b5082516b087d44010fb8 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Tue, 26 Jun 2012 01:22:05 +0000 Subject: use m_ prefix for compositor class members (all compositor operations). --- .../operations/COM_AlphaOverKeyOperation.cpp | 6 +- .../operations/COM_AlphaOverMixedOperation.cpp | 6 +- .../COM_AlphaOverPremultiplyOperation.cpp | 6 +- .../operations/COM_AntiAliasOperation.cpp | 30 ++-- .../compositor/operations/COM_AntiAliasOperation.h | 4 +- .../operations/COM_BilateralBlurOperation.cpp | 26 ++-- .../operations/COM_BilateralBlurOperation.h | 10 +- .../operations/COM_BlurBaseOperation.cpp | 52 +++---- .../compositor/operations/COM_BlurBaseOperation.h | 29 ++-- .../operations/COM_BokehBlurOperation.cpp | 60 ++++---- .../compositor/operations/COM_BokehBlurOperation.h | 16 +-- .../operations/COM_BokehImageOperation.cpp | 58 ++++---- .../operations/COM_BokehImageOperation.h | 22 +-- .../compositor/operations/COM_BoxMaskOperation.cpp | 50 +++---- .../compositor/operations/COM_BoxMaskOperation.h | 18 +-- .../operations/COM_BrightnessOperation.cpp | 20 +-- .../operations/COM_BrightnessOperation.h | 6 +- .../operations/COM_CalculateMeanOperation.cpp | 29 ++-- .../operations/COM_CalculateMeanOperation.h | 10 +- .../COM_CalculateStandardDeviationOperation.cpp | 17 ++- .../COM_CalculateStandardDeviationOperation.h | 2 +- .../operations/COM_ChangeHSVOperation.cpp | 14 +- .../compositor/operations/COM_ChangeHSVOperation.h | 14 +- .../operations/COM_ChannelMatteOperation.cpp | 52 +++---- .../operations/COM_ChannelMatteOperation.h | 28 ++-- .../operations/COM_ChromaMatteOperation.cpp | 22 +-- .../operations/COM_ChromaMatteOperation.h | 8 +- .../operations/COM_ColorBalanceASCCDLOperation.cpp | 22 +-- .../operations/COM_ColorBalanceASCCDLOperation.h | 16 +-- .../operations/COM_ColorBalanceLGGOperation.cpp | 22 +-- .../operations/COM_ColorBalanceLGGOperation.h | 28 ++-- .../operations/COM_ColorCorrectionOperation.cpp | 60 ++++---- .../operations/COM_ColorCorrectionOperation.h | 20 +-- .../operations/COM_ColorCurveOperation.cpp | 64 ++++----- .../operations/COM_ColorCurveOperation.h | 20 +-- .../operations/COM_ColorMatteOperation.cpp | 22 +-- .../operations/COM_ColorMatteOperation.h | 8 +- .../operations/COM_ColorRampOperation.cpp | 12 +- .../compositor/operations/COM_ColorRampOperation.h | 6 +- .../operations/COM_ColorSpillOperation.cpp | 86 +++++------ .../operations/COM_ColorSpillOperation.h | 18 +-- .../operations/COM_CombineChannelsOperation.cpp | 40 +++--- .../operations/COM_CombineChannelsOperation.h | 8 +- .../operations/COM_CompositorOperation.cpp | 44 +++--- .../operations/COM_CompositorOperation.h | 10 +- .../COM_ConvertColorProfileOperation.cpp | 12 +- .../operations/COM_ConvertColorProfileOperation.h | 14 +- .../operations/COM_ConvertColorToBWOperation.cpp | 8 +- .../operations/COM_ConvertColorToBWOperation.h | 2 +- .../COM_ConvertColorToVectorOperation.cpp | 8 +- .../operations/COM_ConvertColorToVectorOperation.h | 2 +- .../operations/COM_ConvertColourToValueProg.cpp | 8 +- .../operations/COM_ConvertColourToValueProg.h | 2 +- .../COM_ConvertDepthToRadiusOperation.cpp | 36 ++--- .../operations/COM_ConvertDepthToRadiusOperation.h | 24 ++-- .../operations/COM_ConvertHSVToRGBOperation.cpp | 8 +- .../operations/COM_ConvertHSVToRGBOperation.h | 2 +- .../operations/COM_ConvertKeyToPremulOperation.cpp | 8 +- .../operations/COM_ConvertKeyToPremulOperation.h | 2 +- .../operations/COM_ConvertPremulToKeyOperation.cpp | 8 +- .../operations/COM_ConvertPremulToKeyOperation.h | 2 +- .../operations/COM_ConvertRGBToHSVOperation.cpp | 8 +- .../operations/COM_ConvertRGBToHSVOperation.h | 2 +- .../operations/COM_ConvertRGBToYCCOperation.cpp | 16 +-- .../operations/COM_ConvertRGBToYCCOperation.h | 4 +- .../operations/COM_ConvertRGBToYUVOperation.cpp | 8 +- .../operations/COM_ConvertRGBToYUVOperation.h | 2 +- .../operations/COM_ConvertValueToColourProg.cpp | 8 +- .../operations/COM_ConvertValueToColourProg.h | 2 +- .../COM_ConvertValueToVectorOperation.cpp | 8 +- .../operations/COM_ConvertValueToVectorOperation.h | 2 +- .../COM_ConvertVectorToColorOperation.cpp | 8 +- .../operations/COM_ConvertVectorToColorOperation.h | 2 +- .../COM_ConvertVectorToValueOperation.cpp | 8 +- .../operations/COM_ConvertVectorToValueOperation.h | 2 +- .../operations/COM_ConvertYCCToRGBOperation.cpp | 16 +-- .../operations/COM_ConvertYCCToRGBOperation.h | 4 +- .../operations/COM_ConvertYUVToRGBOperation.cpp | 8 +- .../operations/COM_ConvertYUVToRGBOperation.h | 2 +- .../COM_ConvolutionEdgeFilterOperation.cpp | 56 ++++---- .../operations/COM_ConvolutionFilterOperation.cpp | 84 +++++------ .../operations/COM_ConvolutionFilterOperation.h | 10 +- .../compositor/operations/COM_CropOperation.cpp | 65 ++++----- .../compositor/operations/COM_CropOperation.h | 18 +-- .../operations/COM_CurveBaseOperation.cpp | 4 +- .../compositor/operations/COM_CurveBaseOperation.h | 4 +- .../operations/COM_DifferenceMatteOperation.cpp | 20 +-- .../operations/COM_DifferenceMatteOperation.h | 8 +- .../operations/COM_DilateErodeOperation.cpp | 156 ++++++++++---------- .../operations/COM_DilateErodeOperation.h | 32 ++--- .../operations/COM_DirectionalBlurOperation.cpp | 63 ++++---- .../operations/COM_DirectionalBlurOperation.h | 12 +- .../operations/COM_DisplaceOperation.cpp | 44 +++--- .../compositor/operations/COM_DisplaceOperation.h | 12 +- .../operations/COM_DisplaceSimpleOperation.cpp | 40 +++--- .../operations/COM_DisplaceSimpleOperation.h | 12 +- .../operations/COM_DistanceMatteOperation.cpp | 20 +-- .../operations/COM_DistanceMatteOperation.h | 8 +- .../operations/COM_DotproductOperation.cpp | 16 +-- .../operations/COM_DotproductOperation.h | 4 +- .../operations/COM_DoubleEdgeMaskOperation.cpp | 45 +++--- .../operations/COM_DoubleEdgeMaskOperation.h | 14 +- .../operations/COM_EllipseMaskOperation.cpp | 46 +++--- .../operations/COM_EllipseMaskOperation.h | 18 +-- .../operations/COM_FastGaussianBlurOperation.cpp | 34 ++--- .../operations/COM_FastGaussianBlurOperation.h | 6 +- .../compositor/operations/COM_FlipOperation.cpp | 20 +-- .../compositor/operations/COM_FlipOperation.h | 10 +- .../operations/COM_GammaCorrectOperation.cpp | 16 +-- .../operations/COM_GammaCorrectOperation.h | 4 +- .../compositor/operations/COM_GammaOperation.cpp | 16 +-- .../compositor/operations/COM_GammaOperation.h | 4 +- .../operations/COM_GaussianAlphaXBlurOperation.cpp | 58 ++++---- .../operations/COM_GaussianAlphaXBlurOperation.h | 14 +- .../operations/COM_GaussianAlphaYBlurOperation.cpp | 58 ++++---- .../operations/COM_GaussianAlphaYBlurOperation.h | 14 +- .../operations/COM_GaussianBokehBlurOperation.cpp | 50 +++---- .../operations/COM_GaussianBokehBlurOperation.h | 4 +- .../operations/COM_GaussianXBlurOperation.cpp | 40 +++--- .../operations/COM_GaussianXBlurOperation.h | 4 +- .../operations/COM_GaussianYBlurOperation.cpp | 40 +++--- .../operations/COM_GaussianYBlurOperation.h | 4 +- .../operations/COM_GlareBaseOperation.cpp | 10 +- .../compositor/operations/COM_GlareBaseOperation.h | 6 +- .../operations/COM_GlareFogGlowOperation.h | 3 +- .../operations/COM_GlareGhostOperation.h | 3 +- .../operations/COM_GlareSimpleStarOperation.h | 3 +- .../operations/COM_GlareStreaksOperation.h | 3 +- .../operations/COM_GlareThresholdOperation.cpp | 14 +- .../operations/COM_GlareThresholdOperation.h | 6 +- .../COM_HueSaturationValueCorrectOperation.cpp | 14 +- .../COM_HueSaturationValueCorrectOperation.h | 2 +- .../compositor/operations/COM_IDMaskOperation.cpp | 10 +- .../compositor/operations/COM_IDMaskOperation.h | 6 +- .../compositor/operations/COM_ImageOperation.cpp | 61 ++++---- .../compositor/operations/COM_ImageOperation.h | 24 ++-- .../compositor/operations/COM_InvertOperation.cpp | 24 ++-- .../compositor/operations/COM_InvertOperation.h | 12 +- .../operations/COM_KeyingBlurOperation.cpp | 20 +-- .../operations/COM_KeyingBlurOperation.h | 8 +- .../operations/COM_KeyingClipOperation.cpp | 30 ++-- .../operations/COM_KeyingClipOperation.h | 20 +-- .../operations/COM_KeyingDespillOperation.cpp | 22 +-- .../operations/COM_KeyingDespillOperation.h | 8 +- .../compositor/operations/COM_KeyingOperation.cpp | 38 ++--- .../compositor/operations/COM_KeyingOperation.h | 12 +- .../operations/COM_KeyingScreenOperation.cpp | 46 +++--- .../operations/COM_KeyingScreenOperation.h | 24 ++-- .../operations/COM_LuminanceMatteOperation.cpp | 12 +- .../operations/COM_LuminanceMatteOperation.h | 6 +- .../compositor/operations/COM_MapUVOperation.cpp | 40 +++--- .../compositor/operations/COM_MapUVOperation.h | 8 +- .../operations/COM_MapValueOperation.cpp | 10 +- .../compositor/operations/COM_MapValueOperation.h | 6 +- .../compositor/operations/COM_MaskOperation.cpp | 44 +++--- .../compositor/operations/COM_MaskOperation.h | 26 ++-- .../operations/COM_MathBaseOperation.cpp | 80 +++++------ .../compositor/operations/COM_MathBaseOperation.h | 4 +- .../compositor/operations/COM_MixAddOperation.cpp | 6 +- .../compositor/operations/COM_MixBaseOperation.cpp | 24 ++-- .../compositor/operations/COM_MixBaseOperation.h | 12 +- .../operations/COM_MixBlendOperation.cpp | 6 +- .../compositor/operations/COM_MixBurnOperation.cpp | 6 +- .../operations/COM_MixColorOperation.cpp | 6 +- .../operations/COM_MixDarkenOperation.cpp | 6 +- .../operations/COM_MixDifferenceOperation.cpp | 6 +- .../operations/COM_MixDivideOperation.cpp | 6 +- .../operations/COM_MixDodgeOperation.cpp | 6 +- .../operations/COM_MixGlareOperation.cpp | 6 +- .../compositor/operations/COM_MixHueOperation.cpp | 6 +- .../operations/COM_MixLightenOperation.cpp | 6 +- .../operations/COM_MixLinearLightOperation.cpp | 6 +- .../operations/COM_MixMultiplyOperation.cpp | 6 +- .../operations/COM_MixOverlayOperation.cpp | 6 +- .../operations/COM_MixSaturationOperation.cpp | 6 +- .../operations/COM_MixScreenOperation.cpp | 6 +- .../operations/COM_MixSoftLightOperation.cpp | 6 +- .../operations/COM_MixSubtractOperation.cpp | 6 +- .../operations/COM_MixValueOperation.cpp | 6 +- .../operations/COM_MovieClipAttributeOperation.cpp | 28 ++-- .../operations/COM_MovieClipAttributeOperation.h | 16 +-- .../operations/COM_MovieClipOperation.cpp | 43 +++--- .../compositor/operations/COM_MovieClipOperation.h | 18 +-- .../operations/COM_MovieDistortionOperation.cpp | 42 +++--- .../operations/COM_MovieDistortionOperation.h | 123 ++++++++-------- .../operations/COM_MultilayerImageOperation.cpp | 32 ++--- .../operations/COM_MultilayerImageOperation.h | 6 +- .../operations/COM_NormalizeOperation.cpp | 24 ++-- .../compositor/operations/COM_NormalizeOperation.h | 4 +- .../operations/COM_OutputFileOperation.cpp | 82 +++++------ .../operations/COM_OutputFileOperation.h | 24 ++-- .../compositor/operations/COM_PreviewOperation.cpp | 64 +++++---- .../compositor/operations/COM_PreviewOperation.h | 10 +- .../COM_ProjectorLensDistortionOperation.cpp | 34 ++--- .../COM_ProjectorLensDistortionOperation.h | 12 +- .../operations/COM_QualityStepHelper.cpp | 34 ++--- .../compositor/operations/COM_QualityStepHelper.h | 12 +- .../operations/COM_ReadBufferOperation.cpp | 18 +-- .../operations/COM_ReadBufferOperation.h | 14 +- .../operations/COM_RenderLayersBaseProg.cpp | 38 ++--- .../operations/COM_RenderLayersBaseProg.h | 20 +-- .../operations/COM_RenderLayersMistOperation.h | 22 +++ .../compositor/operations/COM_RotateOperation.cpp | 66 ++++----- .../compositor/operations/COM_RotateOperation.h | 18 +-- .../compositor/operations/COM_ScaleOperation.cpp | 160 ++++++++++----------- .../compositor/operations/COM_ScaleOperation.h | 50 +++---- .../COM_ScreenLensDistortionOperation.cpp | 82 +++++------ .../operations/COM_ScreenLensDistortionOperation.h | 24 ++-- .../operations/COM_SeparateChannelOperation.cpp | 10 +- .../operations/COM_SeparateChannelOperation.h | 6 +- .../operations/COM_SetAlphaOperation.cpp | 16 +-- .../compositor/operations/COM_SetAlphaOperation.h | 4 +- .../operations/COM_SetColorOperation.cpp | 8 +- .../compositor/operations/COM_SetColorOperation.h | 32 +++-- .../operations/COM_SetSamplerOperation.cpp | 6 +- .../operations/COM_SetSamplerOperation.h | 6 +- .../operations/COM_SetValueOperation.cpp | 2 +- .../compositor/operations/COM_SetValueOperation.h | 6 +- .../operations/COM_SetVectorOperation.cpp | 8 +- .../compositor/operations/COM_SetVectorOperation.h | 24 ++-- .../operations/COM_SocketProxyOperation.cpp | 10 +- .../operations/COM_SocketProxyOperation.h | 2 +- .../operations/COM_SplitViewerOperation.cpp | 28 ++-- .../operations/COM_SplitViewerOperation.h | 12 +- .../compositor/operations/COM_TextureOperation.cpp | 26 ++-- .../compositor/operations/COM_TextureOperation.h | 12 +- .../compositor/operations/COM_TonemapOperation.cpp | 40 +++--- .../compositor/operations/COM_TonemapOperation.h | 8 +- .../operations/COM_TranslateOperation.cpp | 22 +-- .../compositor/operations/COM_TranslateOperation.h | 28 ++-- .../COM_VariableSizeBokehBlurOperation.cpp | 60 ++++---- .../COM_VariableSizeBokehBlurOperation.h | 16 +-- .../operations/COM_VectorBlurOperation.cpp | 63 ++++---- .../operations/COM_VectorBlurOperation.h | 12 +- .../operations/COM_VectorCurveOperation.cpp | 10 +- .../operations/COM_VectorCurveOperation.h | 2 +- .../operations/COM_ViewerBaseOperation.cpp | 20 +-- .../operations/COM_ViewerBaseOperation.h | 46 +++--- .../compositor/operations/COM_ViewerOperation.cpp | 26 ++-- .../compositor/operations/COM_ViewerOperation.h | 4 +- .../operations/COM_WriteBufferOperation.cpp | 36 ++--- .../operations/COM_WriteBufferOperation.h | 6 +- .../operations/COM_ZCombineOperation.cpp | 44 +++--- .../compositor/operations/COM_ZCombineOperation.h | 8 +- 244 files changed, 2595 insertions(+), 2593 deletions(-) (limited to 'source/blender/compositor/operations') diff --git a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp index e614e1fa15a..e688332a039 100644 --- a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp +++ b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp @@ -33,9 +33,9 @@ void AlphaOverKeyOperation::executePixel(float *outputValue, float x, float y, P float inputOverColor[4]; float value[4]; - inputValueOperation->read(value, x, y, sampler, inputBuffers); - inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); - inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers); if (inputOverColor[3] <= 0.0f) { copy_v4_v4(outputValue, inputColor1); diff --git a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp index 81c1e4d2587..b521a2a5415 100644 --- a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp +++ b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp @@ -33,9 +33,9 @@ void AlphaOverMixedOperation::executePixel(float outputValue[4], float x, float float inputOverColor[4]; float value[4]; - inputValueOperation->read(value, x, y, sampler, inputBuffers); - inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); - inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers); if (inputOverColor[3] <= 0.0f) { copy_v4_v4(outputValue, inputColor1); diff --git a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp index a6bf8b8834c..b2c40a058ba 100644 --- a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp +++ b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp @@ -33,9 +33,9 @@ void AlphaOverPremultiplyOperation::executePixel(float *outputValue, float x, fl float inputOverColor[4]; float value[4]; - inputValueOperation->read(value, x, y, sampler, inputBuffers); - inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); - inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers); /* Zero alpha values should still permit an add of RGB data */ if (inputOverColor[3] < 0.0f) { diff --git a/source/blender/compositor/operations/COM_AntiAliasOperation.cpp b/source/blender/compositor/operations/COM_AntiAliasOperation.cpp index 458d11f2616..46fa07893e8 100644 --- a/source/blender/compositor/operations/COM_AntiAliasOperation.cpp +++ b/source/blender/compositor/operations/COM_AntiAliasOperation.cpp @@ -32,33 +32,33 @@ AntiAliasOperation::AntiAliasOperation() : NodeOperation() { this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->valueReader = NULL; - this->buffer = NULL; + this->m_valueReader = NULL; + this->m_buffer = NULL; this->setComplex(true); } void AntiAliasOperation::initExecution() { - this->valueReader = this->getInputSocketReader(0); + this->m_valueReader = this->getInputSocketReader(0); NodeOperation::initMutex(); } void AntiAliasOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - if (y < 0 || (unsigned int)y >= this->height || x < 0 || (unsigned int)x >= this->width) { + if (y < 0 || (unsigned int)y >= this->m_height || x < 0 || (unsigned int)x >= this->m_width) { color[0] = 0.0f; } else { - int offset = y * this->width + x; - color[0] = buffer[offset] / 255.0f; + int offset = y * this->m_width + x; + color[0] = this->m_buffer[offset] / 255.0f; } } void AntiAliasOperation::deinitExecution() { - this->valueReader = NULL; - if (this->buffer) { - delete buffer; + this->m_valueReader = NULL; + if (this->m_buffer) { + delete this->m_buffer; } NodeOperation::deinitMutex(); } @@ -66,7 +66,7 @@ void AntiAliasOperation::deinitExecution() bool AntiAliasOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti imageInput; - if (this->buffer) { + if (this->m_buffer) { return false; } else { @@ -84,10 +84,10 @@ bool AntiAliasOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe void *AntiAliasOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - if (this->buffer) {return buffer; } + if (this->m_buffer) { return this->m_buffer; } lockMutex(); - if (this->buffer == NULL) { - MemoryBuffer *tile = (MemoryBuffer *)valueReader->initializeTileData(rect, memoryBuffers); + if (this->m_buffer == NULL) { + MemoryBuffer *tile = (MemoryBuffer *)this->m_valueReader->initializeTileData(rect, memoryBuffers); int size = tile->getHeight() * tile->getWidth(); float *input = tile->getBuffer(); char *valuebuffer = new char[size]; @@ -98,8 +98,8 @@ void *AntiAliasOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBu valuebuffer[i] = in * 255; } antialias_tagbuf(tile->getWidth(), tile->getHeight(), valuebuffer); - this->buffer = valuebuffer; + this->m_buffer = valuebuffer; } unlockMutex(); - return this->buffer; + return this->m_buffer; } diff --git a/source/blender/compositor/operations/COM_AntiAliasOperation.h b/source/blender/compositor/operations/COM_AntiAliasOperation.h index 906da598da1..3d9bcf6d90a 100644 --- a/source/blender/compositor/operations/COM_AntiAliasOperation.h +++ b/source/blender/compositor/operations/COM_AntiAliasOperation.h @@ -35,8 +35,8 @@ protected: /** * @brief Cached reference to the reader */ - SocketReader *valueReader; - char *buffer; + SocketReader *m_valueReader; + char *m_buffer; public: AntiAliasOperation(); diff --git a/source/blender/compositor/operations/COM_BilateralBlurOperation.cpp b/source/blender/compositor/operations/COM_BilateralBlurOperation.cpp index 3628c399581..4f7f5eea8a0 100644 --- a/source/blender/compositor/operations/COM_BilateralBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.cpp @@ -34,15 +34,15 @@ BilateralBlurOperation::BilateralBlurOperation() : NodeOperation() this->addOutputSocket(COM_DT_COLOR); this->setComplex(true); - this->inputColorProgram = NULL; - this->inputDeterminatorProgram = NULL; + this->m_inputColorProgram = NULL; + this->m_inputDeterminatorProgram = NULL; } void BilateralBlurOperation::initExecution() { - this->inputColorProgram = getInputSocketReader(0); - this->inputDeterminatorProgram = getInputSocketReader(1); - this->space = this->data->sigma_space + this->data->iter; + this->m_inputColorProgram = getInputSocketReader(0); + this->m_inputDeterminatorProgram = getInputSocketReader(1); + this->m_space = this->m_data->sigma_space + this->m_data->iter; QualityStepHelper::initExecution(COM_QH_INCREASE); } @@ -54,27 +54,27 @@ void BilateralBlurOperation::executePixel(float *color, int x, int y, MemoryBuff float tempColor[4]; float blurColor[4]; float blurDivider; - float space = this->space; - float sigmacolor = this->data->sigma_color; + float space = this->m_space; + float sigmacolor = this->m_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; - this->inputDeterminatorProgram->read(determinatorReferenceColor, x, y, inputBuffers, data); + this->m_inputDeterminatorProgram->read(determinatorReferenceColor, x, y, inputBuffers, data); zero_v4(blurColor); blurDivider = 0.0f; for (int yi = miny; yi < maxy; yi += QualityStepHelper::getStep()) { for (int xi = minx; xi < maxx; xi += QualityStepHelper::getStep()) { // read determinator - this->inputDeterminatorProgram->read(determinator, xi, yi, inputBuffers, data); + this->m_inputDeterminatorProgram->read(determinator, xi, yi, inputBuffers, data); deltaColor = (fabsf(determinatorReferenceColor[0] - determinator[0]) + fabsf(determinatorReferenceColor[1] - determinator[1]) + fabsf(determinatorReferenceColor[2] - determinator[2])); // do not take the alpha channel into account if (deltaColor < sigmacolor) { // add this to the blur - this->inputColorProgram->read(tempColor, xi, yi, inputBuffers, data); + this->m_inputColorProgram->read(tempColor, xi, yi, inputBuffers, data); add_v4_v4(blurColor, tempColor); blurDivider += 1.0f; } @@ -94,14 +94,14 @@ void BilateralBlurOperation::executePixel(float *color, int x, int y, MemoryBuff void BilateralBlurOperation::deinitExecution() { - this->inputColorProgram = NULL; - this->inputDeterminatorProgram = NULL; + this->m_inputColorProgram = NULL; + this->m_inputDeterminatorProgram = NULL; } bool BilateralBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newInput; - int add = ceil(this->space) + 1; + int add = ceil(this->m_space) + 1; newInput.xmax = input->xmax + (add); newInput.xmin = input->xmin - (add); diff --git a/source/blender/compositor/operations/COM_BilateralBlurOperation.h b/source/blender/compositor/operations/COM_BilateralBlurOperation.h index 08b379dc4ea..be6ce7a221e 100644 --- a/source/blender/compositor/operations/COM_BilateralBlurOperation.h +++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.h @@ -27,10 +27,10 @@ class BilateralBlurOperation : public NodeOperation, public QualityStepHelper { private: - SocketReader *inputColorProgram; - SocketReader *inputDeterminatorProgram; - NodeBilateralBlurData *data; - float space; + SocketReader *m_inputColorProgram; + SocketReader *m_inputDeterminatorProgram; + NodeBilateralBlurData *m_data; + float m_space; public: BilateralBlurOperation(); @@ -52,6 +52,6 @@ public: bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); - void setData(NodeBilateralBlurData *data) { this->data = data; } + void setData(NodeBilateralBlurData *data) { this->m_data = data; } }; #endif diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.cpp b/source/blender/compositor/operations/COM_BlurBaseOperation.cpp index df64b7c8ddc..d1ddecc0df6 100644 --- a/source/blender/compositor/operations/COM_BlurBaseOperation.cpp +++ b/source/blender/compositor/operations/COM_BlurBaseOperation.cpp @@ -33,31 +33,31 @@ BlurBaseOperation::BlurBaseOperation(DataType data_type=COM_DT_COLOR) : NodeOper this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(data_type); this->setComplex(true); - this->inputProgram = NULL; - this->data = NULL; - this->size = 1.0f; - this->deleteData = false; - this->sizeavailable = false; + this->m_inputProgram = NULL; + this->m_data = NULL; + this->m_size = 1.0f; + this->m_deleteData = false; + this->m_sizeavailable = false; } void BlurBaseOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); - this->inputSize = this->getInputSocketReader(1); - this->data->image_in_width = this->getWidth(); - this->data->image_in_height = this->getHeight(); - if (this->data->relative) { - switch (this->data->aspect) { + this->m_inputProgram = this->getInputSocketReader(0); + this->m_inputSize = this->getInputSocketReader(1); + this->m_data->image_in_width = this->getWidth(); + this->m_data->image_in_height = this->getHeight(); + if (this->m_data->relative) { + switch (this->m_data->aspect) { case CMP_NODE_BLUR_ASPECT_NONE: - this->data->sizex = (int)(this->data->percentx * 0.01f * this->data->image_in_width); - this->data->sizey = (int)(this->data->percenty * 0.01f * this->data->image_in_height); + this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_width); + this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_height); break; case CMP_NODE_BLUR_ASPECT_Y: - this->data->sizex = (int)(this->data->percentx * 0.01f * this->data->image_in_width); - this->data->sizey = (int)(this->data->percenty * 0.01f * this->data->image_in_width); + this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_width); + this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_width); break; case CMP_NODE_BLUR_ASPECT_X: - this->data->sizex = (int)(this->data->percentx * 0.01f * this->data->image_in_height); - this->data->sizey = (int)(this->data->percenty * 0.01f * this->data->image_in_height); + this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_height); + this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_height); break; } } @@ -77,7 +77,7 @@ float *BlurBaseOperation::make_gausstab(int rad) sum = 0.0f; for (i = -rad; i <= rad; i++) { - val = RE_filter_value(this->data->filtertype, (float)i / (float)rad); + val = RE_filter_value(this->m_data->filtertype, (float)i / (float)rad); sum += val; gausstab[i + rad] = val; } @@ -131,20 +131,20 @@ float *BlurBaseOperation::make_dist_fac_inverse(int rad, int falloff) void BlurBaseOperation::deinitExecution() { - this->inputProgram = NULL; - this->inputSize = NULL; - if (this->deleteData) { - delete this->data; + this->m_inputProgram = NULL; + this->m_inputSize = NULL; + if (this->m_deleteData) { + delete this->m_data; } - this->data = NULL; + this->m_data = NULL; } void BlurBaseOperation::updateSize(MemoryBuffer **memoryBuffers) { - if (!this->sizeavailable) { + if (!this->m_sizeavailable) { float result[4]; this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, memoryBuffers); - this->size = result[0]; - this->sizeavailable = true; + this->m_size = result[0]; + this->m_sizeavailable = true; } } diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.h b/source/blender/compositor/operations/COM_BlurBaseOperation.h index 8f7208274db..6d60abf09bf 100644 --- a/source/blender/compositor/operations/COM_BlurBaseOperation.h +++ b/source/blender/compositor/operations/COM_BlurBaseOperation.h @@ -29,19 +29,24 @@ class BlurBaseOperation : public NodeOperation, public QualityStepHelper { private: protected: - /** - * Cached reference to the inputProgram - */ - SocketReader *inputProgram; - SocketReader *inputSize; - NodeBlurData *data; + BlurBaseOperation(DataType data_type); float *make_gausstab(int rad); float *make_dist_fac_inverse(int rad, int falloff); - float size; - bool deleteData; - bool sizeavailable; + void updateSize(MemoryBuffer **memoryBuffers); + + /** + * Cached reference to the inputProgram + */ + SocketReader *m_inputProgram; + SocketReader *m_inputSize; + NodeBlurData *m_data; + + float m_size; + bool m_deleteData; + bool m_sizeavailable; + public: /** * Initialize the execution @@ -53,10 +58,10 @@ public: */ void deinitExecution(); - void setData(NodeBlurData *data) { this->data = data; } + void setData(NodeBlurData *data) { this->m_data = data; } - void deleteDataWhenFinished() { this->deleteData = true; } + void deleteDataWhenFinished() { this->m_deleteData = true; } - void setSize(float size) { this->size = size; sizeavailable = true; } + void setSize(float size) { this->m_size = size; this->m_sizeavailable = true; } }; #endif diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.cpp b/source/blender/compositor/operations/COM_BokehBlurOperation.cpp index 9fe5abcb075..fb06f6d3761 100644 --- a/source/blender/compositor/operations/COM_BokehBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_BokehBlurOperation.cpp @@ -37,11 +37,11 @@ BokehBlurOperation::BokehBlurOperation() : NodeOperation() this->setComplex(true); this->setOpenCL(true); - this->size = 1.0f; + this->m_size = 1.0f; - this->inputProgram = NULL; - this->inputBokehProgram = NULL; - this->inputBoundingBoxReader = NULL; + this->m_inputProgram = NULL; + this->m_inputBokehProgram = NULL; + this->m_inputBoundingBoxReader = NULL; } void *BokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) @@ -52,12 +52,12 @@ void *BokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBu void BokehBlurOperation::initExecution() { - this->inputProgram = getInputSocketReader(0); - this->inputBokehProgram = getInputSocketReader(1); - this->inputBoundingBoxReader = getInputSocketReader(2); + this->m_inputProgram = getInputSocketReader(0); + this->m_inputBokehProgram = getInputSocketReader(1); + this->m_inputBoundingBoxReader = getInputSocketReader(2); - int width = inputBokehProgram->getWidth(); - int height = inputBokehProgram->getHeight(); + int width = this->m_inputBokehProgram->getWidth(); + int height = this->m_inputBokehProgram->getHeight(); float dimension; if (width < height) { @@ -66,9 +66,9 @@ void BokehBlurOperation::initExecution() else { dimension = height; } - this->bokehMidX = width / 2.0f; - this->bokehMidY = height / 2.0f; - this->bokehDimension = dimension / 2.0f; + this->m_bokehMidX = width / 2.0f; + this->m_bokehMidY = height / 2.0f; + this->m_bokehDimension = dimension / 2.0f; QualityStepHelper::initExecution(COM_QH_INCREASE); } @@ -78,7 +78,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer * float tempBoundingBox[4]; float bokeh[4]; - inputBoundingBoxReader->read(tempBoundingBox, x, y, COM_PS_NEAREST, inputBuffers); + this->m_inputBoundingBoxReader->read(tempBoundingBox, x, y, COM_PS_NEAREST, inputBuffers); if (tempBoundingBox[0] > 0.0f) { float multiplier_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; @@ -86,7 +86,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer * int bufferwidth = inputBuffer->getWidth(); int bufferstartx = inputBuffer->getRect()->xmin; int bufferstarty = inputBuffer->getRect()->ymin; - int pixelSize = this->size * this->getWidth() / 100.0f; + int pixelSize = this->m_size * this->getWidth() / 100.0f; int miny = y - pixelSize; int maxy = y + pixelSize; @@ -102,13 +102,13 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer * int step = getStep(); int offsetadd = getOffsetAdd(); - float m = this->bokehDimension / pixelSize; + float m = this->m_bokehDimension / pixelSize; for (int ny = miny; ny < maxy; ny += step) { int bufferindex = ((minx - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth); for (int nx = minx; nx < maxx; nx += step) { - float u = this->bokehMidX - (nx - x) * m; - float v = this->bokehMidY - (ny - y) * m; - inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST, inputBuffers); + float u = this->m_bokehMidX - (nx - x) * m; + float v = this->m_bokehMidY - (ny - y) * m; + this->m_inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST, inputBuffers); madd_v4_v4v4(color_accum, bokeh, &buffer[bufferindex]); add_v4_v4(multiplier_accum, bokeh); bufferindex += offsetadd; @@ -120,15 +120,15 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer * color[3] = color_accum[3] * (1.0f / multiplier_accum[3]); } else { - inputProgram->read(color, x, y, COM_PS_NEAREST, inputBuffers); + this->m_inputProgram->read(color, x, y, COM_PS_NEAREST, inputBuffers); } } void BokehBlurOperation::deinitExecution() { - this->inputProgram = NULL; - this->inputBokehProgram = NULL; - this->inputBoundingBoxReader = NULL; + this->m_inputProgram = NULL; + this->m_inputBokehProgram = NULL; + this->m_inputBoundingBoxReader = NULL; } bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) @@ -136,10 +136,10 @@ bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe rcti newInput; rcti bokehInput; - newInput.xmax = input->xmax + (size * this->getWidth() / 100.0f); - newInput.xmin = input->xmin - (size * this->getWidth() / 100.0f); - newInput.ymax = input->ymax + (size * this->getWidth() / 100.0f); - newInput.ymin = input->ymin - (size * this->getWidth() / 100.0f); + newInput.xmax = input->xmax + (this->m_size * this->getWidth() / 100.0f); + newInput.xmin = input->xmin - (this->m_size * this->getWidth() / 100.0f); + newInput.ymax = input->ymax + (this->m_size * this->getWidth() / 100.0f); + newInput.ymin = input->ymin - (this->m_size * this->getWidth() / 100.0f); NodeOperation *operation = getInputOperation(1); bokehInput.xmax = operation->getWidth(); @@ -169,12 +169,12 @@ void BokehBlurOperation::executeOpenCL(OpenCLDevice* device, if (!kernel) { kernel = device->COM_clCreateKernel("bokehBlurKernel", NULL); } - cl_int radius = this->getWidth() * this->size / 100.0f; + cl_int radius = this->getWidth() * this->m_size / 100.0f; cl_int step = this->getStep(); - device->COM_clAttachMemoryBufferToKernelParameter(kernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, this->inputBoundingBoxReader); - device->COM_clAttachMemoryBufferToKernelParameter(kernel, 1, 4, clMemToCleanUp, inputMemoryBuffers, this->inputProgram); - device->COM_clAttachMemoryBufferToKernelParameter(kernel, 2, -1, clMemToCleanUp, inputMemoryBuffers, this->inputBokehProgram); + device->COM_clAttachMemoryBufferToKernelParameter(kernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, this->m_inputBoundingBoxReader); + device->COM_clAttachMemoryBufferToKernelParameter(kernel, 1, 4, clMemToCleanUp, inputMemoryBuffers, this->m_inputProgram); + device->COM_clAttachMemoryBufferToKernelParameter(kernel, 2, -1, clMemToCleanUp, inputMemoryBuffers, this->m_inputBokehProgram); device->COM_clAttachOutputMemoryBufferToKernelParameter(kernel, 3, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter(kernel, 5, outputMemoryBuffer); clSetKernelArg(kernel, 6, sizeof(cl_int), &radius); diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.h b/source/blender/compositor/operations/COM_BokehBlurOperation.h index 853855d5c34..0433a4156a8 100644 --- a/source/blender/compositor/operations/COM_BokehBlurOperation.h +++ b/source/blender/compositor/operations/COM_BokehBlurOperation.h @@ -27,13 +27,13 @@ class BokehBlurOperation : public NodeOperation, public QualityStepHelper { private: - SocketReader *inputProgram; - SocketReader *inputBokehProgram; - SocketReader *inputBoundingBoxReader; - float size; - float bokehMidX; - float bokehMidY; - float bokehDimension; + SocketReader *m_inputProgram; + SocketReader *m_inputBokehProgram; + SocketReader *m_inputBoundingBoxReader; + float m_size; + float m_bokehMidX; + float m_bokehMidY; + float m_bokehDimension; public: BokehBlurOperation(); @@ -55,7 +55,7 @@ public: bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); - void setSize(float size) { this->size = size; } + void setSize(float size) { this->m_size = size; } void executeOpenCL(OpenCLDevice* device, MemoryBuffer *outputMemoryBuffer, cl_mem clOutputBuffer, MemoryBuffer **inputMemoryBuffers, list *clMemToCleanUp, list *clKernelsToCleanUp); }; diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.cpp b/source/blender/compositor/operations/COM_BokehImageOperation.cpp index abb378e2adb..90e272438d6 100644 --- a/source/blender/compositor/operations/COM_BokehImageOperation.cpp +++ b/source/blender/compositor/operations/COM_BokehImageOperation.cpp @@ -26,35 +26,35 @@ BokehImageOperation::BokehImageOperation() : NodeOperation() { this->addOutputSocket(COM_DT_COLOR); - this->deleteData = false; + this->m_deleteData = false; } void BokehImageOperation::initExecution() { - this->centerX = getWidth() / 2; - this->centerY = getHeight() / 2; - this->center[0] = this->centerX; - this->center[1] = this->centerY; - this->inverseRounding = 1.0f - this->data->rounding; - this->circularDistance = getWidth() / 2; - this->flapRad = (float)(M_PI * 2) / this->data->flaps; - this->flapRadAdd = (this->data->angle / 360.0f) * (float)(M_PI * 2.0); - while (this->flapRadAdd < 0.0f) { - this->flapRadAdd += (float)(M_PI * 2.0); + this->m_centerX = getWidth() / 2; + this->m_centerY = getHeight() / 2; + this->m_center[0] = this->m_centerX; + this->m_center[1] = this->m_centerY; + this->m_inverseRounding = 1.0f - this->m_data->rounding; + this->m_circularDistance = getWidth() / 2; + this->m_flapRad = (float)(M_PI * 2) / this->m_data->flaps; + this->m_flapRadAdd = (this->m_data->angle / 360.0f) * (float)(M_PI * 2.0); + while (this->m_flapRadAdd < 0.0f) { + this->m_flapRadAdd += (float)(M_PI * 2.0); } - while (this->flapRadAdd > (float)M_PI) { - this->flapRadAdd -= (float)(M_PI * 2.0); + while (this->m_flapRadAdd > (float)M_PI) { + this->m_flapRadAdd -= (float)(M_PI * 2.0); } } void BokehImageOperation::detemineStartPointOfFlap(float r[2], int flapNumber, float distance) { - r[0] = sinf(flapRad * flapNumber + flapRadAdd) * distance + centerX; - r[1] = cosf(flapRad * flapNumber + flapRadAdd) * distance + centerY; + r[0] = sinf(this->m_flapRad * flapNumber + this->m_flapRadAdd) * distance + this->m_centerX; + r[1] = cosf(this->m_flapRad * flapNumber + this->m_flapRadAdd) * distance + this->m_centerY; } float BokehImageOperation::isInsideBokeh(float distance, float x, float y) { float insideBokeh = 0.0f; - const float deltaX = x - centerX; - const float deltaY = y - centerY; + const float deltaX = x - this->m_centerX; + const float deltaY = y - this->m_centerY; float closestPoint[2]; float lineP1[2]; float lineP2[2]; @@ -62,23 +62,23 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y) point[0] = x; point[1] = y; - const float distanceToCenter = len_v2v2(point, center); + const float distanceToCenter = len_v2v2(point, this->m_center); const float bearing = (atan2f(deltaX, deltaY) + (float)(M_PI * 2.0)); - int flapNumber = (int)((bearing - flapRadAdd) / flapRad); + int flapNumber = (int)((bearing - this->m_flapRadAdd) / this->m_flapRad); detemineStartPointOfFlap(lineP1, flapNumber, distance); detemineStartPointOfFlap(lineP2, flapNumber + 1, distance); closest_to_line_v2(closestPoint, point, lineP1, lineP2); - const float distanceLineToCenter = len_v2v2(center, closestPoint); - const float distanceRoundingToCenter = inverseRounding * distanceLineToCenter + this->data->rounding * distance; + const float distanceLineToCenter = len_v2v2(this->m_center, closestPoint); + const float distanceRoundingToCenter = this->m_inverseRounding * distanceLineToCenter + this->m_data->rounding * distance; - const float catadioptricDistanceToCenter = distanceRoundingToCenter * this->data->catadioptric; + const float catadioptricDistanceToCenter = distanceRoundingToCenter * this->m_data->catadioptric; if (distanceRoundingToCenter >= distanceToCenter && catadioptricDistanceToCenter <= distanceToCenter) { if (distanceRoundingToCenter - distanceToCenter < 1.0f) { insideBokeh = (distanceRoundingToCenter - distanceToCenter); } - else if (this->data->catadioptric != 0.0f && distanceToCenter - catadioptricDistanceToCenter < 1.0f) { + else if (this->m_data->catadioptric != 0.0f && distanceToCenter - catadioptricDistanceToCenter < 1.0f) { insideBokeh = (distanceToCenter - catadioptricDistanceToCenter); } else { @@ -89,9 +89,9 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y) } void BokehImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - float shift = this->data->lensshift; + float shift = this->m_data->lensshift; float shift2 = shift / 2.0f; - float distance = this->circularDistance; + float distance = this->m_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); @@ -110,10 +110,10 @@ void BokehImageOperation::executePixel(float *color, float x, float y, PixelSamp void BokehImageOperation::deinitExecution() { - if (deleteData) { - if (data) { - delete data; - data = NULL; + if (this->m_deleteData) { + if (this->m_data) { + delete this->m_data; + this->m_data = NULL; } } } diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.h b/source/blender/compositor/operations/COM_BokehImageOperation.h index 8edd32a4f77..085aaa471f0 100644 --- a/source/blender/compositor/operations/COM_BokehImageOperation.h +++ b/source/blender/compositor/operations/COM_BokehImageOperation.h @@ -27,17 +27,17 @@ class BokehImageOperation : public NodeOperation { private: - NodeBokehImage *data; + NodeBokehImage *m_data; - float center[2]; - float centerX; - float centerY; - float inverseRounding; - float circularDistance; - float flapRad; - float flapRadAdd; + float m_center[2]; + float m_centerX; + float m_centerY; + float m_inverseRounding; + float m_circularDistance; + float m_flapRad; + float m_flapRadAdd; - bool deleteData; + bool m_deleteData; void detemineStartPointOfFlap(float r[2], int flapNumber, float distance); float isInsideBokeh(float distance, float x, float y); @@ -61,7 +61,7 @@ public: void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]); - void setData(NodeBokehImage *data) { this->data = data; } - void deleteDataOnFinish() { this->deleteData = true; } + void setData(NodeBokehImage *data) { this->m_data = data; } + void deleteDataOnFinish() { this->m_deleteData = true; } }; #endif diff --git a/source/blender/compositor/operations/COM_BoxMaskOperation.cpp b/source/blender/compositor/operations/COM_BoxMaskOperation.cpp index 3b99fc9a2a0..96738a2920a 100644 --- a/source/blender/compositor/operations/COM_BoxMaskOperation.cpp +++ b/source/blender/compositor/operations/COM_BoxMaskOperation.cpp @@ -29,19 +29,19 @@ BoxMaskOperation::BoxMaskOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->inputMask = NULL; - this->inputValue = NULL; - this->cosine = 0.0f; - this->sine = 0.0f; + this->m_inputMask = NULL; + this->m_inputValue = NULL; + this->m_cosine = 0.0f; + this->m_sine = 0.0f; } void BoxMaskOperation::initExecution() { - this->inputMask = this->getInputSocketReader(0); - this->inputValue = this->getInputSocketReader(1); - const double rad = DEG2RAD((double)this->data->rotation); - this->cosine = cos(rad); - this->sine = sin(rad); - this->aspectRatio = ((float)this->getWidth()) / this->getHeight(); + this->m_inputMask = this->getInputSocketReader(0); + this->m_inputValue = this->getInputSocketReader(1); + const double rad = DEG2RAD((double)this->m_data->rotation); + this->m_cosine = cos(rad); + this->m_sine = sin(rad); + this->m_aspectRatio = ((float)this->getWidth()) / this->getHeight(); } void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -52,22 +52,22 @@ void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler float rx = x / this->getWidth(); float ry = y / this->getHeight(); - const float dy = (ry - this->data->y) / this->aspectRatio; - const float dx = rx - this->data->x; - rx = this->data->x + (this->cosine * dx + this->sine * dy); - ry = this->data->y + (-this->sine * dx + this->cosine * dy); + const float dy = (ry - this->m_data->y) / this->m_aspectRatio; + const float dx = rx - this->m_data->x; + rx = this->m_data->x + (this->m_cosine * dx + this->m_sine * dy); + ry = this->m_data->y + (-this->m_sine * dx + this->m_cosine * dy); - this->inputMask->read(inputMask, x, y, sampler, inputBuffers); - this->inputValue->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers); + this->m_inputValue->read(inputValue, x, y, sampler, inputBuffers); - float halfHeight = this->data->height / 2.0f; - float halfWidth = this->data->width / 2.0f; - bool inside = (rx > this->data->x - halfWidth && - rx < this->data->x + halfWidth && - ry > this->data->y - halfHeight && - ry < this->data->y + halfHeight); + float halfHeight = this->m_data->height / 2.0f; + float halfWidth = this->m_data->width / 2.0f; + bool inside = (rx > this->m_data->x - halfWidth && + rx < this->m_data->x + halfWidth && + ry > this->m_data->y - halfHeight && + ry < this->m_data->y + halfHeight); - switch (this->maskType) { + switch (this->m_maskType) { case CMP_NODE_MASKTYPE_ADD: if (inside) { color[0] = max(inputMask[0], inputValue[0]); @@ -113,7 +113,7 @@ void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler void BoxMaskOperation::deinitExecution() { - this->inputMask = NULL; - this->inputValue = NULL; + this->m_inputMask = NULL; + this->m_inputValue = NULL; } diff --git a/source/blender/compositor/operations/COM_BoxMaskOperation.h b/source/blender/compositor/operations/COM_BoxMaskOperation.h index 65327abc9a6..cec680ef6c3 100644 --- a/source/blender/compositor/operations/COM_BoxMaskOperation.h +++ b/source/blender/compositor/operations/COM_BoxMaskOperation.h @@ -30,15 +30,15 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputMask; - SocketReader *inputValue; + SocketReader *m_inputMask; + SocketReader *m_inputValue; - float sine; - float cosine; - float aspectRatio; - int maskType; + float m_sine; + float m_cosine; + float m_aspectRatio; + int m_maskType; - NodeBoxMask *data; + NodeBoxMask *m_data; public: BoxMaskOperation(); @@ -57,9 +57,9 @@ public: */ void deinitExecution(); - void setData(NodeBoxMask *data) { this->data = data; } + void setData(NodeBoxMask *data) { this->m_data = data; } - void setMaskType(int maskType) { this->maskType = maskType; } + void setMaskType(int maskType) { this->m_maskType = maskType; } }; #endif diff --git a/source/blender/compositor/operations/COM_BrightnessOperation.cpp b/source/blender/compositor/operations/COM_BrightnessOperation.cpp index 95862a1fd83..8c9fb6394a7 100644 --- a/source/blender/compositor/operations/COM_BrightnessOperation.cpp +++ b/source/blender/compositor/operations/COM_BrightnessOperation.cpp @@ -28,13 +28,13 @@ BrightnessOperation::BrightnessOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void BrightnessOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); - this->inputBrightnessProgram = this->getInputSocketReader(1); - this->inputContrastProgram = this->getInputSocketReader(2); + this->m_inputProgram = this->getInputSocketReader(0); + this->m_inputBrightnessProgram = this->getInputSocketReader(1); + this->m_inputContrastProgram = this->getInputSocketReader(2); } void BrightnessOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -43,9 +43,9 @@ void BrightnessOperation::executePixel(float *color, float x, float y, PixelSamp float a, b; float inputBrightness[4]; float inputContrast[4]; - this->inputProgram->read(inputValue, x, y, sampler, inputBuffers); - this->inputBrightnessProgram->read(inputBrightness, x, y, sampler, inputBuffers); - this->inputContrastProgram->read(inputContrast, x, y, sampler, inputBuffers); + this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputBrightnessProgram->read(inputBrightness, x, y, sampler, inputBuffers); + this->m_inputContrastProgram->read(inputContrast, x, y, sampler, inputBuffers); float brightness = inputBrightness[0]; float contrast = inputContrast[0]; brightness /= 100.0f; @@ -73,8 +73,8 @@ void BrightnessOperation::executePixel(float *color, float x, float y, PixelSamp void BrightnessOperation::deinitExecution() { - this->inputProgram = NULL; - this->inputBrightnessProgram = NULL; - this->inputContrastProgram = NULL; + this->m_inputProgram = NULL; + this->m_inputBrightnessProgram = NULL; + this->m_inputContrastProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_BrightnessOperation.h b/source/blender/compositor/operations/COM_BrightnessOperation.h index 74c648fd8fb..61f667aa1be 100644 --- a/source/blender/compositor/operations/COM_BrightnessOperation.h +++ b/source/blender/compositor/operations/COM_BrightnessOperation.h @@ -30,9 +30,9 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; - SocketReader *inputBrightnessProgram; - SocketReader *inputContrastProgram; + SocketReader *m_inputProgram; + SocketReader *m_inputBrightnessProgram; + SocketReader *m_inputContrastProgram; public: BrightnessOperation(); diff --git a/source/blender/compositor/operations/COM_CalculateMeanOperation.cpp b/source/blender/compositor/operations/COM_CalculateMeanOperation.cpp index fe6be55e237..a1c679b3e15 100644 --- a/source/blender/compositor/operations/COM_CalculateMeanOperation.cpp +++ b/source/blender/compositor/operations/COM_CalculateMeanOperation.cpp @@ -30,33 +30,33 @@ CalculateMeanOperation::CalculateMeanOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE); this->addOutputSocket(COM_DT_VALUE); - this->imageReader = NULL; - this->iscalculated = false; - this->setting = 1; + this->m_imageReader = NULL; + this->m_iscalculated = false; + this->m_setting = 1; this->setComplex(true); } void CalculateMeanOperation::initExecution() { - this->imageReader = this->getInputSocketReader(0); - this->iscalculated = false; + this->m_imageReader = this->getInputSocketReader(0); + this->m_iscalculated = false; NodeOperation::initMutex(); } void CalculateMeanOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - color[0] = this->result; + color[0] = this->m_result; } void CalculateMeanOperation::deinitExecution() { - this->imageReader = NULL; + this->m_imageReader = NULL; NodeOperation::deinitMutex(); } bool CalculateMeanOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti imageInput; - if (iscalculated) { + if (this->m_iscalculated) { return false; } NodeOperation *operation = getInputOperation(0); @@ -73,10 +73,10 @@ bool CalculateMeanOperation::determineDependingAreaOfInterest(rcti *input, ReadB void *CalculateMeanOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (!this->iscalculated) { - MemoryBuffer *tile = (MemoryBuffer *)imageReader->initializeTileData(rect, memoryBuffers); + if (!this->m_iscalculated) { + MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers); calculateMean(tile); - this->iscalculated = true; + this->m_iscalculated = true; } unlockMutex(); return NULL; @@ -84,7 +84,7 @@ void *CalculateMeanOperation::initializeTileData(rcti *rect, MemoryBuffer **memo void CalculateMeanOperation::calculateMean(MemoryBuffer *tile) { - this->result = 0.0f; + this->m_result = 0.0f; float *buffer = tile->getBuffer(); int size = tile->getWidth() * tile->getHeight(); int pixels = 0; @@ -93,8 +93,7 @@ void CalculateMeanOperation::calculateMean(MemoryBuffer *tile) if (buffer[offset + 3] > 0) { pixels++; - switch (this->setting) - { + switch (this->m_setting) { case 1: { sum += rgb_to_bw(&buffer[offset]); @@ -125,5 +124,5 @@ void CalculateMeanOperation::calculateMean(MemoryBuffer *tile) } } } - this->result = sum / pixels; + this->m_result = sum / pixels; } diff --git a/source/blender/compositor/operations/COM_CalculateMeanOperation.h b/source/blender/compositor/operations/COM_CalculateMeanOperation.h index 7a28eb3774a..2bd723c40a3 100644 --- a/source/blender/compositor/operations/COM_CalculateMeanOperation.h +++ b/source/blender/compositor/operations/COM_CalculateMeanOperation.h @@ -34,11 +34,11 @@ protected: /** * @brief Cached reference to the reader */ - SocketReader *imageReader; + SocketReader *m_imageReader; - bool iscalculated; - float result; - int setting; + bool m_iscalculated; + float m_result; + int m_setting; public: CalculateMeanOperation(); @@ -61,7 +61,7 @@ public: void deinitExecution(); bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); - void setSetting(int setting) { this->setting = setting; } + void setSetting(int setting) { this->m_setting = setting; } protected: void calculateMean(MemoryBuffer *tile); diff --git a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp index 811975c5e13..2d860df449c 100644 --- a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp +++ b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp @@ -33,27 +33,26 @@ CalculateStandardDeviationOperation::CalculateStandardDeviationOperation() : Cal void CalculateStandardDeviationOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - color[0] = this->standardDeviation; + color[0] = this->m_standardDeviation; } void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (!this->iscalculated) { - MemoryBuffer *tile = (MemoryBuffer *)imageReader->initializeTileData(rect, memoryBuffers); + if (!this->m_iscalculated) { + MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers); CalculateMeanOperation::calculateMean(tile); - this->standardDeviation = 0.0f; + this->m_standardDeviation = 0.0f; float *buffer = tile->getBuffer(); int size = tile->getWidth() * tile->getHeight(); int pixels = 0; float sum = 0.0f; - float mean = this->result; + float mean = this->m_result; for (int i = 0, offset = 0; i < size; i++, offset += 4) { if (buffer[offset + 3] > 0) { pixels++; - switch (this->setting) - { + switch (this->m_setting) { case 1: { float value = rgb_to_bw(&buffer[offset]); @@ -90,8 +89,8 @@ void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect, Memory } } } - this->standardDeviation = sqrt(sum / (float)(pixels - 1)); - this->iscalculated = true; + this->m_standardDeviation = sqrt(sum / (float)(pixels - 1)); + this->m_iscalculated = true; } unlockMutex(); return NULL; diff --git a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h index d3163d4cc32..506c5d6fe3a 100644 --- a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h +++ b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h @@ -31,7 +31,7 @@ */ class CalculateStandardDeviationOperation : public CalculateMeanOperation { protected: - float standardDeviation; + float m_standardDeviation; public: CalculateStandardDeviationOperation(); diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp b/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp index 487c1869782..0812dd45bf6 100644 --- a/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp +++ b/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp @@ -26,30 +26,30 @@ ChangeHSVOperation::ChangeHSVOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ChangeHSVOperation::initExecution() { - this->inputOperation = getInputSocketReader(0); + this->m_inputOperation = getInputSocketReader(0); } void ChangeHSVOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ChangeHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor1[4]; - inputOperation->read(inputColor1, x, y, sampler, inputBuffers); + this->m_inputOperation->read(inputColor1, x, y, sampler, inputBuffers); - outputValue[0] = inputColor1[0] + (this->hue - 0.5f); + outputValue[0] = inputColor1[0] + (this->m_hue - 0.5f); if (outputValue[0] > 1.0f) outputValue[0] -= 1.0f; else if (outputValue[0] < 0.0f) outputValue[0] += 1.0f; - outputValue[1] = inputColor1[1] * this->saturation; - outputValue[2] = inputColor1[2] * this->value; + outputValue[1] = inputColor1[1] * this->m_saturation; + outputValue[2] = inputColor1[2] * this->m_value; outputValue[3] = inputColor1[3]; } diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.h b/source/blender/compositor/operations/COM_ChangeHSVOperation.h index a2a6c034a82..9c343db9c3c 100644 --- a/source/blender/compositor/operations/COM_ChangeHSVOperation.h +++ b/source/blender/compositor/operations/COM_ChangeHSVOperation.h @@ -31,11 +31,11 @@ */ class ChangeHSVOperation : public NodeOperation { private: - SocketReader *inputOperation; + SocketReader *m_inputOperation; - float hue; - float saturation; - float value; + float m_hue; + float m_saturation; + float m_value; public: /** @@ -51,9 +51,9 @@ public: */ void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); - void setHue(float hue) { this->hue = hue; } - void setSaturation(float saturation) { this->saturation = saturation; } - void setValue(float value) { this->value = value; } + void setHue(float hue) { this->m_hue = hue; } + void setSaturation(float saturation) { this->m_saturation = saturation; } + void setValue(float value) { this->m_value = value; } }; #endif diff --git a/source/blender/compositor/operations/COM_ChannelMatteOperation.cpp b/source/blender/compositor/operations/COM_ChannelMatteOperation.cpp index 24af1a3aa53..b2de934e6d8 100644 --- a/source/blender/compositor/operations/COM_ChannelMatteOperation.cpp +++ b/source/blender/compositor/operations/COM_ChannelMatteOperation.cpp @@ -27,45 +27,45 @@ ChannelMatteOperation::ChannelMatteOperation() : NodeOperation() addInputSocket(COM_DT_COLOR); addOutputSocket(COM_DT_VALUE); - inputImageProgram = NULL; + this->m_inputImageProgram = NULL; } void ChannelMatteOperation::initExecution() { - this->inputImageProgram = this->getInputSocketReader(0); + this->m_inputImageProgram = this->getInputSocketReader(0); - this->limit_range = this->limit_max - this->limit_min; + this->m_limit_range = this->m_limit_max - this->m_limit_min; - switch (this->limit_method) { + switch (this->m_limit_method) { /* SINGLE */ case 0: { /* 123 / RGB / HSV / YUV / YCC */ - const int matte_channel = this->matte_channel - 1; - const int limit_channel = this->limit_channel - 1; - this->ids[0] = matte_channel; - this->ids[1] = limit_channel; - this->ids[2] = limit_channel; + const int matte_channel = this->m_matte_channel - 1; + const int limit_channel = this->m_limit_channel - 1; + this->m_ids[0] = matte_channel; + this->m_ids[1] = limit_channel; + this->m_ids[2] = limit_channel; break; } /* MAX */ case 1: { - switch (this->matte_channel) { + switch (this->m_matte_channel) { case 1: { - this->ids[0] = 0; - this->ids[1] = 1; - this->ids[2] = 2; + this->m_ids[0] = 0; + this->m_ids[1] = 1; + this->m_ids[2] = 2; break; } case 2: { - this->ids[0] = 1; - this->ids[1] = 0; - this->ids[2] = 2; + this->m_ids[0] = 1; + this->m_ids[1] = 0; + this->m_ids[2] = 2; break; } case 3: { - this->ids[0] = 2; - this->ids[1] = 0; - this->ids[2] = 1; + this->m_ids[0] = 2; + this->m_ids[1] = 0; + this->m_ids[2] = 1; break; } default: @@ -80,7 +80,7 @@ void ChannelMatteOperation::initExecution() void ChannelMatteOperation::deinitExecution() { - this->inputImageProgram = NULL; + this->m_inputImageProgram = NULL; } void ChannelMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -88,17 +88,17 @@ void ChannelMatteOperation::executePixel(float *outputValue, float x, float y, P float inColor[4]; float alpha; - const float limit_max = this->limit_max; - const float limit_min = this->limit_min; - const float limit_range = this->limit_range; + const float limit_max = this->m_limit_max; + const float limit_min = this->m_limit_min; + const float limit_range = this->m_limit_range; - this->inputImageProgram->read(inColor, x, y, sampler, inputBuffers); + this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers); /* matte operation */ - alpha = inColor[this->ids[0]] - max(inColor[this->ids[1]], inColor[this->ids[2]]); + alpha = inColor[this->m_ids[0]] - max(inColor[this->m_ids[1]], inColor[this->m_ids[2]]); /* flip because 0.0 is transparent, not 1.0 */ - alpha = 1.f - alpha; + alpha = 1.0f - alpha; /* test range*/ if (alpha > limit_max) { diff --git a/source/blender/compositor/operations/COM_ChannelMatteOperation.h b/source/blender/compositor/operations/COM_ChannelMatteOperation.h index 17db0f9ffe2..859df200020 100644 --- a/source/blender/compositor/operations/COM_ChannelMatteOperation.h +++ b/source/blender/compositor/operations/COM_ChannelMatteOperation.h @@ -30,16 +30,16 @@ */ class ChannelMatteOperation : public NodeOperation { private: - SocketReader *inputImageProgram; + SocketReader *m_inputImageProgram; - int color_space; /* node->custom1 */ - int matte_channel; /* node->custom2 */ - int limit_method; /* node->algorithm */ - int limit_channel; /* node->channel */ - float limit_max; /* node->storage->t1 */ - float limit_min; /* node->storage->t2 */ + int m_color_space; /* node->custom1 */ + int m_matte_channel; /* node->custom2 */ + int m_limit_method; /* node->algorithm */ + int m_limit_channel; /* node->channel */ + float m_limit_max; /* node->storage->t1 */ + float m_limit_min; /* node->storage->t2 */ - float limit_range; + float m_limit_range; /** ids to use for the operations (max and simple) * alpha = in[ids[0]] - max(in[ids[1]], in[ids[2]]) @@ -49,7 +49,7 @@ private: * ids[2] = ids[1] * alpha = in[ids[0]] - max(in[ids[1]], in[ids[2]]) */ - int ids[3]; + int m_ids[3]; public: /** * Default constructor @@ -66,11 +66,11 @@ public: void setSettings(NodeChroma *nodeChroma, const int custom2) { - this->limit_max = nodeChroma->t1; - this->limit_min = nodeChroma->t2; - this->limit_method = nodeChroma->algorithm; - this->limit_channel = nodeChroma->channel; - this->matte_channel = custom2; + this->m_limit_max = nodeChroma->t1; + this->m_limit_min = nodeChroma->t2; + this->m_limit_method = nodeChroma->algorithm; + this->m_limit_channel = nodeChroma->channel; + this->m_matte_channel = custom2; } }; #endif diff --git a/source/blender/compositor/operations/COM_ChromaMatteOperation.cpp b/source/blender/compositor/operations/COM_ChromaMatteOperation.cpp index 0ce1a585598..e88feb6db9c 100644 --- a/source/blender/compositor/operations/COM_ChromaMatteOperation.cpp +++ b/source/blender/compositor/operations/COM_ChromaMatteOperation.cpp @@ -28,20 +28,20 @@ ChromaMatteOperation::ChromaMatteOperation() : NodeOperation() addInputSocket(COM_DT_COLOR); addOutputSocket(COM_DT_VALUE); - inputImageProgram = NULL; - inputKeyProgram = NULL; + this->m_inputImageProgram = NULL; + this->m_inputKeyProgram = NULL; } void ChromaMatteOperation::initExecution() { - this->inputImageProgram = this->getInputSocketReader(0); - this->inputKeyProgram = this->getInputSocketReader(1); + this->m_inputImageProgram = this->getInputSocketReader(0); + this->m_inputKeyProgram = this->getInputSocketReader(1); } void ChromaMatteOperation::deinitExecution() { - this->inputImageProgram = NULL; - this->inputKeyProgram = NULL; + this->m_inputImageProgram = NULL; + this->m_inputKeyProgram = NULL; } void ChromaMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -49,16 +49,16 @@ void ChromaMatteOperation::executePixel(float *outputValue, float x, float y, Pi float inKey[4]; float inImage[4]; - const float acceptance = this->settings->t1; /* in radians */ - const float cutoff = this->settings->t2; /* in radians */ - const float gain = this->settings->fstrength; + const float acceptance = this->m_settings->t1; /* in radians */ + const float cutoff = this->m_settings->t2; /* in radians */ + const float gain = this->m_settings->fstrength; float x_angle, z_angle, alpha; float theta, beta; float kfg; - this->inputKeyProgram->read(inKey, x, y, sampler, inputBuffers); - this->inputImageProgram->read(inImage, x, y, sampler, inputBuffers); + this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers); + this->m_inputImageProgram->read(inImage, x, y, sampler, inputBuffers); /* store matte(alpha) value in [0] to go with * COM_SetAlphaOperation and the Value output diff --git a/source/blender/compositor/operations/COM_ChromaMatteOperation.h b/source/blender/compositor/operations/COM_ChromaMatteOperation.h index a09203f29b3..472a797fa28 100644 --- a/source/blender/compositor/operations/COM_ChromaMatteOperation.h +++ b/source/blender/compositor/operations/COM_ChromaMatteOperation.h @@ -30,9 +30,9 @@ */ class ChromaMatteOperation : public NodeOperation { private: - NodeChroma *settings; - SocketReader *inputImageProgram; - SocketReader *inputKeyProgram; + NodeChroma *m_settings; + SocketReader *m_inputImageProgram; + SocketReader *m_inputKeyProgram; public: /** * Default constructor @@ -47,6 +47,6 @@ public: void initExecution(); void deinitExecution(); - void setSettings(NodeChroma *nodeChroma) { this->settings = nodeChroma; } + void setSettings(NodeChroma *nodeChroma) { this->m_settings = nodeChroma; } }; #endif diff --git a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp index a48fe169fd7..66ce86234b7 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp +++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp @@ -38,15 +38,15 @@ ColorBalanceASCCDLOperation::ColorBalanceASCCDLOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputValueOperation = NULL; - this->inputColorOperation = NULL; + this->m_inputValueOperation = NULL; + this->m_inputColorOperation = NULL; this->setResolutionInputSocketIndex(1); } void ColorBalanceASCCDLOperation::initExecution() { - this->inputValueOperation = this->getInputSocketReader(0); - this->inputColorOperation = this->getInputSocketReader(1); + this->m_inputValueOperation = this->getInputSocketReader(0); + this->m_inputColorOperation = this->getInputSocketReader(1); } void ColorBalanceASCCDLOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -54,22 +54,22 @@ void ColorBalanceASCCDLOperation::executePixel(float *outputColor, float x, floa float inputColor[4]; float value[4]; - inputValueOperation->read(value, x, y, sampler, inputBuffers); - inputColorOperation->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers); + this->m_inputColorOperation->read(inputColor, x, y, sampler, inputBuffers); float fac = value[0]; fac = min(1.0f, fac); const float mfac = 1.0f - fac; - outputColor[0] = mfac * inputColor[0] + fac *colorbalance_cdl(inputColor[0], this->lift[0], this->gamma[0], this->gain[0]); - outputColor[1] = mfac * inputColor[1] + fac *colorbalance_cdl(inputColor[1], this->lift[1], this->gamma[1], this->gain[1]); - outputColor[2] = mfac * inputColor[2] + fac *colorbalance_cdl(inputColor[2], this->lift[2], this->gamma[2], this->gain[2]); + outputColor[0] = mfac * inputColor[0] + fac *colorbalance_cdl(inputColor[0], this->m_lift[0], this->m_gamma[0], this->m_gain[0]); + outputColor[1] = mfac * inputColor[1] + fac *colorbalance_cdl(inputColor[1], this->m_lift[1], this->m_gamma[1], this->m_gain[1]); + outputColor[2] = mfac * inputColor[2] + fac *colorbalance_cdl(inputColor[2], this->m_lift[2], this->m_gamma[2], this->m_gain[2]); outputColor[3] = inputColor[3]; } void ColorBalanceASCCDLOperation::deinitExecution() { - this->inputValueOperation = NULL; - this->inputColorOperation = NULL; + this->m_inputValueOperation = NULL; + this->m_inputColorOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h index 9e7db59d99d..479927d30d1 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h +++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h @@ -33,12 +33,12 @@ protected: /** * Prefetched reference to the inputProgram */ - SocketReader *inputValueOperation; - SocketReader *inputColorOperation; + SocketReader *m_inputValueOperation; + SocketReader *m_inputColorOperation; - float gain[3]; - float lift[3]; - float gamma[3]; + float m_gain[3]; + float m_lift[3]; + float m_gamma[3]; public: /** @@ -61,8 +61,8 @@ public: */ void deinitExecution(); - void setGain(float gain[3]) { copy_v3_v3(this->gain, gain); } - void setLift(float lift[3]) { copy_v3_v3(this->lift, lift); } - void setGamma(float gamma[3]) { copy_v3_v3(this->gamma, gamma); } + void setGain(float gain[3]) { copy_v3_v3(this->m_gain, gain); } + void setLift(float lift[3]) { copy_v3_v3(this->m_lift, lift); } + void setGamma(float gamma[3]) { copy_v3_v3(this->m_gamma, gamma); } }; #endif diff --git a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp index 7a8d62dfe21..13863a9ec5a 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp +++ b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp @@ -43,15 +43,15 @@ ColorBalanceLGGOperation::ColorBalanceLGGOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputValueOperation = NULL; - this->inputColorOperation = NULL; + this->m_inputValueOperation = NULL; + this->m_inputColorOperation = NULL; this->setResolutionInputSocketIndex(1); } void ColorBalanceLGGOperation::initExecution() { - this->inputValueOperation = this->getInputSocketReader(0); - this->inputColorOperation = this->getInputSocketReader(1); + this->m_inputValueOperation = this->getInputSocketReader(0); + this->m_inputColorOperation = this->getInputSocketReader(1); } void ColorBalanceLGGOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -59,22 +59,22 @@ void ColorBalanceLGGOperation::executePixel(float *outputColor, float x, float y float inputColor[4]; float value[4]; - inputValueOperation->read(value, x, y, sampler, inputBuffers); - inputColorOperation->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers); + this->m_inputColorOperation->read(inputColor, x, y, sampler, inputBuffers); float fac = value[0]; fac = min(1.0f, fac); const float mfac = 1.0f - fac; - outputColor[0] = mfac * inputColor[0] + fac *colorbalance_lgg(inputColor[0], this->lift[0], this->gamma_inv[0], this->gain[0]); - outputColor[1] = mfac * inputColor[1] + fac *colorbalance_lgg(inputColor[1], this->lift[1], this->gamma_inv[1], this->gain[1]); - outputColor[2] = mfac * inputColor[2] + fac *colorbalance_lgg(inputColor[2], this->lift[2], this->gamma_inv[2], this->gain[2]); + outputColor[0] = mfac * inputColor[0] + fac *colorbalance_lgg(inputColor[0], this->m_lift[0], this->m_gamma_inv[0], this->m_gain[0]); + outputColor[1] = mfac * inputColor[1] + fac *colorbalance_lgg(inputColor[1], this->m_lift[1], this->m_gamma_inv[1], this->m_gain[1]); + outputColor[2] = mfac * inputColor[2] + fac *colorbalance_lgg(inputColor[2], this->m_lift[2], this->m_gamma_inv[2], this->m_gain[2]); outputColor[3] = inputColor[3]; } void ColorBalanceLGGOperation::deinitExecution() { - this->inputValueOperation = NULL; - this->inputColorOperation = NULL; + this->m_inputValueOperation = NULL; + this->m_inputColorOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h index 54cfb49327f..ec3652da09e 100644 --- a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h +++ b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h @@ -34,12 +34,12 @@ protected: /** * Prefetched reference to the inputProgram */ - SocketReader *inputValueOperation; - SocketReader *inputColorOperation; + SocketReader *m_inputValueOperation; + SocketReader *m_inputColorOperation; - float gain[3]; - float lift[3]; - float gamma_inv[3]; + float m_gain[3]; + float m_lift[3]; + float m_gamma_inv[3]; public: /** @@ -62,20 +62,8 @@ public: */ void deinitExecution(); - void setGain(float gain[3]) { - this->gain[0] = gain[0]; - this->gain[1] = gain[1]; - this->gain[2] = gain[2]; - } - void setLift(float lift[3]) { - this->lift[0] = lift[0]; - this->lift[1] = lift[1]; - this->lift[2] = lift[2]; - } - void setGammaInv(float gamma_inv[3]) { - this->gamma_inv[0] = gamma_inv[0]; - this->gamma_inv[1] = gamma_inv[1]; - this->gamma_inv[2] = gamma_inv[2]; - } + void setGain(const float gain[3]) { copy_v3_v3(this->m_gain, gain); } + void setLift(const float lift[3]) { copy_v3_v3(this->m_lift, lift); } + void setGammaInv(const float gamma_inv[3]) { copy_v3_v3(this->m_gamma_inv, gamma_inv); } }; #endif diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp index 5f62f9ec403..8008866752f 100644 --- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp +++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp @@ -28,31 +28,31 @@ ColorCorrectionOperation::ColorCorrectionOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR); this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); - this->inputImage = NULL; - this->inputMask = NULL; - this->redChannelEnabled = true; - this->greenChannelEnabled = true; - this->blueChannelEnabled = true; + this->m_inputImage = NULL; + this->m_inputMask = NULL; + this->m_redChannelEnabled = true; + this->m_greenChannelEnabled = true; + this->m_blueChannelEnabled = true; } void ColorCorrectionOperation::initExecution() { - this->inputImage = this->getInputSocketReader(0); - this->inputMask = this->getInputSocketReader(1); + this->m_inputImage = this->getInputSocketReader(0); + this->m_inputMask = this->getInputSocketReader(1); } void ColorCorrectionOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputImageColor[4]; float inputMask[4]; - this->inputImage->read(inputImageColor, x, y, sampler, inputBuffers); - this->inputMask->read(inputMask, x, y, sampler, inputBuffers); + this->m_inputImage->read(inputImageColor, x, y, sampler, inputBuffers); + this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers); float level = (inputImageColor[0] + inputImageColor[1] + inputImageColor[2]) / 3.0f; - float contrast = this->data->master.contrast; - float saturation = this->data->master.saturation; - float gamma = this->data->master.gamma; - float gain = this->data->master.gain; - float lift = this->data->master.lift; + float contrast = this->m_data->master.contrast; + float saturation = this->m_data->master.saturation; + float gamma = this->m_data->master.gamma; + float gain = this->m_data->master.gain; + float lift = this->m_data->master.lift; float r, g, b; float value = inputMask[0]; @@ -64,18 +64,18 @@ void ColorCorrectionOperation::executePixel(float *output, float x, float y, Pix float levelHighlights = 0.0; #define MARGIN 0.10f #define MARGIN_DIV (0.5f / MARGIN) - if (level < this->data->startmidtones - MARGIN) { + if (level < this->m_data->startmidtones - MARGIN) { levelShadows = 1.0f; } - else if (level < this->data->startmidtones + MARGIN) { - levelMidtones = ((level - this->data->startmidtones) * MARGIN_DIV) + 0.5f; + else if (level < this->m_data->startmidtones + MARGIN) { + levelMidtones = ((level - this->m_data->startmidtones) * MARGIN_DIV) + 0.5f; levelShadows = 1.0f - levelMidtones; } - else if (level < this->data->endmidtones - MARGIN) { + else if (level < this->m_data->endmidtones - MARGIN) { levelMidtones = 1.0f; } - else if (level < this->data->endmidtones + MARGIN) { - levelHighlights = ((level - this->data->endmidtones) * MARGIN_DIV) + 0.5f; + else if (level < this->m_data->endmidtones + MARGIN) { + levelHighlights = ((level - this->m_data->endmidtones) * MARGIN_DIV) + 0.5f; levelMidtones = 1.0f - levelHighlights; } else { @@ -83,11 +83,11 @@ void ColorCorrectionOperation::executePixel(float *output, float x, float y, Pix } #undef MARGIN #undef MARGIN_DIV - contrast *= (levelShadows * this->data->shadows.contrast) + (levelMidtones * this->data->midtones.contrast) + (levelHighlights * this->data->highlights.contrast); - saturation *= (levelShadows * this->data->shadows.saturation) + (levelMidtones * this->data->midtones.saturation) + (levelHighlights * this->data->highlights.saturation); - gamma *= (levelShadows * this->data->shadows.gamma) + (levelMidtones * this->data->midtones.gamma) + (levelHighlights * this->data->highlights.gamma); - gain *= (levelShadows * this->data->shadows.gain) + (levelMidtones * this->data->midtones.gain) + (levelHighlights * this->data->highlights.gain); - lift += (levelShadows * this->data->shadows.lift) + (levelMidtones * this->data->midtones.lift) + (levelHighlights * this->data->highlights.lift); + contrast *= (levelShadows * this->m_data->shadows.contrast) + (levelMidtones * this->m_data->midtones.contrast) + (levelHighlights * this->m_data->highlights.contrast); + saturation *= (levelShadows * this->m_data->shadows.saturation) + (levelMidtones * this->m_data->midtones.saturation) + (levelHighlights * this->m_data->highlights.saturation); + gamma *= (levelShadows * this->m_data->shadows.gamma) + (levelMidtones * this->m_data->midtones.gamma) + (levelHighlights * this->m_data->highlights.gamma); + gain *= (levelShadows * this->m_data->shadows.gain) + (levelMidtones * this->m_data->midtones.gain) + (levelHighlights * this->m_data->highlights.gain); + lift += (levelShadows * this->m_data->shadows.lift) + (levelMidtones * this->m_data->midtones.lift) + (levelHighlights * this->m_data->highlights.lift); float invgamma = 1.0f / gamma; float luma = rgb_to_luma_y(inputImageColor); @@ -114,19 +114,19 @@ void ColorCorrectionOperation::executePixel(float *output, float x, float y, Pix g = mvalue * inputImageColor[1] + value * g; b = mvalue * inputImageColor[2] + value * b; - if (this->redChannelEnabled) { + if (this->m_redChannelEnabled) { output[0] = r; } else { output[0] = inputImageColor[0]; } - if (this->greenChannelEnabled) { + if (this->m_greenChannelEnabled) { output[1] = g; } else { output[1] = inputImageColor[1]; } - if (this->blueChannelEnabled) { + if (this->m_blueChannelEnabled) { output[2] = b; } else { @@ -137,7 +137,7 @@ void ColorCorrectionOperation::executePixel(float *output, float x, float y, Pix void ColorCorrectionOperation::deinitExecution() { - this->inputImage = NULL; - this->inputMask = NULL; + this->m_inputImage = NULL; + this->m_inputMask = NULL; } diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.h b/source/blender/compositor/operations/COM_ColorCorrectionOperation.h index c0c33f7f2fa..8db3870709e 100644 --- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.h +++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.h @@ -30,13 +30,13 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputImage; - SocketReader *inputMask; - NodeColorCorrection *data; + SocketReader *m_inputImage; + SocketReader *m_inputMask; + NodeColorCorrection *m_data; - bool redChannelEnabled; - bool greenChannelEnabled; - bool blueChannelEnabled; + bool m_redChannelEnabled; + bool m_greenChannelEnabled; + bool m_blueChannelEnabled; public: ColorCorrectionOperation(); @@ -56,9 +56,9 @@ public: */ void deinitExecution(); - void setData(NodeColorCorrection *data) { this->data = data; } - void setRedChannelEnabled(bool enabled) { this->redChannelEnabled = enabled; } - void setGreenChannelEnabled(bool enabled) { this->greenChannelEnabled = enabled; } - void setBlueChannelEnabled(bool enabled) { this->blueChannelEnabled = enabled; } + void setData(NodeColorCorrection *data) { this->m_data = data; } + void setRedChannelEnabled(bool enabled) { this->m_redChannelEnabled = enabled; } + void setGreenChannelEnabled(bool enabled) { this->m_greenChannelEnabled = enabled; } + void setBlueChannelEnabled(bool enabled) { this->m_blueChannelEnabled = enabled; } }; #endif diff --git a/source/blender/compositor/operations/COM_ColorCurveOperation.cpp b/source/blender/compositor/operations/COM_ColorCurveOperation.cpp index 4feac3e7273..9848d191c04 100644 --- a/source/blender/compositor/operations/COM_ColorCurveOperation.cpp +++ b/source/blender/compositor/operations/COM_ColorCurveOperation.cpp @@ -39,28 +39,28 @@ ColorCurveOperation::ColorCurveOperation() : CurveBaseOperation() this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputFacProgram = NULL; - this->inputImageProgram = NULL; - this->inputBlackProgram = NULL; - this->inputWhiteProgram = NULL; + this->m_inputFacProgram = NULL; + this->m_inputImageProgram = NULL; + this->m_inputBlackProgram = NULL; + this->m_inputWhiteProgram = NULL; this->setResolutionInputSocketIndex(1); } void ColorCurveOperation::initExecution() { CurveBaseOperation::initExecution(); - this->inputFacProgram = this->getInputSocketReader(0); - this->inputImageProgram = this->getInputSocketReader(1); - this->inputBlackProgram = this->getInputSocketReader(2); - this->inputWhiteProgram = this->getInputSocketReader(3); + this->m_inputFacProgram = this->getInputSocketReader(0); + this->m_inputImageProgram = this->getInputSocketReader(1); + this->m_inputBlackProgram = this->getInputSocketReader(2); + this->m_inputWhiteProgram = this->getInputSocketReader(3); - curvemapping_premultiply(this->curveMapping, 0); + curvemapping_premultiply(this->m_curveMapping, 0); } void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - CurveMapping *cumap = this->curveMapping; + CurveMapping *cumap = this->m_curveMapping; CurveMapping *workingCopy = (CurveMapping *)MEM_dupallocN(cumap); float black[4]; @@ -68,13 +68,13 @@ void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSamp float fac[4]; float image[4]; - this->inputBlackProgram->read(black, x, y, sampler, inputBuffers); - this->inputWhiteProgram->read(white, x, y, sampler, inputBuffers); + this->m_inputBlackProgram->read(black, x, y, sampler, inputBuffers); + this->m_inputWhiteProgram->read(white, x, y, sampler, inputBuffers); curvemapping_set_black_white(workingCopy, black, white); - this->inputFacProgram->read(fac, x, y, sampler, inputBuffers); - this->inputImageProgram->read(image, x, y, sampler, inputBuffers); + this->m_inputFacProgram->read(fac, x, y, sampler, inputBuffers); + this->m_inputImageProgram->read(image, x, y, sampler, inputBuffers); if (*fac >= 1.0f) curvemapping_evaluate_premulRGBF(workingCopy, color, image); @@ -94,11 +94,11 @@ void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSamp void ColorCurveOperation::deinitExecution() { - this->inputFacProgram = NULL; - this->inputImageProgram = NULL; - this->inputBlackProgram = NULL; - this->inputWhiteProgram = NULL; - curvemapping_premultiply(this->curveMapping, 1); + this->m_inputFacProgram = NULL; + this->m_inputImageProgram = NULL; + this->m_inputBlackProgram = NULL; + this->m_inputWhiteProgram = NULL; + curvemapping_premultiply(this->m_curveMapping, 1); } @@ -110,20 +110,20 @@ ConstantLevelColorCurveOperation::ConstantLevelColorCurveOperation() : CurveBase this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputFacProgram = NULL; - this->inputImageProgram = NULL; + this->m_inputFacProgram = NULL; + this->m_inputImageProgram = NULL; this->setResolutionInputSocketIndex(1); } void ConstantLevelColorCurveOperation::initExecution() { CurveBaseOperation::initExecution(); - this->inputFacProgram = this->getInputSocketReader(0); - this->inputImageProgram = this->getInputSocketReader(1); + this->m_inputFacProgram = this->getInputSocketReader(0); + this->m_inputImageProgram = this->getInputSocketReader(1); - curvemapping_premultiply(this->curveMapping, 0); + curvemapping_premultiply(this->m_curveMapping, 0); - curvemapping_set_black_white(this->curveMapping, this->black, this->white); + curvemapping_set_black_white(this->m_curveMapping, this->m_black, this->m_white); } void ConstantLevelColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -132,17 +132,17 @@ void ConstantLevelColorCurveOperation::executePixel(float *color, float x, float float image[4]; - this->inputFacProgram->read(fac, x, y, sampler, inputBuffers); - this->inputImageProgram->read(image, x, y, sampler, inputBuffers); + this->m_inputFacProgram->read(fac, x, y, sampler, inputBuffers); + this->m_inputImageProgram->read(image, x, y, sampler, inputBuffers); if (*fac >= 1.0f) - curvemapping_evaluate_premulRGBF(this->curveMapping, color, image); + curvemapping_evaluate_premulRGBF(this->m_curveMapping, color, image); else if (*fac <= 0.0f) { copy_v3_v3(color, image); } else { float col[4], mfac = 1.0f - *fac; - curvemapping_evaluate_premulRGBF(this->curveMapping, col, image); + curvemapping_evaluate_premulRGBF(this->m_curveMapping, col, image); color[0] = mfac * image[0] + *fac * col[0]; color[1] = mfac * image[1] + *fac * col[1]; color[2] = mfac * image[2] + *fac * col[2]; @@ -152,7 +152,7 @@ void ConstantLevelColorCurveOperation::executePixel(float *color, float x, float void ConstantLevelColorCurveOperation::deinitExecution() { - this->inputFacProgram = NULL; - this->inputImageProgram = NULL; - curvemapping_premultiply(this->curveMapping, 1); + this->m_inputFacProgram = NULL; + this->m_inputImageProgram = NULL; + curvemapping_premultiply(this->m_curveMapping, 1); } diff --git a/source/blender/compositor/operations/COM_ColorCurveOperation.h b/source/blender/compositor/operations/COM_ColorCurveOperation.h index fcd78be8372..3bcbc31650c 100644 --- a/source/blender/compositor/operations/COM_ColorCurveOperation.h +++ b/source/blender/compositor/operations/COM_ColorCurveOperation.h @@ -31,10 +31,10 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputFacProgram; - SocketReader *inputImageProgram; - SocketReader *inputBlackProgram; - SocketReader *inputWhiteProgram; + SocketReader *m_inputFacProgram; + SocketReader *m_inputImageProgram; + SocketReader *m_inputBlackProgram; + SocketReader *m_inputWhiteProgram; public: ColorCurveOperation(); @@ -59,10 +59,10 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputFacProgram; - SocketReader *inputImageProgram; - float black[3]; - float white[3]; + SocketReader *m_inputFacProgram; + SocketReader *m_inputImageProgram; + float m_black[3]; + float m_white[3]; public: ConstantLevelColorCurveOperation(); @@ -82,8 +82,8 @@ public: */ void deinitExecution(); - void setBlackLevel(float black[3]) { this->black[0] = black[0]; this->black[1] = black[1]; this->black[2] = black[2]; } - void setWhiteLevel(float white[3]) { this->white[0] = white[0]; this->white[1] = white[1]; this->white[2] = white[2]; } + void setBlackLevel(float black[3]) { this->m_black[0] = black[0]; this->m_black[1] = black[1]; this->m_black[2] = black[2]; } + void setWhiteLevel(float white[3]) { this->m_white[0] = white[0]; this->m_white[1] = white[1]; this->m_white[2] = white[2]; } }; #endif diff --git a/source/blender/compositor/operations/COM_ColorMatteOperation.cpp b/source/blender/compositor/operations/COM_ColorMatteOperation.cpp index afb362dbdcd..4a01499b060 100644 --- a/source/blender/compositor/operations/COM_ColorMatteOperation.cpp +++ b/source/blender/compositor/operations/COM_ColorMatteOperation.cpp @@ -28,20 +28,20 @@ ColorMatteOperation::ColorMatteOperation() : NodeOperation() addInputSocket(COM_DT_COLOR); addOutputSocket(COM_DT_VALUE); - inputImageProgram = NULL; - inputKeyProgram = NULL; + this->m_inputImageProgram = NULL; + this->m_inputKeyProgram = NULL; } void ColorMatteOperation::initExecution() { - this->inputImageProgram = this->getInputSocketReader(0); - this->inputKeyProgram = this->getInputSocketReader(1); + this->m_inputImageProgram = this->getInputSocketReader(0); + this->m_inputKeyProgram = this->getInputSocketReader(1); } void ColorMatteOperation::deinitExecution() { - this->inputImageProgram = NULL; - this->inputKeyProgram = NULL; + this->m_inputImageProgram = NULL; + this->m_inputKeyProgram = NULL; } void ColorMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -49,14 +49,14 @@ void ColorMatteOperation::executePixel(float *outputValue, float x, float y, Pix float inColor[4]; float inKey[4]; - const float hue = this->settings->t1; - const float sat = this->settings->t2; - const float val = this->settings->t3; + const float hue = this->m_settings->t1; + const float sat = this->m_settings->t2; + const float val = this->m_settings->t3; float h_wrap; - this->inputImageProgram->read(inColor, x, y, sampler, inputBuffers); - this->inputKeyProgram->read(inKey, x, y, sampler, inputBuffers); + this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers); + this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers); /* store matte(alpha) value in [0] to go with diff --git a/source/blender/compositor/operations/COM_ColorMatteOperation.h b/source/blender/compositor/operations/COM_ColorMatteOperation.h index e5dd9efd820..ae904f8f938 100644 --- a/source/blender/compositor/operations/COM_ColorMatteOperation.h +++ b/source/blender/compositor/operations/COM_ColorMatteOperation.h @@ -30,9 +30,9 @@ */ class ColorMatteOperation : public NodeOperation { private: - NodeChroma *settings; - SocketReader *inputImageProgram; - SocketReader *inputKeyProgram; + NodeChroma *m_settings; + SocketReader *m_inputImageProgram; + SocketReader *m_inputKeyProgram; public: /** * Default constructor @@ -47,6 +47,6 @@ public: void initExecution(); void deinitExecution(); - void setSettings(NodeChroma *nodeChroma) { this->settings = nodeChroma; } + void setSettings(NodeChroma *nodeChroma) { this->m_settings = nodeChroma; } }; #endif diff --git a/source/blender/compositor/operations/COM_ColorRampOperation.cpp b/source/blender/compositor/operations/COM_ColorRampOperation.cpp index 9af70ddc5a7..95dca0dc410 100644 --- a/source/blender/compositor/operations/COM_ColorRampOperation.cpp +++ b/source/blender/compositor/operations/COM_ColorRampOperation.cpp @@ -35,23 +35,23 @@ ColorRampOperation::ColorRampOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); - this->inputProgram = NULL; - this->colorBand = NULL; + this->m_inputProgram = NULL; + this->m_colorBand = NULL; } void ColorRampOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void ColorRampOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float values[4]; - this->inputProgram->read(values, x, y, sampler, inputBuffers); - do_colorband(this->colorBand, values[0], color); + this->m_inputProgram->read(values, x, y, sampler, inputBuffers); + do_colorband(this->m_colorBand, values[0], color); } void ColorRampOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_ColorRampOperation.h b/source/blender/compositor/operations/COM_ColorRampOperation.h index eef5321eb19..42bc6b943b7 100644 --- a/source/blender/compositor/operations/COM_ColorRampOperation.h +++ b/source/blender/compositor/operations/COM_ColorRampOperation.h @@ -30,8 +30,8 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; - ColorBand *colorBand; + SocketReader *m_inputProgram; + ColorBand *m_colorBand; public: ColorRampOperation(); @@ -51,7 +51,7 @@ public: void deinitExecution(); void setColorBand(ColorBand *colorBand) { - this->colorBand = colorBand; + this->m_colorBand = colorBand; } diff --git a/source/blender/compositor/operations/COM_ColorSpillOperation.cpp b/source/blender/compositor/operations/COM_ColorSpillOperation.cpp index 1a534d778c0..e2773f3a6b4 100644 --- a/source/blender/compositor/operations/COM_ColorSpillOperation.cpp +++ b/source/blender/compositor/operations/COM_ColorSpillOperation.cpp @@ -30,72 +30,72 @@ ColorSpillOperation::ColorSpillOperation() : NodeOperation() addInputSocket(COM_DT_VALUE); addOutputSocket(COM_DT_COLOR); - inputImageReader = NULL; - inputFacReader = NULL; - this->spillChannel = 1; // GREEN + this->m_inputImageReader = NULL; + this->m_inputFacReader = NULL; + this->m_spillChannel = 1; // GREEN } void ColorSpillOperation::initExecution() { - this->inputImageReader = this->getInputSocketReader(0); - this->inputFacReader = this->getInputSocketReader(1); - if (spillChannel == 0) { - this->rmut = -1.0f; - this->gmut = 1.0f; - this->bmut = 1.0f; - this->channel2 = 1; - this->channel3 = 2; - if (this->settings->unspill == 0) { - this->settings->uspillr = 1.0f; - this->settings->uspillg = 0.0f; - this->settings->uspillb = 0.0f; + this->m_inputImageReader = this->getInputSocketReader(0); + this->m_inputFacReader = this->getInputSocketReader(1); + if (this->m_spillChannel == 0) { + this->m_rmut = -1.0f; + this->m_gmut = 1.0f; + this->m_bmut = 1.0f; + this->m_channel2 = 1; + this->m_channel3 = 2; + if (this->m_settings->unspill == 0) { + this->m_settings->uspillr = 1.0f; + this->m_settings->uspillg = 0.0f; + this->m_settings->uspillb = 0.0f; } } - else if (spillChannel == 1) { - this->rmut = 1.0f; - this->gmut = -1.0f; - this->bmut = 1.0f; - this->channel2 = 0; - this->channel3 = 2; - if (this->settings->unspill == 0) { - this->settings->uspillr = 0.0f; - this->settings->uspillg = 1.0f; - this->settings->uspillb = 0.0f; + else if (this->m_spillChannel == 1) { + this->m_rmut = 1.0f; + this->m_gmut = -1.0f; + this->m_bmut = 1.0f; + this->m_channel2 = 0; + this->m_channel3 = 2; + if (this->m_settings->unspill == 0) { + this->m_settings->uspillr = 0.0f; + this->m_settings->uspillg = 1.0f; + this->m_settings->uspillb = 0.0f; } } else { - this->rmut = 1.0f; - this->gmut = 1.0f; - this->bmut = -1.0f; + this->m_rmut = 1.0f; + this->m_gmut = 1.0f; + this->m_bmut = -1.0f; - this->channel2 = 0; - this->channel3 = 1; - if (this->settings->unspill == 0) { - this->settings->uspillr = 0.0f; - this->settings->uspillg = 0.0f; - this->settings->uspillb = 1.0f; + this->m_channel2 = 0; + this->m_channel3 = 1; + if (this->m_settings->unspill == 0) { + this->m_settings->uspillr = 0.0f; + this->m_settings->uspillg = 0.0f; + this->m_settings->uspillb = 1.0f; } } } void ColorSpillOperation::deinitExecution() { - this->inputImageReader = NULL; - this->inputFacReader = NULL; + this->m_inputImageReader = NULL; + this->m_inputFacReader = NULL; } void ColorSpillOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float fac[4]; float input[4]; - this->inputFacReader->read(fac, x, y, sampler, inputBuffers); - this->inputImageReader->read(input, x, y, sampler, inputBuffers); + this->m_inputFacReader->read(fac, x, y, sampler, inputBuffers); + this->m_inputImageReader->read(input, x, y, sampler, inputBuffers); float rfac = min(1.0f, fac[0]); float map = calculateMapValue(rfac, input); if (map > 0.0f) { - outputValue[0] = input[0] + this->rmut * (this->settings->uspillr * map); - outputValue[1] = input[1] + this->gmut * (this->settings->uspillg * map); - outputValue[2] = input[2] + this->bmut * (this->settings->uspillb * map); + outputValue[0] = input[0] + this->m_rmut * (this->m_settings->uspillr * map); + outputValue[1] = input[1] + this->m_gmut * (this->m_settings->uspillg * map); + outputValue[2] = input[2] + this->m_bmut * (this->m_settings->uspillb * map); outputValue[3] = input[3]; } else { @@ -104,11 +104,11 @@ void ColorSpillOperation::executePixel(float *outputValue, float x, float y, Pix } float ColorSpillOperation::calculateMapValue(float fac, float *input) { - return fac * (input[this->spillChannel] - (this->settings->limscale * input[this->settings->limchan])); + return fac * (input[this->m_spillChannel] - (this->m_settings->limscale * input[this->m_settings->limchan])); } float ColorSpillAverageOperation::calculateMapValue(float fac, float *input) { - return fac * (input[this->spillChannel] - (this->settings->limscale * AVG(input[this->channel2], input[this->channel3]))); + return fac * (input[this->m_spillChannel] - (this->m_settings->limscale * AVG(input[this->m_channel2], input[this->m_channel3]))); } diff --git a/source/blender/compositor/operations/COM_ColorSpillOperation.h b/source/blender/compositor/operations/COM_ColorSpillOperation.h index e890a1e1564..6e3156819b2 100644 --- a/source/blender/compositor/operations/COM_ColorSpillOperation.h +++ b/source/blender/compositor/operations/COM_ColorSpillOperation.h @@ -30,13 +30,13 @@ */ class ColorSpillOperation : public NodeOperation { protected: - NodeColorspill *settings; - SocketReader *inputImageReader; - SocketReader *inputFacReader; - int spillChannel; - int channel2; - int channel3; - float rmut, gmut, bmut; + NodeColorspill *m_settings; + SocketReader *m_inputImageReader; + SocketReader *m_inputFacReader; + int m_spillChannel; + int m_channel2; + int m_channel3; + float m_rmut, m_gmut, m_bmut; public: /** * Default constructor @@ -51,8 +51,8 @@ public: void initExecution(); void deinitExecution(); - void setSettings(NodeColorspill *nodeColorSpill) { this->settings = nodeColorSpill; } - void setSpillChannel(int channel) { this->spillChannel = channel; } + void setSettings(NodeColorspill *nodeColorSpill) { this->m_settings = nodeColorSpill; } + void setSpillChannel(int channel) { this->m_spillChannel = channel; } float calculateMapValue(float fac, float *input); }; diff --git a/source/blender/compositor/operations/COM_CombineChannelsOperation.cpp b/source/blender/compositor/operations/COM_CombineChannelsOperation.cpp index fb4e6f03e76..9f175a381a4 100644 --- a/source/blender/compositor/operations/COM_CombineChannelsOperation.cpp +++ b/source/blender/compositor/operations/COM_CombineChannelsOperation.cpp @@ -31,10 +31,10 @@ CombineChannelsOperation::CombineChannelsOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->inputChannel1Operation = NULL; - this->inputChannel2Operation = NULL; - this->inputChannel3Operation = NULL; - this->inputChannel4Operation = NULL; + this->m_inputChannel1Operation = NULL; + this->m_inputChannel2Operation = NULL; + this->m_inputChannel3Operation = NULL; + this->m_inputChannel4Operation = NULL; } bool CombineChannelsOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) @@ -63,18 +63,18 @@ bool CombineChannelsOperation::determineDependingAreaOfInterest(rcti *input, Rea void CombineChannelsOperation::initExecution() { - this->inputChannel1Operation = this->getInputSocketReader(0); - this->inputChannel2Operation = this->getInputSocketReader(1); - this->inputChannel3Operation = this->getInputSocketReader(2); - this->inputChannel4Operation = this->getInputSocketReader(3); + this->m_inputChannel1Operation = this->getInputSocketReader(0); + this->m_inputChannel2Operation = this->getInputSocketReader(1); + this->m_inputChannel3Operation = this->getInputSocketReader(2); + this->m_inputChannel4Operation = this->getInputSocketReader(3); } void CombineChannelsOperation::deinitExecution() { - this->inputChannel1Operation = NULL; - this->inputChannel2Operation = NULL; - this->inputChannel3Operation = NULL; - this->inputChannel4Operation = NULL; + this->m_inputChannel1Operation = NULL; + this->m_inputChannel2Operation = NULL; + this->m_inputChannel3Operation = NULL; + this->m_inputChannel4Operation = NULL; } @@ -82,20 +82,20 @@ void CombineChannelsOperation::executePixel(float *color, float x, float y, Pixe { float input[4]; /// @todo: remove if statements - if (this->inputChannel1Operation) { - this->inputChannel1Operation->read(input, x, y, sampler, inputBuffers); + if (this->m_inputChannel1Operation) { + this->m_inputChannel1Operation->read(input, x, y, sampler, inputBuffers); color[0] = input[0]; } - if (this->inputChannel2Operation) { - this->inputChannel2Operation->read(input, x, y, sampler, inputBuffers); + if (this->m_inputChannel2Operation) { + this->m_inputChannel2Operation->read(input, x, y, sampler, inputBuffers); color[1] = input[0]; } - if (this->inputChannel3Operation) { - this->inputChannel3Operation->read(input, x, y, sampler, inputBuffers); + if (this->m_inputChannel3Operation) { + this->m_inputChannel3Operation->read(input, x, y, sampler, inputBuffers); color[2] = input[0]; } - if (this->inputChannel4Operation) { - this->inputChannel4Operation->read(input, x, y, sampler, inputBuffers); + if (this->m_inputChannel4Operation) { + this->m_inputChannel4Operation->read(input, x, y, sampler, inputBuffers); color[3] = input[0]; } } diff --git a/source/blender/compositor/operations/COM_CombineChannelsOperation.h b/source/blender/compositor/operations/COM_CombineChannelsOperation.h index cc71f44b4f5..8e4c2120614 100644 --- a/source/blender/compositor/operations/COM_CombineChannelsOperation.h +++ b/source/blender/compositor/operations/COM_CombineChannelsOperation.h @@ -27,10 +27,10 @@ class CombineChannelsOperation : public NodeOperation { private: - SocketReader *inputChannel1Operation; - SocketReader *inputChannel2Operation; - SocketReader *inputChannel3Operation; - SocketReader *inputChannel4Operation; + SocketReader *m_inputChannel1Operation; + SocketReader *m_inputChannel2Operation; + SocketReader *m_inputChannel3Operation; + SocketReader *m_inputChannel4Operation; public: CombineChannelsOperation(); void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); diff --git a/source/blender/compositor/operations/COM_CompositorOperation.cpp b/source/blender/compositor/operations/COM_CompositorOperation.cpp index 936cbaadd84..717b6ce76cc 100644 --- a/source/blender/compositor/operations/COM_CompositorOperation.cpp +++ b/source/blender/compositor/operations/COM_CompositorOperation.cpp @@ -42,36 +42,36 @@ CompositorOperation::CompositorOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->setRenderData(NULL); - this->outputBuffer = NULL; - this->imageInput = NULL; - this->alphaInput = NULL; + this->m_outputBuffer = NULL; + this->m_imageInput = NULL; + this->m_alphaInput = NULL; } void CompositorOperation::initExecution() { // When initializing the tree during initial load the width and height can be zero. - this->imageInput = getInputSocketReader(0); - this->alphaInput = getInputSocketReader(1); + this->m_imageInput = getInputSocketReader(0); + this->m_alphaInput = getInputSocketReader(1); if (this->getWidth() * this->getHeight() != 0) { - this->outputBuffer = (float *) MEM_callocN(this->getWidth() * this->getHeight() * 4 * sizeof(float), "CompositorOperation"); + this->m_outputBuffer = (float *) MEM_callocN(this->getWidth() * this->getHeight() * 4 * sizeof(float), "CompositorOperation"); } } void CompositorOperation::deinitExecution() { if (!isBreaked()) { - const RenderData *rd = this->rd; + const RenderData *rd = this->m_rd; Render *re = RE_GetRender_FromData(rd); RenderResult *rr = RE_AcquireResultWrite(re); if (rr) { if (rr->rectf != NULL) { MEM_freeN(rr->rectf); } - rr->rectf = outputBuffer; + rr->rectf = this->m_outputBuffer; } else { - if (this->outputBuffer) { - MEM_freeN(this->outputBuffer); + if (this->m_outputBuffer) { + MEM_freeN(this->m_outputBuffer); } } @@ -83,21 +83,21 @@ void CompositorOperation::deinitExecution() } } else { - if (this->outputBuffer) { - MEM_freeN(this->outputBuffer); + if (this->m_outputBuffer) { + MEM_freeN(this->m_outputBuffer); } } - this->outputBuffer = NULL; - this->imageInput = NULL; - this->alphaInput = NULL; + this->m_outputBuffer = NULL; + this->m_imageInput = NULL; + this->m_alphaInput = NULL; } void CompositorOperation::executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers) { float color[8]; // 7 is enough - float *buffer = this->outputBuffer; + float *buffer = this->m_outputBuffer; if (!buffer) return; int x1 = rect->xmin; @@ -111,9 +111,9 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int tileNumber, Mem for (y = y1; y < y2 && (!breaked); y++) { for (x = x1; x < x2 && (!breaked); x++) { - imageInput->read(color, x, y, COM_PS_NEAREST, memoryBuffers); - if (alphaInput != NULL) { - alphaInput->read(&(color[3]), x, y, COM_PS_NEAREST, memoryBuffers); + this->m_imageInput->read(color, x, y, COM_PS_NEAREST, memoryBuffers); + if (this->m_alphaInput != NULL) { + this->m_alphaInput->read(&(color[3]), x, y, COM_PS_NEAREST, memoryBuffers); } copy_v4_v4(buffer + offset, color); offset += COM_NUMBER_OF_CHANNELS; @@ -127,12 +127,12 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int tileNumber, Mem void CompositorOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) { - int width = this->rd->xsch * this->rd->size / 100; - int height = this->rd->ysch * this->rd->size / 100; + int width = this->m_rd->xsch * this->m_rd->size / 100; + int height = this->m_rd->ysch * this->m_rd->size / 100; // check actual render resolution with cropping it may differ with cropped border.rendering // FIX for: [31777] Border Crop gives black (easy) - Render *re = RE_GetRender_FromData(this->rd); + Render *re = RE_GetRender_FromData(this->m_rd); if (re) { RenderResult *rr = RE_AcquireResultRead(re); if (rr) { diff --git a/source/blender/compositor/operations/COM_CompositorOperation.h b/source/blender/compositor/operations/COM_CompositorOperation.h index 280f39b7729..2719d376339 100644 --- a/source/blender/compositor/operations/COM_CompositorOperation.h +++ b/source/blender/compositor/operations/COM_CompositorOperation.h @@ -34,26 +34,26 @@ private: /** * @brief local reference to the scene */ - const RenderData *rd; + const RenderData *m_rd; /** * @brief reference to the output float buffer */ - float *outputBuffer; + float *m_outputBuffer; /** * @brief local reference to the input image operation */ - SocketReader *imageInput; + SocketReader *m_imageInput; /** * @brief local reference to the input alpha operation */ - SocketReader *alphaInput; + SocketReader *m_alphaInput; public: CompositorOperation(); void executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers); - void setRenderData(const RenderData *rd) { this->rd = rd; } + void setRenderData(const RenderData *rd) { this->m_rd = rd; } bool isOutputOperation(bool rendering) const { return true; } void initExecution(); void deinitExecution(); diff --git a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp index 2e8fc9005b8..4d829eae7a0 100644 --- a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp @@ -29,23 +29,23 @@ ConvertColorProfileOperation::ConvertColorProfileOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; - this->predivided = false; + this->m_inputOperation = NULL; + this->m_predivided = false; } void ConvertColorProfileOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertColorProfileOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float color[4]; - inputOperation->read(color, x, y, sampler, inputBuffers); - IMB_buffer_float_from_float(outputValue, color, 4, this->toProfile, this->fromProfile, this->predivided, 1, 1, 0, 0); + this->m_inputOperation->read(color, x, y, sampler, inputBuffers); + IMB_buffer_float_from_float(outputValue, color, 4, this->m_toProfile, this->m_fromProfile, this->m_predivided, 1, 1, 0, 0); } void ConvertColorProfileOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h index b11a06f7749..0b9a07a57ca 100644 --- a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h +++ b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h @@ -34,22 +34,22 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; /** * @brief color profile where to convert from */ - int fromProfile; + int m_fromProfile; /** * @brief color profile where to convert to */ - int toProfile; + int m_toProfile; /** * @brief is color predivided */ - bool predivided; + bool m_predivided; public: /** * Default constructor @@ -71,8 +71,8 @@ public: */ void deinitExecution(); - void setFromColorProfile(int colorProfile) { this->fromProfile = colorProfile; } - void setToColorProfile(int colorProfile) { this->toProfile = colorProfile; } - void setPredivided(bool predivided) { this->predivided = predivided; } + void setFromColorProfile(int colorProfile) { this->m_fromProfile = colorProfile; } + void setToColorProfile(int colorProfile) { this->m_toProfile = colorProfile; } + void setPredivided(bool predivided) { this->m_predivided = predivided; } }; #endif diff --git a/source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp b/source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp index 0e2c1e29a1d..a8c57449a2e 100644 --- a/source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp @@ -26,22 +26,22 @@ ConvertColorToBWOperation::ConvertColorToBWOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_VALUE); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertColorToBWOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertColorToBWOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - inputOperation->read(&inputColor[0], x, y, sampler, inputBuffers); + this->m_inputOperation->read(&inputColor[0], x, y, sampler, inputBuffers); outputValue[0] = rgb_to_bw(inputColor); } void ConvertColorToBWOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertColorToBWOperation.h b/source/blender/compositor/operations/COM_ConvertColorToBWOperation.h index 814c0c2e808..2a57c997196 100644 --- a/source/blender/compositor/operations/COM_ConvertColorToBWOperation.h +++ b/source/blender/compositor/operations/COM_ConvertColorToBWOperation.h @@ -34,7 +34,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp b/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp index 613bfe68fbb..6c79c4ea6a3 100644 --- a/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp @@ -26,20 +26,20 @@ ConvertColorToVectorOperation::ConvertColorToVectorOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_VECTOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertColorToVectorOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertColorToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - inputOperation->read(outputValue, x, y, sampler, inputBuffers); + this->m_inputOperation->read(outputValue, x, y, sampler, inputBuffers); } void ConvertColorToVectorOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h b/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h index 1167b565a8e..f9170dfc7aa 100644 --- a/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h +++ b/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h @@ -34,7 +34,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertColourToValueProg.cpp b/source/blender/compositor/operations/COM_ConvertColourToValueProg.cpp index 2c8caec6f61..c872f3e85bb 100644 --- a/source/blender/compositor/operations/COM_ConvertColourToValueProg.cpp +++ b/source/blender/compositor/operations/COM_ConvertColourToValueProg.cpp @@ -26,22 +26,22 @@ ConvertColourToValueProg::ConvertColourToValueProg() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_VALUE); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertColourToValueProg::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertColourToValueProg::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - inputOperation->read(&inputColor[0], x, y, sampler, inputBuffers); + this->m_inputOperation->read(&inputColor[0], x, y, sampler, inputBuffers); outputValue[0] = (inputColor[0] + inputColor[1] + inputColor[2]) / 3.0f; } void ConvertColourToValueProg::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertColourToValueProg.h b/source/blender/compositor/operations/COM_ConvertColourToValueProg.h index 9c43ec47604..ebd4bcbd59b 100644 --- a/source/blender/compositor/operations/COM_ConvertColourToValueProg.h +++ b/source/blender/compositor/operations/COM_ConvertColourToValueProg.h @@ -34,7 +34,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp index 1746afea713..91b68a90126 100644 --- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp @@ -28,27 +28,27 @@ ConvertDepthToRadiusOperation::ConvertDepthToRadiusOperation() : NodeOperation() { this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->inputOperation = NULL; - this->fStop = 128.0f; - this->cameraObject = NULL; - this->maxRadius = 32.0f; + this->m_inputOperation = NULL; + this->m_fStop = 128.0f; + this->m_cameraObject = NULL; + this->m_maxRadius = 32.0f; } float ConvertDepthToRadiusOperation::determineFocalDistance() { - if (cameraObject == NULL || cameraObject->type != OB_CAMERA) { + if (this->m_cameraObject == NULL || this->m_cameraObject->type != OB_CAMERA) { return 10.0f; } else { - Camera *camera = (Camera *)this->cameraObject->data; - cam_lens = camera->lens; + Camera *camera = (Camera *)this->m_cameraObject->data; + this->m_cam_lens = camera->lens; if (camera->dof_ob) { /* too simple, better to return the distance on the view axis only * return len_v3v3(ob->obmat[3], cam->dof_ob->obmat[3]); */ float mat[4][4], imat[4][4], obmat[4][4]; - copy_m4_m4(obmat, cameraObject->obmat); + copy_m4_m4(obmat, this->m_cameraObject->obmat); normalize_m4(obmat); invert_m4_m4(imat, obmat); mult_m4_m4m4(mat, imat, camera->dof_ob->obmat); @@ -60,14 +60,14 @@ float ConvertDepthToRadiusOperation::determineFocalDistance() void ConvertDepthToRadiusOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); float focalDistance = determineFocalDistance(); if (focalDistance == 0.0f) focalDistance = 1e10f; /* if the dof is 0.0 then set it be be far away */ - inverseFocalDistance = 1.f / focalDistance; - this->aspect = (this->getWidth() > this->getHeight()) ? (this->getHeight() / (float)this->getWidth()) : (this->getWidth() / (float)this->getHeight()); - this->aperture = 0.5f * (this->cam_lens / (this->aspect * 32.f)) / this->fStop; + this->m_inverseFocalDistance = 1.f / focalDistance; + this->m_aspect = (this->getWidth() > this->getHeight()) ? (this->getHeight() / (float)this->getWidth()) : (this->getWidth() / (float)this->getHeight()); + this->m_aperture = 0.5f * (this->m_cam_lens / (this->m_aspect * 32.0f)) / this->m_fStop; float minsz = MIN2(getWidth(), getHeight()); - this->dof_sp = (float)minsz / (16.f / cam_lens); // <- == aspect * MIN2(img->x, img->y) / tan(0.5f * fov); + this->m_dof_sp = (float)minsz / (16.f / this->m_cam_lens); // <- == aspect * MIN2(img->x, img->y) / tan(0.5f * fov); } void ConvertDepthToRadiusOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -75,7 +75,7 @@ void ConvertDepthToRadiusOperation::executePixel(float *outputValue, float x, fl float inputValue[4]; float z; float radius; - inputOperation->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputOperation->read(inputValue, x, y, sampler, inputBuffers); z = inputValue[0]; if (z != 0.f) { float iZ = (1.f / z); @@ -86,11 +86,11 @@ void ConvertDepthToRadiusOperation::executePixel(float *outputValue, float x, fl // 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(this->aperture * (dof_sp * (inverseFocalDistance - iZ) - 1.f)); + radius = 0.5f * fabsf(this->m_aperture * (this->m_dof_sp * (this->m_inverseFocalDistance - iZ) - 1.f)); // 'bug' #6615, limit minimum radius to 1 pixel, not really a solution, but somewhat mitigates the problem if (radius < 0.5f) radius = 0.5f; - if (radius > maxRadius) { - radius = maxRadius; + if (radius > this->m_maxRadius) { + radius = this->m_maxRadius; } outputValue[0] = radius; } @@ -99,5 +99,5 @@ void ConvertDepthToRadiusOperation::executePixel(float *outputValue, float x, fl void ConvertDepthToRadiusOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h index c6da6bc94a9..966a74c04ad 100644 --- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h +++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h @@ -34,15 +34,15 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; - float fStop; - float aspect; - float maxRadius; - float inverseFocalDistance; - float aperture; - float cam_lens; - float dof_sp; - Object *cameraObject; + SocketReader *m_inputOperation; + float m_fStop; + float m_aspect; + float m_maxRadius; + float m_inverseFocalDistance; + float m_aperture; + float m_cam_lens; + float m_dof_sp; + Object *m_cameraObject; public: /** * Default constructor @@ -64,9 +64,9 @@ public: */ void deinitExecution(); - void setfStop(float fStop) { this->fStop = fStop; } - void setMaxRadius(float maxRadius) { this->maxRadius = maxRadius; } - void setCameraObject(Object *camera) { this->cameraObject = camera; } + void setfStop(float fStop) { this->m_fStop = fStop; } + void setMaxRadius(float maxRadius) { this->m_maxRadius = maxRadius; } + void setCameraObject(Object *camera) { this->m_cameraObject = camera; } float determineFocalDistance(); }; #endif diff --git a/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp b/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp index e8c0061319c..5149e370208 100644 --- a/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp @@ -27,24 +27,24 @@ ConvertHSVToRGBOperation::ConvertHSVToRGBOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertHSVToRGBOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertHSVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - inputOperation->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers); hsv_to_rgb(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]); outputValue[3] = inputColor[3]; } void ConvertHSVToRGBOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h b/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h index 29c82361d12..f8b6a4c11fa 100644 --- a/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h +++ b/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h @@ -34,7 +34,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp b/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp index 842546a2755..b7db0a6a2c7 100644 --- a/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp @@ -27,12 +27,12 @@ ConvertKeyToPremulOperation::ConvertKeyToPremulOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputColor = NULL; + this->m_inputColor = NULL; } void ConvertKeyToPremulOperation::initExecution() { - this->inputColor = getInputSocketReader(0); + this->m_inputColor = getInputSocketReader(0); } void ConvertKeyToPremulOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -40,7 +40,7 @@ void ConvertKeyToPremulOperation::executePixel(float *outputValue, float x, floa float inputValue[4]; float alpha; - this->inputColor->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputColor->read(inputValue, x, y, sampler, inputBuffers); alpha = inputValue[3]; mul_v3_v3fl(outputValue, inputValue, alpha); @@ -51,5 +51,5 @@ void ConvertKeyToPremulOperation::executePixel(float *outputValue, float x, floa void ConvertKeyToPremulOperation::deinitExecution() { - this->inputColor = NULL; + this->m_inputColor = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h b/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h index fe0586f7a88..2b5e1871972 100644 --- a/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h +++ b/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h @@ -30,7 +30,7 @@ */ class ConvertKeyToPremulOperation : public NodeOperation { private: - SocketReader *inputColor; + SocketReader *m_inputColor; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp b/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp index 3554be53e3f..0ba23b2ec2e 100644 --- a/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp @@ -27,12 +27,12 @@ ConvertPremulToKeyOperation::ConvertPremulToKeyOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputColor = NULL; + this->m_inputColor = NULL; } void ConvertPremulToKeyOperation::initExecution() { - this->inputColor = getInputSocketReader(0); + this->m_inputColor = getInputSocketReader(0); } void ConvertPremulToKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -40,7 +40,7 @@ void ConvertPremulToKeyOperation::executePixel(float *outputValue, float x, floa float inputValue[4]; float alpha; - this->inputColor->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputColor->read(inputValue, x, y, sampler, inputBuffers); alpha = inputValue[3]; if (fabsf(alpha) < 1e-5f) { @@ -56,5 +56,5 @@ void ConvertPremulToKeyOperation::executePixel(float *outputValue, float x, floa void ConvertPremulToKeyOperation::deinitExecution() { - this->inputColor = NULL; + this->m_inputColor = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h b/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h index 093f28df3e5..05c6b26b171 100644 --- a/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h +++ b/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h @@ -30,7 +30,7 @@ */ class ConvertPremulToKeyOperation : public NodeOperation { private: - SocketReader *inputColor; + SocketReader *m_inputColor; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp b/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp index 051d9d2b8f9..dd5e9907642 100644 --- a/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp @@ -27,23 +27,23 @@ ConvertRGBToHSVOperation::ConvertRGBToHSVOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertRGBToHSVOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertRGBToHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - inputOperation->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers); rgb_to_hsv(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]); outputValue[3] = inputColor[3]; } void ConvertRGBToHSVOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h b/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h index 61270539e70..af8a7f78a61 100644 --- a/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h +++ b/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h @@ -34,7 +34,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp b/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp index d984a1ab943..e4322ae728f 100644 --- a/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp @@ -26,12 +26,12 @@ ConvertRGBToYCCOperation::ConvertRGBToYCCOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertRGBToYCCOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertRGBToYCCOperation::setMode(int mode) @@ -39,14 +39,14 @@ void ConvertRGBToYCCOperation::setMode(int mode) switch (mode) { case 1: - this->mode = BLI_YCC_ITU_BT709; + this->m_mode = BLI_YCC_ITU_BT709; break; case 2: - this->mode = BLI_YCC_JFIF_0_255; + this->m_mode = BLI_YCC_JFIF_0_255; break; case 0: default: - this->mode = BLI_YCC_ITU_BT601; + this->m_mode = BLI_YCC_ITU_BT601; break; } } @@ -56,8 +56,8 @@ void ConvertRGBToYCCOperation::executePixel(float *outputValue, float x, float y float inputColor[4]; float color[3]; - inputOperation->read(inputColor, x, y, sampler, inputBuffers); - rgb_to_ycc(inputColor[0], inputColor[1], inputColor[2], &color[0], &color[1], &color[2], this->mode); + this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers); + rgb_to_ycc(inputColor[0], inputColor[1], inputColor[2], &color[0], &color[1], &color[2], this->m_mode); /* divided by 255 to normalize for viewing in */ /* R,G,B --> Y,Cb,Cr */ @@ -67,5 +67,5 @@ void ConvertRGBToYCCOperation::executePixel(float *outputValue, float x, float y void ConvertRGBToYCCOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h b/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h index 33075cda509..97fbdb29874 100644 --- a/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h +++ b/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h @@ -33,12 +33,12 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; /** * YCbCr mode (Jpeg, ITU601, ITU709) */ - int mode; + int m_mode; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp b/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp index e5a8e7de1bb..e87a765f2eb 100644 --- a/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp @@ -26,23 +26,23 @@ ConvertRGBToYUVOperation::ConvertRGBToYUVOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertRGBToYUVOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertRGBToYUVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - inputOperation->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers); rgb_to_yuv(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]); outputValue[3] = inputColor[3]; } void ConvertRGBToYUVOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h b/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h index 4fc525456f8..89998897782 100644 --- a/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h +++ b/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h @@ -33,7 +33,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertValueToColourProg.cpp b/source/blender/compositor/operations/COM_ConvertValueToColourProg.cpp index 9d95c51a546..a29a381938f 100644 --- a/source/blender/compositor/operations/COM_ConvertValueToColourProg.cpp +++ b/source/blender/compositor/operations/COM_ConvertValueToColourProg.cpp @@ -26,17 +26,17 @@ ConvertValueToColourProg::ConvertValueToColourProg() : NodeOperation() { this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void ConvertValueToColourProg::initExecution() { - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void ConvertValueToColourProg::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputValue[4]; - this->inputProgram->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers); color[0] = inputValue[0]; color[1] = inputValue[0]; color[2] = inputValue[0]; @@ -45,5 +45,5 @@ void ConvertValueToColourProg::executePixel(float *color, float x, float y, Pixe void ConvertValueToColourProg::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertValueToColourProg.h b/source/blender/compositor/operations/COM_ConvertValueToColourProg.h index ff1d1aaeae7..69ce7e9afea 100644 --- a/source/blender/compositor/operations/COM_ConvertValueToColourProg.h +++ b/source/blender/compositor/operations/COM_ConvertValueToColourProg.h @@ -30,7 +30,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; public: ConvertValueToColourProg(); diff --git a/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp b/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp index 5ba3f6ef4a9..37760fe26d7 100644 --- a/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp @@ -26,18 +26,18 @@ ConvertValueToVectorOperation::ConvertValueToVectorOperation() : NodeOperation() { this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VECTOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertValueToVectorOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertValueToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float input[4]; - inputOperation->read(input, x, y, sampler, inputBuffers); + this->m_inputOperation->read(input, x, y, sampler, inputBuffers); outputValue[0] = input[0]; outputValue[1] = input[0]; outputValue[2] = input[0]; @@ -46,5 +46,5 @@ void ConvertValueToVectorOperation::executePixel(float *outputValue, float x, fl void ConvertValueToVectorOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h b/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h index fbb294d6a26..781b31f7fce 100644 --- a/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h +++ b/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h @@ -34,7 +34,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp b/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp index f6a2072932c..395b96e8b25 100644 --- a/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp @@ -26,21 +26,21 @@ ConvertVectorToColorOperation::ConvertVectorToColorOperation() : NodeOperation() { this->addInputSocket(COM_DT_VECTOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertVectorToColorOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertVectorToColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - inputOperation->read(outputValue, x, y, sampler, inputBuffers); + this->m_inputOperation->read(outputValue, x, y, sampler, inputBuffers); outputValue[3] = 1.0f; } void ConvertVectorToColorOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h b/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h index c26adc5a6b1..2f1173ba4e8 100644 --- a/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h +++ b/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h @@ -34,7 +34,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp b/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp index ef2d45eea03..68842c5a055 100644 --- a/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp @@ -26,22 +26,22 @@ ConvertVectorToValueOperation::ConvertVectorToValueOperation() : NodeOperation() { this->addInputSocket(COM_DT_VECTOR); this->addOutputSocket(COM_DT_VALUE); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertVectorToValueOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertVectorToValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float input[4]; - inputOperation->read(input, x, y, sampler, inputBuffers); + this->m_inputOperation->read(input, x, y, sampler, inputBuffers); outputValue[0] = (input[0] + input[1] + input[2]) / 3.0f; } void ConvertVectorToValueOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h b/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h index dd29d1bb9a9..8770992c69c 100644 --- a/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h +++ b/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h @@ -34,7 +34,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp b/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp index 373de25a276..11f4dd5a2d6 100644 --- a/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp @@ -26,12 +26,12 @@ ConvertYCCToRGBOperation::ConvertYCCToRGBOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertYCCToRGBOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertYCCToRGBOperation::setMode(int mode) @@ -39,14 +39,14 @@ void ConvertYCCToRGBOperation::setMode(int mode) switch (mode) { case 1: - this->mode = BLI_YCC_ITU_BT709; + this->m_mode = BLI_YCC_ITU_BT709; break; case 2: - this->mode = BLI_YCC_JFIF_0_255; + this->m_mode = BLI_YCC_JFIF_0_255; break; case 0: default: - this->mode = BLI_YCC_ITU_BT601; + this->m_mode = BLI_YCC_ITU_BT601; break; } } @@ -54,18 +54,18 @@ void ConvertYCCToRGBOperation::setMode(int mode) void ConvertYCCToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - inputOperation->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers); /* need to un-normalize the data */ /* R,G,B --> Y,Cb,Cr */ mul_v3_fl(inputColor, 255.0f); - ycc_to_rgb(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2], this->mode); + ycc_to_rgb(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2], this->m_mode); outputValue[3] = inputColor[3]; } void ConvertYCCToRGBOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h b/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h index d7ddd910ed7..a595fc19bc7 100644 --- a/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h +++ b/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h @@ -33,12 +33,12 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; /** * YCbCr mode (Jpeg, ITU601, ITU709) */ - int mode; + int m_mode; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp b/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp index a77806d16d0..b4393c53b92 100644 --- a/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp @@ -26,24 +26,24 @@ ConvertYUVToRGBOperation::ConvertYUVToRGBOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ConvertYUVToRGBOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void ConvertYUVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - inputOperation->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers); yuv_to_rgb(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]); outputValue[3] = inputColor[3]; } void ConvertYUVToRGBOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h b/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h index f77954606cf..e89f1500d69 100644 --- a/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h +++ b/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h @@ -33,7 +33,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: /** * Default constructor diff --git a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp index 5ac8c2254dc..cf3ffe6d8f4 100644 --- a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp @@ -46,7 +46,7 @@ void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, Me CLAMP(y3, 0, getHeight() - 1); float value[4]; - this->inputValueOperation->read(value, x2, y2, inputBuffers, NULL); + this->m_inputValueOperation->read(value, x2, y2, inputBuffers, NULL); float mval = 1.0f - value[0]; res1[0] = 0.0f; @@ -58,41 +58,41 @@ void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, Me res2[2] = 0.0f; res2[3] = 0.0f; - this->inputOperation->read(in1, x1, y1, inputBuffers, NULL); - madd_v3_v3fl(res1, in1, this->filter[0]); - madd_v3_v3fl(res2, in1, this->filter[0]); + this->m_inputOperation->read(in1, x1, y1, inputBuffers, NULL); + madd_v3_v3fl(res1, in1, this->m_filter[0]); + madd_v3_v3fl(res2, in1, this->m_filter[0]); - this->inputOperation->read(in1, x2, y1, inputBuffers, NULL); - madd_v3_v3fl(res1, in1, this->filter[1]); - madd_v3_v3fl(res2, in1, this->filter[3]); + this->m_inputOperation->read(in1, x2, y1, inputBuffers, NULL); + madd_v3_v3fl(res1, in1, this->m_filter[1]); + madd_v3_v3fl(res2, in1, this->m_filter[3]); - this->inputOperation->read(in1, x3, y1, inputBuffers, NULL); - madd_v3_v3fl(res1, in1, this->filter[2]); - madd_v3_v3fl(res2, in1, this->filter[6]); + this->m_inputOperation->read(in1, x3, y1, inputBuffers, NULL); + madd_v3_v3fl(res1, in1, this->m_filter[2]); + madd_v3_v3fl(res2, in1, this->m_filter[6]); - this->inputOperation->read(in1, x1, y2, inputBuffers, NULL); - madd_v3_v3fl(res1, in1, this->filter[3]); - madd_v3_v3fl(res2, in1, this->filter[1]); + this->m_inputOperation->read(in1, x1, y2, inputBuffers, NULL); + madd_v3_v3fl(res1, in1, this->m_filter[3]); + madd_v3_v3fl(res2, in1, this->m_filter[1]); - this->inputOperation->read(in2, x2, y2, inputBuffers, NULL); - madd_v3_v3fl(res1, in2, this->filter[4]); - madd_v3_v3fl(res2, in2, this->filter[4]); + this->m_inputOperation->read(in2, x2, y2, inputBuffers, NULL); + madd_v3_v3fl(res1, in2, this->m_filter[4]); + madd_v3_v3fl(res2, in2, this->m_filter[4]); - this->inputOperation->read(in1, x3, y2, inputBuffers, NULL); - madd_v3_v3fl(res1, in1, this->filter[5]); - madd_v3_v3fl(res2, in1, this->filter[7]); + this->m_inputOperation->read(in1, x3, y2, inputBuffers, NULL); + madd_v3_v3fl(res1, in1, this->m_filter[5]); + madd_v3_v3fl(res2, in1, this->m_filter[7]); - this->inputOperation->read(in1, x1, y3, inputBuffers, NULL); - madd_v3_v3fl(res1, in1, this->filter[6]); - madd_v3_v3fl(res2, in1, this->filter[2]); + this->m_inputOperation->read(in1, x1, y3, inputBuffers, NULL); + madd_v3_v3fl(res1, in1, this->m_filter[6]); + madd_v3_v3fl(res2, in1, this->m_filter[2]); - this->inputOperation->read(in1, x2, y3, inputBuffers, NULL); - madd_v3_v3fl(res1, in1, this->filter[7]); - madd_v3_v3fl(res2, in1, this->filter[5]); + this->m_inputOperation->read(in1, x2, y3, inputBuffers, NULL); + madd_v3_v3fl(res1, in1, this->m_filter[7]); + madd_v3_v3fl(res2, in1, this->m_filter[5]); - this->inputOperation->read(in1, x3, y3, inputBuffers, NULL); - madd_v3_v3fl(res1, in1, this->filter[8]); - madd_v3_v3fl(res2, in1, this->filter[8]); + this->m_inputOperation->read(in1, x3, y3, inputBuffers, NULL); + madd_v3_v3fl(res1, in1, this->m_filter[8]); + madd_v3_v3fl(res2, in1, this->m_filter[8]); color[0] = sqrt(res1[0] * res1[0] + res2[0] * res2[0]); color[1] = sqrt(res1[1] * res1[1] + res2[1] * res2[1]); diff --git a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp index b4f2714360e..3840e775fe3 100644 --- a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp +++ b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp @@ -30,39 +30,39 @@ ConvolutionFilterOperation::ConvolutionFilterOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->inputOperation = NULL; - this->filter = NULL; + this->m_inputOperation = NULL; + this->m_filter = NULL; this->setComplex(true); } void ConvolutionFilterOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); - this->inputValueOperation = this->getInputSocketReader(1); + this->m_inputOperation = this->getInputSocketReader(0); + this->m_inputValueOperation = this->getInputSocketReader(1); } void ConvolutionFilterOperation::set3x3Filter(float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9) { - this->filter = new float[9]; - this->filter[0] = f1; - this->filter[1] = f2; - this->filter[2] = f3; - this->filter[3] = f4; - this->filter[4] = f5; - this->filter[5] = f6; - this->filter[6] = f7; - this->filter[7] = f8; - this->filter[8] = f9; - this->filterHeight = 3; - this->filterWidth = 3; + this->m_filter = new float[9]; + this->m_filter[0] = f1; + this->m_filter[1] = f2; + this->m_filter[2] = f3; + this->m_filter[3] = f4; + this->m_filter[4] = f5; + this->m_filter[5] = f6; + this->m_filter[6] = f7; + this->m_filter[7] = f8; + this->m_filter[8] = f9; + this->m_filterHeight = 3; + this->m_filterWidth = 3; } void ConvolutionFilterOperation::deinitExecution() { - this->inputOperation = NULL; - this->inputValueOperation = NULL; - if (this->filter) { - delete[] this->filter; - this->filter = NULL; + this->m_inputOperation = NULL; + this->m_inputValueOperation = NULL; + if (this->m_filter) { + delete[] this->m_filter; + this->m_filter = NULL; } } @@ -84,28 +84,28 @@ void ConvolutionFilterOperation::executePixel(float *color, int x, int y, Memory CLAMP(y2, 0, getHeight() - 1); CLAMP(y3, 0, getHeight() - 1); float value[4]; - this->inputValueOperation->read(value, x2, y2, inputBuffers, NULL); + this->m_inputValueOperation->read(value, x2, y2, inputBuffers, NULL); const float mval = 1.0f - value[0]; zero_v4(color); - this->inputOperation->read(in1, x1, y1, inputBuffers, NULL); - madd_v4_v4fl(color, in1, this->filter[0]); - this->inputOperation->read(in1, x2, y1, inputBuffers, NULL); - madd_v4_v4fl(color, in1, this->filter[1]); - this->inputOperation->read(in1, x3, y1, inputBuffers, NULL); - madd_v4_v4fl(color, in1, this->filter[2]); - this->inputOperation->read(in1, x1, y2, inputBuffers, NULL); - madd_v4_v4fl(color, in1, this->filter[3]); - this->inputOperation->read(in2, x2, y2, inputBuffers, NULL); - madd_v4_v4fl(color, in2, this->filter[4]); - this->inputOperation->read(in1, x3, y2, inputBuffers, NULL); - madd_v4_v4fl(color, in1, this->filter[5]); - this->inputOperation->read(in1, x1, y3, inputBuffers, NULL); - madd_v4_v4fl(color, in1, this->filter[6]); - this->inputOperation->read(in1, x2, y3, inputBuffers, NULL); - madd_v4_v4fl(color, in1, this->filter[7]); - this->inputOperation->read(in1, x3, y3, inputBuffers, NULL); - madd_v4_v4fl(color, in1, this->filter[8]); + this->m_inputOperation->read(in1, x1, y1, inputBuffers, NULL); + madd_v4_v4fl(color, in1, this->m_filter[0]); + this->m_inputOperation->read(in1, x2, y1, inputBuffers, NULL); + madd_v4_v4fl(color, in1, this->m_filter[1]); + this->m_inputOperation->read(in1, x3, y1, inputBuffers, NULL); + madd_v4_v4fl(color, in1, this->m_filter[2]); + this->m_inputOperation->read(in1, x1, y2, inputBuffers, NULL); + madd_v4_v4fl(color, in1, this->m_filter[3]); + this->m_inputOperation->read(in2, x2, y2, inputBuffers, NULL); + madd_v4_v4fl(color, in2, this->m_filter[4]); + this->m_inputOperation->read(in1, x3, y2, inputBuffers, NULL); + madd_v4_v4fl(color, in1, this->m_filter[5]); + this->m_inputOperation->read(in1, x1, y3, inputBuffers, NULL); + madd_v4_v4fl(color, in1, this->m_filter[6]); + this->m_inputOperation->read(in1, x2, y3, inputBuffers, NULL); + madd_v4_v4fl(color, in1, this->m_filter[7]); + this->m_inputOperation->read(in1, x3, y3, inputBuffers, NULL); + madd_v4_v4fl(color, in1, this->m_filter[8]); color[0] = color[0] * value[0] + in2[0] * mval; color[1] = color[1] * value[0] + in2[1] * mval; @@ -116,8 +116,8 @@ void ConvolutionFilterOperation::executePixel(float *color, int x, int y, Memory bool ConvolutionFilterOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newInput; - int addx = (this->filterWidth - 1) / 2 + 1; - int addy = (this->filterHeight - 1) / 2 + 1; + int addx = (this->m_filterWidth - 1) / 2 + 1; + int addy = (this->m_filterHeight - 1) / 2 + 1; newInput.xmax = input->xmax + addx; newInput.xmin = input->xmin - addx; newInput.ymax = input->ymax + addy; diff --git a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h index f3347eb583a..0b5dfb4d75a 100644 --- a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h +++ b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h @@ -27,13 +27,13 @@ class ConvolutionFilterOperation : public NodeOperation { private: - int filterWidth; - int filterHeight; + int m_filterWidth; + int m_filterHeight; protected: - SocketReader *inputOperation; - SocketReader *inputValueOperation; - float *filter; + SocketReader *m_inputOperation; + SocketReader *m_inputValueOperation; + float *m_filter; public: ConvolutionFilterOperation(); diff --git a/source/blender/compositor/operations/COM_CropOperation.cpp b/source/blender/compositor/operations/COM_CropOperation.cpp index 0bdd2cfcb51..0a40f2370c8 100644 --- a/source/blender/compositor/operations/COM_CropOperation.cpp +++ b/source/blender/compositor/operations/COM_CropOperation.cpp @@ -27,8 +27,8 @@ CropBaseOperation::CropBaseOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE); this->addOutputSocket(COM_DT_COLOR); - this->inputOperation = NULL; - this->settings = NULL; + this->m_inputOperation = NULL; + this->m_settings = NULL; } void CropBaseOperation::updateArea() @@ -36,36 +36,36 @@ void CropBaseOperation::updateArea() SocketReader *inputReference = this->getInputSocketReader(0); float width = inputReference->getWidth(); float height = inputReference->getHeight(); - if (this->relative) { - settings->x1 = width * settings->fac_x1; - settings->x2 = width * settings->fac_x2; - settings->y1 = height * settings->fac_y1; - settings->y2 = height * settings->fac_y2; + if (this->m_relative) { + this->m_settings->x1 = width * this->m_settings->fac_x1; + this->m_settings->x2 = width * this->m_settings->fac_x2; + this->m_settings->y1 = height * this->m_settings->fac_y1; + this->m_settings->y2 = height * this->m_settings->fac_y2; } - if (width <= settings->x1 + 1) - settings->x1 = width - 1; - if (height <= settings->y1 + 1) - settings->y1 = height - 1; - if (width <= settings->x2 + 1) - settings->x2 = width - 1; - if (height <= settings->y2 + 1) - settings->y2 = height - 1; + if (width <= this->m_settings->x1 + 1) + this->m_settings->x1 = width - 1; + if (height <= this->m_settings->y1 + 1) + this->m_settings->y1 = height - 1; + if (width <= this->m_settings->x2 + 1) + this->m_settings->x2 = width - 1; + if (height <= this->m_settings->y2 + 1) + this->m_settings->y2 = height - 1; - this->xmax = MAX2(settings->x1, settings->x2) + 1; - this->xmin = MIN2(settings->x1, settings->x2); - this->ymax = MAX2(settings->y1, settings->y2) + 1; - this->ymin = MIN2(settings->y1, settings->y2); + this->m_xmax = MAX2(this->m_settings->x1, this->m_settings->x2) + 1; + this->m_xmin = MIN2(this->m_settings->x1, this->m_settings->x2); + this->m_ymax = MAX2(this->m_settings->y1, this->m_settings->y2) + 1; + this->m_ymin = MIN2(this->m_settings->y1, this->m_settings->y2); } void CropBaseOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); updateArea(); } void CropBaseOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } CropOperation::CropOperation() : CropBaseOperation() @@ -75,14 +75,11 @@ CropOperation::CropOperation() : CropBaseOperation() void CropOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - if ((x < this->xmax && x >= xmin) && (y < ymax && y >= ymin)) { - inputOperation->read(color, x, y, sampler, inputBuffers); + if ((x < this->m_xmax && x >= this->m_xmin) && (y < this->m_ymax && y >= this->m_ymin)) { + this->m_inputOperation->read(color, x, y, sampler, inputBuffers); } else { - color[0] = 0.0f; - color[1] = 0.0f; - color[2] = 0.0f; - color[3] = 0.0f; + zero_v4(color); } } @@ -95,10 +92,10 @@ bool CropImageOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe { rcti newInput; - newInput.xmax = input->xmax + this->xmin; - newInput.xmin = input->xmin + this->xmin; - newInput.ymax = input->ymax + this->ymin; - newInput.ymin = input->ymin + this->ymin; + newInput.xmax = input->xmax + this->m_xmin; + newInput.xmin = input->xmin + this->m_xmin; + newInput.ymax = input->ymax + this->m_ymin; + newInput.ymin = input->ymin + this->m_ymin; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -107,11 +104,11 @@ void CropImageOperation::determineResolution(unsigned int resolution[], unsigned { NodeOperation::determineResolution(resolution, preferedResolution); updateArea(); - resolution[0] = this->xmax - this->xmin; - resolution[1] = this->ymax - this->ymin; + resolution[0] = this->m_xmax - this->m_xmin; + resolution[1] = this->m_ymax - this->m_ymin; } void CropImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - this->inputOperation->read(color, (x + this->xmin), (y + this->ymin), sampler, inputBuffers); + this->m_inputOperation->read(color, (x + this->m_xmin), (y + this->m_ymin), sampler, inputBuffers); } diff --git a/source/blender/compositor/operations/COM_CropOperation.h b/source/blender/compositor/operations/COM_CropOperation.h index 48e5ab7f75b..39dbb8aa873 100644 --- a/source/blender/compositor/operations/COM_CropOperation.h +++ b/source/blender/compositor/operations/COM_CropOperation.h @@ -27,21 +27,21 @@ class CropBaseOperation : public NodeOperation { protected: - SocketReader *inputOperation; - NodeTwoXYs *settings; - bool relative; - int xmax; - int xmin; - int ymax; - int ymin; + SocketReader *m_inputOperation; + NodeTwoXYs *m_settings; + bool m_relative; + int m_xmax; + int m_xmin; + int m_ymax; + int m_ymin; void updateArea(); public: CropBaseOperation(); void initExecution(); void deinitExecution(); - void setCropSettings(NodeTwoXYs *settings) { this->settings = settings; } - void setRelative(bool rel) { this->relative = rel; } + void setCropSettings(NodeTwoXYs *settings) { this->m_settings = settings; } + void setRelative(bool rel) { this->m_relative = rel; } }; class CropOperation : public CropBaseOperation { diff --git a/source/blender/compositor/operations/COM_CurveBaseOperation.cpp b/source/blender/compositor/operations/COM_CurveBaseOperation.cpp index 6aa8bc2a0df..48d2bcd0ef9 100644 --- a/source/blender/compositor/operations/COM_CurveBaseOperation.cpp +++ b/source/blender/compositor/operations/COM_CurveBaseOperation.cpp @@ -32,9 +32,9 @@ extern "C" { CurveBaseOperation::CurveBaseOperation() : NodeOperation() { - this->curveMapping = NULL; + this->m_curveMapping = NULL; } void CurveBaseOperation::initExecution() { - curvemapping_initialize(this->curveMapping); + curvemapping_initialize(this->m_curveMapping); } diff --git a/source/blender/compositor/operations/COM_CurveBaseOperation.h b/source/blender/compositor/operations/COM_CurveBaseOperation.h index 9cddb3be46b..1636c13a571 100644 --- a/source/blender/compositor/operations/COM_CurveBaseOperation.h +++ b/source/blender/compositor/operations/COM_CurveBaseOperation.h @@ -30,7 +30,7 @@ protected: /** * Cached reference to the inputProgram */ - CurveMapping *curveMapping; + CurveMapping *m_curveMapping; public: CurveBaseOperation(); @@ -39,6 +39,6 @@ public: */ void initExecution(); - void setCurveMapping(CurveMapping *mapping) { this->curveMapping = mapping; } + void setCurveMapping(CurveMapping *mapping) { this->m_curveMapping = mapping; } }; #endif diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp index c27e699f627..75f909e2198 100644 --- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp +++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp @@ -29,19 +29,19 @@ DifferenceMatteOperation::DifferenceMatteOperation() : NodeOperation() addInputSocket(COM_DT_COLOR); addOutputSocket(COM_DT_VALUE); - inputImage1Program = NULL; - inputImage2Program = NULL; + this->m_inputImage1Program = NULL; + this->m_inputImage2Program = NULL; } void DifferenceMatteOperation::initExecution() { - this->inputImage1Program = this->getInputSocketReader(0); - this->inputImage2Program = this->getInputSocketReader(1); + this->m_inputImage1Program = this->getInputSocketReader(0); + this->m_inputImage2Program = this->getInputSocketReader(1); } void DifferenceMatteOperation::deinitExecution() { - this->inputImage1Program = NULL; - this->inputImage2Program = NULL; + this->m_inputImage1Program = NULL; + this->m_inputImage2Program = NULL; } void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -49,13 +49,13 @@ void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y float inColor1[4]; float inColor2[4]; - const float tolerence = this->settings->t1; - const float falloff = this->settings->t2; + const float tolerence = this->m_settings->t1; + const float falloff = this->m_settings->t2; float difference; float alpha; - this->inputImage1Program->read(inColor1, x, y, sampler, inputBuffers); - this->inputImage2Program->read(inColor2, x, y, sampler, inputBuffers); + this->m_inputImage1Program->read(inColor1, x, y, sampler, inputBuffers); + this->m_inputImage2Program->read(inColor2, x, y, sampler, inputBuffers); difference = (fabsf(inColor2[0] - inColor1[0]) + fabsf(inColor2[1] - inColor1[1]) + diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.h b/source/blender/compositor/operations/COM_DifferenceMatteOperation.h index 3bdc3384556..48eb2626f02 100644 --- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.h +++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.h @@ -31,9 +31,9 @@ */ class DifferenceMatteOperation : public NodeOperation { private: - NodeChroma *settings; - SocketReader *inputImage1Program; - SocketReader *inputImage2Program; + NodeChroma *m_settings; + SocketReader *m_inputImage1Program; + SocketReader *m_inputImage2Program; public: /** * Default constructor @@ -48,6 +48,6 @@ public: void initExecution(); void deinitExecution(); - void setSettings(NodeChroma *nodeChroma) { this->settings = nodeChroma; } + void setSettings(NodeChroma *nodeChroma) { this->m_settings = nodeChroma; } }; #endif diff --git a/source/blender/compositor/operations/COM_DilateErodeOperation.cpp b/source/blender/compositor/operations/COM_DilateErodeOperation.cpp index 80d1c6444eb..338a3a0b59b 100644 --- a/source/blender/compositor/operations/COM_DilateErodeOperation.cpp +++ b/source/blender/compositor/operations/COM_DilateErodeOperation.cpp @@ -30,57 +30,57 @@ DilateErodeThresholdOperation::DilateErodeThresholdOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); this->setComplex(true); - this->inputProgram = NULL; - this->inset = 0.0f; - this->_switch = 0.5f; - this->distance = 0.0f; + this->m_inputProgram = NULL; + this->m_inset = 0.0f; + this->m__switch = 0.5f; + this->m_distance = 0.0f; } void DilateErodeThresholdOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); - if (this->distance < 0.0f) { - this->scope = -this->distance + this->inset; + this->m_inputProgram = this->getInputSocketReader(0); + if (this->m_distance < 0.0f) { + this->m_scope = -this->m_distance + this->m_inset; } else { - if (this->inset * 2 > this->distance) { - this->scope = max(this->inset * 2 - this->distance, this->distance); + if (this->m_inset * 2 > this->m_distance) { + this->m_scope = max(this->m_inset * 2 - this->m_distance, this->m_distance); } else { - this->scope = distance; + this->m_scope = this->m_distance; } } - if (scope < 3) { - scope = 3; + if (this->m_scope < 3) { + this->m_scope = 3; } } void *DilateErodeThresholdOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - void *buffer = inputProgram->initializeTileData(NULL, memoryBuffers); + void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers); return buffer; } void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { float inputValue[4]; - const float sw = this->_switch; - const float distance = this->distance; + const float sw = this->m__switch; + const float distance = this->m_distance; float pixelvalue; - const float rd = scope * scope; - const float inset = this->inset; + const float rd = this->m_scope * this->m_scope; + const float inset = this->m_inset; float mindist = rd * 2; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); rcti *rect = inputBuffer->getRect(); - const int minx = max(x - scope, rect->xmin); - const int miny = max(y - scope, rect->ymin); - const int maxx = min(x + scope, rect->xmax); - const int maxy = min(y + scope, rect->ymax); + const int minx = max(x - this->m_scope, rect->xmin); + const int miny = max(y - this->m_scope, rect->ymin); + const int maxx = min(x + this->m_scope, rect->xmax); + const int maxy = min(y + this->m_scope, rect->ymax); const int bufferWidth = rect->xmax - rect->xmin; int offset; - this->inputProgram->read(inputValue, x, y, inputBuffers, NULL); + this->m_inputProgram->read(inputValue, x, y, inputBuffers, NULL); if (inputValue[0] > sw) { for (int yi = miny; yi < maxy; yi++) { const float dy = yi - y; @@ -145,17 +145,17 @@ void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, Mem void DilateErodeThresholdOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } bool DilateErodeThresholdOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newInput; - newInput.xmax = input->xmax + scope; - newInput.xmin = input->xmin - scope; - newInput.ymax = input->ymax + scope; - newInput.ymin = input->ymin - scope; + newInput.xmax = input->xmax + this->m_scope; + newInput.xmin = input->xmin - this->m_scope; + newInput.ymax = input->ymax + this->m_scope; + newInput.ymin = input->ymin - this->m_scope; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -166,37 +166,37 @@ DilateDistanceOperation::DilateDistanceOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); this->setComplex(true); - this->inputProgram = NULL; - this->distance = 0.0f; + this->m_inputProgram = NULL; + this->m_distance = 0.0f; this->setOpenCL(true); } void DilateDistanceOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); - this->scope = distance; - if (scope < 3) { - scope = 3; + this->m_inputProgram = this->getInputSocketReader(0); + this->m_scope = this->m_distance; + if (this->m_scope < 3) { + this->m_scope = 3; } } void *DilateDistanceOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - void *buffer = inputProgram->initializeTileData(NULL, memoryBuffers); + void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers); return buffer; } void DilateDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - const float distance = this->distance; + const float distance = this->m_distance; const float mindist = distance * distance; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); rcti *rect = inputBuffer->getRect(); - const int minx = max(x - scope, rect->xmin); - const int miny = max(y - scope, rect->ymin); - const int maxx = min(x + scope, rect->xmax); - const int maxy = min(y + scope, rect->ymax); + const int minx = max(x - this->m_scope, rect->xmin); + const int miny = max(y - this->m_scope, rect->ymin); + const int maxx = min(x + this->m_scope, rect->xmax); + const int maxy = min(y + this->m_scope, rect->ymax); const int bufferWidth = rect->xmax - rect->xmin; int offset; @@ -219,17 +219,17 @@ void DilateDistanceOperation::executePixel(float *color, int x, int y, MemoryBuf void DilateDistanceOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } bool DilateDistanceOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newInput; - newInput.xmax = input->xmax + scope; - newInput.xmin = input->xmin - scope; - newInput.ymax = input->ymax + scope; - newInput.ymin = input->ymin - scope; + newInput.xmax = input->xmax + this->m_scope; + newInput.xmin = input->xmin - this->m_scope; + newInput.ymax = input->ymax + this->m_scope; + newInput.ymin = input->ymin - this->m_scope; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -243,10 +243,10 @@ void DilateDistanceOperation::executeOpenCL(OpenCLDevice* device, if (!dilateKernel) { dilateKernel = device->COM_clCreateKernel("dilateKernel", NULL); } - cl_int distanceSquared = this->distance * this->distance; - cl_int scope = this->scope; + cl_int distanceSquared = this->m_distance * this->m_distance; + cl_int scope = this->m_scope; - device->COM_clAttachMemoryBufferToKernelParameter(dilateKernel, 0, 2, clMemToCleanUp, inputMemoryBuffers, this->inputProgram); + device->COM_clAttachMemoryBufferToKernelParameter(dilateKernel, 0, 2, clMemToCleanUp, inputMemoryBuffers, this->m_inputProgram); device->COM_clAttachOutputMemoryBufferToKernelParameter(dilateKernel, 1, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter(dilateKernel, 3, outputMemoryBuffer); clSetKernelArg(dilateKernel, 4, sizeof(cl_int), &scope); @@ -263,16 +263,16 @@ ErodeDistanceOperation::ErodeDistanceOperation() : DilateDistanceOperation() void ErodeDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - const float distance = this->distance; + const float distance = this->m_distance; const float mindist = distance * distance; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); rcti *rect = inputBuffer->getRect(); - const int minx = max(x - scope, rect->xmin); - const int miny = max(y - scope, rect->ymin); - const int maxx = min(x + scope, rect->xmax); - const int maxy = min(y + scope, rect->ymax); + const int minx = max(x - this->m_scope, rect->xmin); + const int miny = max(y - this->m_scope, rect->ymin); + const int maxx = min(x + this->m_scope, rect->xmax); + const int maxy = min(y + this->m_scope, rect->ymax); const int bufferWidth = rect->xmax - rect->xmin; int offset; @@ -302,10 +302,10 @@ void ErodeDistanceOperation::executeOpenCL(OpenCLDevice* device, if (!erodeKernel) { erodeKernel = device->COM_clCreateKernel("erodeKernel", NULL); } - cl_int distanceSquared = this->distance * this->distance; - cl_int scope = this->scope; + cl_int distanceSquared = this->m_distance * this->m_distance; + cl_int scope = this->m_scope; - device->COM_clAttachMemoryBufferToKernelParameter(erodeKernel, 0, 2, clMemToCleanUp, inputMemoryBuffers, this->inputProgram); + device->COM_clAttachMemoryBufferToKernelParameter(erodeKernel, 0, 2, clMemToCleanUp, inputMemoryBuffers, this->m_inputProgram); device->COM_clAttachOutputMemoryBufferToKernelParameter(erodeKernel, 1, clOutputBuffer); device->COM_clAttachMemoryBufferOffsetToKernelParameter(erodeKernel, 3, outputMemoryBuffer); clSetKernelArg(erodeKernel, 4, sizeof(cl_int), &scope); @@ -320,29 +320,29 @@ DilateStepOperation::DilateStepOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); this->setComplex(true); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void DilateStepOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); - this->cached_buffer = NULL; + this->m_inputProgram = this->getInputSocketReader(0); + this->m_cached_buffer = NULL; this->initMutex(); } void *DilateStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - if (this->cached_buffer != NULL) { - return this->cached_buffer; + if (this->m_cached_buffer != NULL) { + return this->m_cached_buffer; } lockMutex(); - if (this->cached_buffer == NULL) { - MemoryBuffer *buffer = (MemoryBuffer *)inputProgram->initializeTileData(NULL, memoryBuffers); + if (this->m_cached_buffer == NULL) { + MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL, memoryBuffers); float *rectf = buffer->convertToValueBuffer(); int x, y, i; float *p; int bwidth = buffer->getWidth(); int bheight = buffer->getHeight(); - for (i = 0; i < this->iterations; i++) { + for (i = 0; i < this->m_iterations; i++) { for (y = 0; y < bheight; y++) { for (x = 0; x < bwidth - 1; x++) { p = rectf + (bwidth * y + x); @@ -371,31 +371,31 @@ void *DilateStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryB } } } - this->cached_buffer = rectf; + this->m_cached_buffer = rectf; } unlockMutex(); - return this->cached_buffer; + return this->m_cached_buffer; } void DilateStepOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - color[0] = this->cached_buffer[y * this->getWidth() + x]; + color[0] = this->m_cached_buffer[y * this->getWidth() + x]; } void DilateStepOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; this->deinitMutex(); - if (this->cached_buffer) { - delete cached_buffer; - this->cached_buffer = NULL; + if (this->m_cached_buffer) { + delete this->m_cached_buffer; + this->m_cached_buffer = NULL; } } bool DilateStepOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { - if (this->cached_buffer) { + if (this->m_cached_buffer) { return false; } else { @@ -418,18 +418,18 @@ ErodeStepOperation::ErodeStepOperation() : DilateStepOperation() void *ErodeStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - if (this->cached_buffer != NULL) { - return this->cached_buffer; + if (this->m_cached_buffer != NULL) { + return this->m_cached_buffer; } lockMutex(); - if (this->cached_buffer == NULL) { - MemoryBuffer *buffer = (MemoryBuffer *)inputProgram->initializeTileData(NULL, memoryBuffers); + if (this->m_cached_buffer == NULL) { + MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL, memoryBuffers); float *rectf = buffer->convertToValueBuffer(); int x, y, i; float *p; int bwidth = buffer->getWidth(); int bheight = buffer->getHeight(); - for (i = 0; i < this->iterations; i++) { + for (i = 0; i < this->m_iterations; i++) { for (y = 0; y < bheight; y++) { for (x = 0; x < bwidth - 1; x++) { p = rectf + (bwidth * y + x); @@ -458,8 +458,8 @@ void *ErodeStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBu } } } - this->cached_buffer = rectf; + this->m_cached_buffer = rectf; } unlockMutex(); - return this->cached_buffer; + return this->m_cached_buffer; } diff --git a/source/blender/compositor/operations/COM_DilateErodeOperation.h b/source/blender/compositor/operations/COM_DilateErodeOperation.h index 4d0bf9de0ec..bc6049bf992 100644 --- a/source/blender/compositor/operations/COM_DilateErodeOperation.h +++ b/source/blender/compositor/operations/COM_DilateErodeOperation.h @@ -30,17 +30,17 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; - float distance; - float _switch; - float inset; + float m_distance; + float m__switch; + float m_inset; /** * determines the area of interest to track pixels * keep this one as small as possible for speed gain. */ - int scope; + int m_scope; public: DilateErodeThresholdOperation(); @@ -60,9 +60,9 @@ public: */ void deinitExecution(); - void setDistance(float distance) { this->distance = distance; } - void setSwitch(float sw) { this->_switch = sw; } - void setInset(float inset) { this->inset = inset; } + void setDistance(float distance) { this->m_distance = distance; } + void setSwitch(float sw) { this->m__switch = sw; } + void setInset(float inset) { this->m_inset = inset; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); @@ -74,9 +74,9 @@ protected: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; - float distance; - int scope; + SocketReader *m_inputProgram; + float m_distance; + int m_scope; public: DilateDistanceOperation(); @@ -96,7 +96,7 @@ public: */ void deinitExecution(); - void setDistance(float distance) { this->distance = distance; } + void setDistance(float distance) { this->m_distance = distance; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); void executeOpenCL(OpenCLDevice* device, @@ -124,11 +124,11 @@ protected: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; - int iterations; + int m_iterations; - float *cached_buffer; + float *m_cached_buffer; public: DilateStepOperation(); @@ -148,7 +148,7 @@ public: */ void deinitExecution(); - void setIterations(int iterations) { this->iterations = iterations; } + void setIterations(int iterations) { this->m_iterations = iterations; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); }; diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp index 271a165f0ff..da7336afc07 100644 --- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp @@ -33,20 +33,20 @@ DirectionalBlurOperation::DirectionalBlurOperation() : NodeOperation() this->addOutputSocket(COM_DT_COLOR); this->setComplex(true); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void DirectionalBlurOperation::initExecution() { - this->inputProgram = getInputSocketReader(0); + this->m_inputProgram = getInputSocketReader(0); QualityStepHelper::initExecution(COM_QH_INCREASE); - const float angle = this->data->angle; - const float zoom = this->data->zoom; - const float spin = this->data->spin; - const float iterations = this->data->iter; - const float distance = this->data->distance; - const float center_x = this->data->center_x; - const float center_y = this->data->center_y; + const float angle = this->m_data->angle; + const float zoom = this->m_data->zoom; + const float spin = this->m_data->spin; + const float iterations = this->m_data->iter; + const float distance = this->m_data->distance; + const float center_x = this->m_data->center_x; + const float center_y = this->m_data->center_y; const float width = getWidth(); const float height = getHeight(); @@ -55,43 +55,46 @@ void DirectionalBlurOperation::initExecution() float D; D = distance * sqrtf(width * width + height * height); - center_x_pix = center_x * width; - center_y_pix = center_y * height; + this->m_center_x_pix = center_x * width; + this->m_center_y_pix = center_y * height; - tx = itsc * D * cosf(a); - ty = -itsc *D *sinf(a); - sc = itsc * zoom; - rot = itsc * spin; + this->m_tx = itsc * D * cosf(a); + this->m_ty = -itsc *D *sinf(a); + this->m_sc = itsc * zoom; + this->m_rot = itsc * spin; } void DirectionalBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - const int iterations = pow(2.f, this->data->iter); + const int iterations = pow(2.0f, this->m_data->iter); float col[4] = {0, 0, 0, 0}; float col2[4] = {0, 0, 0, 0}; - this->inputProgram->read(col2, x, y, COM_PS_NEAREST, inputBuffers); - float ltx = tx; - float lty = ty; - float lsc = sc; - float lrot = rot; + this->m_inputProgram->read(col2, x, y, COM_PS_NEAREST, inputBuffers); + float ltx = this->m_tx; + float lty = this->m_ty; + float lsc = this->m_sc; + float lrot = this->m_rot; /* blur the image */ for (int i = 0; i < iterations; ++i) { const float cs = cos(lrot), ss = sin(lrot); - const float isc = 1.f / (1.f + lsc); + const float isc = 1.0f / (1.0f + lsc); - const float v = isc * (y - center_y_pix) + lty; - const float u = isc * (x - center_x_pix) + ltx; + const float v = isc * (y - this->m_center_y_pix) + lty; + const float u = isc * (x - this->m_center_x_pix) + ltx; - this->inputProgram->read(col, cs * u + ss * v + center_x_pix, cs * v - ss * u + center_y_pix, COM_PS_NEAREST, inputBuffers); + this->m_inputProgram->read(col, + cs * u + ss * v + this->m_center_x_pix, + cs * v - ss * u + this->m_center_y_pix, + COM_PS_NEAREST, inputBuffers); add_v4_v4(col2, col); /* double transformations */ - ltx += tx; - lty += ty; - lrot += rot; - lsc += sc; + ltx += this->m_tx; + lty += this->m_ty; + lrot += this->m_rot; + lsc += this->m_sc; } mul_v4_v4fl(color, col2, 1.0f / iterations); @@ -99,7 +102,7 @@ void DirectionalBlurOperation::executePixel(float *color, int x, int y, MemoryBu void DirectionalBlurOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } bool DirectionalBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.h b/source/blender/compositor/operations/COM_DirectionalBlurOperation.h index 9cc0a4361f1..329f855871e 100644 --- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.h +++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.h @@ -27,12 +27,12 @@ class DirectionalBlurOperation : public NodeOperation, public QualityStepHelper { private: - SocketReader *inputProgram; - NodeDBlurData *data; + SocketReader *m_inputProgram; + NodeDBlurData *m_data; - float center_x_pix, center_y_pix; - float tx, ty; - float sc, rot; + float m_center_x_pix, m_center_y_pix; + float m_tx, m_ty; + float m_sc, m_rot; public: DirectionalBlurOperation(); @@ -54,6 +54,6 @@ public: bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); - void setData(NodeDBlurData *data) { this->data = data; } + void setData(NodeDBlurData *data) { this->m_data = data; } }; #endif diff --git a/source/blender/compositor/operations/COM_DisplaceOperation.cpp b/source/blender/compositor/operations/COM_DisplaceOperation.cpp index be50641a125..c7df53770c5 100644 --- a/source/blender/compositor/operations/COM_DisplaceOperation.cpp +++ b/source/blender/compositor/operations/COM_DisplaceOperation.cpp @@ -32,21 +32,21 @@ DisplaceOperation::DisplaceOperation() : NodeOperation() this->addOutputSocket(COM_DT_COLOR); this->setComplex(true); - this->inputColorProgram = NULL; - this->inputVectorProgram = NULL; - this->inputScaleXProgram = NULL; - this->inputScaleYProgram = NULL; + this->m_inputColorProgram = NULL; + this->m_inputVectorProgram = NULL; + this->m_inputScaleXProgram = NULL; + this->m_inputScaleYProgram = NULL; } void DisplaceOperation::initExecution() { - this->inputColorProgram = this->getInputSocketReader(0); - this->inputVectorProgram = this->getInputSocketReader(1); - this->inputScaleXProgram = this->getInputSocketReader(2); - this->inputScaleYProgram = this->getInputSocketReader(3); + this->m_inputColorProgram = this->getInputSocketReader(0); + this->m_inputVectorProgram = this->getInputSocketReader(1); + this->m_inputScaleXProgram = this->getInputSocketReader(2); + this->m_inputScaleYProgram = this->getInputSocketReader(3); - width_x4 = this->getWidth() * 4; - height_x4 = this->getHeight() * 4; + this->m_width_x4 = this->getWidth() * 4; + this->m_height_x4 = this->getHeight() * 4; } @@ -64,17 +64,17 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i float dxt, dyt; float u, v; - this->inputScaleXProgram->read(inScale, x, y, COM_PS_NEAREST, inputBuffers); + this->m_inputScaleXProgram->read(inScale, x, y, COM_PS_NEAREST, inputBuffers); float xs = inScale[0]; - this->inputScaleYProgram->read(inScale, x, y, COM_PS_NEAREST, inputBuffers); + this->m_inputScaleYProgram->read(inScale, x, y, COM_PS_NEAREST, inputBuffers); float ys = inScale[0]; /* clamp x and y displacement to triple image resolution - * to prevent hangs from huge values mistakenly plugged in eg. z buffers */ - CLAMP(xs, -width_x4, width_x4); - CLAMP(ys, -height_x4, height_x4); + CLAMP(xs, -this->m_width_x4, this->m_width_x4); + CLAMP(ys, -this->m_height_x4, this->m_height_x4); - this->inputVectorProgram->read(inVector, x, y, COM_PS_NEAREST, inputBuffers); + this->m_inputVectorProgram->read(inVector, x, y, COM_PS_NEAREST, inputBuffers); p_dx = inVector[0] * xs; p_dy = inVector[1] * ys; @@ -83,9 +83,9 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i v = y - p_dy + 0.5f; /* calc derivatives */ - this->inputVectorProgram->read(inVector, x + 1, y, COM_PS_NEAREST, inputBuffers); + this->m_inputVectorProgram->read(inVector, x + 1, y, COM_PS_NEAREST, inputBuffers); d_dx = inVector[0] * xs; - this->inputVectorProgram->read(inVector, x, y + 1, COM_PS_NEAREST, inputBuffers); + this->m_inputVectorProgram->read(inVector, x, y + 1, COM_PS_NEAREST, inputBuffers); d_dy = inVector[0] * ys; /* clamp derivatives to minimum displacement distance in UV space */ @@ -96,15 +96,15 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i dyt = signf(dyt) * maxf(fabsf(dyt), DISPLACE_EPSILON) / this->getHeight(); /* EWA filtering */ - this->inputColorProgram->read(color, u, v, dxt, dyt, inputBuffers); + this->m_inputColorProgram->read(color, u, v, dxt, dyt, inputBuffers); } void DisplaceOperation::deinitExecution() { - this->inputColorProgram = NULL; - this->inputVectorProgram = NULL; - this->inputScaleXProgram = NULL; - this->inputScaleYProgram = NULL; + this->m_inputColorProgram = NULL; + this->m_inputVectorProgram = NULL; + this->m_inputScaleXProgram = NULL; + this->m_inputScaleYProgram = NULL; } bool DisplaceOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) diff --git a/source/blender/compositor/operations/COM_DisplaceOperation.h b/source/blender/compositor/operations/COM_DisplaceOperation.h index 82788e37e3a..e01c9190396 100644 --- a/source/blender/compositor/operations/COM_DisplaceOperation.h +++ b/source/blender/compositor/operations/COM_DisplaceOperation.h @@ -29,13 +29,13 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputColorProgram; - SocketReader *inputVectorProgram; - SocketReader *inputScaleXProgram; - SocketReader *inputScaleYProgram; + SocketReader *m_inputColorProgram; + SocketReader *m_inputVectorProgram; + SocketReader *m_inputScaleXProgram; + SocketReader *m_inputScaleYProgram; - float width_x4; - float height_x4; + float m_width_x4; + float m_height_x4; public: DisplaceOperation(); diff --git a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp index 716646e9c36..d21fc62abd7 100644 --- a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp +++ b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp @@ -31,21 +31,21 @@ DisplaceSimpleOperation::DisplaceSimpleOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); - this->inputColorProgram = NULL; - this->inputVectorProgram = NULL; - this->inputScaleXProgram = NULL; - this->inputScaleYProgram = NULL; + this->m_inputColorProgram = NULL; + this->m_inputVectorProgram = NULL; + this->m_inputScaleXProgram = NULL; + this->m_inputScaleYProgram = NULL; } void DisplaceSimpleOperation::initExecution() { - this->inputColorProgram = this->getInputSocketReader(0); - this->inputVectorProgram = this->getInputSocketReader(1); - this->inputScaleXProgram = this->getInputSocketReader(2); - this->inputScaleYProgram = this->getInputSocketReader(3); + this->m_inputColorProgram = this->getInputSocketReader(0); + this->m_inputVectorProgram = this->getInputSocketReader(1); + this->m_inputScaleXProgram = this->getInputSocketReader(2); + this->m_inputScaleYProgram = this->getInputSocketReader(3); - width_x4 = this->getWidth() * 4; - height_x4 = this->getHeight() * 4; + this->m_width_x4 = this->getWidth() * 4; + this->m_height_x4 = this->getHeight() * 4; } @@ -61,17 +61,17 @@ void DisplaceSimpleOperation::executePixel(float *color, float x, float y, Pixel float p_dx, p_dy; /* main displacement in pixel space */ float u, v; - this->inputScaleXProgram->read(inScale, x, y, sampler, inputBuffers); + this->m_inputScaleXProgram->read(inScale, x, y, sampler, inputBuffers); float xs = inScale[0]; - this->inputScaleYProgram->read(inScale, x, y, sampler, inputBuffers); + this->m_inputScaleYProgram->read(inScale, x, y, sampler, inputBuffers); float ys = inScale[0]; /* clamp x and y displacement to triple image resolution - * to prevent hangs from huge values mistakenly plugged in eg. z buffers */ - CLAMP(xs, -width_x4, width_x4); - CLAMP(ys, -height_x4, height_x4); + CLAMP(xs, -this->m_width_x4, this->m_width_x4); + CLAMP(ys, -this->m_height_x4, this->m_height_x4); - this->inputVectorProgram->read(inVector, x, y, sampler, inputBuffers); + this->m_inputVectorProgram->read(inVector, x, y, sampler, inputBuffers); p_dx = inVector[0] * xs; p_dy = inVector[1] * ys; @@ -82,15 +82,15 @@ void DisplaceSimpleOperation::executePixel(float *color, float x, float y, Pixel CLAMP(u, 0.f, this->getWidth() - 1.f); CLAMP(v, 0.f, this->getHeight() - 1.f); - this->inputColorProgram->read(color, u, v, sampler, inputBuffers); + this->m_inputColorProgram->read(color, u, v, sampler, inputBuffers); } void DisplaceSimpleOperation::deinitExecution() { - this->inputColorProgram = NULL; - this->inputVectorProgram = NULL; - this->inputScaleXProgram = NULL; - this->inputScaleYProgram = NULL; + this->m_inputColorProgram = NULL; + this->m_inputVectorProgram = NULL; + this->m_inputScaleXProgram = NULL; + this->m_inputScaleYProgram = NULL; } bool DisplaceSimpleOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) diff --git a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h index 1ebb238855b..25afbafe335 100644 --- a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h +++ b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h @@ -29,13 +29,13 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputColorProgram; - SocketReader *inputVectorProgram; - SocketReader *inputScaleXProgram; - SocketReader *inputScaleYProgram; + SocketReader *m_inputColorProgram; + SocketReader *m_inputVectorProgram; + SocketReader *m_inputScaleXProgram; + SocketReader *m_inputScaleYProgram; - float width_x4; - float height_x4; + float m_width_x4; + float m_height_x4; public: DisplaceSimpleOperation(); diff --git a/source/blender/compositor/operations/COM_DistanceMatteOperation.cpp b/source/blender/compositor/operations/COM_DistanceMatteOperation.cpp index ec01ba922b5..19cca3d25bb 100644 --- a/source/blender/compositor/operations/COM_DistanceMatteOperation.cpp +++ b/source/blender/compositor/operations/COM_DistanceMatteOperation.cpp @@ -28,20 +28,20 @@ DistanceMatteOperation::DistanceMatteOperation() : NodeOperation() addInputSocket(COM_DT_COLOR); addOutputSocket(COM_DT_VALUE); - inputImageProgram = NULL; - inputKeyProgram = NULL; + this->m_inputImageProgram = NULL; + this->m_inputKeyProgram = NULL; } void DistanceMatteOperation::initExecution() { - this->inputImageProgram = this->getInputSocketReader(0); - this->inputKeyProgram = this->getInputSocketReader(1); + this->m_inputImageProgram = this->getInputSocketReader(0); + this->m_inputKeyProgram = this->getInputSocketReader(1); } void DistanceMatteOperation::deinitExecution() { - this->inputImageProgram = NULL; - this->inputKeyProgram = NULL; + this->m_inputImageProgram = NULL; + this->m_inputKeyProgram = NULL; } void DistanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -49,14 +49,14 @@ void DistanceMatteOperation::executePixel(float *outputValue, float x, float y, float inKey[4]; float inImage[4]; - const float tolerence = this->settings->t1; - const float falloff = this->settings->t2; + const float tolerence = this->m_settings->t1; + const float falloff = this->m_settings->t2; float distance; float alpha; - this->inputKeyProgram->read(inKey, x, y, sampler, inputBuffers); - this->inputImageProgram->read(inImage, x, y, sampler, inputBuffers); + this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers); + this->m_inputImageProgram->read(inImage, x, y, sampler, inputBuffers); distance = sqrt(pow((inKey[0] - inImage[0]), 2) + pow((inKey[1] - inImage[1]), 2) + diff --git a/source/blender/compositor/operations/COM_DistanceMatteOperation.h b/source/blender/compositor/operations/COM_DistanceMatteOperation.h index cf1172a8c11..51e139d179e 100644 --- a/source/blender/compositor/operations/COM_DistanceMatteOperation.h +++ b/source/blender/compositor/operations/COM_DistanceMatteOperation.h @@ -30,9 +30,9 @@ */ class DistanceMatteOperation : public NodeOperation { private: - NodeChroma *settings; - SocketReader *inputImageProgram; - SocketReader *inputKeyProgram; + NodeChroma *m_settings; + SocketReader *m_inputImageProgram; + SocketReader *m_inputKeyProgram; public: /** * Default constructor @@ -47,6 +47,6 @@ public: void initExecution(); void deinitExecution(); - void setSettings(NodeChroma *nodeChroma) { this->settings = nodeChroma; } + void setSettings(NodeChroma *nodeChroma) { this->m_settings = nodeChroma; } }; #endif diff --git a/source/blender/compositor/operations/COM_DotproductOperation.cpp b/source/blender/compositor/operations/COM_DotproductOperation.cpp index e225a677989..53ab5f97518 100644 --- a/source/blender/compositor/operations/COM_DotproductOperation.cpp +++ b/source/blender/compositor/operations/COM_DotproductOperation.cpp @@ -28,19 +28,19 @@ DotproductOperation::DotproductOperation() : NodeOperation() this->addInputSocket(COM_DT_VECTOR); this->addOutputSocket(COM_DT_VALUE); this->setResolutionInputSocketIndex(0); - this->input1Operation = NULL; - this->input2Operation = NULL; + this->m_input1Operation = NULL; + this->m_input2Operation = NULL; } void DotproductOperation::initExecution() { - this->input1Operation = this->getInputSocketReader(0); - this->input2Operation = this->getInputSocketReader(1); + this->m_input1Operation = this->getInputSocketReader(0); + this->m_input2Operation = this->getInputSocketReader(1); } void DotproductOperation::deinitExecution() { - this->input1Operation = NULL; - this->input2Operation = NULL; + this->m_input1Operation = NULL; + this->m_input2Operation = NULL; } /** @todo: current implementation is the inverse of a dotproduct. not 'logically' correct @@ -49,7 +49,7 @@ void DotproductOperation::executePixel(float *color, float x, float y, PixelSamp { float input1[4]; float input2[4]; - this->input1Operation->read(input1, x, y, sampler, inputBuffers); - this->input2Operation->read(input2, x, y, sampler, inputBuffers); + this->m_input1Operation->read(input1, x, y, sampler, inputBuffers); + this->m_input2Operation->read(input2, x, y, sampler, inputBuffers); color[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 849dc83a9cd..7ca540983d9 100644 --- a/source/blender/compositor/operations/COM_DotproductOperation.h +++ b/source/blender/compositor/operations/COM_DotproductOperation.h @@ -27,8 +27,8 @@ class DotproductOperation : public NodeOperation { private: - SocketReader *input1Operation; - SocketReader *input2Operation; + SocketReader *m_input1Operation; + SocketReader *m_input2Operation; public: DotproductOperation(); void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp index 8344a4d248b..c3c115b7c3b 100644 --- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp +++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp @@ -1184,8 +1184,8 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float * * Each version has slightly different criteria for detecting an edge pixel. */ - if (this->adjecentOnly) { // if "adjacent only" inner edge mode is turned on - if (this->keepInside) { // if "keep inside" buffer edge mode is turned on + if (this->m_adjecentOnly) { // if "adjacent only" inner edge mode is turned on + if (this->m_keepInside) { // if "keep inside" buffer edge mode is turned on do_adjacentKeepBorders(t, rw, limask, lomask, lres, res, rsize); } else { // "bleed out" buffer edge mode is turned on @@ -1198,7 +1198,7 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float do_adjacentEdgeDetection(t, rw, limask, lomask, lres, res, rsize, isz, osz, gsz); } else { // "all" inner edge mode is turned on - if (this->keepInside) { // if "keep inside" buffer edge mode is turned on + if (this->m_keepInside) { // if "keep inside" buffer edge mode is turned on do_allKeepBorders(t, rw, limask, lomask, lres, res, rsize); } else { // "bleed out" buffer edge mode is turned on @@ -1230,16 +1230,16 @@ DoubleEdgeMaskOperation::DoubleEdgeMaskOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->inputInnerMask = NULL; - this->inputOuterMask = NULL; - this->adjecentOnly = false; - this->keepInside = false; + this->m_inputInnerMask = NULL; + this->m_inputOuterMask = NULL; + this->m_adjecentOnly = false; + this->m_keepInside = false; this->setComplex(true); } bool DoubleEdgeMaskOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { - if (this->cachedInstance == NULL) { + if (this->m_cachedInstance == NULL) { rcti newInput; newInput.xmax = this->getWidth(); newInput.xmin = 0; @@ -1254,30 +1254,31 @@ bool DoubleEdgeMaskOperation::determineDependingAreaOfInterest(rcti *input, Read void DoubleEdgeMaskOperation::initExecution() { - this->inputInnerMask = this->getInputSocketReader(0); - this->inputOuterMask = this->getInputSocketReader(1); + this->m_inputInnerMask = this->getInputSocketReader(0); + this->m_inputOuterMask = this->getInputSocketReader(1); initMutex(); - this->cachedInstance = NULL; + this->m_cachedInstance = NULL; } void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - if (this->cachedInstance) return this->cachedInstance; + if (this->m_cachedInstance) + return this->m_cachedInstance; lockMutex(); - if (this->cachedInstance == NULL) { - MemoryBuffer *innerMask = (MemoryBuffer *)inputInnerMask->initializeTileData(rect, memoryBuffers); - MemoryBuffer *outerMask = (MemoryBuffer *)inputOuterMask->initializeTileData(rect, memoryBuffers); + if (this->m_cachedInstance == NULL) { + MemoryBuffer *innerMask = (MemoryBuffer *)this->m_inputInnerMask->initializeTileData(rect, memoryBuffers); + MemoryBuffer *outerMask = (MemoryBuffer *)this->m_inputOuterMask->initializeTileData(rect, memoryBuffers); float *data = new float[this->getWidth() * this->getHeight()]; float *imask = innerMask->convertToValueBuffer(); float *omask = outerMask->convertToValueBuffer(); doDoubleEdgeMask(imask, omask, data); delete imask; delete omask; - this->cachedInstance = data; + this->m_cachedInstance = data; } unlockMutex(); - return this->cachedInstance; + return this->m_cachedInstance; } void DoubleEdgeMaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { @@ -1291,12 +1292,12 @@ void DoubleEdgeMaskOperation::executePixel(float *color, int x, int y, MemoryBuf void DoubleEdgeMaskOperation::deinitExecution() { - this->inputInnerMask = NULL; - this->inputOuterMask = NULL; + this->m_inputInnerMask = NULL; + this->m_inputOuterMask = NULL; deinitMutex(); - if (this->cachedInstance) { - delete cachedInstance; - this->cachedInstance = NULL; + if (this->m_cachedInstance) { + delete this->m_cachedInstance; + this->m_cachedInstance = NULL; } } diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h index a18d59ae5a2..442680e320e 100644 --- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h +++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h @@ -30,11 +30,11 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOuterMask; - SocketReader *inputInnerMask; - bool adjecentOnly; - bool keepInside; - float *cachedInstance; + SocketReader *m_inputOuterMask; + SocketReader *m_inputInnerMask; + bool m_adjecentOnly; + bool m_keepInside; + float *m_cachedInstance; public: DoubleEdgeMaskOperation(); @@ -58,7 +58,7 @@ public: bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); - void setAdjecentOnly(bool adjecentOnly) { this->adjecentOnly = adjecentOnly; } - void setKeepInside(bool keepInside) { this->keepInside = keepInside; } + void setAdjecentOnly(bool adjecentOnly) { this->m_adjecentOnly = adjecentOnly; } + void setKeepInside(bool keepInside) { this->m_keepInside = keepInside; } }; #endif diff --git a/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp b/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp index 0beacd02738..1aa1b89ee76 100644 --- a/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp +++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp @@ -29,19 +29,19 @@ EllipseMaskOperation::EllipseMaskOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->inputMask = NULL; - this->inputValue = NULL; - this->cosine = 0.0f; - this->sine = 0.0f; + this->m_inputMask = NULL; + this->m_inputValue = NULL; + this->m_cosine = 0.0f; + this->m_sine = 0.0f; } void EllipseMaskOperation::initExecution() { - this->inputMask = this->getInputSocketReader(0); - this->inputValue = this->getInputSocketReader(1); - const double rad = DEG2RAD((double)this->data->rotation); - this->cosine = cos(rad); - this->sine = sin(rad); - this->aspectRatio = ((float)this->getWidth()) / this->getHeight(); + this->m_inputMask = this->getInputSocketReader(0); + this->m_inputValue = this->getInputSocketReader(1); + const double rad = DEG2RAD((double)this->m_data->rotation); + this->m_cosine = cos(rad); + this->m_sine = sin(rad); + this->m_aspectRatio = ((float)this->getWidth()) / this->getHeight(); } void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -52,26 +52,26 @@ void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSam float rx = x / this->getWidth(); float ry = y / this->getHeight(); - const float dy = (ry - this->data->y) / this->aspectRatio; - const float dx = rx - this->data->x; - rx = this->data->x + (this->cosine * dx + this->sine * dy); - ry = this->data->y + (-this->sine * dx + this->cosine * dy); + const float dy = (ry - this->m_data->y) / this->m_aspectRatio; + const float dx = rx - this->m_data->x; + rx = this->m_data->x + (this->m_cosine * dx + this->m_sine * dy); + ry = this->m_data->y + (-this->m_sine * dx + this->m_cosine * dy); - this->inputMask->read(inputMask, x, y, sampler, inputBuffers); - this->inputValue->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers); + this->m_inputValue->read(inputValue, x, y, sampler, inputBuffers); - const float halfHeight = (this->data->height) / 2.0f; - const float halfWidth = this->data->width / 2.0f; - float sx = rx - this->data->x; + const float halfHeight = (this->m_data->height) / 2.0f; + const float halfWidth = this->m_data->width / 2.0f; + float sx = rx - this->m_data->x; sx *= sx; const float tx = halfWidth * halfWidth; - float sy = ry - this->data->y; + float sy = ry - this->m_data->y; sy *= sy; const float ty = halfHeight * halfHeight; bool inside = ((sx / tx) + (sy / ty)) < 1.0f; - switch (this->maskType) { + switch (this->m_maskType) { case CMP_NODE_MASKTYPE_ADD: if (inside) { color[0] = max(inputMask[0], inputValue[0]); @@ -117,7 +117,7 @@ void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSam void EllipseMaskOperation::deinitExecution() { - this->inputMask = NULL; - this->inputValue = NULL; + this->m_inputMask = NULL; + this->m_inputValue = NULL; } diff --git a/source/blender/compositor/operations/COM_EllipseMaskOperation.h b/source/blender/compositor/operations/COM_EllipseMaskOperation.h index 61d724c2f15..0b0ffa023cb 100644 --- a/source/blender/compositor/operations/COM_EllipseMaskOperation.h +++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.h @@ -30,15 +30,15 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputMask; - SocketReader *inputValue; + SocketReader *m_inputMask; + SocketReader *m_inputValue; - float sine; - float cosine; - float aspectRatio; - int maskType; + float m_sine; + float m_cosine; + float m_aspectRatio; + int m_maskType; - NodeEllipseMask *data; + NodeEllipseMask *m_data; public: EllipseMaskOperation(); @@ -57,9 +57,9 @@ public: */ void deinitExecution(); - void setData(NodeEllipseMask *data) { this->data = data; } + void setData(NodeEllipseMask *data) { this->m_data = data; } - void setMaskType(int maskType) { this->maskType = maskType; } + void setMaskType(int maskType) { this->m_maskType = maskType; } }; #endif diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp index 7491b0f30dd..8f0ebd9b8d2 100644 --- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp @@ -28,7 +28,7 @@ FastGaussianBlurOperation::FastGaussianBlurOperation() : BlurBaseOperation(COM_DT_COLOR) { - this->iirgaus = NULL; + this->m_iirgaus = NULL; } void FastGaussianBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) @@ -51,7 +51,7 @@ bool FastGaussianBlurOperation::determineDependingAreaOfInterest(rcti *input, Re return true; } else { - if (this->iirgaus) { + if (this->m_iirgaus) { return false; } else { @@ -72,9 +72,9 @@ void FastGaussianBlurOperation::initExecution() void FastGaussianBlurOperation::deinitExecution() { - if (this->iirgaus) { - delete this->iirgaus; - this->iirgaus = NULL; + if (this->m_iirgaus) { + delete this->m_iirgaus; + this->m_iirgaus = NULL; } BlurBaseOperation::deinitMutex(); } @@ -82,33 +82,33 @@ void FastGaussianBlurOperation::deinitExecution() void *FastGaussianBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (!iirgaus) { - MemoryBuffer *newBuf = (MemoryBuffer *)this->inputProgram->initializeTileData(rect, memoryBuffers); + if (!this->m_iirgaus) { + MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect, memoryBuffers); MemoryBuffer *copy = newBuf->duplicate(); updateSize(memoryBuffers); int c; - sx = data->sizex * this->size / 2.0f; - sy = data->sizey * this->size / 2.0f; + this->m_sx = this->m_data->sizex * this->m_size / 2.0f; + this->m_sy = this->m_data->sizey * this->m_size / 2.0f; - if ((sx == sy) && (sx > 0.f)) { + if ((this->m_sx == this->m_sy) && (this->m_sx > 0.f)) { for (c = 0; c < COM_NUMBER_OF_CHANNELS; ++c) - IIR_gauss(copy, sx, c, 3); + IIR_gauss(copy, this->m_sx, c, 3); } else { - if (sx > 0.f) { + if (this->m_sx > 0.0f) { for (c = 0; c < COM_NUMBER_OF_CHANNELS; ++c) - IIR_gauss(copy, sx, c, 1); + IIR_gauss(copy, this->m_sx, c, 1); } - if (sy > 0.f) { + if (this->m_sy > 0.0f) { for (c = 0; c < COM_NUMBER_OF_CHANNELS; ++c) - IIR_gauss(copy, sy, c, 2); + IIR_gauss(copy, this->m_sy, c, 2); } } - this->iirgaus = copy; + this->m_iirgaus = copy; } unlockMutex(); - return iirgaus; + return this->m_iirgaus; } void FastGaussianBlurOperation::IIR_gauss(MemoryBuffer *src, float sigma, unsigned int chan, unsigned int xy) diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h index 0f3929f052c..1e303b23869 100644 --- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h +++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h @@ -28,9 +28,9 @@ class FastGaussianBlurOperation : public BlurBaseOperation { private: - float sx; - float sy; - MemoryBuffer *iirgaus; + float m_sx; + float m_sy; + MemoryBuffer *m_iirgaus; public: FastGaussianBlurOperation(); bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); diff --git a/source/blender/compositor/operations/COM_FlipOperation.cpp b/source/blender/compositor/operations/COM_FlipOperation.cpp index 5023473f4aa..60dabb86bb5 100644 --- a/source/blender/compositor/operations/COM_FlipOperation.cpp +++ b/source/blender/compositor/operations/COM_FlipOperation.cpp @@ -27,34 +27,34 @@ FlipOperation::FlipOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->inputOperation = NULL; - this->flipX = true; - this->flipY = false; + this->m_inputOperation = NULL; + this->m_flipX = true; + this->m_flipY = false; } void FlipOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void FlipOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void FlipOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - float nx = this->flipX ? this->getWidth() - 1 - x : x; - float ny = this->flipY ? this->getHeight() - 1 - y : y; + float nx = this->m_flipX ? this->getWidth() - 1 - x : x; + float ny = this->m_flipY ? this->getHeight() - 1 - y : y; - this->inputOperation->read(color, nx, ny, sampler, inputBuffers); + this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers); } bool FlipOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newInput; - if (this->flipX) { + if (this->m_flipX) { newInput.xmax = (this->getWidth() - 1 - input->xmin) + 1; newInput.xmin = (this->getWidth() - 1 - input->xmax) - 1; } @@ -62,7 +62,7 @@ bool FlipOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOper newInput.xmin = input->xmin; newInput.xmax = input->xmax; } - if (this->flipY) { + if (this->m_flipY) { newInput.ymax = (this->getHeight() - 1 - input->ymin) + 1; newInput.ymin = (this->getHeight() - 1 - input->ymax) - 1; } diff --git a/source/blender/compositor/operations/COM_FlipOperation.h b/source/blender/compositor/operations/COM_FlipOperation.h index f83fa6ac3a8..5442774c94c 100644 --- a/source/blender/compositor/operations/COM_FlipOperation.h +++ b/source/blender/compositor/operations/COM_FlipOperation.h @@ -27,9 +27,9 @@ class FlipOperation : public NodeOperation { private: - SocketReader *inputOperation; - bool flipX; - bool flipY; + SocketReader *m_inputOperation; + bool m_flipX; + bool m_flipY; public: FlipOperation(); bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); @@ -37,8 +37,8 @@ public: void initExecution(); void deinitExecution(); - void setFlipX(bool flipX) { this->flipX = flipX; } - void setFlipY(bool flipY) { this->flipY = flipY; } + void setFlipX(bool flipX) { this->m_flipX = flipX; } + void setFlipY(bool flipY) { this->m_flipY = flipY; } }; #endif diff --git a/source/blender/compositor/operations/COM_GammaCorrectOperation.cpp b/source/blender/compositor/operations/COM_GammaCorrectOperation.cpp index 3e90b643604..db8d54a2f3c 100644 --- a/source/blender/compositor/operations/COM_GammaCorrectOperation.cpp +++ b/source/blender/compositor/operations/COM_GammaCorrectOperation.cpp @@ -27,17 +27,17 @@ GammaCorrectOperation::GammaCorrectOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void GammaCorrectOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void GammaCorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - this->inputProgram->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputProgram->read(inputColor, x, y, sampler, inputBuffers); if (inputColor[3] > 0.0f) { inputColor[0] /= inputColor[3]; inputColor[1] /= inputColor[3]; @@ -61,24 +61,24 @@ void GammaCorrectOperation::executePixel(float *color, float x, float y, PixelSa void GammaCorrectOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } GammaUncorrectOperation::GammaUncorrectOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void GammaUncorrectOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void GammaUncorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputColor[4]; - this->inputProgram->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputProgram->read(inputColor, x, y, sampler, inputBuffers); if (inputColor[3] > 0.0f) { inputColor[0] /= inputColor[3]; @@ -102,5 +102,5 @@ void GammaUncorrectOperation::executePixel(float *color, float x, float y, Pixel void GammaUncorrectOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_GammaCorrectOperation.h b/source/blender/compositor/operations/COM_GammaCorrectOperation.h index 4bf03eac0a1..4db911bb9b5 100644 --- a/source/blender/compositor/operations/COM_GammaCorrectOperation.h +++ b/source/blender/compositor/operations/COM_GammaCorrectOperation.h @@ -30,7 +30,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; public: GammaCorrectOperation(); @@ -56,7 +56,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; public: GammaUncorrectOperation(); diff --git a/source/blender/compositor/operations/COM_GammaOperation.cpp b/source/blender/compositor/operations/COM_GammaOperation.cpp index 2c3e78840ee..9ccc76f4392 100644 --- a/source/blender/compositor/operations/COM_GammaOperation.cpp +++ b/source/blender/compositor/operations/COM_GammaOperation.cpp @@ -28,13 +28,13 @@ GammaOperation::GammaOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR); this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); - this->inputProgram = NULL; - this->inputGammaProgram = NULL; + this->m_inputProgram = NULL; + this->m_inputGammaProgram = NULL; } void GammaOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); - this->inputGammaProgram = this->getInputSocketReader(1); + this->m_inputProgram = this->getInputSocketReader(0); + this->m_inputGammaProgram = this->getInputSocketReader(1); } void GammaOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -42,8 +42,8 @@ void GammaOperation::executePixel(float *color, float x, float y, PixelSampler s float inputValue[4]; float inputGamma[4]; - this->inputProgram->read(inputValue, x, y, sampler, inputBuffers); - this->inputGammaProgram->read(inputGamma, x, y, sampler, inputBuffers); + this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputGammaProgram->read(inputGamma, x, y, sampler, inputBuffers); const float gamma = inputGamma[0]; /* check for negative to avoid nan's */ color[0] = inputValue[0] > 0.0f ? powf(inputValue[0], gamma) : inputValue[0]; @@ -55,6 +55,6 @@ void GammaOperation::executePixel(float *color, float x, float y, PixelSampler s void GammaOperation::deinitExecution() { - this->inputProgram = NULL; - this->inputGammaProgram = NULL; + this->m_inputProgram = NULL; + this->m_inputGammaProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_GammaOperation.h b/source/blender/compositor/operations/COM_GammaOperation.h index 8c007d27843..758f7bda04d 100644 --- a/source/blender/compositor/operations/COM_GammaOperation.h +++ b/source/blender/compositor/operations/COM_GammaOperation.h @@ -30,8 +30,8 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; - SocketReader *inputGammaProgram; + SocketReader *m_inputProgram; + SocketReader *m_inputGammaProgram; public: GammaOperation(); diff --git a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp index 2d78085e3b0..a138d4be1d9 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp @@ -30,14 +30,14 @@ extern "C" { GaussianAlphaXBlurOperation::GaussianAlphaXBlurOperation() : BlurBaseOperation(COM_DT_VALUE) { - this->gausstab = NULL; - this->rad = 0; + this->m_gausstab = NULL; + this->m_rad = 0; } void *GaussianAlphaXBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (!this->sizeavailable) { + if (!this->m_sizeavailable) { updateGauss(memoryBuffers); } void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers); @@ -51,37 +51,37 @@ void GaussianAlphaXBlurOperation::initExecution() initMutex(); - if (this->sizeavailable) { - float rad = size * this->data->sizex; + if (this->m_sizeavailable) { + float rad = this->m_size * this->m_data->sizex; if (rad < 1) rad = 1; - this->rad = rad; - this->gausstab = BlurBaseOperation::make_gausstab(rad); - this->distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->falloff); + this->m_rad = rad; + this->m_gausstab = BlurBaseOperation::make_gausstab(rad); + this->m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->m_falloff); } } void GaussianAlphaXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers) { - if (this->gausstab == NULL) { + if (this->m_gausstab == NULL) { updateSize(memoryBuffers); - float rad = size * this->data->sizex; + float rad = this->m_size * this->m_data->sizex; if (rad < 1) rad = 1; - this->rad = rad; - this->gausstab = BlurBaseOperation::make_gausstab(rad); + this->m_rad = rad; + this->m_gausstab = BlurBaseOperation::make_gausstab(rad); } - if (this->distbuf_inv == NULL) { + if (this->m_distbuf_inv == NULL) { updateSize(memoryBuffers); - float rad = size * this->data->sizex; + float rad = this->m_size * this->m_data->sizex; if (rad < 1) rad = 1; - this->rad = rad; - this->distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->falloff); + this->m_rad = rad; + this->m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->m_falloff); } } @@ -92,7 +92,7 @@ BLI_INLINE float finv_test(const float f, const bool test) void GaussianAlphaXBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - const bool do_invert = this->do_subtract; + const bool do_invert = this->m_do_subtract; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); int bufferwidth = inputBuffer->getWidth(); @@ -101,8 +101,8 @@ void GaussianAlphaXBlurOperation::executePixel(float *color, int x, int y, Memor int miny = y; int maxy = y; - int minx = x - this->rad; - int maxx = x + this->rad; + int minx = x - this->m_rad; + int maxx = x + this->m_rad; miny = max(miny, inputBuffer->getRect()->ymin); minx = max(minx, inputBuffer->getRect()->xmin); maxy = min(maxy, inputBuffer->getRect()->ymax); @@ -122,20 +122,20 @@ void GaussianAlphaXBlurOperation::executePixel(float *color, int x, int y, Memor float distfacinv_max = 1.0f; /* 0 to 1 */ for (int nx = minx; nx < maxx; nx += step) { - const int index = (nx - x) + this->rad; + const int index = (nx - x) + this->m_rad; float value = finv_test(buffer[bufferindex], do_invert); float multiplier; /* gauss */ { - multiplier = gausstab[index]; + multiplier = this->m_gausstab[index]; alpha_accum += value * multiplier; multiplier_accum += multiplier; } /* dilate - find most extreme color */ if (value > value_max) { - multiplier = distbuf_inv[index]; + multiplier = this->m_distbuf_inv[index]; value *= multiplier; if (value > value_max) { value_max = value; @@ -154,10 +154,10 @@ void GaussianAlphaXBlurOperation::executePixel(float *color, int x, int y, Memor void GaussianAlphaXBlurOperation::deinitExecution() { BlurBaseOperation::deinitExecution(); - delete [] this->gausstab; - this->gausstab = NULL; - delete [] this->distbuf_inv; - this->distbuf_inv = NULL; + delete [] this->m_gausstab; + this->m_gausstab = NULL; + delete [] this->m_distbuf_inv; + this->m_distbuf_inv = NULL; deinitMutex(); } @@ -179,9 +179,9 @@ bool GaussianAlphaXBlurOperation::determineDependingAreaOfInterest(rcti *input, else #endif { - if (this->sizeavailable && this->gausstab != NULL) { - newInput.xmax = input->xmax + rad; - newInput.xmin = input->xmin - rad; + if (this->m_sizeavailable && this->m_gausstab != NULL) { + newInput.xmax = input->xmax + this->m_rad; + newInput.xmin = input->xmin - this->m_rad; newInput.ymax = input->ymax; newInput.ymin = input->ymin; } diff --git a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h index 38817ebef1d..59797c27952 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h @@ -28,11 +28,11 @@ class GaussianAlphaXBlurOperation : public BlurBaseOperation { private: - float *gausstab; - float *distbuf_inv; - int falloff; /* falloff for distbuf_inv */ - bool do_subtract; - int rad; + float *m_gausstab; + float *m_distbuf_inv; + int m_falloff; /* falloff for distbuf_inv */ + bool m_do_subtract; + int m_rad; void updateGauss(MemoryBuffer **memoryBuffers); public: GaussianAlphaXBlurOperation(); @@ -58,7 +58,7 @@ public: /** * Set subtract for Dilate/Erode functionality */ - void setSubtract(bool subtract) { this->do_subtract = subtract; } - void setFalloff(int falloff) { this->falloff = falloff; } + void setSubtract(bool subtract) { this->m_do_subtract = subtract; } + void setFalloff(int falloff) { this->m_falloff = falloff; } }; #endif diff --git a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp index ef5f9d5c31b..ab5f8d33850 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp @@ -30,14 +30,14 @@ extern "C" { GaussianAlphaYBlurOperation::GaussianAlphaYBlurOperation() : BlurBaseOperation(COM_DT_VALUE) { - this->gausstab = NULL; - this->rad = 0; + this->m_gausstab = NULL; + this->m_rad = 0; } void *GaussianAlphaYBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (!this->sizeavailable) { + if (!this->m_sizeavailable) { updateGauss(memoryBuffers); } void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers); @@ -51,37 +51,37 @@ void GaussianAlphaYBlurOperation::initExecution() initMutex(); - if (this->sizeavailable) { - float rad = size * this->data->sizey; + if (this->m_sizeavailable) { + float rad = this->m_size * this->m_data->sizey; if (rad < 1) rad = 1; - this->rad = rad; - this->gausstab = BlurBaseOperation::make_gausstab(rad); - this->distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->falloff); + this->m_rad = rad; + this->m_gausstab = BlurBaseOperation::make_gausstab(rad); + this->m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->m_falloff); } } void GaussianAlphaYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers) { - if (this->gausstab == NULL) { + if (this->m_gausstab == NULL) { updateSize(memoryBuffers); - float rad = size * this->data->sizey; + float rad = this->m_size * this->m_data->sizey; if (rad < 1) rad = 1; - this->rad = rad; - this->gausstab = BlurBaseOperation::make_gausstab(rad); + this->m_rad = rad; + this->m_gausstab = BlurBaseOperation::make_gausstab(rad); } - if (this->distbuf_inv == NULL) { + if (this->m_distbuf_inv == NULL) { updateSize(memoryBuffers); - float rad = size * this->data->sizex; + float rad = this->m_size * this->m_data->sizex; if (rad < 1) rad = 1; - this->rad = rad; - this->distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->falloff); + this->m_rad = rad; + this->m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->m_falloff); } } @@ -92,15 +92,15 @@ BLI_INLINE float finv_test(const float f, const bool test) void GaussianAlphaYBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - const bool do_invert = this->do_subtract; + const bool do_invert = this->m_do_subtract; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); int bufferwidth = inputBuffer->getWidth(); int bufferstartx = inputBuffer->getRect()->xmin; int bufferstarty = inputBuffer->getRect()->ymin; - int miny = y - this->rad; - int maxy = y + this->rad; + int miny = y - this->m_rad; + int maxy = y + this->m_rad; int minx = x; int maxx = x; miny = max(miny, inputBuffer->getRect()->ymin); @@ -122,20 +122,20 @@ void GaussianAlphaYBlurOperation::executePixel(float *color, int x, int y, Memor for (int ny = miny; ny < maxy; ny += step) { int bufferindex = ((minx - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth); - const int index = (ny - y) + this->rad; + const int index = (ny - y) + this->m_rad; float value = finv_test(buffer[bufferindex], do_invert); float multiplier; /* gauss */ { - multiplier = gausstab[index]; + multiplier = this->m_gausstab[index]; alpha_accum += value * multiplier; multiplier_accum += multiplier; } /* dilate - find most extreme color */ if (value > value_max) { - multiplier = distbuf_inv[index]; + multiplier = this->m_distbuf_inv[index]; value *= multiplier; if (value > value_max) { value_max = value; @@ -154,10 +154,10 @@ void GaussianAlphaYBlurOperation::executePixel(float *color, int x, int y, Memor void GaussianAlphaYBlurOperation::deinitExecution() { BlurBaseOperation::deinitExecution(); - delete [] this->gausstab; - this->gausstab = NULL; - delete [] this->distbuf_inv; - this->distbuf_inv = NULL; + delete [] this->m_gausstab; + this->m_gausstab = NULL; + delete [] this->m_distbuf_inv; + this->m_distbuf_inv = NULL; deinitMutex(); } @@ -179,11 +179,11 @@ bool GaussianAlphaYBlurOperation::determineDependingAreaOfInterest(rcti *input, else #endif { - if (this->sizeavailable && this->gausstab != NULL) { + if (this->m_sizeavailable && this->m_gausstab != NULL) { newInput.xmax = input->xmax; newInput.xmin = input->xmin; - newInput.ymax = input->ymax + rad; - newInput.ymin = input->ymin - rad; + newInput.ymax = input->ymax + this->m_rad; + newInput.ymin = input->ymin - this->m_rad; } else { newInput.xmax = this->getWidth(); diff --git a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h index 67166be8241..e0789db7815 100644 --- a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h @@ -28,11 +28,11 @@ class GaussianAlphaYBlurOperation : public BlurBaseOperation { private: - float *gausstab; - float *distbuf_inv; - bool do_subtract; - int falloff; - int rad; + float *m_gausstab; + float *m_distbuf_inv; + bool m_do_subtract; + int m_falloff; + int m_rad; void updateGauss(MemoryBuffer **memoryBuffers); public: GaussianAlphaYBlurOperation(); @@ -58,7 +58,7 @@ public: /** * Set subtract for Dilate/Erode functionality */ - void setSubtract(bool subtract) { this->do_subtract = subtract; } - void setFalloff(int falloff) { this->falloff = falloff; } + void setSubtract(bool subtract) { this->m_do_subtract = subtract; } + void setFalloff(int falloff) { this->m_falloff = falloff; } }; #endif diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp index 8d6a601b7dc..ac91d3336e2 100644 --- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp @@ -29,13 +29,13 @@ extern "C" { GaussianBokehBlurOperation::GaussianBokehBlurOperation() : BlurBaseOperation(COM_DT_COLOR) { - this->gausstab = NULL; + this->m_gausstab = NULL; } void *GaussianBokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (!sizeavailable) { + if (!this->m_sizeavailable) { updateGauss(memoryBuffers); } void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers); @@ -49,14 +49,14 @@ void GaussianBokehBlurOperation::initExecution() initMutex(); - if (this->sizeavailable) { + if (this->m_sizeavailable) { updateGauss(NULL); } } void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers) { - if (this->gausstab == NULL) { + if (this->m_gausstab == NULL) { float radxf; float radyf; int n; @@ -66,37 +66,37 @@ void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers) int j, i; const float width = this->getWidth(); const float height = this->getHeight(); - if (!sizeavailable) { + if (!this->m_sizeavailable) { updateSize(memoryBuffers); } - radxf = size * (float)this->data->sizex; + radxf = this->m_size * (float)this->m_data->sizex; if (radxf > width / 2.0f) radxf = width / 2.0f; else if (radxf < 1.0f) radxf = 1.0f; /* vertical */ - radyf = size * (float)this->data->sizey; + radyf = this->m_size * (float)this->m_data->sizey; if (radyf > height / 2.0f) radyf = height / 2.0f; else if (radyf < 1.0f) radyf = 1.0f; - radx = ceil(radxf); - rady = ceil(radyf); + this->m_radx = ceil(radxf); + this->m_rady = ceil(radyf); - n = (2 * radx + 1) * (2 * rady + 1); + n = (2 * this->m_radx + 1) * (2 * this->m_rady + 1); /* create a full filter image */ ddgauss = new float[n]; dgauss = ddgauss; val = 0.0f; - for (j = -rady; j <= rady; j++) { - for (i = -radx; i <= radx; i++, dgauss++) { + for (j = -this->m_rady; j <= this->m_rady; j++) { + for (i = -this->m_radx; i <= this->m_radx; i++, dgauss++) { float fj = (float)j / radyf; float fi = (float)i / radxf; float dist = sqrt(fj * fj + fi * fi); - *dgauss = RE_filter_value(this->data->filtertype, dist); + *dgauss = RE_filter_value(this->m_data->filtertype, dist); val += *dgauss; } @@ -108,7 +108,7 @@ void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers) } else ddgauss[4] = 1.0f; - gausstab = ddgauss; + this->m_gausstab = ddgauss; } } @@ -126,10 +126,10 @@ void GaussianBokehBlurOperation::executePixel(float *color, int x, int y, Memory int bufferstartx = inputBuffer->getRect()->xmin; int bufferstarty = inputBuffer->getRect()->ymin; - int miny = y - this->rady; - int maxy = y + this->rady; - int minx = x - this->radx; - int maxx = x + this->radx; + int miny = y - this->m_rady; + int maxy = y + this->m_rady; + int minx = x - this->m_radx; + int maxx = x + this->m_radx; miny = max(miny, inputBuffer->getRect()->ymin); minx = max(minx, inputBuffer->getRect()->xmin); maxy = min(maxy, inputBuffer->getRect()->ymax); @@ -139,10 +139,10 @@ void GaussianBokehBlurOperation::executePixel(float *color, int x, int y, Memory int step = QualityStepHelper::getStep(); int offsetadd = QualityStepHelper::getOffsetAdd(); for (int ny = miny; ny < maxy; ny += step) { - index = ((ny - y) + this->rady) * (this->radx * 2 + 1) + (minx - x + this->radx); + index = ((ny - y) + this->m_rady) * (this->m_radx * 2 + 1) + (minx - x + this->m_radx); int bufferindex = ((minx - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth); for (int nx = minx; nx < maxx; nx += step) { - const float multiplier = gausstab[index]; + const float multiplier = this->m_gausstab[index]; madd_v4_v4fl(tempColor, &buffer[bufferindex], multiplier); multiplier_accum += multiplier; index += step; @@ -156,8 +156,8 @@ void GaussianBokehBlurOperation::executePixel(float *color, int x, int y, Memory void GaussianBokehBlurOperation::deinitExecution() { BlurBaseOperation::deinitExecution(); - delete [] this->gausstab; - this->gausstab = NULL; + delete [] this->m_gausstab; + this->m_gausstab = NULL; deinitMutex(); } @@ -176,15 +176,15 @@ bool GaussianBokehBlurOperation::determineDependingAreaOfInterest(rcti *input, R return true; } else { - if (this->sizeavailable && this->gausstab != NULL) { + if (this->m_sizeavailable && this->m_gausstab != NULL) { newInput.xmin = 0; newInput.ymin = 0; newInput.xmax = this->getWidth(); newInput.ymax = this->getHeight(); } else { - int addx = radx; - int addy = rady; + int addx = this->m_radx; + int addy = this->m_rady; newInput.xmax = input->xmax + addx; newInput.xmin = input->xmin - addx; newInput.ymax = input->ymax + addy; diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h index 616a6539ad4..54dc8caed53 100644 --- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h @@ -28,8 +28,8 @@ class GaussianBokehBlurOperation : public BlurBaseOperation { private: - float *gausstab; - int radx, rady; + float *m_gausstab; + int m_radx, m_rady; void updateGauss(MemoryBuffer **memoryBuffers); public: diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp index 51a71b90923..d18dd17528d 100644 --- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp @@ -29,14 +29,14 @@ extern "C" { GaussianXBlurOperation::GaussianXBlurOperation() : BlurBaseOperation(COM_DT_COLOR) { - this->gausstab = NULL; - this->rad = 0; + this->m_gausstab = NULL; + this->m_rad = 0; } void *GaussianXBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (!this->sizeavailable) { + if (!this->m_sizeavailable) { updateGauss(memoryBuffers); } void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers); @@ -50,26 +50,26 @@ void GaussianXBlurOperation::initExecution() initMutex(); - if (this->sizeavailable) { - float rad = size * this->data->sizex; + if (this->m_sizeavailable) { + float rad = this->m_size * this->m_data->sizex; if (rad < 1) rad = 1; - this->rad = rad; - this->gausstab = BlurBaseOperation::make_gausstab(rad); + this->m_rad = rad; + this->m_gausstab = BlurBaseOperation::make_gausstab(rad); } } void GaussianXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers) { - if (this->gausstab == NULL) { + if (this->m_gausstab == NULL) { updateSize(memoryBuffers); - float rad = size * this->data->sizex; + float rad = this->m_size * this->m_data->sizex; if (rad < 1) rad = 1; - this->rad = rad; - this->gausstab = BlurBaseOperation::make_gausstab(rad); + this->m_rad = rad; + this->m_gausstab = BlurBaseOperation::make_gausstab(rad); } } @@ -85,8 +85,8 @@ void GaussianXBlurOperation::executePixel(float *color, int x, int y, MemoryBuff int miny = y; int maxy = y; - int minx = x - this->rad; - int maxx = x + this->rad; + int minx = x - this->m_rad; + int maxx = x + this->m_rad; miny = max(miny, inputBuffer->getRect()->ymin); minx = max(minx, inputBuffer->getRect()->xmin); maxy = min(maxy, inputBuffer->getRect()->ymax); @@ -97,8 +97,8 @@ void GaussianXBlurOperation::executePixel(float *color, int x, int y, MemoryBuff int offsetadd = getOffsetAdd(); int bufferindex = ((minx - bufferstartx) * 4) + ((miny - bufferstarty) * 4 * bufferwidth); for (int nx = minx; nx < maxx; nx += step) { - index = (nx - x) + this->rad; - const float multiplier = gausstab[index]; + index = (nx - x) + this->m_rad; + const float multiplier = this->m_gausstab[index]; madd_v4_v4fl(color_accum, &buffer[bufferindex], multiplier); multiplier_accum += multiplier; bufferindex += offsetadd; @@ -109,8 +109,8 @@ void GaussianXBlurOperation::executePixel(float *color, int x, int y, MemoryBuff void GaussianXBlurOperation::deinitExecution() { BlurBaseOperation::deinitExecution(); - delete [] this->gausstab; - this->gausstab = NULL; + delete [] this->m_gausstab; + this->m_gausstab = NULL; deinitMutex(); } @@ -129,9 +129,9 @@ bool GaussianXBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadB return true; } else { - if (this->sizeavailable && this->gausstab != NULL) { - newInput.xmax = input->xmax + rad; - newInput.xmin = input->xmin - rad; + if (this->m_sizeavailable && this->m_gausstab != NULL) { + newInput.xmax = input->xmax + this->m_rad; + newInput.xmin = input->xmin - this->m_rad; newInput.ymax = input->ymax; newInput.ymin = input->ymin; } diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.h b/source/blender/compositor/operations/COM_GaussianXBlurOperation.h index 10a8a538391..9b5c2131b74 100644 --- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.h @@ -27,8 +27,8 @@ class GaussianXBlurOperation : public BlurBaseOperation { private: - float *gausstab; - int rad; + float *m_gausstab; + int m_rad; void updateGauss(MemoryBuffer **memoryBuffers); public: GaussianXBlurOperation(); diff --git a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp index f69eeb913ad..d2d30da8ddf 100644 --- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp @@ -29,14 +29,14 @@ extern "C" { GaussianYBlurOperation::GaussianYBlurOperation() : BlurBaseOperation(COM_DT_COLOR) { - this->gausstab = NULL; - this->rad = 0; + this->m_gausstab = NULL; + this->m_rad = 0; } void *GaussianYBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (!this->sizeavailable) { + if (!this->m_sizeavailable) { updateGauss(memoryBuffers); } void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers); @@ -50,26 +50,26 @@ void GaussianYBlurOperation::initExecution() initMutex(); - if (this->sizeavailable) { - float rad = size * this->data->sizey; + if (this->m_sizeavailable) { + float rad = this->m_size * this->m_data->sizey; if (rad < 1) rad = 1; - this->rad = rad; - this->gausstab = BlurBaseOperation::make_gausstab(rad); + this->m_rad = rad; + this->m_gausstab = BlurBaseOperation::make_gausstab(rad); } } void GaussianYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers) { - if (this->gausstab == NULL) { + if (this->m_gausstab == NULL) { updateSize(memoryBuffers); - float rad = size * this->data->sizey; + float rad = this->m_size * this->m_data->sizey; if (rad < 1) rad = 1; - this->rad = rad; - this->gausstab = BlurBaseOperation::make_gausstab(rad); + this->m_rad = rad; + this->m_gausstab = BlurBaseOperation::make_gausstab(rad); } } @@ -83,8 +83,8 @@ void GaussianYBlurOperation::executePixel(float *color, int x, int y, MemoryBuff int bufferstartx = inputBuffer->getRect()->xmin; int bufferstarty = inputBuffer->getRect()->ymin; - int miny = y - this->rad; - int maxy = y + this->rad; + int miny = y - this->m_rad; + int maxy = y + this->m_rad; int minx = x; int maxx = x; miny = max(miny, inputBuffer->getRect()->ymin); @@ -95,9 +95,9 @@ void GaussianYBlurOperation::executePixel(float *color, int x, int y, MemoryBuff int index; int step = getStep(); for (int ny = miny; ny < maxy; ny += step) { - index = (ny - y) + this->rad; + index = (ny - y) + this->m_rad; int bufferindex = ((minx - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth); - const float multiplier = gausstab[index]; + const float multiplier = this->m_gausstab[index]; madd_v4_v4fl(color_accum, &buffer[bufferindex], multiplier); multiplier_accum += multiplier; } @@ -107,8 +107,8 @@ void GaussianYBlurOperation::executePixel(float *color, int x, int y, MemoryBuff void GaussianYBlurOperation::deinitExecution() { BlurBaseOperation::deinitExecution(); - delete [] this->gausstab; - this->gausstab = NULL; + delete [] this->m_gausstab; + this->m_gausstab = NULL; deinitMutex(); } @@ -127,11 +127,11 @@ bool GaussianYBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadB return true; } else { - if (this->sizeavailable && this->gausstab != NULL) { + if (this->m_sizeavailable && this->m_gausstab != NULL) { newInput.xmax = input->xmax; newInput.xmin = input->xmin; - newInput.ymax = input->ymax + rad; - newInput.ymin = input->ymin - rad; + newInput.ymax = input->ymax + this->m_rad; + newInput.ymin = input->ymin - this->m_rad; } else { newInput.xmax = this->getWidth(); diff --git a/source/blender/compositor/operations/COM_GaussianYBlurOperation.h b/source/blender/compositor/operations/COM_GaussianYBlurOperation.h index e8d362e4c32..f4d40c231dc 100644 --- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.h +++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.h @@ -27,8 +27,8 @@ class GaussianYBlurOperation : public BlurBaseOperation { private: - float *gausstab; - int rad; + float *m_gausstab; + int m_rad; void updateGauss(MemoryBuffer **memoryBuffers); public: GaussianYBlurOperation(); diff --git a/source/blender/compositor/operations/COM_GlareBaseOperation.cpp b/source/blender/compositor/operations/COM_GlareBaseOperation.cpp index 90bdd705a7c..a6678fdecef 100644 --- a/source/blender/compositor/operations/COM_GlareBaseOperation.cpp +++ b/source/blender/compositor/operations/COM_GlareBaseOperation.cpp @@ -27,23 +27,23 @@ GlareBaseOperation::GlareBaseOperation() : SingleThreadedNodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->settings = NULL; + this->m_settings = NULL; } void GlareBaseOperation::initExecution() { SingleThreadedNodeOperation::initExecution(); - this->inputProgram = getInputSocketReader(0); + this->m_inputProgram = getInputSocketReader(0); } void GlareBaseOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; SingleThreadedNodeOperation::deinitExecution(); } MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2, MemoryBuffer **memoryBuffers) { - MemoryBuffer *tile = (MemoryBuffer *)inputProgram->initializeTileData(rect2, memoryBuffers); + MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect2, memoryBuffers); rcti rect; rect.xmin = 0; rect.ymin = 0; @@ -51,7 +51,7 @@ MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2, MemoryBuffer * rect.ymax = getHeight(); MemoryBuffer *result = new MemoryBuffer(NULL, &rect); float *data = result->getBuffer(); - this->generateGlare(data, tile, this->settings); + this->generateGlare(data, tile, this->m_settings); return result; } diff --git a/source/blender/compositor/operations/COM_GlareBaseOperation.h b/source/blender/compositor/operations/COM_GlareBaseOperation.h index ac67ac055e9..6104ec7a81e 100644 --- a/source/blender/compositor/operations/COM_GlareBaseOperation.h +++ b/source/blender/compositor/operations/COM_GlareBaseOperation.h @@ -41,12 +41,12 @@ private: /** * @brief Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; /** * @brief settings of the glare node. */ - NodeGlare *settings; + NodeGlare *m_settings; public: /** * Initialize the execution @@ -59,7 +59,7 @@ public: void deinitExecution(); void setGlareSettings(NodeGlare *settings) { - this->settings = settings; + this->m_settings = settings; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); diff --git a/source/blender/compositor/operations/COM_GlareFogGlowOperation.h b/source/blender/compositor/operations/COM_GlareFogGlowOperation.h index 5737a6a1ff0..1231185a21a 100644 --- a/source/blender/compositor/operations/COM_GlareFogGlowOperation.h +++ b/source/blender/compositor/operations/COM_GlareFogGlowOperation.h @@ -28,8 +28,7 @@ class GlareFogGlowOperation : public GlareBaseOperation { public: - GlareFogGlowOperation() : GlareBaseOperation() { - } + GlareFogGlowOperation() : GlareBaseOperation() {} protected: void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings); }; diff --git a/source/blender/compositor/operations/COM_GlareGhostOperation.h b/source/blender/compositor/operations/COM_GlareGhostOperation.h index 2ee85cc4543..7ce1048efe9 100644 --- a/source/blender/compositor/operations/COM_GlareGhostOperation.h +++ b/source/blender/compositor/operations/COM_GlareGhostOperation.h @@ -28,8 +28,7 @@ class GlareGhostOperation : public GlareBaseOperation { public: - GlareGhostOperation() : GlareBaseOperation() { - } + GlareGhostOperation() : GlareBaseOperation() {} protected: void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings); }; diff --git a/source/blender/compositor/operations/COM_GlareSimpleStarOperation.h b/source/blender/compositor/operations/COM_GlareSimpleStarOperation.h index a12d1191a1a..440f3ba147a 100644 --- a/source/blender/compositor/operations/COM_GlareSimpleStarOperation.h +++ b/source/blender/compositor/operations/COM_GlareSimpleStarOperation.h @@ -28,8 +28,7 @@ class GlareSimpleStarOperation : public GlareBaseOperation { public: - GlareSimpleStarOperation() : GlareBaseOperation() { - } + GlareSimpleStarOperation() : GlareBaseOperation() {} protected: void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings); }; diff --git a/source/blender/compositor/operations/COM_GlareStreaksOperation.h b/source/blender/compositor/operations/COM_GlareStreaksOperation.h index 6520a05b44f..e629ac11623 100644 --- a/source/blender/compositor/operations/COM_GlareStreaksOperation.h +++ b/source/blender/compositor/operations/COM_GlareStreaksOperation.h @@ -28,8 +28,7 @@ class GlareStreaksOperation : public GlareBaseOperation { public: - GlareStreaksOperation() : GlareBaseOperation() { - } + GlareStreaksOperation() : GlareBaseOperation() {} protected: void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings); }; diff --git a/source/blender/compositor/operations/COM_GlareThresholdOperation.cpp b/source/blender/compositor/operations/COM_GlareThresholdOperation.cpp index f9b2ec2b32d..6d8c567c1b5 100644 --- a/source/blender/compositor/operations/COM_GlareThresholdOperation.cpp +++ b/source/blender/compositor/operations/COM_GlareThresholdOperation.cpp @@ -27,26 +27,26 @@ GlareThresholdOperation::GlareThresholdOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR, COM_SC_FIT); this->addOutputSocket(COM_DT_COLOR); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void GlareThresholdOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) { NodeOperation::determineResolution(resolution, preferredResolution); - resolution[0] = resolution[0] / (1 << settings->quality); - resolution[1] = resolution[1] / (1 << settings->quality); + resolution[0] = resolution[0] / (1 << this->m_settings->quality); + resolution[1] = resolution[1] / (1 << this->m_settings->quality); } void GlareThresholdOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void GlareThresholdOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - const float threshold = settings->threshold; + const float threshold = this->m_settings->threshold; - this->inputProgram->read(color, x, y, sampler, inputBuffers); + this->m_inputProgram->read(color, x, y, sampler, inputBuffers); if (rgb_to_luma_y(color) >= threshold) { color[0] -= threshold, color[1] -= threshold, color[2] -= threshold; color[0] = MAX2(color[0], 0.0f); @@ -60,5 +60,5 @@ void GlareThresholdOperation::executePixel(float *color, float x, float y, Pixel void GlareThresholdOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_GlareThresholdOperation.h b/source/blender/compositor/operations/COM_GlareThresholdOperation.h index 70692565e27..d89f3a0f29d 100644 --- a/source/blender/compositor/operations/COM_GlareThresholdOperation.h +++ b/source/blender/compositor/operations/COM_GlareThresholdOperation.h @@ -30,12 +30,12 @@ private: /** * @brief Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; /** * @brief settings of the glare node. */ - NodeGlare *settings; + NodeGlare *m_settings; public: GlareThresholdOperation(); @@ -55,7 +55,7 @@ public: void deinitExecution(); void setGlareSettings(NodeGlare *settings) { - this->settings = settings; + this->m_settings = settings; } void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]); diff --git a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp index b8e46e2d0be..02914487072 100644 --- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp +++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp @@ -37,30 +37,30 @@ HueSaturationValueCorrectOperation::HueSaturationValueCorrectOperation() : Curve this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void HueSaturationValueCorrectOperation::initExecution() { CurveBaseOperation::initExecution(); - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void HueSaturationValueCorrectOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float hsv[4], f; - this->inputProgram->read(hsv, x, y, sampler, inputBuffers); + this->m_inputProgram->read(hsv, x, y, sampler, inputBuffers); /* adjust hue, scaling returned default 0.5 up to 1 */ - f = curvemapping_evaluateF(this->curveMapping, 0, hsv[0]); + f = curvemapping_evaluateF(this->m_curveMapping, 0, hsv[0]); hsv[0] += f - 0.5f; /* adjust saturation, scaling returned default 0.5 up to 1 */ - f = curvemapping_evaluateF(this->curveMapping, 1, hsv[0]); + f = curvemapping_evaluateF(this->m_curveMapping, 1, hsv[0]); hsv[1] *= (f * 2.f); /* adjust value, scaling returned default 0.5 up to 1 */ - f = curvemapping_evaluateF(this->curveMapping, 2, hsv[0]); + f = curvemapping_evaluateF(this->m_curveMapping, 2, hsv[0]); hsv[2] *= (f * 2.f); hsv[0] = hsv[0] - floorf(hsv[0]); /* mod 1.0 */ @@ -74,5 +74,5 @@ void HueSaturationValueCorrectOperation::executePixel(float *output, float x, fl void HueSaturationValueCorrectOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h index 5ede0491773..7ae5f53e370 100644 --- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h +++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h @@ -30,7 +30,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; public: HueSaturationValueCorrectOperation(); diff --git a/source/blender/compositor/operations/COM_IDMaskOperation.cpp b/source/blender/compositor/operations/COM_IDMaskOperation.cpp index d02367088d7..c84124368be 100644 --- a/source/blender/compositor/operations/COM_IDMaskOperation.cpp +++ b/source/blender/compositor/operations/COM_IDMaskOperation.cpp @@ -26,24 +26,24 @@ IDMaskOperation::IDMaskOperation() : NodeOperation() { this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void IDMaskOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void IDMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputValue[4]; - this->inputProgram->read(inputValue, x, y, sampler, inputBuffers); - const float a = (inputValue[0] == this->objectIndex) ? 1.0f : 0.0f; + this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers); + const float a = (inputValue[0] == this->m_objectIndex) ? 1.0f : 0.0f; color[0] = a; } void IDMaskOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_IDMaskOperation.h b/source/blender/compositor/operations/COM_IDMaskOperation.h index 229e1b2dd82..23e8ec704e8 100644 --- a/source/blender/compositor/operations/COM_IDMaskOperation.h +++ b/source/blender/compositor/operations/COM_IDMaskOperation.h @@ -30,9 +30,9 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; - float objectIndex; + float m_objectIndex; public: IDMaskOperation(); @@ -51,7 +51,7 @@ public: */ void deinitExecution(); - void setObjectIndex(float objectIndex) { this->objectIndex = objectIndex; } + void setObjectIndex(float objectIndex) { this->m_objectIndex = objectIndex; } }; #endif diff --git a/source/blender/compositor/operations/COM_ImageOperation.cpp b/source/blender/compositor/operations/COM_ImageOperation.cpp index 9dbe8419daa..eb2eaa8167a 100644 --- a/source/blender/compositor/operations/COM_ImageOperation.cpp +++ b/source/blender/compositor/operations/COM_ImageOperation.cpp @@ -38,15 +38,15 @@ extern "C" { BaseImageOperation::BaseImageOperation() : NodeOperation() { - this->image = NULL; - this->buffer = NULL; - this->imageBuffer = NULL; - this->imageUser = NULL; - this->imagewidth = 0; - this->imageheight = 0; - this->framenumber = 0; - this->depthBuffer = NULL; - this->numberOfChannels = 0; + this->m_image = NULL; + this->m_buffer = NULL; + this->m_imageBuffer = NULL; + this->m_imageUser = NULL; + this->m_imagewidth = 0; + this->m_imageheight = 0; + this->m_framenumber = 0; + this->m_depthBuffer = NULL; + this->m_numberOfChannels = 0; } ImageOperation::ImageOperation() : BaseImageOperation() { @@ -65,7 +65,7 @@ ImBuf *BaseImageOperation::getImBuf() { ImBuf *ibuf; - ibuf = BKE_image_get_ibuf(this->image, this->imageUser); + ibuf = BKE_image_get_ibuf(this->m_image, this->m_imageUser); if (ibuf == NULL || (ibuf->rect == NULL && ibuf->rect_float == NULL)) { return NULL; } @@ -80,19 +80,19 @@ ImBuf *BaseImageOperation::getImBuf() void BaseImageOperation::initExecution() { ImBuf *stackbuf = getImBuf(); - this->buffer = stackbuf; + this->m_buffer = stackbuf; if (stackbuf) { - this->imageBuffer = stackbuf->rect_float; - this->depthBuffer = stackbuf->zbuf_float; - this->imagewidth = stackbuf->x; - this->imageheight = stackbuf->y; - this->numberOfChannels = stackbuf->channels; + this->m_imageBuffer = stackbuf->rect_float; + this->m_depthBuffer = stackbuf->zbuf_float; + this->m_imagewidth = stackbuf->x; + this->m_imageheight = stackbuf->y; + this->m_numberOfChannels = stackbuf->channels; } } void BaseImageOperation::deinitExecution() { - this->imageBuffer = NULL; + this->m_imageBuffer = NULL; } void BaseImageOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) @@ -110,22 +110,19 @@ void BaseImageOperation::determineResolution(unsigned int resolution[], unsigned void ImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - if (this->imageBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) { - color[0] = 0.0f; - color[1] = 0.0f; - color[2] = 0.0f; - color[3] = 0.0f; + if (this->m_imageBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) { + zero_v4(color); } else { switch (sampler) { case COM_PS_NEAREST: - neareast_interpolation_color(this->buffer, NULL, color, x, y); + neareast_interpolation_color(this->m_buffer, NULL, color, x, y); break; case COM_PS_BILINEAR: - bilinear_interpolation_color(this->buffer, NULL, color, x, y); + bilinear_interpolation_color(this->m_buffer, NULL, color, x, y); break; case COM_PS_BICUBIC: - bicubic_interpolation_color(this->buffer, NULL, color, x, y); + bicubic_interpolation_color(this->m_buffer, NULL, color, x, y); break; } } @@ -135,20 +132,20 @@ void ImageAlphaOperation::executePixel(float *color, float x, float y, PixelSamp { float tempcolor[4]; - if (this->imageBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) { + if (this->m_imageBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) { color[0] = 0.0f; } else { tempcolor[3] = 1.0f; switch (sampler) { case COM_PS_NEAREST: - neareast_interpolation_color(this->buffer, NULL, tempcolor, x, y); + neareast_interpolation_color(this->m_buffer, NULL, tempcolor, x, y); break; case COM_PS_BILINEAR: - bilinear_interpolation_color(this->buffer, NULL, tempcolor, x, y); + bilinear_interpolation_color(this->m_buffer, NULL, tempcolor, x, y); break; case COM_PS_BICUBIC: - bicubic_interpolation_color(this->buffer, NULL, tempcolor, x, y); + bicubic_interpolation_color(this->m_buffer, NULL, tempcolor, x, y); break; } color[0] = tempcolor[3]; @@ -157,11 +154,11 @@ void ImageAlphaOperation::executePixel(float *color, float x, float y, PixelSamp void ImageDepthOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - if (this->depthBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) { + if (this->m_depthBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) { color[0] = 0.0f; } else { - int offset = y * width + x; - color[0] = this->depthBuffer[offset]; + int offset = y * this->m_width + x; + color[0] = this->m_depthBuffer[offset]; } } diff --git a/source/blender/compositor/operations/COM_ImageOperation.h b/source/blender/compositor/operations/COM_ImageOperation.h index a4645c9d504..c87b06b9c4d 100644 --- a/source/blender/compositor/operations/COM_ImageOperation.h +++ b/source/blender/compositor/operations/COM_ImageOperation.h @@ -40,15 +40,15 @@ extern "C" { */ class BaseImageOperation : public NodeOperation { protected: - ImBuf *buffer; - Image *image; - ImageUser *imageUser; - float *imageBuffer; - float *depthBuffer; - int imageheight; - int imagewidth; - int framenumber; - int numberOfChannels; + ImBuf *m_buffer; + Image *m_image; + ImageUser *m_imageUser; + float *m_imageBuffer; + float *m_depthBuffer; + int m_imageheight; + int m_imagewidth; + int m_framenumber; + int m_numberOfChannels; BaseImageOperation(); /** @@ -62,10 +62,10 @@ public: void initExecution(); void deinitExecution(); - void setImage(Image *image) { this->image = image; } - void setImageUser(ImageUser *imageuser) { this->imageUser = imageuser; } + void setImage(Image *image) { this->m_image = image; } + void setImageUser(ImageUser *imageuser) { this->m_imageUser = imageuser; } - void setFramenumber(int framenumber) { this->framenumber = framenumber; } + void setFramenumber(int framenumber) { this->m_framenumber = framenumber; } }; class ImageOperation : public BaseImageOperation { public: diff --git a/source/blender/compositor/operations/COM_InvertOperation.cpp b/source/blender/compositor/operations/COM_InvertOperation.cpp index 6142959a12e..9e9c2522d66 100644 --- a/source/blender/compositor/operations/COM_InvertOperation.cpp +++ b/source/blender/compositor/operations/COM_InvertOperation.cpp @@ -27,29 +27,29 @@ InvertOperation::InvertOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputValueProgram = NULL; - this->inputColorProgram = NULL; - this->color = true; - this->alpha = false; + this->m_inputValueProgram = NULL; + this->m_inputColorProgram = NULL; + this->m_color = true; + this->m_alpha = false; setResolutionInputSocketIndex(1); } void InvertOperation::initExecution() { - this->inputValueProgram = this->getInputSocketReader(0); - this->inputColorProgram = this->getInputSocketReader(1); + this->m_inputValueProgram = this->getInputSocketReader(0); + this->m_inputColorProgram = this->getInputSocketReader(1); } void InvertOperation::executePixel(float *out, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inputValue[4]; float inputColor[4]; - this->inputValueProgram->read(inputValue, x, y, sampler, inputBuffers); - this->inputColorProgram->read(inputColor, x, y, sampler, inputBuffers); + this->m_inputValueProgram->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputColorProgram->read(inputColor, x, y, sampler, inputBuffers); const float value = inputValue[0]; const float invertedValue = 1.0f - value; - if (color) { + if (this->m_color) { out[0] = (1.0f - inputColor[0]) * value + inputColor[0] * invertedValue; out[1] = (1.0f - inputColor[1]) * value + inputColor[1] * invertedValue; out[2] = (1.0f - inputColor[2]) * value + inputColor[2] * invertedValue; @@ -58,7 +58,7 @@ void InvertOperation::executePixel(float *out, float x, float y, PixelSampler sa copy_v3_v3(out, inputColor); } - if (alpha) + if (this->m_alpha) out[3] = (1.0f - inputColor[3]) * value + inputColor[3] * invertedValue; else out[3] = inputColor[3]; @@ -67,7 +67,7 @@ void InvertOperation::executePixel(float *out, float x, float y, PixelSampler sa void InvertOperation::deinitExecution() { - this->inputValueProgram = NULL; - this->inputColorProgram = NULL; + this->m_inputValueProgram = NULL; + this->m_inputColorProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_InvertOperation.h b/source/blender/compositor/operations/COM_InvertOperation.h index 48432aecdd0..f00a3fb739d 100644 --- a/source/blender/compositor/operations/COM_InvertOperation.h +++ b/source/blender/compositor/operations/COM_InvertOperation.h @@ -30,11 +30,11 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputValueProgram; - SocketReader *inputColorProgram; + SocketReader *m_inputValueProgram; + SocketReader *m_inputColorProgram; - bool alpha; - bool color; + bool m_alpha; + bool m_color; public: InvertOperation(); @@ -54,7 +54,7 @@ public: */ void deinitExecution(); - void setColor(bool color) { this->color = color; } - void setAlpha(bool alpha) { this->alpha = alpha; } + void setColor(bool color) { this->m_color = color; } + void setAlpha(bool alpha) { this->m_alpha = alpha; } }; #endif diff --git a/source/blender/compositor/operations/COM_KeyingBlurOperation.cpp b/source/blender/compositor/operations/COM_KeyingBlurOperation.cpp index 4f78e23d86b..3285bd32039 100644 --- a/source/blender/compositor/operations/COM_KeyingBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_KeyingBlurOperation.cpp @@ -33,8 +33,8 @@ KeyingBlurOperation::KeyingBlurOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->size = 0; - this->axis = BLUR_AXIS_X; + this->m_size = 0; + this->m_axis = BLUR_AXIS_X; this->setComplex(true); } @@ -58,8 +58,8 @@ void KeyingBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer float average = 0.0f; - if (this->axis == 0) { - for (i = -this->size + 1; i < this->size; i++) { + if (this->m_axis == 0) { + for (i = -this->m_size + 1; i < this->m_size; i++) { int cx = x + i; if (cx >= 0 && cx < bufferWidth) { @@ -71,7 +71,7 @@ void KeyingBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer } } else { - for (i = -this->size + 1; i < this->size; i++) { + for (i = -this->m_size + 1; i < this->m_size; i++) { int cy = y + i; if (cy >= 0 && cy < bufferHeight) { @@ -92,17 +92,17 @@ bool KeyingBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBuff { rcti newInput; - if (this->axis == BLUR_AXIS_X) { - newInput.xmin = input->xmin - this->size; + if (this->m_axis == BLUR_AXIS_X) { + newInput.xmin = input->xmin - this->m_size; newInput.ymin = input->ymin; - newInput.xmax = input->xmax + this->size; + newInput.xmax = input->xmax + this->m_size; newInput.ymax = input->ymax; } else { newInput.xmin = input->xmin; - newInput.ymin = input->ymin - this->size; + newInput.ymin = input->ymin - this->m_size; newInput.xmax = input->xmax; - newInput.ymax = input->ymax + this->size; + newInput.ymax = input->ymax + this->m_size; } return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); diff --git a/source/blender/compositor/operations/COM_KeyingBlurOperation.h b/source/blender/compositor/operations/COM_KeyingBlurOperation.h index 41ccb465eab..6e08712bf39 100644 --- a/source/blender/compositor/operations/COM_KeyingBlurOperation.h +++ b/source/blender/compositor/operations/COM_KeyingBlurOperation.h @@ -31,8 +31,8 @@ */ class KeyingBlurOperation : public NodeOperation { protected: - int size; - int axis; + int m_size; + int m_axis; public: enum BlurAxis { @@ -42,8 +42,8 @@ public: KeyingBlurOperation(); - void setSize(int value) {this->size = value;} - void setAxis(int value) {this->axis = value;} + void setSize(int value) {this->m_size = value;} + void setAxis(int value) {this->m_axis = value;} void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers); diff --git a/source/blender/compositor/operations/COM_KeyingClipOperation.cpp b/source/blender/compositor/operations/COM_KeyingClipOperation.cpp index 1d7ae1372b0..8f7d7fbf625 100644 --- a/source/blender/compositor/operations/COM_KeyingClipOperation.cpp +++ b/source/blender/compositor/operations/COM_KeyingClipOperation.cpp @@ -33,13 +33,13 @@ KeyingClipOperation::KeyingClipOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->kernelRadius = 3; - this->kernelTolerance = 0.1f; + this->m_kernelRadius = 3; + this->m_kernelTolerance = 0.1f; - this->clipBlack = 0.0f; - this->clipWhite = 1.0f; + this->m_clipBlack = 0.0f; + this->m_clipWhite = 1.0f; - this->isEdgeMatte = false; + this->m_isEdgeMatte = false; this->setComplex(true); } @@ -53,8 +53,8 @@ void *KeyingClipOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryB void KeyingClipOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { - const int delta = this->kernelRadius; - const float tolerance = this->kernelTolerance; + const int delta = this->m_kernelRadius; + const float tolerance = this->m_kernelTolerance; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; float *buffer = inputBuffer->getBuffer(); @@ -90,7 +90,7 @@ void KeyingClipOperation::executePixel(float *color, int x, int y, MemoryBuffer ok = count >= (float) totalCount * 0.9f; - if (this->isEdgeMatte) { + if (this->m_isEdgeMatte) { if (ok) color[0] = 0.0f; else @@ -100,12 +100,12 @@ void KeyingClipOperation::executePixel(float *color, int x, int y, MemoryBuffer color[0] = value; if (ok) { - if (color[0] < this->clipBlack) + if (color[0] < this->m_clipBlack) color[0] = 0.0f; - else if (color[0] >= this->clipWhite) + else if (color[0] >= this->m_clipWhite) color[0] = 1.0f; else - color[0] = (color[0] - this->clipBlack) / (this->clipWhite - this->clipBlack); + color[0] = (color[0] - this->m_clipBlack) / (this->m_clipWhite - this->m_clipBlack); } } } @@ -114,10 +114,10 @@ bool KeyingClipOperation::determineDependingAreaOfInterest(rcti *input, ReadBuff { rcti newInput; - newInput.xmin = input->xmin - this->kernelRadius; - newInput.ymin = input->ymin - this->kernelRadius; - newInput.xmax = input->xmax + this->kernelRadius; - newInput.ymax = input->ymax + this->kernelRadius; + newInput.xmin = input->xmin - this->m_kernelRadius; + newInput.ymin = input->ymin - this->m_kernelRadius; + newInput.xmax = input->xmax + this->m_kernelRadius; + newInput.ymax = input->ymax + this->m_kernelRadius; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } diff --git a/source/blender/compositor/operations/COM_KeyingClipOperation.h b/source/blender/compositor/operations/COM_KeyingClipOperation.h index 9c7b23b0160..bffcdb96877 100644 --- a/source/blender/compositor/operations/COM_KeyingClipOperation.h +++ b/source/blender/compositor/operations/COM_KeyingClipOperation.h @@ -31,23 +31,23 @@ */ class KeyingClipOperation : public NodeOperation { protected: - float clipBlack; - float clipWhite; + float m_clipBlack; + float m_clipWhite; - int kernelRadius; - float kernelTolerance; + int m_kernelRadius; + float m_kernelTolerance; - bool isEdgeMatte; + bool m_isEdgeMatte; public: KeyingClipOperation(); - void setClipBlack(float value) {this->clipBlack = value;} - void setClipWhite(float value) {this->clipWhite = value;} + void setClipBlack(float value) {this->m_clipBlack = value;} + void setClipWhite(float value) {this->m_clipWhite = value;} - void setKernelRadius(int value) {this->kernelRadius = value;} - void setKernelTolerance(float value) {this->kernelTolerance = value;} + void setKernelRadius(int value) {this->m_kernelRadius = value;} + void setKernelTolerance(float value) {this->m_kernelTolerance = value;} - void setIsEdgeMatte(bool value) {this->isEdgeMatte = value;} + void setIsEdgeMatte(bool value) {this->m_isEdgeMatte = value;} void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers); diff --git a/source/blender/compositor/operations/COM_KeyingDespillOperation.cpp b/source/blender/compositor/operations/COM_KeyingDespillOperation.cpp index 04523384653..081d9f723e8 100644 --- a/source/blender/compositor/operations/COM_KeyingDespillOperation.cpp +++ b/source/blender/compositor/operations/COM_KeyingDespillOperation.cpp @@ -46,22 +46,22 @@ KeyingDespillOperation::KeyingDespillOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->despillFactor = 0.5f; + this->m_despillFactor = 0.5f; - this->pixelReader = NULL; - this->screenReader = NULL; + this->m_pixelReader = NULL; + this->m_screenReader = NULL; } void KeyingDespillOperation::initExecution() { - this->pixelReader = this->getInputSocketReader(0); - this->screenReader = this->getInputSocketReader(1); + this->m_pixelReader = this->getInputSocketReader(0); + this->m_screenReader = this->getInputSocketReader(1); } void KeyingDespillOperation::deinitExecution() { - this->pixelReader = NULL; - this->screenReader = NULL; + this->m_pixelReader = NULL; + this->m_screenReader = NULL; } void KeyingDespillOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -69,8 +69,8 @@ void KeyingDespillOperation::executePixel(float *color, float x, float y, PixelS float pixelColor[4]; float screenColor[4]; - this->pixelReader->read(pixelColor, x, y, sampler, inputBuffers); - this->screenReader->read(screenColor, x, y, sampler, inputBuffers); + this->m_pixelReader->read(pixelColor, x, y, sampler, inputBuffers); + this->m_screenReader->read(screenColor, x, y, sampler, inputBuffers); int screen_primary_channel = get_pixel_primary_channel(screenColor); float average_value, amount; @@ -83,7 +83,7 @@ void KeyingDespillOperation::executePixel(float *color, float x, float y, PixelS color[2] = pixelColor[2]; color[3] = pixelColor[3]; - if (this->despillFactor * amount > 0) { - color[screen_primary_channel] = pixelColor[screen_primary_channel] - this->despillFactor * amount; + if (this->m_despillFactor * amount > 0) { + color[screen_primary_channel] = pixelColor[screen_primary_channel] - this->m_despillFactor * amount; } } diff --git a/source/blender/compositor/operations/COM_KeyingDespillOperation.h b/source/blender/compositor/operations/COM_KeyingDespillOperation.h index 92a1415a1f0..879ee0acaca 100644 --- a/source/blender/compositor/operations/COM_KeyingDespillOperation.h +++ b/source/blender/compositor/operations/COM_KeyingDespillOperation.h @@ -31,9 +31,9 @@ */ class KeyingDespillOperation : public NodeOperation { protected: - SocketReader *pixelReader; - SocketReader *screenReader; - float despillFactor; + SocketReader *m_pixelReader; + SocketReader *m_screenReader; + float m_despillFactor; public: KeyingDespillOperation(); @@ -41,7 +41,7 @@ public: void initExecution(); void deinitExecution(); - void setDespillFactor(float value) {this->despillFactor = value;} + void setDespillFactor(float value) {this->m_despillFactor = value;} void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]); }; diff --git a/source/blender/compositor/operations/COM_KeyingOperation.cpp b/source/blender/compositor/operations/COM_KeyingOperation.cpp index d5d477a5385..e92e5c84c2d 100644 --- a/source/blender/compositor/operations/COM_KeyingOperation.cpp +++ b/source/blender/compositor/operations/COM_KeyingOperation.cpp @@ -60,28 +60,28 @@ KeyingOperation::KeyingOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->screenBalance = 0.5f; + this->m_screenBalance = 0.5f; - this->pixelReader = NULL; - this->screenReader = NULL; - this->garbageReader = NULL; - this->coreReader = NULL; + this->m_pixelReader = NULL; + this->m_screenReader = NULL; + this->m_garbageReader = NULL; + this->m_coreReader = NULL; } void KeyingOperation::initExecution() { - this->pixelReader = this->getInputSocketReader(0); - this->screenReader = this->getInputSocketReader(1); - this->garbageReader = this->getInputSocketReader(2); - this->coreReader = this->getInputSocketReader(3); + this->m_pixelReader = this->getInputSocketReader(0); + this->m_screenReader = this->getInputSocketReader(1); + this->m_garbageReader = this->getInputSocketReader(2); + this->m_coreReader = this->getInputSocketReader(3); } void KeyingOperation::deinitExecution() { - this->pixelReader = NULL; - this->screenReader = NULL; - this->garbageReader = NULL; - this->coreReader = NULL; + this->m_pixelReader = NULL; + this->m_screenReader = NULL; + this->m_garbageReader = NULL; + this->m_coreReader = NULL; } void KeyingOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -91,10 +91,10 @@ void KeyingOperation::executePixel(float *color, float x, float y, PixelSampler float garbageValue[4]; float coreValue[4]; - this->pixelReader->read(pixelColor, x, y, sampler, inputBuffers); - this->screenReader->read(screenColor, x, y, sampler, inputBuffers); - this->garbageReader->read(garbageValue, x, y, sampler, inputBuffers); - this->coreReader->read(coreValue, x, y, sampler, inputBuffers); + this->m_pixelReader->read(pixelColor, x, y, sampler, inputBuffers); + this->m_screenReader->read(screenColor, x, y, sampler, inputBuffers); + this->m_garbageReader->read(garbageValue, x, y, sampler, inputBuffers); + this->m_coreReader->read(coreValue, x, y, sampler, inputBuffers); int primary_channel = get_pixel_primary_channel(screenColor); @@ -107,8 +107,8 @@ void KeyingOperation::executePixel(float *color, float x, float y, PixelSampler color[0] = 1.0f; } else { - float saturation = get_pixel_saturation(pixelColor, this->screenBalance, primary_channel); - float screen_saturation = get_pixel_saturation(screenColor, this->screenBalance, primary_channel); + float saturation = get_pixel_saturation(pixelColor, this->m_screenBalance, primary_channel); + float screen_saturation = get_pixel_saturation(screenColor, this->m_screenBalance, primary_channel); if (saturation < 0) { /* means main channel of pixel is different from screen, diff --git a/source/blender/compositor/operations/COM_KeyingOperation.h b/source/blender/compositor/operations/COM_KeyingOperation.h index 6e8ada927bd..61036bead80 100644 --- a/source/blender/compositor/operations/COM_KeyingOperation.h +++ b/source/blender/compositor/operations/COM_KeyingOperation.h @@ -36,12 +36,12 @@ */ class KeyingOperation : public NodeOperation { protected: - SocketReader *pixelReader; - SocketReader *screenReader; - SocketReader *garbageReader; - SocketReader *coreReader; + SocketReader *m_pixelReader; + SocketReader *m_screenReader; + SocketReader *m_garbageReader; + SocketReader *m_coreReader; - float screenBalance; + float m_screenBalance; public: KeyingOperation(); @@ -49,7 +49,7 @@ public: void initExecution(); void deinitExecution(); - void setScreenBalance(float value) {this->screenBalance = value;} + void setScreenBalance(float value) {this->m_screenBalance = value;} void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]); }; diff --git a/source/blender/compositor/operations/COM_KeyingScreenOperation.cpp b/source/blender/compositor/operations/COM_KeyingScreenOperation.cpp index c75762a3f86..0fbe0aea555 100644 --- a/source/blender/compositor/operations/COM_KeyingScreenOperation.cpp +++ b/source/blender/compositor/operations/COM_KeyingScreenOperation.cpp @@ -42,22 +42,22 @@ extern "C" { KeyingScreenOperation::KeyingScreenOperation() : NodeOperation() { this->addOutputSocket(COM_DT_COLOR); - this->movieClip = NULL; - this->framenumber = 0; - this->trackingObject[0] = 0; + this->m_movieClip = NULL; + this->m_framenumber = 0; + this->m_trackingObject[0] = 0; setComplex(true); } void KeyingScreenOperation::initExecution() { initMutex(); - this->cachedTriangulation = NULL; + this->m_cachedTriangulation = NULL; } void KeyingScreenOperation::deinitExecution() { - if (this->cachedTriangulation) { - TriangulationData *triangulation = cachedTriangulation; + if (this->m_cachedTriangulation) { + TriangulationData *triangulation = this->m_cachedTriangulation; if (triangulation->triangulated_points) MEM_freeN(triangulation->triangulated_points); @@ -68,9 +68,9 @@ void KeyingScreenOperation::deinitExecution() if (triangulation->triangles_AABB) MEM_freeN(triangulation->triangles_AABB); - MEM_freeN(this->cachedTriangulation); + MEM_freeN(this->m_cachedTriangulation); - this->cachedTriangulation = NULL; + this->m_cachedTriangulation = NULL; } } @@ -78,7 +78,7 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri { MovieClipUser user = {0}; TriangulationData *triangulation; - MovieTracking *tracking = &movieClip->tracking; + MovieTracking *tracking = &this->m_movieClip->tracking; MovieTrackingTrack *track; VoronoiSite *sites; ImBuf *ibuf; @@ -88,10 +88,10 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri int i; int width = this->getWidth(); int height = this->getHeight(); - int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(this->movieClip, framenumber); + int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(this->m_movieClip, this->m_framenumber); - if (this->trackingObject[0]) { - MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, this->trackingObject); + if (this->m_trackingObject[0]) { + MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, this->m_trackingObject); if (!object) return NULL; @@ -114,7 +114,7 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri return NULL; BKE_movieclip_user_set_frame(&user, clip_frame); - ibuf = BKE_movieclip_get_ibuf(movieClip, &user); + ibuf = BKE_movieclip_get_ibuf(this->m_movieClip, &user); if (!ibuf) return NULL; @@ -199,19 +199,19 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri void *KeyingScreenOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - if (this->movieClip == NULL) + if (this->m_movieClip == NULL) return NULL; - if (this->cachedTriangulation) - return this->cachedTriangulation; + if (this->m_cachedTriangulation) + return this->m_cachedTriangulation; lockMutex(); - if (this->cachedTriangulation == NULL) { - this->cachedTriangulation = buildVoronoiTriangulation(); + if (this->m_cachedTriangulation == NULL) { + this->m_cachedTriangulation = buildVoronoiTriangulation(); } unlockMutex(); - return this->cachedTriangulation; + return this->m_cachedTriangulation; } void KeyingScreenOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) @@ -219,13 +219,13 @@ void KeyingScreenOperation::determineResolution(unsigned int resolution[], unsig resolution[0] = 0; resolution[1] = 0; - if (this->movieClip) { + if (this->m_movieClip) { MovieClipUser user = {0}; int width, height; - int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(this->movieClip, framenumber); + int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(this->m_movieClip, this->m_framenumber); BKE_movieclip_user_set_frame(&user, clip_frame); - BKE_movieclip_get_size(this->movieClip, &user, &width, &height); + BKE_movieclip_get_size(this->m_movieClip, &user, &width, &height); resolution[0] = width; resolution[1] = height; @@ -239,7 +239,7 @@ void KeyingScreenOperation::executePixel(float *color, int x, int y, MemoryBuffe color[2] = 0.0f; color[3] = 1.0f; - if (this->movieClip && data) { + if (this->m_movieClip && data) { TriangulationData *triangulation = (TriangulationData *) data; int i; float co[2] = {(float) x, (float) y}; diff --git a/source/blender/compositor/operations/COM_KeyingScreenOperation.h b/source/blender/compositor/operations/COM_KeyingScreenOperation.h index a539ecf696e..7cf7ad3e959 100644 --- a/source/blender/compositor/operations/COM_KeyingScreenOperation.h +++ b/source/blender/compositor/operations/COM_KeyingScreenOperation.h @@ -39,8 +39,8 @@ extern "C" { } /** - * Class with implementation of green screen gradient rasterization - */ + * Class with implementation of green screen gradient rasterization + */ class KeyingScreenOperation : public NodeOperation { protected: typedef struct TriangulationData { @@ -50,19 +50,19 @@ protected: rctf *triangles_AABB; } TriangulationData; - MovieClip *movieClip; - int framenumber; - TriangulationData *cachedTriangulation; - char trackingObject[64]; + MovieClip *m_movieClip; + int m_framenumber; + TriangulationData *m_cachedTriangulation; + char m_trackingObject[64]; /** - * Determine the output resolution. The resolution is retrieved from the Renderer - */ + * Determine the output resolution. The resolution is retrieved from the Renderer + */ void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]); TriangulationData *buildVoronoiTriangulation(); - public: +public: KeyingScreenOperation(); void initExecution(); @@ -70,9 +70,9 @@ protected: void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers); - void setMovieClip(MovieClip *clip) {this->movieClip = clip;} - void setTrackingObject(char *object) {strncpy(this->trackingObject, object, sizeof(this->trackingObject));} - void setFramenumber(int framenumber) {this->framenumber = framenumber;} + void setMovieClip(MovieClip *clip) {this->m_movieClip = clip;} + void setTrackingObject(const char *object) {strncpy(this->m_trackingObject, object, sizeof(this->m_trackingObject));} + void setFramenumber(int framenumber) {this->m_framenumber = framenumber;} void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data); }; diff --git a/source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp b/source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp index 6e8aa9461e6..233f903c3e3 100644 --- a/source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp +++ b/source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp @@ -27,29 +27,29 @@ LuminanceMatteOperation::LuminanceMatteOperation() : NodeOperation() addInputSocket(COM_DT_COLOR); addOutputSocket(COM_DT_VALUE); - inputImageProgram = NULL; + this->m_inputImageProgram = NULL; } void LuminanceMatteOperation::initExecution() { - this->inputImageProgram = this->getInputSocketReader(0); + this->m_inputImageProgram = this->getInputSocketReader(0); } void LuminanceMatteOperation::deinitExecution() { - this->inputImageProgram = NULL; + this->m_inputImageProgram = NULL; } void LuminanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float inColor[4]; - const float high = this->settings->t1; - const float low = this->settings->t2; + const float high = this->m_settings->t1; + const float low = this->m_settings->t2; float alpha; - this->inputImageProgram->read(inColor, x, y, sampler, inputBuffers); + this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers); /* one line thread-friend algorithm: * outputValue[0] = max(inputValue[3], min(high, max(low, ((inColor[0]-low)/(high-low)))) diff --git a/source/blender/compositor/operations/COM_LuminanceMatteOperation.h b/source/blender/compositor/operations/COM_LuminanceMatteOperation.h index f44e32396a3..7da56465cd8 100644 --- a/source/blender/compositor/operations/COM_LuminanceMatteOperation.h +++ b/source/blender/compositor/operations/COM_LuminanceMatteOperation.h @@ -30,8 +30,8 @@ */ class LuminanceMatteOperation : public NodeOperation { private: - NodeChroma *settings; - SocketReader *inputImageProgram; + NodeChroma *m_settings; + SocketReader *m_inputImageProgram; public: /** * Default constructor @@ -46,6 +46,6 @@ public: void initExecution(); void deinitExecution(); - void setSettings(NodeChroma *nodeChroma) { this->settings = nodeChroma; } + void setSettings(NodeChroma *nodeChroma) { this->m_settings = nodeChroma; } }; #endif diff --git a/source/blender/compositor/operations/COM_MapUVOperation.cpp b/source/blender/compositor/operations/COM_MapUVOperation.cpp index b29dcfab194..dec2d0849c9 100644 --- a/source/blender/compositor/operations/COM_MapUVOperation.cpp +++ b/source/blender/compositor/operations/COM_MapUVOperation.cpp @@ -27,17 +27,17 @@ MapUVOperation::MapUVOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR); this->addInputSocket(COM_DT_VECTOR); this->addOutputSocket(COM_DT_COLOR); - this->alpha = 0.f; + this->m_alpha = 0.0f; this->setComplex(true); - this->inputUVProgram = NULL; - this->inputColorProgram = NULL; + this->m_inputUVProgram = NULL; + this->m_inputColorProgram = NULL; } void MapUVOperation::initExecution() { - this->inputColorProgram = this->getInputSocketReader(0); - this->inputUVProgram = this->getInputSocketReader(1); + this->m_inputColorProgram = this->getInputSocketReader(0); + this->m_inputUVProgram = this->getInputSocketReader(1); } void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -50,30 +50,30 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s float uv_l, uv_r; float uv_u, uv_d; - this->inputUVProgram->read(inputUV, x, y, sampler, inputBuffers); + this->m_inputUVProgram->read(inputUV, x, y, sampler, inputBuffers); if (inputUV[2] == 0.f) { zero_v4(color); return; } /* adaptive sampling, red (U) channel */ - this->inputUVProgram->read(uv_a, x - 1, y, COM_PS_NEAREST, inputBuffers); - this->inputUVProgram->read(uv_b, x + 1, y, COM_PS_NEAREST, inputBuffers); + this->m_inputUVProgram->read(uv_a, x - 1, y, COM_PS_NEAREST, inputBuffers); + this->m_inputUVProgram->read(uv_b, x + 1, y, COM_PS_NEAREST, inputBuffers); uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f; uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f; dx = 0.5f * (uv_l + uv_r); /* adaptive sampling, green (V) channel */ - this->inputUVProgram->read(uv_a, x, y - 1, COM_PS_NEAREST, inputBuffers); - this->inputUVProgram->read(uv_b, x, y + 1, COM_PS_NEAREST, inputBuffers); + this->m_inputUVProgram->read(uv_a, x, y - 1, COM_PS_NEAREST, inputBuffers); + this->m_inputUVProgram->read(uv_b, x, y + 1, COM_PS_NEAREST, inputBuffers); uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f; uv_d = uv_b[2] != 0.f ? fabsf(inputUV[1] - uv_b[1]) : 0.f; dy = 0.5f * (uv_u + uv_d); /* more adaptive sampling, red and green (UV) channels */ - this->inputUVProgram->read(uv_a, x - 1, y - 1, COM_PS_NEAREST, inputBuffers); - this->inputUVProgram->read(uv_b, x - 1, y + 1, COM_PS_NEAREST, inputBuffers); + this->m_inputUVProgram->read(uv_a, x - 1, y - 1, COM_PS_NEAREST, inputBuffers); + this->m_inputUVProgram->read(uv_b, x - 1, y + 1, COM_PS_NEAREST, inputBuffers); uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f; uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f; uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f; @@ -82,8 +82,8 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s dx += 0.25f * (uv_l + uv_r); dy += 0.25f * (uv_u + uv_d); - this->inputUVProgram->read(uv_a, x + 1, y - 1, COM_PS_NEAREST, inputBuffers); - this->inputUVProgram->read(uv_b, x + 1, y + 1, COM_PS_NEAREST, inputBuffers); + this->m_inputUVProgram->read(uv_a, x + 1, y - 1, COM_PS_NEAREST, inputBuffers); + this->m_inputUVProgram->read(uv_b, x + 1, y + 1, COM_PS_NEAREST, inputBuffers); uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f; uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f; uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f; @@ -93,7 +93,7 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s dy += 0.25f * (uv_u + uv_d); /* UV to alpha threshold */ - const float threshold = this->alpha * 0.05f; + const float threshold = this->m_alpha * 0.05f; float alpha = 1.0f - threshold * (dx + dy); if (alpha < 0.f) alpha = 0.f; else alpha *= inputUV[2]; @@ -104,10 +104,10 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s /* EWA filtering */ - u = inputUV[0] * inputColorProgram->getWidth(); - v = inputUV[1] * inputColorProgram->getHeight(); + u = inputUV[0] * this->m_inputColorProgram->getWidth(); + v = inputUV[1] * this->m_inputColorProgram->getHeight(); - this->inputColorProgram->read(color, u, v, dx, dy, inputBuffers); + this->m_inputColorProgram->read(color, u, v, dx, dy, inputBuffers); /* "premul" */ if (alpha < 1.0f) { @@ -117,8 +117,8 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s void MapUVOperation::deinitExecution() { - this->inputUVProgram = NULL; - this->inputColorProgram = NULL; + this->m_inputUVProgram = NULL; + this->m_inputColorProgram = NULL; } bool MapUVOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) diff --git a/source/blender/compositor/operations/COM_MapUVOperation.h b/source/blender/compositor/operations/COM_MapUVOperation.h index 22e3531e838..c14640da61c 100644 --- a/source/blender/compositor/operations/COM_MapUVOperation.h +++ b/source/blender/compositor/operations/COM_MapUVOperation.h @@ -29,10 +29,10 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputUVProgram; - SocketReader *inputColorProgram; + SocketReader *m_inputUVProgram; + SocketReader *m_inputColorProgram; - float alpha; + float m_alpha; public: MapUVOperation(); @@ -57,6 +57,6 @@ public: */ void deinitExecution(); - void setAlpha(float alpha) { this->alpha = alpha; } + void setAlpha(float alpha) { this->m_alpha = alpha; } }; #endif diff --git a/source/blender/compositor/operations/COM_MapValueOperation.cpp b/source/blender/compositor/operations/COM_MapValueOperation.cpp index 6d7804dd6e3..17d82e85723 100644 --- a/source/blender/compositor/operations/COM_MapValueOperation.cpp +++ b/source/blender/compositor/operations/COM_MapValueOperation.cpp @@ -26,19 +26,19 @@ MapValueOperation::MapValueOperation() : NodeOperation() { this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void MapValueOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void MapValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float src[4]; - inputOperation->read(src, x, y, sampler, inputBuffers); - TexMapping *texmap = this->settings; + this->m_inputOperation->read(src, x, y, sampler, inputBuffers); + TexMapping *texmap = this->m_settings; float value = (src[0] + texmap->loc[0]) * texmap->size[0]; if (texmap->flag & TEXMAP_CLIP_MIN) if (value < texmap->min[0]) @@ -52,5 +52,5 @@ void MapValueOperation::executePixel(float *outputValue, float x, float y, Pixel void MapValueOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } diff --git a/source/blender/compositor/operations/COM_MapValueOperation.h b/source/blender/compositor/operations/COM_MapValueOperation.h index 5fae74e0a6a..53157c39938 100644 --- a/source/blender/compositor/operations/COM_MapValueOperation.h +++ b/source/blender/compositor/operations/COM_MapValueOperation.h @@ -34,8 +34,8 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputOperation; - TexMapping *settings; + SocketReader *m_inputOperation; + TexMapping *m_settings; public: /** * Default constructor @@ -60,7 +60,7 @@ public: /** * @brief set the TexMapping settings */ - void setSettings(TexMapping *settings) { this->settings = settings; } + void setSettings(TexMapping *settings) { this->m_settings = settings; } }; #endif diff --git a/source/blender/compositor/operations/COM_MaskOperation.cpp b/source/blender/compositor/operations/COM_MaskOperation.cpp index 3b7e98433e4..aa16ecf5d09 100644 --- a/source/blender/compositor/operations/COM_MaskOperation.cpp +++ b/source/blender/compositor/operations/COM_MaskOperation.cpp @@ -38,69 +38,69 @@ extern "C" { MaskOperation::MaskOperation() : NodeOperation() { this->addOutputSocket(COM_DT_VALUE); - this->mask = NULL; - this->maskWidth = 0; - this->maskHeight = 0; - this->framenumber = 0; - this->rasterizedMask = NULL; + this->m_mask = NULL; + this->m_maskWidth = 0; + this->m_maskHeight = 0; + this->m_framenumber = 0; + this->m_rasterizedMask = NULL; setComplex(true); } void MaskOperation::initExecution() { initMutex(); - this->rasterizedMask = NULL; + this->m_rasterizedMask = NULL; } void MaskOperation::deinitExecution() { - if (this->rasterizedMask) { - MEM_freeN(rasterizedMask); - this->rasterizedMask = NULL; + if (this->m_rasterizedMask) { + MEM_freeN(this->m_rasterizedMask); + this->m_rasterizedMask = NULL; } } void *MaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - if (this->rasterizedMask) - return this->rasterizedMask; + if (this->m_rasterizedMask) + return this->m_rasterizedMask; - if (!this->mask) + if (!this->m_mask) return NULL; lockMutex(); - if (this->rasterizedMask == NULL) { + if (this->m_rasterizedMask == NULL) { int width = this->getWidth(); int height = this->getHeight(); float *buffer; buffer = (float *)MEM_callocN(sizeof(float) * width * height, "rasterized mask"); - BKE_mask_rasterize(mask, width, height, buffer, TRUE, this->do_smooth, this->do_feather); - if (this->do_smooth) { + BKE_mask_rasterize(this->m_mask, width, height, buffer, TRUE, this->m_do_smooth, this->m_do_feather); + if (this->m_do_smooth) { PLX_antialias_buffer(buffer, width, height); } - this->rasterizedMask = buffer; + this->m_rasterizedMask = buffer; } unlockMutex(); - return this->rasterizedMask; + return this->m_rasterizedMask; } void MaskOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) { - if (maskWidth == 0 || maskHeight == 0) { + if (this->m_maskWidth == 0 || this->m_maskHeight == 0) { NodeOperation::determineResolution(resolution, preferredResolution); } else { unsigned int nr[2]; - nr[0] = maskWidth; - nr[1] = maskHeight; + nr[0] = this->m_maskWidth; + nr[1] = this->m_maskHeight; NodeOperation::determineResolution(resolution, nr); - resolution[0] = maskWidth; - resolution[1] = maskHeight; + resolution[0] = this->m_maskWidth; + resolution[1] = this->m_maskHeight; } } diff --git a/source/blender/compositor/operations/COM_MaskOperation.h b/source/blender/compositor/operations/COM_MaskOperation.h index 6b6d9aa9eeb..d50f5c619bb 100644 --- a/source/blender/compositor/operations/COM_MaskOperation.h +++ b/source/blender/compositor/operations/COM_MaskOperation.h @@ -36,13 +36,13 @@ */ class MaskOperation : public NodeOperation { protected: - Mask *mask; - int maskWidth; - int maskHeight; - int framenumber; - bool do_smooth; - bool do_feather; - float *rasterizedMask; + Mask *m_mask; + int m_maskWidth; + int m_maskHeight; + int m_framenumber; + bool m_do_smooth; + bool m_do_feather; + float *m_rasterizedMask; /** * Determine the output resolution. The resolution is retrieved from the Renderer @@ -57,12 +57,12 @@ public: void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers); - void setMask(Mask *mask) { this->mask = mask; } - void setMaskWidth(int width) { this->maskWidth = width; } - void setMaskHeight(int height) { this->maskHeight = height; } - void setFramenumber(int framenumber) { this->framenumber = framenumber; } - void setSmooth(bool smooth) { this->do_smooth = smooth; } - void setFeather(bool feather) { this->do_feather = feather; } + void setMask(Mask *mask) { this->m_mask = mask; } + void setMaskWidth(int width) { this->m_maskWidth = width; } + void setMaskHeight(int height) { this->m_maskHeight = height; } + void setFramenumber(int framenumber) { this->m_framenumber = framenumber; } + void setSmooth(bool smooth) { this->m_do_smooth = smooth; } + void setFeather(bool feather) { this->m_do_feather = feather; } void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data); }; diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.cpp b/source/blender/compositor/operations/COM_MathBaseOperation.cpp index 5e9fb70b206..1bf89be57b5 100644 --- a/source/blender/compositor/operations/COM_MathBaseOperation.cpp +++ b/source/blender/compositor/operations/COM_MathBaseOperation.cpp @@ -30,21 +30,21 @@ MathBaseOperation::MathBaseOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->inputValue1Operation = NULL; - this->inputValue2Operation = NULL; + this->m_inputValue1Operation = NULL; + this->m_inputValue2Operation = NULL; } void MathBaseOperation::initExecution() { - this->inputValue1Operation = this->getInputSocketReader(0); - this->inputValue2Operation = this->getInputSocketReader(1); + this->m_inputValue1Operation = this->getInputSocketReader(0); + this->m_inputValue2Operation = this->getInputSocketReader(1); } void MathBaseOperation::deinitExecution() { - this->inputValue1Operation = NULL; - this->inputValue2Operation = NULL; + this->m_inputValue1Operation = NULL; + this->m_inputValue2Operation = NULL; } void MathBaseOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) @@ -69,8 +69,8 @@ void MathAddOperation::executePixel(float *outputValue, float x, float y, PixelS float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = inputValue1[0] + inputValue2[0]; } @@ -80,8 +80,8 @@ void MathSubtractOperation::executePixel(float *outputValue, float x, float y, P float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = inputValue1[0] - inputValue2[0]; } @@ -91,8 +91,8 @@ void MathMultiplyOperation::executePixel(float *outputValue, float x, float y, P float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = inputValue1[0] * inputValue2[0]; } @@ -102,8 +102,8 @@ void MathDivideOperation::executePixel(float *outputValue, float x, float y, Pix float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); if (inputValue2[0] == 0) /* We don't want to divide by zero. */ outputValue[0] = 0.0; @@ -116,8 +116,8 @@ void MathSineOperation::executePixel(float *outputValue, float x, float y, Pixel float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = sin(inputValue1[0]); } @@ -127,8 +127,8 @@ void MathCosineOperation::executePixel(float *outputValue, float x, float y, Pix float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = cos(inputValue1[0]); } @@ -138,8 +138,8 @@ void MathTangentOperation::executePixel(float *outputValue, float x, float y, Pi float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = tan(inputValue1[0]); } @@ -149,8 +149,8 @@ void MathArcSineOperation::executePixel(float *outputValue, float x, float y, Pi float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); if (inputValue1[0] <= 1 && inputValue1[0] >= -1) outputValue[0] = asin(inputValue1[0]); @@ -163,8 +163,8 @@ void MathArcCosineOperation::executePixel(float *outputValue, float x, float y, float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); if (inputValue1[0] <= 1 && inputValue1[0] >= -1) outputValue[0] = acos(inputValue1[0]); @@ -177,8 +177,8 @@ void MathArcTangentOperation::executePixel(float *outputValue, float x, float y, float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = atan(inputValue1[0]); } @@ -188,8 +188,8 @@ void MathPowerOperation::executePixel(float *outputValue, float x, float y, Pixe float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); if (inputValue1[0] >= 0) { outputValue[0] = pow(inputValue1[0], inputValue2[0]); @@ -211,8 +211,8 @@ void MathLogarithmOperation::executePixel(float *outputValue, float x, float y, float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); if (inputValue1[0] > 0 && inputValue2[0] > 0) outputValue[0] = log(inputValue1[0]) / log(inputValue2[0]); @@ -225,8 +225,8 @@ void MathMinimumOperation::executePixel(float *outputValue, float x, float y, Pi float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = min(inputValue1[0], inputValue2[0]); } @@ -236,8 +236,8 @@ void MathMaximumOperation::executePixel(float *outputValue, float x, float y, Pi float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = max(inputValue1[0], inputValue2[0]); } @@ -247,8 +247,8 @@ void MathRoundOperation::executePixel(float *outputValue, float x, float y, Pixe float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = round(inputValue1[0]); } @@ -258,8 +258,8 @@ void MathLessThanOperation::executePixel(float *outputValue, float x, float y, P float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = inputValue1[0] < inputValue2[0] ? 1.0f : 0.0f; } @@ -269,8 +269,8 @@ void MathGreaterThanOperation::executePixel(float *outputValue, float x, float y float inputValue1[4]; float inputValue2[4]; - inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); - inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); + this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers); + this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers); outputValue[0] = inputValue1[0] > inputValue2[0] ? 1.0f : 0.0f; } diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.h b/source/blender/compositor/operations/COM_MathBaseOperation.h index 12dc5fa36c7..bf77223e26f 100644 --- a/source/blender/compositor/operations/COM_MathBaseOperation.h +++ b/source/blender/compositor/operations/COM_MathBaseOperation.h @@ -34,8 +34,8 @@ protected: /** * Prefetched reference to the inputProgram */ - SocketReader *inputValue1Operation; - SocketReader *inputValue2Operation; + SocketReader *m_inputValue1Operation; + SocketReader *m_inputValue2Operation; protected: /** diff --git a/source/blender/compositor/operations/COM_MixAddOperation.cpp b/source/blender/compositor/operations/COM_MixAddOperation.cpp index bd9538a5600..7f7315fb3ff 100644 --- a/source/blender/compositor/operations/COM_MixAddOperation.cpp +++ b/source/blender/compositor/operations/COM_MixAddOperation.cpp @@ -33,9 +33,9 @@ void MixAddOperation::executePixel(float *outputValue, float x, float y, PixelSa float inputColor2[4]; float inputValue[4]; - inputValueOperation->read(inputValue, x, y, sampler, inputBuffers); - inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); - inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers); float value = inputValue[0]; diff --git a/source/blender/compositor/operations/COM_MixBaseOperation.cpp b/source/blender/compositor/operations/COM_MixBaseOperation.cpp index 0efab2942b0..fbe92f54aa8 100644 --- a/source/blender/compositor/operations/COM_MixBaseOperation.cpp +++ b/source/blender/compositor/operations/COM_MixBaseOperation.cpp @@ -28,17 +28,17 @@ MixBaseOperation::MixBaseOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR); this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); - this->inputValueOperation = NULL; - this->inputColor1Operation = NULL; - this->inputColor2Operation = NULL; + this->m_inputValueOperation = NULL; + this->m_inputColor1Operation = NULL; + this->m_inputColor2Operation = NULL; this->setUseValueAlphaMultiply(false); } void MixBaseOperation::initExecution() { - this->inputValueOperation = this->getInputSocketReader(0); - this->inputColor1Operation = this->getInputSocketReader(1); - this->inputColor2Operation = this->getInputSocketReader(2); + this->m_inputValueOperation = this->getInputSocketReader(0); + this->m_inputColor1Operation = this->getInputSocketReader(1); + this->m_inputColor2Operation = this->getInputSocketReader(2); } void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -47,9 +47,9 @@ void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelS float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; @@ -63,9 +63,9 @@ void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelS void MixBaseOperation::deinitExecution() { - this->inputValueOperation = NULL; - this->inputColor1Operation = NULL; - this->inputColor2Operation = NULL; + this->m_inputValueOperation = NULL; + this->m_inputColor1Operation = NULL; + this->m_inputColor2Operation = NULL; } void MixBaseOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) diff --git a/source/blender/compositor/operations/COM_MixBaseOperation.h b/source/blender/compositor/operations/COM_MixBaseOperation.h index 3637cc9eacf..8e9bb283533 100644 --- a/source/blender/compositor/operations/COM_MixBaseOperation.h +++ b/source/blender/compositor/operations/COM_MixBaseOperation.h @@ -34,10 +34,10 @@ protected: /** * Prefetched reference to the inputProgram */ - SocketReader *inputValueOperation; - SocketReader *inputColor1Operation; - SocketReader *inputColor2Operation; - bool valueAlphaMultiply; + SocketReader *m_inputValueOperation; + SocketReader *m_inputColor1Operation; + SocketReader *m_inputColor2Operation; + bool m_valueAlphaMultiply; public: /** * Default constructor @@ -61,7 +61,7 @@ public: void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]); - void setUseValueAlphaMultiply(const bool value) { this->valueAlphaMultiply = value; } - bool useValueAlphaMultiply() { return this->valueAlphaMultiply; } + void setUseValueAlphaMultiply(const bool value) { this->m_valueAlphaMultiply = value; } + bool useValueAlphaMultiply() { return this->m_valueAlphaMultiply; } }; #endif diff --git a/source/blender/compositor/operations/COM_MixBlendOperation.cpp b/source/blender/compositor/operations/COM_MixBlendOperation.cpp index f010d23ce60..341aba0e7fc 100644 --- a/source/blender/compositor/operations/COM_MixBlendOperation.cpp +++ b/source/blender/compositor/operations/COM_MixBlendOperation.cpp @@ -34,9 +34,9 @@ void MixBlendOperation::executePixel(float *outputValue, float x, float y, Pixel float inputValue[4]; float value; - inputValueOperation->read(inputValue, x, y, sampler, inputBuffers); - inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); - inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers); value = inputValue[0]; if (this->useValueAlphaMultiply()) { diff --git a/source/blender/compositor/operations/COM_MixBurnOperation.cpp b/source/blender/compositor/operations/COM_MixBurnOperation.cpp index e94834148e8..039915ab66a 100644 --- a/source/blender/compositor/operations/COM_MixBurnOperation.cpp +++ b/source/blender/compositor/operations/COM_MixBurnOperation.cpp @@ -34,9 +34,9 @@ void MixBurnOperation::executePixel(float *outputValue, float x, float y, PixelS float value; float tmp; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixColorOperation.cpp b/source/blender/compositor/operations/COM_MixColorOperation.cpp index f3e893bc18f..cb5791c02bb 100644 --- a/source/blender/compositor/operations/COM_MixColorOperation.cpp +++ b/source/blender/compositor/operations/COM_MixColorOperation.cpp @@ -37,9 +37,9 @@ void MixColorOperation::executePixel(float *outputValue, float x, float y, Pixel float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixDarkenOperation.cpp b/source/blender/compositor/operations/COM_MixDarkenOperation.cpp index a36c663ddda..db243cf4a87 100644 --- a/source/blender/compositor/operations/COM_MixDarkenOperation.cpp +++ b/source/blender/compositor/operations/COM_MixDarkenOperation.cpp @@ -33,9 +33,9 @@ void MixDarkenOperation::executePixel(float *outputValue, float x, float y, Pixe float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixDifferenceOperation.cpp b/source/blender/compositor/operations/COM_MixDifferenceOperation.cpp index 69886753480..9fe1a3cb94b 100644 --- a/source/blender/compositor/operations/COM_MixDifferenceOperation.cpp +++ b/source/blender/compositor/operations/COM_MixDifferenceOperation.cpp @@ -34,9 +34,9 @@ void MixDifferenceOperation::executePixel(float *outputValue, float x, float y, float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixDivideOperation.cpp b/source/blender/compositor/operations/COM_MixDivideOperation.cpp index 8b6586c5336..0e1bd408b89 100644 --- a/source/blender/compositor/operations/COM_MixDivideOperation.cpp +++ b/source/blender/compositor/operations/COM_MixDivideOperation.cpp @@ -33,9 +33,9 @@ void MixDivideOperation::executePixel(float *outputValue, float x, float y, Pixe float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixDodgeOperation.cpp b/source/blender/compositor/operations/COM_MixDodgeOperation.cpp index 971ddd5b736..ea01806267b 100644 --- a/source/blender/compositor/operations/COM_MixDodgeOperation.cpp +++ b/source/blender/compositor/operations/COM_MixDodgeOperation.cpp @@ -34,9 +34,9 @@ void MixDodgeOperation::executePixel(float *outputValue, float x, float y, Pixel float value; float tmp; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixGlareOperation.cpp b/source/blender/compositor/operations/COM_MixGlareOperation.cpp index bfb0efe692f..7cd24b3bf06 100644 --- a/source/blender/compositor/operations/COM_MixGlareOperation.cpp +++ b/source/blender/compositor/operations/COM_MixGlareOperation.cpp @@ -34,9 +34,9 @@ void MixGlareOperation::executePixel(float *outputValue, float x, float y, Pixel float inputValue[4]; float value; - inputValueOperation->read(inputValue, x, y, sampler, inputBuffers); - inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); - inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers); value = inputValue[0]; float mf = 2.f - 2.f * fabsf(value - 0.5f); diff --git a/source/blender/compositor/operations/COM_MixHueOperation.cpp b/source/blender/compositor/operations/COM_MixHueOperation.cpp index 05d02805ebc..e7b444616f4 100644 --- a/source/blender/compositor/operations/COM_MixHueOperation.cpp +++ b/source/blender/compositor/operations/COM_MixHueOperation.cpp @@ -37,9 +37,9 @@ void MixHueOperation::executePixel(float *outputValue, float x, float y, PixelSa float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixLightenOperation.cpp b/source/blender/compositor/operations/COM_MixLightenOperation.cpp index 6e1af7a3c44..89166637f9f 100644 --- a/source/blender/compositor/operations/COM_MixLightenOperation.cpp +++ b/source/blender/compositor/operations/COM_MixLightenOperation.cpp @@ -33,9 +33,9 @@ void MixLightenOperation::executePixel(float *outputValue, float x, float y, Pix float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixLinearLightOperation.cpp b/source/blender/compositor/operations/COM_MixLinearLightOperation.cpp index bf1c181b566..5406a3cbcc1 100644 --- a/source/blender/compositor/operations/COM_MixLinearLightOperation.cpp +++ b/source/blender/compositor/operations/COM_MixLinearLightOperation.cpp @@ -33,9 +33,9 @@ void MixLinearLightOperation::executePixel(float *outputValue, float x, float y, float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixMultiplyOperation.cpp b/source/blender/compositor/operations/COM_MixMultiplyOperation.cpp index 62018ed5698..978e96eb2f6 100644 --- a/source/blender/compositor/operations/COM_MixMultiplyOperation.cpp +++ b/source/blender/compositor/operations/COM_MixMultiplyOperation.cpp @@ -33,9 +33,9 @@ void MixMultiplyOperation::executePixel(float *outputValue, float x, float y, Pi float inputColor2[4]; float inputValue[4]; - inputValueOperation->read(inputValue, x, y, sampler, inputBuffers); - inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); - inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers); float value = inputValue[0]; if (this->useValueAlphaMultiply()) { diff --git a/source/blender/compositor/operations/COM_MixOverlayOperation.cpp b/source/blender/compositor/operations/COM_MixOverlayOperation.cpp index a269045c598..f4f96747acd 100644 --- a/source/blender/compositor/operations/COM_MixOverlayOperation.cpp +++ b/source/blender/compositor/operations/COM_MixOverlayOperation.cpp @@ -33,9 +33,9 @@ void MixOverlayOperation::executePixel(float *outputValue, float x, float y, Pix float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixSaturationOperation.cpp b/source/blender/compositor/operations/COM_MixSaturationOperation.cpp index 863a17a7f80..c9c6f691fdb 100644 --- a/source/blender/compositor/operations/COM_MixSaturationOperation.cpp +++ b/source/blender/compositor/operations/COM_MixSaturationOperation.cpp @@ -37,9 +37,9 @@ void MixSaturationOperation::executePixel(float *outputValue, float x, float y, float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixScreenOperation.cpp b/source/blender/compositor/operations/COM_MixScreenOperation.cpp index 6fb7befeba4..9bc9144f4ff 100644 --- a/source/blender/compositor/operations/COM_MixScreenOperation.cpp +++ b/source/blender/compositor/operations/COM_MixScreenOperation.cpp @@ -33,9 +33,9 @@ void MixScreenOperation::executePixel(float *outputValue, float x, float y, Pixe float inputColor2[4]; float valuev[4]; - inputValueOperation->read(valuev, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(valuev, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); float value = valuev[0]; if (this->useValueAlphaMultiply()) { diff --git a/source/blender/compositor/operations/COM_MixSoftLightOperation.cpp b/source/blender/compositor/operations/COM_MixSoftLightOperation.cpp index 9f7d0823473..52c2e8829dc 100644 --- a/source/blender/compositor/operations/COM_MixSoftLightOperation.cpp +++ b/source/blender/compositor/operations/COM_MixSoftLightOperation.cpp @@ -33,9 +33,9 @@ void MixSoftLightOperation::executePixel(float *outputValue, float x, float y, P float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixSubtractOperation.cpp b/source/blender/compositor/operations/COM_MixSubtractOperation.cpp index 80086053872..60f54ab478d 100644 --- a/source/blender/compositor/operations/COM_MixSubtractOperation.cpp +++ b/source/blender/compositor/operations/COM_MixSubtractOperation.cpp @@ -33,9 +33,9 @@ void MixSubtractOperation::executePixel(float *outputValue, float x, float y, Pi float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MixValueOperation.cpp b/source/blender/compositor/operations/COM_MixValueOperation.cpp index cd79c54318d..2651b0d7dee 100644 --- a/source/blender/compositor/operations/COM_MixValueOperation.cpp +++ b/source/blender/compositor/operations/COM_MixValueOperation.cpp @@ -37,9 +37,9 @@ void MixValueOperation::executePixel(float *outputValue, float x, float y, Pixel float inputColor2[4]; float value; - inputValueOperation->read(&value, x, y, sampler, inputBuffers); - inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); - inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); + this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers); + this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers); + this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers); if (this->useValueAlphaMultiply()) { value *= inputColor2[3]; diff --git a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp index 662212567de..1af206920c5 100644 --- a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp +++ b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp @@ -28,40 +28,40 @@ extern "C" { MovieClipAttributeOperation::MovieClipAttributeOperation() : NodeOperation() { this->addOutputSocket(COM_DT_VALUE); - this->valueSet = false; - this->framenumber = 0; - this->attribute = MCA_X; + this->m_valueSet = false; + this->m_framenumber = 0; + this->m_attribute = MCA_X; } void MovieClipAttributeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - if (!valueSet) { + if (!this->m_valueSet) { float loc[2], scale, angle; loc[0] = 0.0f; loc[1] = 0.0f; scale = 1.0f; angle = 0.0f; - if (clip) { - int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, framenumber); - BKE_tracking_stabilization_data_get(&clip->tracking, clip_framenr, getWidth(), getHeight(), loc, &scale, &angle); + if (this->m_clip) { + int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(this->m_clip, this->m_framenumber); + BKE_tracking_stabilization_data_get(&this->m_clip->tracking, clip_framenr, getWidth(), getHeight(), loc, &scale, &angle); } - switch (this->attribute) { + switch (this->m_attribute) { case MCA_SCALE: - this->value = scale; + this->m_value = scale; break; case MCA_ANGLE: - this->value = angle; + this->m_value = angle; break; case MCA_X: - this->value = loc[0]; + this->m_value = loc[0]; break; case MCA_Y: - this->value = loc[1]; + this->m_value = loc[1]; break; } - valueSet = true; + this->m_valueSet = true; } - outputValue[0] = this->value; + outputValue[0] = this->m_value; } void MovieClipAttributeOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) diff --git a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h index b6e89fa345c..ba104d07572 100644 --- a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h +++ b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h @@ -37,11 +37,11 @@ typedef enum MovieClipAttribute { */ class MovieClipAttributeOperation : public NodeOperation { private: - MovieClip *clip; - float value; - bool valueSet; - int framenumber; - MovieClipAttribute attribute; + MovieClip *m_clip; + float m_value; + bool m_valueSet; + int m_framenumber; + MovieClipAttribute m_attribute; public: /** * Default constructor @@ -54,8 +54,8 @@ public: void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]); - void setMovieClip(MovieClip *clip) { this->clip = clip; } - void setFramenumber(int framenumber) { this->framenumber = framenumber; } - void setAttribute(MovieClipAttribute attribute) { this->attribute = attribute; } + void setMovieClip(MovieClip *clip) { this->m_clip = clip; } + void setFramenumber(int framenumber) { this->m_framenumber = framenumber; } + void setAttribute(MovieClipAttribute attribute) { this->m_attribute = attribute; } }; #endif diff --git a/source/blender/compositor/operations/COM_MovieClipOperation.cpp b/source/blender/compositor/operations/COM_MovieClipOperation.cpp index b8bda12c626..f53bb66d478 100644 --- a/source/blender/compositor/operations/COM_MovieClipOperation.cpp +++ b/source/blender/compositor/operations/COM_MovieClipOperation.cpp @@ -34,23 +34,23 @@ extern "C" { MovieClipOperation::MovieClipOperation() : NodeOperation() { this->addOutputSocket(COM_DT_COLOR); - this->movieClip = NULL; - this->movieClipBuffer = NULL; - this->movieClipUser = NULL; - this->movieClipwidth = 0; - this->movieClipheight = 0; - this->framenumber = 0; + this->m_movieClip = NULL; + this->m_movieClipBuffer = NULL; + this->m_movieClipUser = NULL; + this->m_movieClipwidth = 0; + this->m_movieClipheight = 0; + this->m_framenumber = 0; } void MovieClipOperation::initExecution() { - if (this->movieClip) { - BKE_movieclip_user_set_frame(this->movieClipUser, this->framenumber); + if (this->m_movieClip) { + BKE_movieclip_user_set_frame(this->m_movieClipUser, this->m_framenumber); ImBuf *ibuf; - ibuf = BKE_movieclip_get_ibuf(this->movieClip, this->movieClipUser); + ibuf = BKE_movieclip_get_ibuf(this->m_movieClip, this->m_movieClipUser); if (ibuf) { - this->movieClipBuffer = ibuf; + this->m_movieClipBuffer = ibuf; if (ibuf->rect_float == NULL || ibuf->userflags & IB_RECT_INVALID) { IMB_float_from_rect(ibuf); ibuf->userflags &= ~IB_RECT_INVALID; @@ -61,10 +61,10 @@ void MovieClipOperation::initExecution() void MovieClipOperation::deinitExecution() { - if (this->movieClipBuffer) { - IMB_freeImBuf(this->movieClipBuffer); + if (this->m_movieClipBuffer) { + IMB_freeImBuf(this->m_movieClipBuffer); - this->movieClipBuffer = NULL; + this->m_movieClipBuffer = NULL; } } @@ -73,10 +73,10 @@ void MovieClipOperation::determineResolution(unsigned int resolution[], unsigned resolution[0] = 0; resolution[1] = 0; - if (this->movieClip) { + if (this->m_movieClip) { int width, height; - BKE_movieclip_get_size(this->movieClip, this->movieClipUser, &width, &height); + BKE_movieclip_get_size(this->m_movieClip, this->m_movieClipUser, &width, &height); resolution[0] = width; resolution[1] = height; @@ -85,22 +85,19 @@ void MovieClipOperation::determineResolution(unsigned int resolution[], unsigned void MovieClipOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - if (this->movieClipBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) { - color[0] = 0.0f; - color[1] = 0.0f; - color[2] = 0.0f; - color[3] = 0.0f; + if (this->m_movieClipBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) { + zero_v4(color); } else { switch (sampler) { case COM_PS_NEAREST: - neareast_interpolation_color(this->movieClipBuffer, NULL, color, x, y); + neareast_interpolation_color(this->m_movieClipBuffer, NULL, color, x, y); break; case COM_PS_BILINEAR: - bilinear_interpolation_color(this->movieClipBuffer, NULL, color, x, y); + bilinear_interpolation_color(this->m_movieClipBuffer, NULL, color, x, y); break; case COM_PS_BICUBIC: - bicubic_interpolation_color(this->movieClipBuffer, NULL, color, x, y); + bicubic_interpolation_color(this->m_movieClipBuffer, NULL, color, x, y); break; } } diff --git a/source/blender/compositor/operations/COM_MovieClipOperation.h b/source/blender/compositor/operations/COM_MovieClipOperation.h index 454c442a167..2e824009ab6 100644 --- a/source/blender/compositor/operations/COM_MovieClipOperation.h +++ b/source/blender/compositor/operations/COM_MovieClipOperation.h @@ -37,12 +37,12 @@ */ class MovieClipOperation : public NodeOperation { protected: - MovieClip *movieClip; - MovieClipUser *movieClipUser; - ImBuf *movieClipBuffer; - int movieClipheight; - int movieClipwidth; - int framenumber; + MovieClip *m_movieClip; + MovieClipUser *m_movieClipUser; + ImBuf *m_movieClipBuffer; + int m_movieClipheight; + int m_movieClipwidth; + int m_framenumber; /** * Determine the output resolution. The resolution is retrieved from the Renderer @@ -54,10 +54,10 @@ public: void initExecution(); void deinitExecution(); - void setMovieClip(MovieClip *image) { this->movieClip = image; } - void setMovieClipUser(MovieClipUser *imageuser) { this->movieClipUser = imageuser; } + void setMovieClip(MovieClip *image) { this->m_movieClip = image; } + void setMovieClipUser(MovieClipUser *imageuser) { this->m_movieClipUser = imageuser; } - void setFramenumber(int framenumber) { this->framenumber = framenumber; } + void setFramenumber(int framenumber) { this->m_framenumber = framenumber; } void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); }; diff --git a/source/blender/compositor/operations/COM_MovieDistortionOperation.cpp b/source/blender/compositor/operations/COM_MovieDistortionOperation.cpp index 5320f901747..6b423cadcc6 100644 --- a/source/blender/compositor/operations/COM_MovieDistortionOperation.cpp +++ b/source/blender/compositor/operations/COM_MovieDistortionOperation.cpp @@ -37,57 +37,57 @@ MovieDistortionOperation::MovieDistortionOperation(bool distortion) : NodeOperat this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->inputOperation = NULL; - this->movieClip = NULL; - this->cache = NULL; - this->distortion = distortion; + this->m_inputOperation = NULL; + this->m_movieClip = NULL; + this->m_cache = NULL; + this->m_distortion = distortion; } void MovieDistortionOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); - if (this->movieClip) { + this->m_inputOperation = this->getInputSocketReader(0); + if (this->m_movieClip) { MovieClipUser clipUser = {0}; int calibration_width, calibration_height; - BKE_movieclip_user_set_frame(&clipUser, this->framenumber); - BKE_movieclip_get_size(this->movieClip, &clipUser, &calibration_width, &calibration_height); + BKE_movieclip_user_set_frame(&clipUser, this->m_framenumber); + BKE_movieclip_get_size(this->m_movieClip, &clipUser, &calibration_width, &calibration_height); for (unsigned int i = 0; i < s_cache.size(); i++) { DistortionCache *c = (DistortionCache *)s_cache[i]; - if (c->isCacheFor(this->movieClip, this->width, this->height, - calibration_width, calibration_height, this->distortion)) + if (c->isCacheFor(this->m_movieClip, this->m_width, this->m_height, + calibration_width, calibration_height, this->m_distortion)) { - this->cache = c; + this->m_cache = c; return; } } - DistortionCache *newC = new DistortionCache(this->movieClip, this->width, this->height, - calibration_width, calibration_height, this->distortion); + DistortionCache *newC = new DistortionCache(this->m_movieClip, this->m_width, this->m_height, + calibration_width, calibration_height, this->m_distortion); s_cache.push_back(newC); - this->cache = newC; + this->m_cache = newC; } else { - this->cache = NULL; + this->m_cache = NULL; } } void MovieDistortionOperation::deinitExecution() { - this->inputOperation = NULL; - this->movieClip = NULL; + this->m_inputOperation = NULL; + this->m_movieClip = NULL; } void MovieDistortionOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - if (this->cache != NULL) { + if (this->m_cache != NULL) { float u, v; - this->cache->getUV(&this->movieClip->tracking, x, y, &u, &v); - this->inputOperation->read(color, u, v, sampler, inputBuffers); + this->m_cache->getUV(&this->m_movieClip->tracking, x, y, &u, &v); + this->m_inputOperation->read(color, u, v, sampler, inputBuffers); } else { - this->inputOperation->read(color, x, y, sampler, inputBuffers); + this->m_inputOperation->read(color, x, y, sampler, inputBuffers); } } diff --git a/source/blender/compositor/operations/COM_MovieDistortionOperation.h b/source/blender/compositor/operations/COM_MovieDistortionOperation.h index c2ce04a78e1..ab81ae44597 100644 --- a/source/blender/compositor/operations/COM_MovieDistortionOperation.h +++ b/source/blender/compositor/operations/COM_MovieDistortionOperation.h @@ -31,100 +31,101 @@ extern "C" { class DistortionCache { private: - float k1; - float k2; - float k3; - float principal_x; - float principal_y; - float pixel_aspect; - int width; - int height; - int calibration_width; - int calibration_height; - bool inverted; - float *buffer; - int *bufferCalculated; + float m_k1; + float m_k2; + float m_k3; + float m_principal_x; + float m_principal_y; + float m_pixel_aspect; + int m_width; + int m_height; + int m_calibration_width; + int m_calibration_height; + bool m_inverted; + float *m_buffer; + int *m_bufferCalculated; public: DistortionCache(MovieClip *movieclip, int width, int height, int calibration_width, int calibration_height, bool inverted) { - this->k1 = movieclip->tracking.camera.k1; - this->k2 = movieclip->tracking.camera.k2; - this->k3 = movieclip->tracking.camera.k3; - this->principal_x = movieclip->tracking.camera.principal[0]; - this->principal_y = movieclip->tracking.camera.principal[1]; - this->pixel_aspect = movieclip->tracking.camera.pixel_aspect; - this->width = width; - this->height = height; - this->calibration_width = calibration_width; - this->calibration_height = calibration_height; - this->inverted = inverted; - this->bufferCalculated = new int[this->width * this->height]; - this->buffer = new float[this->width * this->height * 2]; - for (int i = 0; i < this->width * this->height; i++) { - this->bufferCalculated[i] = 0; + this->m_k1 = movieclip->tracking.camera.k1; + this->m_k2 = movieclip->tracking.camera.k2; + this->m_k3 = movieclip->tracking.camera.k3; + this->m_principal_x = movieclip->tracking.camera.principal[0]; + this->m_principal_y = movieclip->tracking.camera.principal[1]; + this->m_pixel_aspect = movieclip->tracking.camera.pixel_aspect; + this->m_width = width; + this->m_height = height; + this->m_calibration_width = calibration_width; + this->m_calibration_height = calibration_height; + this->m_inverted = inverted; + this->m_bufferCalculated = new int[this->m_width * this->m_height]; + this->m_buffer = new float[this->m_width * this->m_height * 2]; + for (int i = 0; i < this->m_width * this->m_height; i++) { + this->m_bufferCalculated[i] = 0; } } bool isCacheFor(MovieClip *movieclip, int width, int height, int calibration_width, int claibration_height, bool inverted) { - return this->k1 == movieclip->tracking.camera.k1 && - this->k2 == movieclip->tracking.camera.k2 && - this->k3 == movieclip->tracking.camera.k3 && - this->principal_x == movieclip->tracking.camera.principal[0] && - this->principal_y == movieclip->tracking.camera.principal[1] && - this->pixel_aspect == movieclip->tracking.camera.pixel_aspect && - this->inverted == inverted && - this->width == width && - this->height == height && - this->calibration_width == calibration_width && - this->calibration_height == calibration_height; + return this->m_k1 == movieclip->tracking.camera.k1 && + this->m_k2 == movieclip->tracking.camera.k2 && + this->m_k3 == movieclip->tracking.camera.k3 && + this->m_principal_x == movieclip->tracking.camera.principal[0] && + this->m_principal_y == movieclip->tracking.camera.principal[1] && + this->m_pixel_aspect == movieclip->tracking.camera.pixel_aspect && + this->m_inverted == inverted && + this->m_width == width && + this->m_height == height && + this->m_calibration_width == this->m_calibration_width && + this->m_calibration_height == this->m_calibration_height; } - void getUV(MovieTracking *trackingData, int x, int y, float *u, float *v) { - if (x < 0 || x >= this->width || y < 0 || y >= this->height) { + void getUV(MovieTracking *trackingData, int x, int y, float *u, float *v) + { + if (x < 0 || x >= this->m_width || y < 0 || y >= this->m_height) { *u = x; *v = y; } else { - int offset = y * this->width + x; + int offset = y * this->m_width + x; int offset2 = offset * 2; - if (!bufferCalculated[offset]) { + if (!this->m_bufferCalculated[offset]) { //float overscan = 0.0f; - float w = (float)this->width /* / (1 + overscan) */; - float h = (float)this->height /* / (1 + overscan) */; - float aspx = (float)w / this->calibration_width; - float aspy = (float)h / this->calibration_height; + float w = (float)this->m_width /* / (1 + overscan) */; + float h = (float)this->m_height /* / (1 + overscan) */; + float aspx = (float)w / this->m_calibration_width; + float aspy = (float)h / this->m_calibration_height; float in[2]; float out[2]; in[0] = (x /* - 0.5 * overscan * w */) / aspx; - in[1] = (y /* - 0.5 * overscan * h */) / aspy / this->pixel_aspect; + in[1] = (y /* - 0.5 * overscan * h */) / aspy / this->m_pixel_aspect; - if (inverted) { + if (this->m_inverted) { BKE_tracking_undistort_v2(trackingData, in, out); } else { BKE_tracking_distort_v2(trackingData, in, out); } - buffer[offset2] = out[0] * aspx /* + 0.5 * overscan * w */; - buffer[offset2 + 1] = (out[1] * aspy /* + 0.5 * overscan * h */) * this->pixel_aspect; + this->m_buffer[offset2] = out[0] * aspx /* + 0.5 * overscan * w */; + this->m_buffer[offset2 + 1] = (out[1] * aspy /* + 0.5 * overscan * h */) * this->m_pixel_aspect; - bufferCalculated[offset] = 1; + this->m_bufferCalculated[offset] = 1; } - *u = buffer[offset2]; - *v = buffer[offset2 + 1]; + *u = this->m_buffer[offset2]; + *v = this->m_buffer[offset2 + 1]; } } }; class MovieDistortionOperation : public NodeOperation { private: - DistortionCache *cache; - SocketReader *inputOperation; - MovieClip *movieClip; + DistortionCache *m_cache; + SocketReader *m_inputOperation; + MovieClip *m_movieClip; protected: - bool distortion; - int framenumber; + bool m_distortion; + int m_framenumber; public: MovieDistortionOperation(bool distortion); @@ -134,8 +135,8 @@ public: void initExecution(); void deinitExecution(); - void setMovieClip(MovieClip *clip) { this->movieClip = clip; } - void setFramenumber(int framenumber) { this->framenumber = framenumber; } + void setMovieClip(MovieClip *clip) { this->m_movieClip = clip; } + void setFramenumber(int framenumber) { this->m_framenumber = framenumber; } }; #endif diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.cpp b/source/blender/compositor/operations/COM_MultilayerImageOperation.cpp index 1bd21f6e712..363c0379770 100644 --- a/source/blender/compositor/operations/COM_MultilayerImageOperation.cpp +++ b/source/blender/compositor/operations/COM_MultilayerImageOperation.cpp @@ -29,15 +29,15 @@ extern "C" { MultilayerBaseOperation::MultilayerBaseOperation(int pass) : BaseImageOperation() { - this->passId = pass; + this->m_passId = pass; } ImBuf *MultilayerBaseOperation::getImBuf() { RenderPass *rpass; - rpass = (RenderPass *)BLI_findlink(&this->renderlayer->passes, this->passId); + rpass = (RenderPass *)BLI_findlink(&this->m_renderlayer->passes, this->m_passId); if (rpass) { - this->imageUser->pass = this->passId; - BKE_image_multilayer_index(image->rr, this->imageUser); + this->m_imageUser->pass = this->m_passId; + BKE_image_multilayer_index(this->m_image->rr, this->m_imageUser); return BaseImageOperation::getImBuf(); } return NULL; @@ -47,31 +47,29 @@ void MultilayerColorOperation::executePixel(float *color, float x, float y, Pixe { int yi = y; int xi = x; - if (this->imageBuffer == NULL || xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || (unsigned int)yi >= this->getHeight() ) { + if (this->m_imageBuffer == NULL || xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || (unsigned int)yi >= this->getHeight() ) { color[0] = 0.0f; color[1] = 0.0f; color[2] = 0.0f; color[3] = 0.0f; } else { - if (this->numberOfChannels == 4) { + if (this->m_numberOfChannels == 4) { switch (sampler) { case COM_PS_NEAREST: - neareast_interpolation_color(this->buffer, NULL, color, x, y); + neareast_interpolation_color(this->m_buffer, NULL, color, x, y); break; case COM_PS_BILINEAR: - bilinear_interpolation_color(this->buffer, NULL, color, x, y); + bilinear_interpolation_color(this->m_buffer, NULL, color, x, y); break; case COM_PS_BICUBIC: - bicubic_interpolation_color(this->buffer, NULL, color, x, y); + bicubic_interpolation_color(this->m_buffer, NULL, color, x, y); break; } } else { int offset = (yi * this->getWidth() + xi) * 3; - color[0] = this->imageBuffer[offset]; - color[1] = this->imageBuffer[offset + 1]; - color[2] = this->imageBuffer[offset + 2]; + copy_v3_v3(color, &this->m_imageBuffer[offset]); } } } @@ -80,11 +78,11 @@ void MultilayerValueOperation::executePixel(float *color, float x, float y, Pixe { int yi = y; int xi = x; - if (this->imageBuffer == NULL || xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || (unsigned int)yi >= this->getHeight() ) { + if (this->m_imageBuffer == NULL || xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || (unsigned int)yi >= this->getHeight() ) { color[0] = 0.0f; } else { - float result = this->imageBuffer[yi * this->getWidth() + xi]; + float result = this->m_imageBuffer[yi * this->getWidth() + xi]; color[0] = result; } } @@ -93,13 +91,11 @@ void MultilayerVectorOperation::executePixel(float *color, float x, float y, Pix { int yi = y; int xi = x; - if (this->imageBuffer == NULL || xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || (unsigned int)yi >= this->getHeight() ) { + if (this->m_imageBuffer == NULL || xi < 0 || yi < 0 || (unsigned int)xi >= this->getWidth() || (unsigned int)yi >= this->getHeight() ) { color[0] = 0.0f; } else { int offset = (yi * this->getWidth() + xi) * 3; - color[0] = this->imageBuffer[offset]; - color[1] = this->imageBuffer[offset + 1]; - color[2] = this->imageBuffer[offset + 2]; + copy_v3_v3(color, &this->m_imageBuffer[offset]); } } diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.h b/source/blender/compositor/operations/COM_MultilayerImageOperation.h index c33e65fc55b..f946c44dd35 100644 --- a/source/blender/compositor/operations/COM_MultilayerImageOperation.h +++ b/source/blender/compositor/operations/COM_MultilayerImageOperation.h @@ -29,8 +29,8 @@ class MultilayerBaseOperation : public BaseImageOperation { private: - int passId; - RenderLayer *renderlayer; + int m_passId; + RenderLayer *m_renderlayer; protected: ImBuf *getImBuf(); public: @@ -38,7 +38,7 @@ public: * Constructor */ MultilayerBaseOperation(int pass); - void setRenderLayer(RenderLayer *renderlayer) { this->renderlayer = renderlayer; } + void setRenderLayer(RenderLayer *renderlayer) { this->m_renderlayer = renderlayer; } }; class MultilayerColorOperation : public MultilayerBaseOperation { diff --git a/source/blender/compositor/operations/COM_NormalizeOperation.cpp b/source/blender/compositor/operations/COM_NormalizeOperation.cpp index c0c22e05508..8a83ef7f3ae 100644 --- a/source/blender/compositor/operations/COM_NormalizeOperation.cpp +++ b/source/blender/compositor/operations/COM_NormalizeOperation.cpp @@ -25,13 +25,13 @@ NormalizeOperation::NormalizeOperation() : NodeOperation() { this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_VALUE); - this->imageReader = NULL; - this->cachedInstance = NULL; + this->m_imageReader = NULL; + this->m_cachedInstance = NULL; this->setComplex(true); } void NormalizeOperation::initExecution() { - this->imageReader = this->getInputSocketReader(0); + this->m_imageReader = this->getInputSocketReader(0); NodeOperation::initMutex(); } @@ -41,16 +41,16 @@ void NormalizeOperation::executePixel(float *color, int x, int y, MemoryBuffer * NodeTwoFloats *minmult = (NodeTwoFloats *)data; float output[4]; - this->imageReader->read(output, x, y, inputBuffers, NULL); + this->m_imageReader->read(output, x, y, inputBuffers, NULL); color[0] = (output[0] - minmult->x) * minmult->y; } void NormalizeOperation::deinitExecution() { - this->imageReader = NULL; - if (this->cachedInstance) { - delete cachedInstance; + this->m_imageReader = NULL; + if (this->m_cachedInstance) { + delete this->m_cachedInstance; } NodeOperation::deinitMutex(); } @@ -58,7 +58,7 @@ void NormalizeOperation::deinitExecution() bool NormalizeOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti imageInput; - if (this->cachedInstance) return false; + if (this->m_cachedInstance) return false; NodeOperation *operation = getInputOperation(0); imageInput.xmax = operation->getWidth(); @@ -78,8 +78,8 @@ bool NormalizeOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe void *NormalizeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (this->cachedInstance == NULL) { - MemoryBuffer *tile = (MemoryBuffer *)imageReader->initializeTileData(rect, memoryBuffers); + if (this->m_cachedInstance == NULL) { + MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers); /* using generic two floats struct to store x: min y: mult */ NodeTwoFloats *minmult = new NodeTwoFloats(); @@ -106,11 +106,11 @@ void *NormalizeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBu /* The rare case of flat buffer would cause a divide by 0 */ minmult->y = ((maxv != minv) ? 1.0f / (maxv - minv) : 0.f); - this->cachedInstance = minmult; + this->m_cachedInstance = minmult; } unlockMutex(); - return this->cachedInstance; + return this->m_cachedInstance; } void NormalizeOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data) diff --git a/source/blender/compositor/operations/COM_NormalizeOperation.h b/source/blender/compositor/operations/COM_NormalizeOperation.h index de1c4d67bba..1f4a403434e 100644 --- a/source/blender/compositor/operations/COM_NormalizeOperation.h +++ b/source/blender/compositor/operations/COM_NormalizeOperation.h @@ -33,13 +33,13 @@ protected: /** * @brief Cached reference to the reader */ - SocketReader *imageReader; + SocketReader *m_imageReader; /** * @brief temporarily cache of the execution storage * it stores x->min and y->mult */ - NodeTwoFloats *cachedInstance; + NodeTwoFloats *m_cachedInstance; public: NormalizeOperation(); diff --git a/source/blender/compositor/operations/COM_OutputFileOperation.cpp b/source/blender/compositor/operations/COM_OutputFileOperation.cpp index c0aa139b032..ecfcdb7c70f 100644 --- a/source/blender/compositor/operations/COM_OutputFileOperation.cpp +++ b/source/blender/compositor/operations/COM_OutputFileOperation.cpp @@ -94,59 +94,59 @@ static void write_buffer_rect(rcti *rect, MemoryBuffer **memoryBuffers, const bN OutputSingleLayerOperation::OutputSingleLayerOperation( const RenderData *rd, const bNodeTree *tree, DataType datatype, ImageFormatData *format, const char *path) { - this->rd = rd; - this->tree = tree; + this->m_rd = rd; + this->m_tree = tree; this->addInputSocket(datatype); - this->outputBuffer = NULL; - this->datatype = datatype; - this->imageInput = NULL; + this->m_outputBuffer = NULL; + this->m_datatype = datatype; + this->m_imageInput = NULL; - this->format = format; - BLI_strncpy(this->path, path, sizeof(this->path)); + this->m_format = format; + BLI_strncpy(this->m_path, path, sizeof(this->m_path)); } void OutputSingleLayerOperation::initExecution() { - this->imageInput = getInputSocketReader(0); - this->outputBuffer = init_buffer(this->getWidth(), this->getHeight(), this->datatype); + this->m_imageInput = getInputSocketReader(0); + this->m_outputBuffer = init_buffer(this->getWidth(), this->getHeight(), this->m_datatype); } void OutputSingleLayerOperation::executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers) { - write_buffer_rect(rect, memoryBuffers, this->tree, imageInput, this->outputBuffer, this->getWidth(), this->datatype); + write_buffer_rect(rect, memoryBuffers, this->m_tree, this->m_imageInput, this->m_outputBuffer, this->getWidth(), this->m_datatype); } void OutputSingleLayerOperation::deinitExecution() { if (this->getWidth() * this->getHeight() != 0) { - int size = get_datatype_size(this->datatype); + int size = get_datatype_size(this->m_datatype); ImBuf *ibuf = IMB_allocImBuf(this->getWidth(), this->getHeight(), size * 8, 0); Main *bmain = G.main; /* TODO, have this passed along */ char filename[FILE_MAX]; ibuf->channels = size; - ibuf->rect_float = this->outputBuffer; + ibuf->rect_float = this->m_outputBuffer; ibuf->mall |= IB_rectfloat; - ibuf->dither = this->rd->dither_intensity; + ibuf->dither = this->m_rd->dither_intensity; - if (this->rd->color_mgt_flag & R_COLOR_MANAGEMENT) + if (this->m_rd->color_mgt_flag & R_COLOR_MANAGEMENT) ibuf->profile = IB_PROFILE_LINEAR_RGB; - BKE_makepicstring(filename, this->path, bmain->name, this->rd->cfra, this->format->imtype, - (this->rd->scemode & R_EXTENSION), true); + BKE_makepicstring(filename, this->m_path, bmain->name, this->m_rd->cfra, this->m_format->imtype, + (this->m_rd->scemode & R_EXTENSION), true); - if (0 == BKE_imbuf_write(ibuf, filename, this->format)) + if (0 == BKE_imbuf_write(ibuf, filename, this->m_format)) printf("Cannot save Node File Output to %s\n", filename); else printf("Saved: %s\n", filename); IMB_freeImBuf(ibuf); } - this->outputBuffer = NULL; - this->imageInput = NULL; + this->m_outputBuffer = NULL; + this->m_imageInput = NULL; } @@ -162,31 +162,31 @@ OutputOpenExrLayer::OutputOpenExrLayer(const char *name, DataType datatype) OutputOpenExrMultiLayerOperation::OutputOpenExrMultiLayerOperation( const RenderData *rd, const bNodeTree *tree, const char *path, char exr_codec) { - this->rd = rd; - this->tree = tree; + this->m_rd = rd; + this->m_tree = tree; - BLI_strncpy(this->path, path, sizeof(this->path)); - this->exr_codec = exr_codec; + BLI_strncpy(this->m_path, path, sizeof(this->m_path)); + this->m_exr_codec = exr_codec; } void OutputOpenExrMultiLayerOperation::add_layer(const char *name, DataType datatype) { this->addInputSocket(datatype); - layers.push_back(OutputOpenExrLayer(name, datatype)); + this->m_layers.push_back(OutputOpenExrLayer(name, datatype)); } void OutputOpenExrMultiLayerOperation::initExecution() { - for (unsigned int i = 0; i < layers.size(); ++i) { - layers[i].imageInput = getInputSocketReader(i); - layers[i].outputBuffer = init_buffer(this->getWidth(), this->getHeight(), layers[i].datatype); + for (unsigned int i = 0; i < this->m_layers.size(); ++i) { + this->m_layers[i].imageInput = getInputSocketReader(i); + this->m_layers[i].outputBuffer = init_buffer(this->getWidth(), this->getHeight(), this->m_layers[i].datatype); } } void OutputOpenExrMultiLayerOperation::executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers) { - for (unsigned int i = 0; i < layers.size(); ++i) { - write_buffer_rect(rect, memoryBuffers, this->tree, layers[i].imageInput, layers[i].outputBuffer, this->getWidth(), layers[i].datatype); + for (unsigned int i = 0; i < this->m_layers.size(); ++i) { + write_buffer_rect(rect, memoryBuffers, this->m_tree, this->m_layers[i].imageInput, this->m_layers[i].outputBuffer, this->getWidth(), this->m_layers[i].datatype); } } @@ -199,19 +199,19 @@ void OutputOpenExrMultiLayerOperation::deinitExecution() char filename[FILE_MAX]; void *exrhandle = IMB_exr_get_handle(); - BKE_makepicstring(filename, this->path, bmain->name, this->rd->cfra, R_IMF_IMTYPE_MULTILAYER, - (this->rd->scemode & R_EXTENSION), true); + BKE_makepicstring(filename, this->m_path, bmain->name, this->m_rd->cfra, R_IMF_IMTYPE_MULTILAYER, + (this->m_rd->scemode & R_EXTENSION), true); BLI_make_existing_file(filename); - for (unsigned int i = 0; i < layers.size(); ++i) { + for (unsigned int i = 0; i < this->m_layers.size(); ++i) { char channelname[EXR_TOT_MAXNAME]; - BLI_strncpy(channelname, layers[i].name, sizeof(channelname) - 2); + BLI_strncpy(channelname, this->m_layers[i].name, sizeof(channelname) - 2); char *channelname_ext = channelname + strlen(channelname); - float *buf = layers[i].outputBuffer; + float *buf = this->m_layers[i].outputBuffer; /* create channels */ - switch (layers[i].datatype) { + switch (this->m_layers[i].datatype) { case COM_DT_VALUE: strcpy(channelname_ext, ".V"); IMB_exr_add_channel(exrhandle, 0, channelname, 1, width, buf); @@ -241,7 +241,7 @@ void OutputOpenExrMultiLayerOperation::deinitExecution() } /* when the filename has no permissions, this can fail */ - if (IMB_exr_begin_write(exrhandle, filename, width, height, this->exr_codec)) { + if (IMB_exr_begin_write(exrhandle, filename, width, height, this->m_exr_codec)) { IMB_exr_write_channels(exrhandle); } else { @@ -251,13 +251,13 @@ 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 = NULL; + for (unsigned int i = 0; i < this->m_layers.size(); ++i) { + if (this->m_layers[i].outputBuffer) { + MEM_freeN(this->m_layers[i].outputBuffer); + this->m_layers[i].outputBuffer = NULL; } - layers[i].imageInput = NULL; + this->m_layers[i].imageInput = NULL; } } } diff --git a/source/blender/compositor/operations/COM_OutputFileOperation.h b/source/blender/compositor/operations/COM_OutputFileOperation.h index 25ee5b31ec0..60244a8bf72 100644 --- a/source/blender/compositor/operations/COM_OutputFileOperation.h +++ b/source/blender/compositor/operations/COM_OutputFileOperation.h @@ -32,15 +32,15 @@ /* Writes the image to a single-layer file. */ class OutputSingleLayerOperation : public NodeOperation { private: - const RenderData *rd; - const bNodeTree *tree; + const RenderData *m_rd; + const bNodeTree *m_tree; - ImageFormatData *format; - char path[FILE_MAX]; + ImageFormatData *m_format; + char m_path[FILE_MAX]; - float *outputBuffer; - DataType datatype; - SocketReader *imageInput; + float *m_outputBuffer; + DataType m_datatype; + SocketReader *m_imageInput; public: OutputSingleLayerOperation(const RenderData *rd, const bNodeTree *tree, DataType datatype, ImageFormatData *format, const char *path); @@ -67,12 +67,12 @@ class OutputOpenExrMultiLayerOperation : public NodeOperation { private: typedef std::vector LayerList; - const RenderData *rd; - const bNodeTree *tree; + const RenderData *m_rd; + const bNodeTree *m_tree; - char path[FILE_MAX]; - char exr_codec; - LayerList layers; + char m_path[FILE_MAX]; + char m_exr_codec; + LayerList m_layers; public: OutputOpenExrMultiLayerOperation(const RenderData *rd, const bNodeTree *tree, const char *path, char exr_codec); diff --git a/source/blender/compositor/operations/COM_PreviewOperation.cpp b/source/blender/compositor/operations/COM_PreviewOperation.cpp index 54a95af33b9..55e94568688 100644 --- a/source/blender/compositor/operations/COM_PreviewOperation.cpp +++ b/source/blender/compositor/operations/COM_PreviewOperation.cpp @@ -42,39 +42,41 @@ extern "C" { PreviewOperation::PreviewOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE); - this->outputBuffer = NULL; - this->input = NULL; - this->divider = 1.0f; - this->node = NULL; + this->m_outputBuffer = NULL; + this->m_input = NULL; + this->m_divider = 1.0f; + this->m_node = NULL; } void PreviewOperation::initExecution() { - this->input = getInputSocketReader(0); - if (!this->node->preview) { - this->node->preview = (bNodePreview *)MEM_callocN(sizeof(bNodePreview), "node preview"); + this->m_input = getInputSocketReader(0); + if (!this->m_node->preview) { + this->m_node->preview = (bNodePreview *)MEM_callocN(sizeof(bNodePreview), "node preview"); } else { - if (this->getWidth() == (unsigned int)this->node->preview->xsize && this->getHeight() == (unsigned int)this->node->preview->ysize) { - this->outputBuffer = this->node->preview->rect; + if (this->getWidth() == (unsigned int)this->m_node->preview->xsize && + this->getHeight() == (unsigned int)this->m_node->preview->ysize) + { + this->m_outputBuffer = this->m_node->preview->rect; } } - if (this->outputBuffer == NULL) { - this->outputBuffer = (unsigned char *)MEM_callocN(sizeof(unsigned char) * 4 * getWidth() * getHeight(), "PreviewOperation"); - if (this->node->preview->rect) { - MEM_freeN(this->node->preview->rect); + if (this->m_outputBuffer == NULL) { + this->m_outputBuffer = (unsigned char *)MEM_callocN(sizeof(unsigned char) * 4 * getWidth() * getHeight(), "PreviewOperation"); + if (this->m_node->preview->rect) { + MEM_freeN(this->m_node->preview->rect); } - this->node->preview->xsize = getWidth(); - this->node->preview->ysize = getHeight(); - this->node->preview->rect = outputBuffer; + this->m_node->preview->xsize = getWidth(); + this->m_node->preview->ysize = getHeight(); + this->m_node->preview->rect = this->m_outputBuffer; } } void PreviewOperation::deinitExecution() { - this->outputBuffer = NULL; - this->input = NULL; + this->m_outputBuffer = NULL; + this->m_input = NULL; } void PreviewOperation::executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers) @@ -84,16 +86,16 @@ void PreviewOperation::executeRegion(rcti *rect, unsigned int tileNumber, Memory for (int y = rect->ymin; y < rect->ymax; y++) { offset = (y * getWidth() + rect->xmin) * 4; for (int x = rect->xmin; x < rect->xmax; x++) { - float rx = floor(x / divider); - float ry = floor(y / divider); + float rx = floor(x / this->m_divider); + float ry = floor(y / this->m_divider); color[0] = 0.0f; color[1] = 0.0f; color[2] = 0.0f; color[3] = 1.0f; - input->read(color, rx, ry, COM_PS_NEAREST, memoryBuffers); + this->m_input->read(color, rx, ry, COM_PS_NEAREST, memoryBuffers); linearrgb_to_srgb_v4(color, color); - F4TOCHAR4(color, outputBuffer + offset); + F4TOCHAR4(color, this->m_outputBuffer + offset); offset += 4; } } @@ -102,10 +104,10 @@ bool PreviewOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferO { rcti newInput; - newInput.xmin = input->xmin / divider; - newInput.xmax = input->xmax / divider; - newInput.ymin = input->ymin / divider; - newInput.ymax = input->ymax / divider; + newInput.xmin = input->xmin / this->m_divider; + newInput.xmax = input->xmax / this->m_divider; + newInput.ymin = input->ymin / this->m_divider; + newInput.ymax = input->ymax / this->m_divider; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -114,15 +116,15 @@ void PreviewOperation::determineResolution(unsigned int resolution[], unsigned i NodeOperation::determineResolution(resolution, preferredResolution); int width = resolution[0]; int height = resolution[1]; - this->divider = 0.0f; + this->m_divider = 0.0f; if (width > height) { - divider = COM_PREVIEW_SIZE / (width - 1); + this->m_divider = COM_PREVIEW_SIZE / (width - 1); } else { - divider = COM_PREVIEW_SIZE / (height - 1); + this->m_divider = COM_PREVIEW_SIZE / (height - 1); } - width = width * divider; - height = height * divider; + width = width * this->m_divider; + height = height * this->m_divider; resolution[0] = width; resolution[1] = height; diff --git a/source/blender/compositor/operations/COM_PreviewOperation.h b/source/blender/compositor/operations/COM_PreviewOperation.h index f9ce0c644a1..e7b8ba55ae0 100644 --- a/source/blender/compositor/operations/COM_PreviewOperation.h +++ b/source/blender/compositor/operations/COM_PreviewOperation.h @@ -28,14 +28,14 @@ class PreviewOperation : public NodeOperation { protected: - unsigned char *outputBuffer; + unsigned char *m_outputBuffer; /** * @brief holds reference to the SDNA bNode, where this nodes will render the preview image for */ - bNode *node; - SocketReader *input; - float divider; + bNode *m_node; + SocketReader *m_input; + float m_divider; public: PreviewOperation(); @@ -46,7 +46,7 @@ public: void executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers); void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]); - void setbNode(bNode *node) { this->node = node; } + void setbNode(bNode *node) { this->m_node = node; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); bool isPreviewOperation() { return true; } diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp index b337e435df4..50bac63d6f2 100644 --- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp +++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp @@ -30,19 +30,19 @@ ProjectorLensDistortionOperation::ProjectorLensDistortionOperation() : NodeOpera this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); this->setComplex(true); - this->inputProgram = NULL; - this->dispersionAvailable = false; - this->dispersion = 0.0f; + this->m_inputProgram = NULL; + this->m_dispersionAvailable = false; + this->m_dispersion = 0.0f; } void ProjectorLensDistortionOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void *ProjectorLensDistortionOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { updateDispersion(memoryBuffers); - void *buffer = inputProgram->initializeTileData(NULL, memoryBuffers); + void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers); return buffer; } @@ -54,45 +54,45 @@ void ProjectorLensDistortionOperation::executePixel(float *color, int x, int y, const float v = (y + 0.5f) / height; const float u = (x + 0.5f) / width; MemoryBuffer *inputBuffer = (MemoryBuffer *)data; - inputBuffer->readCubic(inputValue, (u * width + kr2) - 0.5f, v * height - 0.5f); + inputBuffer->readCubic(inputValue, (u * width + this->m_kr2) - 0.5f, v * height - 0.5f); color[0] = inputValue[0]; inputBuffer->read(inputValue, x, y); color[1] = inputValue[1]; - inputBuffer->readCubic(inputValue, (u * width - kr2) - 0.5f, v * height - 0.5f); + inputBuffer->readCubic(inputValue, (u * width - this->m_kr2) - 0.5f, v * height - 0.5f); color[2] = inputValue[2]; color[3] = 1.0f; } void ProjectorLensDistortionOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } bool ProjectorLensDistortionOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { rcti newInput; - if (dispersionAvailable) { + if (this->m_dispersionAvailable) { newInput.ymax = input->ymax; newInput.ymin = input->ymin; - newInput.xmin = input->xmin - kr2 - 2; - newInput.xmax = input->xmax + kr2 + 2; + newInput.xmin = input->xmin - this->m_kr2 - 2; + newInput.xmax = input->xmax + this->m_kr2 + 2; } else { newInput.xmin = 0; newInput.ymin = input->ymin; newInput.ymax = input->ymax; - newInput.xmax = inputProgram->getWidth(); + newInput.xmax = this->m_inputProgram->getWidth(); } return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } void ProjectorLensDistortionOperation::updateDispersion(MemoryBuffer **inputBuffers) { - if (!dispersionAvailable) { + if (!this->m_dispersionAvailable) { float result[4]; this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, inputBuffers); - dispersion = result[0]; - kr = 0.25f * MAX2(MIN2(this->dispersion, 1.f), 0.f); - kr2 = kr * 20; - dispersionAvailable = true; + this->m_dispersion = result[0]; + this->m_kr = 0.25f * MAX2(MIN2(this->m_dispersion, 1.f), 0.f); + this->m_kr2 = this->m_kr * 20; + this->m_dispersionAvailable = true; } } diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h index 5023a5df507..f992b22f300 100644 --- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h +++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h @@ -30,14 +30,14 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; - NodeLensDist *data; + NodeLensDist *m_data; - float dispersion; - bool dispersionAvailable; + float m_dispersion; + bool m_dispersionAvailable; - float kr, kr2; + float m_kr, m_kr2; public: ProjectorLensDistortionOperation(); @@ -57,7 +57,7 @@ public: */ void deinitExecution(); - void setData(NodeLensDist *data) { this->data = data; } + void setData(NodeLensDist *data) { this->m_data = data; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); diff --git a/source/blender/compositor/operations/COM_QualityStepHelper.cpp b/source/blender/compositor/operations/COM_QualityStepHelper.cpp index 18b3b106138..d99d6f28eff 100644 --- a/source/blender/compositor/operations/COM_QualityStepHelper.cpp +++ b/source/blender/compositor/operations/COM_QualityStepHelper.cpp @@ -24,45 +24,45 @@ QualityStepHelper::QualityStepHelper() { - this->quality = COM_QUALITY_HIGH; - this->step = 1; - this->offsetadd = 4; + this->m_quality = COM_QUALITY_HIGH; + this->m_step = 1; + this->m_offsetadd = 4; } void QualityStepHelper::initExecution(QualityHelper helper) { switch (helper) { case COM_QH_INCREASE: - switch (this->quality) { + switch (this->m_quality) { case COM_QUALITY_HIGH: default: - this->step = 1; - this->offsetadd = 4; + this->m_step = 1; + this->m_offsetadd = 4; break; case COM_QUALITY_MEDIUM: - this->step = 2; - this->offsetadd = 8; + this->m_step = 2; + this->m_offsetadd = 8; break; case COM_QUALITY_LOW: - this->step = 3; - this->offsetadd = 12; + this->m_step = 3; + this->m_offsetadd = 12; break; } break; case COM_QH_MULTIPLY: - switch (this->quality) { + switch (this->m_quality) { case COM_QUALITY_HIGH: default: - this->step = 1; - this->offsetadd = 4; + this->m_step = 1; + this->m_offsetadd = 4; break; case COM_QUALITY_MEDIUM: - this->step = 2; - this->offsetadd = 8; + this->m_step = 2; + this->m_offsetadd = 8; break; case COM_QUALITY_LOW: - this->step = 4; - this->offsetadd = 16; + this->m_step = 4; + this->m_offsetadd = 16; break; } break; diff --git a/source/blender/compositor/operations/COM_QualityStepHelper.h b/source/blender/compositor/operations/COM_QualityStepHelper.h index aef80e22e38..34e2ba1b47c 100644 --- a/source/blender/compositor/operations/COM_QualityStepHelper.h +++ b/source/blender/compositor/operations/COM_QualityStepHelper.h @@ -31,9 +31,9 @@ typedef enum QualityHelper { class QualityStepHelper { private: - CompositorQuality quality; - int step; - int offsetadd; + CompositorQuality m_quality; + int m_step; + int m_offsetadd; protected: /** @@ -41,13 +41,13 @@ protected: */ void initExecution(QualityHelper helper); - inline int getStep() const { return this->step; } - inline int getOffsetAdd() const { return this->offsetadd; } + inline int getStep() const { return this->m_step; } + inline int getOffsetAdd() const { return this->m_offsetadd; } public: QualityStepHelper(); - void setQuality(CompositorQuality quality) { this->quality = quality; } + void setQuality(CompositorQuality quality) { this->m_quality = quality; } }; #endif diff --git a/source/blender/compositor/operations/COM_ReadBufferOperation.cpp b/source/blender/compositor/operations/COM_ReadBufferOperation.cpp index 857131950dd..76e6921503e 100644 --- a/source/blender/compositor/operations/COM_ReadBufferOperation.cpp +++ b/source/blender/compositor/operations/COM_ReadBufferOperation.cpp @@ -27,7 +27,7 @@ ReadBufferOperation::ReadBufferOperation() : NodeOperation() { this->addOutputSocket(COM_DT_COLOR); - this->offset = 0; + this->m_offset = 0; } void *ReadBufferOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) @@ -37,19 +37,21 @@ void *ReadBufferOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryB void ReadBufferOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) { - if (this->memoryProxy != NULL) { - WriteBufferOperation *operation = memoryProxy->getWriteBufferOperation(); + if (this->m_memoryProxy != NULL) { + WriteBufferOperation *operation = this->m_memoryProxy->getWriteBufferOperation(); operation->determineResolution(resolution, preferredResolution); operation->setResolution(resolution); /// @todo: may not occur!, but does with blur node - if (memoryProxy->getExecutor()) memoryProxy->getExecutor()->setResolution(resolution); + if (this->m_memoryProxy->getExecutor()) { + this->m_memoryProxy->getExecutor()->setResolution(resolution); + } } } void ReadBufferOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { if (inputBuffers) { - MemoryBuffer *inputBuffer = inputBuffers[this->offset]; + MemoryBuffer *inputBuffer = inputBuffers[this->m_offset]; if (inputBuffer) { if (sampler == COM_PS_NEAREST) { inputBuffer->read(color, x, y); @@ -68,7 +70,7 @@ void ReadBufferOperation::executePixel(float *color, float x, float y, PixelSamp void ReadBufferOperation::executePixel(float *color, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) { - MemoryBuffer *inputBuffer = inputBuffers[this->offset]; + MemoryBuffer *inputBuffer = inputBuffers[this->m_offset]; if (inputBuffer) { inputBuffer->readEWA(color, x, y, dx, dy); } @@ -85,8 +87,8 @@ bool ReadBufferOperation::determineDependingAreaOfInterest(rcti *input, ReadBuff void ReadBufferOperation::readResolutionFromWriteBuffer() { - if (this->memoryProxy != NULL) { - WriteBufferOperation *operation = memoryProxy->getWriteBufferOperation(); + if (this->m_memoryProxy != NULL) { + WriteBufferOperation *operation = this->m_memoryProxy->getWriteBufferOperation(); this->setWidth(operation->getWidth()); this->setHeight(operation->getHeight()); } diff --git a/source/blender/compositor/operations/COM_ReadBufferOperation.h b/source/blender/compositor/operations/COM_ReadBufferOperation.h index 576aa194bc5..de0c69c0ecc 100644 --- a/source/blender/compositor/operations/COM_ReadBufferOperation.h +++ b/source/blender/compositor/operations/COM_ReadBufferOperation.h @@ -28,23 +28,23 @@ class ReadBufferOperation : public NodeOperation { private: - MemoryProxy *memoryProxy; - unsigned int offset; + MemoryProxy *m_memoryProxy; + unsigned int m_offset; public: ReadBufferOperation(); int isBufferOperation() { return true; } - void setMemoryProxy(MemoryProxy *memoryProxy) { this->memoryProxy = memoryProxy; } - MemoryProxy *getMemoryProxy() { return this->memoryProxy; } + void setMemoryProxy(MemoryProxy *memoryProxy) { this->m_memoryProxy = memoryProxy; } + MemoryProxy *getMemoryProxy() { return this->m_memoryProxy; } void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]); void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers); void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); void executePixel(float *color, float x, float y, float dx, float dy, MemoryBuffer * inputBuffers[]); const bool isReadBufferOperation() const { return true; } - void setOffset(unsigned int offset) { this->offset = offset; } - unsigned int getOffset() { return this->offset; } + void setOffset(unsigned int offset) { this->m_offset = offset; } + unsigned int getOffset() { return this->m_offset; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); - MemoryBuffer *getInputMemoryBuffer(MemoryBuffer **memoryBuffers) { return memoryBuffers[offset]; } + MemoryBuffer *getInputMemoryBuffer(MemoryBuffer **memoryBuffers) { return memoryBuffers[this->m_offset]; } void readResolutionFromWriteBuffer(); }; diff --git a/source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp b/source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp index f27af3c25f5..e4543c06d9b 100644 --- a/source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp +++ b/source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp @@ -33,10 +33,10 @@ extern "C" { RenderLayersBaseProg::RenderLayersBaseProg(int renderpass, int elementsize) : NodeOperation() { - this->renderpass = renderpass; + this->m_renderpass = renderpass; this->setScene(NULL); - this->inputBuffer = NULL; - this->elementsize = elementsize; + this->m_inputBuffer = NULL; + this->m_elementsize = elementsize; } @@ -55,10 +55,10 @@ void RenderLayersBaseProg::initExecution() RenderLayer *rl = RE_GetRenderLayer(rr, srl->name); if (rl && rl->rectf) { - this->inputBuffer = RE_RenderLayerGetPass(rl, renderpass); + this->m_inputBuffer = RE_RenderLayerGetPass(rl, this->m_renderpass); - if (this->inputBuffer == NULL || renderpass == SCE_PASS_COMBINED) { - this->inputBuffer = rl->rectf; + if (this->m_inputBuffer == NULL || this->m_renderpass == SCE_PASS_COMBINED) { + this->m_inputBuffer = rl->rectf; } } } @@ -74,38 +74,30 @@ void RenderLayersBaseProg::executePixel(float *output, float x, float y, PixelSa int ix = x; int iy = y; - if (inputBuffer == NULL || ix < 0 || iy < 0 || ix >= (int)this->getWidth() || iy >= (int)this->getHeight() ) { - output[0] = 0.0f; - output[1] = 0.0f; - output[2] = 0.0f; - output[3] = 0.0f; + if (this->m_inputBuffer == NULL || ix < 0 || iy < 0 || ix >= (int)this->getWidth() || iy >= (int)this->getHeight() ) { + zero_v4(output); } else { - unsigned int offset = (iy * this->getWidth() + ix) * elementsize; - if (elementsize == 1) { - output[0] = inputBuffer[offset]; + unsigned int offset = (iy * this->getWidth() + ix) * this->m_elementsize; + if (this->m_elementsize == 1) { + output[0] = this->m_inputBuffer[offset]; output[1] = 0.0f; output[2] = 0.0f; output[3] = 0.0f; } - else if (elementsize == 3) { - output[0] = inputBuffer[offset]; - output[1] = inputBuffer[offset + 1]; - output[2] = inputBuffer[offset + 2]; + else if (this->m_elementsize == 3) { + copy_v3_v3(output, &this->m_inputBuffer[offset]); output[3] = 1.0f; } else { - output[0] = inputBuffer[offset]; - output[1] = inputBuffer[offset + 1]; - output[2] = inputBuffer[offset + 2]; - output[3] = inputBuffer[offset + 3]; + copy_v4_v4(output, &this->m_inputBuffer[offset]); } } } void RenderLayersBaseProg::deinitExecution() { - this->inputBuffer = NULL; + this->m_inputBuffer = NULL; } void RenderLayersBaseProg::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) diff --git a/source/blender/compositor/operations/COM_RenderLayersBaseProg.h b/source/blender/compositor/operations/COM_RenderLayersBaseProg.h index ce2b8f767b6..a18b515bd7b 100644 --- a/source/blender/compositor/operations/COM_RenderLayersBaseProg.h +++ b/source/blender/compositor/operations/COM_RenderLayersBaseProg.h @@ -45,24 +45,24 @@ private: /** * Reference to the scene object. */ - Scene *scene; + Scene *m_scene; /** * layerId of the layer where this operation needs to get its data from */ - short layerId; + short m_layerId; /** * cached instance to the float buffer inside the layer */ - float *inputBuffer; + float *m_inputBuffer; /** * renderpass where this operation needs to get its data from */ - int renderpass; + int m_renderpass; - int elementsize; + int m_elementsize; protected: /** @@ -78,7 +78,7 @@ protected: /** * retrieve the reference to the float buffer of the renderer. */ - inline float *getInputBuffer() { return this->inputBuffer; } + inline float *getInputBuffer() { return this->m_inputBuffer; } public: /** @@ -86,10 +86,10 @@ public: * @see RenderLayerNode to set the actual scene where * the data will be retrieved from. */ - void setScene(Scene *scene) { this->scene = scene; } - Scene *getScene() { return this->scene; } - void setLayerId(short layerId) { this->layerId = layerId; } - short getLayerId() { return this->layerId; } + void setScene(Scene *scene) { this->m_scene = scene; } + Scene *getScene() { return this->m_scene; } + void setLayerId(short layerId) { this->m_layerId = layerId; } + short getLayerId() { return this->m_layerId; } void initExecution(); void deinitExecution(); void executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]); diff --git a/source/blender/compositor/operations/COM_RenderLayersMistOperation.h b/source/blender/compositor/operations/COM_RenderLayersMistOperation.h index 8c0ee9bfcab..ad838c9e340 100644 --- a/source/blender/compositor/operations/COM_RenderLayersMistOperation.h +++ b/source/blender/compositor/operations/COM_RenderLayersMistOperation.h @@ -1,3 +1,25 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor: + * Jeroen Bakker + * Monique Dewanchand + */ + #ifndef _COM_RenderLayersMistOperation_h #define _COM_RenderLayersMistOperation_h diff --git a/source/blender/compositor/operations/COM_RotateOperation.cpp b/source/blender/compositor/operations/COM_RotateOperation.cpp index 456dc5d1d0f..086ce917e7e 100644 --- a/source/blender/compositor/operations/COM_RotateOperation.cpp +++ b/source/blender/compositor/operations/COM_RotateOperation.cpp @@ -29,41 +29,41 @@ RotateOperation::RotateOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->imageSocket = NULL; - this->degreeSocket = NULL; - this->doDegree2RadConversion = false; - this->isDegreeSet = false; + this->m_imageSocket = NULL; + this->m_degreeSocket = NULL; + this->m_doDegree2RadConversion = false; + this->m_isDegreeSet = false; } void RotateOperation::initExecution() { - this->imageSocket = this->getInputSocketReader(0); - this->degreeSocket = this->getInputSocketReader(1); - this->centerX = this->getWidth() / 2.0; - this->centerY = this->getHeight() / 2.0; + this->m_imageSocket = this->getInputSocketReader(0); + this->m_degreeSocket = this->getInputSocketReader(1); + this->m_centerX = this->getWidth() / 2.0; + this->m_centerY = this->getHeight() / 2.0; } void RotateOperation::deinitExecution() { - this->imageSocket = NULL; - this->degreeSocket = NULL; + this->m_imageSocket = NULL; + this->m_degreeSocket = NULL; } inline void RotateOperation::ensureDegree() { - if (!isDegreeSet) { + if (!this->m_isDegreeSet) { float degree[4]; - this->degreeSocket->read(degree, 0, 0, COM_PS_NEAREST, NULL); + this->m_degreeSocket->read(degree, 0, 0, COM_PS_NEAREST, NULL); double rad; - if (this->doDegree2RadConversion) { + if (this->m_doDegree2RadConversion) { rad = DEG2RAD((double)degree[0]); } else { rad = degree[0]; } - this->cosine = cos(rad); - this->sine = sin(rad); + this->m_cosine = cos(rad); + this->m_sine = sin(rad); - isDegreeSet = true; + this->m_isDegreeSet = true; } } @@ -71,11 +71,11 @@ inline void RotateOperation::ensureDegree() void RotateOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { ensureDegree(); - const float dy = y - this->centerY; - const float dx = x - this->centerX; - const float nx = this->centerX + (this->cosine * dx + this->sine * dy); - const float ny = this->centerY + (-this->sine * dx + this->cosine * dy); - this->imageSocket->read(color, nx, ny, sampler, inputBuffers); + const float dy = y - this->m_centerY; + const float dx = x - this->m_centerX; + const float nx = this->m_centerX + (this->m_cosine * dx + this->m_sine * dy); + const float ny = this->m_centerY + (-this->m_sine * dx + this->m_cosine * dy); + this->m_imageSocket->read(color, nx, ny, sampler, inputBuffers); } bool RotateOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) @@ -83,19 +83,19 @@ bool RotateOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOp ensureDegree(); rcti newInput; - const float dxmin = input->xmin - this->centerX; - const float dymin = input->ymin - this->centerY; - const float dxmax = input->xmax - this->centerX; - const float dymax = input->ymax - this->centerY; + const float dxmin = input->xmin - this->m_centerX; + const float dymin = input->ymin - this->m_centerY; + const float dxmax = input->xmax - this->m_centerX; + const float dymax = input->ymax - this->m_centerY; - const float x1 = this->centerX + (this->cosine * dxmin + this->sine * dymin); - const float x2 = this->centerX + (this->cosine * dxmax + this->sine * dymin); - const float x3 = this->centerX + (this->cosine * dxmin + this->sine * dymax); - const float x4 = this->centerX + (this->cosine * dxmax + this->sine * dymax); - const float y1 = this->centerY + (-this->sine * dxmin + this->cosine * dymin); - const float y2 = this->centerY + (-this->sine * dxmax + this->cosine * dymin); - const float y3 = this->centerY + (-this->sine * dxmin + this->cosine * dymax); - const float y4 = this->centerY + (-this->sine * dxmax + this->cosine * dymax); + const float x1 = this->m_centerX + (this->m_cosine * dxmin + this->m_sine * dymin); + const float x2 = this->m_centerX + (this->m_cosine * dxmax + this->m_sine * dymin); + const float x3 = this->m_centerX + (this->m_cosine * dxmin + this->m_sine * dymax); + const float x4 = this->m_centerX + (this->m_cosine * dxmax + this->m_sine * dymax); + const float y1 = this->m_centerY + (-this->m_sine * dxmin + this->m_cosine * dymin); + const float y2 = this->m_centerY + (-this->m_sine * dxmax + this->m_cosine * dymin); + const float y3 = this->m_centerY + (-this->m_sine * dxmin + this->m_cosine * dymax); + const float y4 = this->m_centerY + (-this->m_sine * dxmax + this->m_cosine * dymax); const float minx = min(x1, min(x2, min(x3, x4))); const float maxx = max(x1, max(x2, max(x3, x4))); const float miny = min(y1, min(y2, min(y3, y4))); diff --git a/source/blender/compositor/operations/COM_RotateOperation.h b/source/blender/compositor/operations/COM_RotateOperation.h index bf7355da80e..9e6dd3987d1 100644 --- a/source/blender/compositor/operations/COM_RotateOperation.h +++ b/source/blender/compositor/operations/COM_RotateOperation.h @@ -27,21 +27,21 @@ class RotateOperation : public NodeOperation { private: - SocketReader *imageSocket; - SocketReader *degreeSocket; - float centerX; - float centerY; - float cosine; - float sine; - bool doDegree2RadConversion; - bool isDegreeSet; + SocketReader *m_imageSocket; + SocketReader *m_degreeSocket; + float m_centerX; + float m_centerY; + float m_cosine; + float m_sine; + bool m_doDegree2RadConversion; + bool m_isDegreeSet; public: RotateOperation(); bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); void initExecution(); void deinitExecution(); - void setDoDegree2RadConversion(bool abool) { this->doDegree2RadConversion = abool; } + void setDoDegree2RadConversion(bool abool) { this->m_doDegree2RadConversion = abool; } void ensureDegree(); }; diff --git a/source/blender/compositor/operations/COM_ScaleOperation.cpp b/source/blender/compositor/operations/COM_ScaleOperation.cpp index 31135d4c40e..6a1f7b62203 100644 --- a/source/blender/compositor/operations/COM_ScaleOperation.cpp +++ b/source/blender/compositor/operations/COM_ScaleOperation.cpp @@ -33,24 +33,24 @@ ScaleOperation::ScaleOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->inputOperation = NULL; - this->inputXOperation = NULL; - this->inputYOperation = NULL; + this->m_inputOperation = NULL; + this->m_inputXOperation = NULL; + this->m_inputYOperation = NULL; } void ScaleOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); - this->inputXOperation = this->getInputSocketReader(1); - this->inputYOperation = this->getInputSocketReader(2); - this->centerX = this->getWidth() / 2.0; - this->centerY = this->getHeight() / 2.0; + this->m_inputOperation = this->getInputSocketReader(0); + this->m_inputXOperation = this->getInputSocketReader(1); + this->m_inputYOperation = this->getInputSocketReader(2); + this->m_centerX = this->getWidth() / 2.0; + this->m_centerY = this->getHeight() / 2.0; } void ScaleOperation::deinitExecution() { - this->inputOperation = NULL; - this->inputXOperation = NULL; - this->inputYOperation = NULL; + this->m_inputOperation = NULL; + this->m_inputXOperation = NULL; + this->m_inputYOperation = NULL; } @@ -63,15 +63,15 @@ void ScaleOperation::executePixel(float *color, float x, float y, PixelSampler s float scaleX[4]; float scaleY[4]; - this->inputXOperation->read(scaleX, x, y, sampler, inputBuffers); - this->inputYOperation->read(scaleY, x, y, sampler, inputBuffers); + this->m_inputXOperation->read(scaleX, x, y, sampler, inputBuffers); + this->m_inputYOperation->read(scaleY, x, y, sampler, inputBuffers); const float scx = scaleX[0]; const float scy = scaleY[0]; - float nx = this->centerX + (x - this->centerX) / scx; - float ny = this->centerY + (y - this->centerY) / scy; - this->inputOperation->read(color, nx, ny, sampler, inputBuffers); + float nx = this->m_centerX + (x - this->m_centerX) / scx; + float ny = this->m_centerY + (y - this->m_centerY) / scy; + this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers); } bool ScaleOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) @@ -80,16 +80,16 @@ bool ScaleOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOpe float scaleX[4]; float scaleY[4]; - this->inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST, NULL); - this->inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST, NULL); + this->m_inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST, NULL); + this->m_inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST, NULL); const float scx = scaleX[0]; const float scy = scaleY[0]; - newInput.xmax = this->centerX + (input->xmax - this->centerX) / scx; - newInput.xmin = this->centerX + (input->xmin - this->centerX) / scx; - newInput.ymax = this->centerY + (input->ymax - this->centerY) / scy; - newInput.ymin = this->centerY + (input->ymin - this->centerY) / scy; + newInput.xmax = this->m_centerX + (input->xmax - this->m_centerX) / scx; + newInput.xmin = this->m_centerX + (input->xmin - this->m_centerX) / scx; + newInput.ymax = this->m_centerY + (input->ymax - this->m_centerY) / scy; + newInput.ymin = this->m_centerY + (input->ymin - this->m_centerY) / scy; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -103,24 +103,24 @@ ScaleAbsoluteOperation::ScaleAbsoluteOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->inputOperation = NULL; - this->inputXOperation = NULL; - this->inputYOperation = NULL; + this->m_inputOperation = NULL; + this->m_inputXOperation = NULL; + this->m_inputYOperation = NULL; } void ScaleAbsoluteOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); - this->inputXOperation = this->getInputSocketReader(1); - this->inputYOperation = this->getInputSocketReader(2); - this->centerX = this->getWidth() / 2.0; - this->centerY = this->getHeight() / 2.0; + this->m_inputOperation = this->getInputSocketReader(0); + this->m_inputXOperation = this->getInputSocketReader(1); + this->m_inputYOperation = this->getInputSocketReader(2); + this->m_centerX = this->getWidth() / 2.0; + this->m_centerY = this->getHeight() / 2.0; } void ScaleAbsoluteOperation::deinitExecution() { - this->inputOperation = NULL; - this->inputXOperation = NULL; - this->inputYOperation = NULL; + this->m_inputOperation = NULL; + this->m_inputXOperation = NULL; + this->m_inputYOperation = NULL; } @@ -133,8 +133,8 @@ void ScaleAbsoluteOperation::executePixel(float *color, float x, float y, PixelS float scaleX[4]; float scaleY[4]; - this->inputXOperation->read(scaleX, x, y, sampler, inputBuffers); - this->inputYOperation->read(scaleY, x, y, sampler, inputBuffers); + this->m_inputXOperation->read(scaleX, x, y, sampler, inputBuffers); + this->m_inputYOperation->read(scaleY, x, y, sampler, inputBuffers); const float scx = scaleX[0]; // target absolute scale const float scy = scaleY[0]; // target absolute scale @@ -145,10 +145,10 @@ void ScaleAbsoluteOperation::executePixel(float *color, float x, float y, PixelS float relativeXScale = scx / width; float relativeYScale = scy / height; - float nx = this->centerX + (x - this->centerX) / relativeXScale; - float ny = this->centerY + (y - this->centerY) / relativeYScale; + float nx = this->m_centerX + (x - this->m_centerX) / relativeXScale; + float ny = this->m_centerY + (y - this->m_centerY) / relativeYScale; - this->inputOperation->read(color, nx, ny, sampler, inputBuffers); + this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers); } bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) @@ -157,8 +157,8 @@ bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, ReadB float scaleX[4]; float scaleY[4]; - this->inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST, NULL); - this->inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST, NULL); + this->m_inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST, NULL); + this->m_inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST, NULL); const float scx = scaleX[0]; const float scy = scaleY[0]; @@ -168,10 +168,10 @@ bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, ReadB float relateveXScale = scx / width; float relateveYScale = scy / height; - newInput.xmax = this->centerX + (input->xmax - this->centerX) / relateveXScale; - newInput.xmin = this->centerX + (input->xmin - this->centerX) / relateveXScale; - newInput.ymax = this->centerY + (input->ymax - this->centerY) / relateveYScale; - newInput.ymin = this->centerY + (input->ymin - this->centerY) / relateveYScale; + newInput.xmax = this->m_centerX + (input->xmax - this->m_centerX) / relateveXScale; + newInput.xmin = this->m_centerX + (input->xmin - this->m_centerX) / relateveXScale; + newInput.ymax = this->m_centerY + (input->ymax - this->m_centerY) / relateveYScale; + newInput.ymin = this->m_centerY + (input->ymin - this->m_centerY) / relateveYScale; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -183,56 +183,56 @@ ScaleFixedSizeOperation::ScaleFixedSizeOperation() : NodeOperation() this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void ScaleFixedSizeOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); - this->relX = inputOperation->getWidth() / (float)this->newWidth; - this->relY = inputOperation->getHeight() / (float)this->newHeight; + this->m_inputOperation = this->getInputSocketReader(0); + this->m_relX = this->m_inputOperation->getWidth() / (float)this->m_newWidth; + this->m_relY = this->m_inputOperation->getHeight() / (float)this->m_newHeight; /* *** all the options below are for a fairly special case - camera framing *** */ - if (this->offsetX != 0.0f || this->offsetY != 0.0f) { - this->is_offset = true; + if (this->m_offsetX != 0.0f || this->m_offsetY != 0.0f) { + this->m_is_offset = true; - if (this->newWidth > this->newHeight) { - this->offsetX *= this->newWidth; - this->offsetY *= this->newWidth; + if (this->m_newWidth > this->m_newHeight) { + this->m_offsetX *= this->m_newWidth; + this->m_offsetY *= this->m_newWidth; } else { - this->offsetX *= this->newHeight; - this->offsetY *= this->newHeight; + this->m_offsetX *= this->m_newHeight; + this->m_offsetY *= this->m_newHeight; } } - if (this->is_aspect) { + if (this->m_is_aspect) { /* apply aspect from clip */ - const float w_src = inputOperation->getWidth(); - const float h_src = inputOperation->getHeight(); + const float w_src = this->m_inputOperation->getWidth(); + const float h_src = this->m_inputOperation->getHeight(); /* destination aspect is already applied from the camera frame */ - const float w_dst = this->newWidth; - const float h_dst = this->newHeight; + const float w_dst = this->m_newWidth; + const float h_dst = this->m_newHeight; const float asp_src = w_src / h_src; const float asp_dst = w_dst / h_dst; if (fabsf(asp_src - asp_dst) >= FLT_EPSILON) { - if ((asp_src > asp_dst) == (this->is_crop == true)) { + if ((asp_src > asp_dst) == (this->m_is_crop == true)) { /* fit X */ const float div = asp_src / asp_dst; - this->relX /= div; - this->offsetX += ((w_src - (w_src * div)) / (w_src / w_dst)) / 2.0f; + this->m_relX /= div; + this->m_offsetX += ((w_src - (w_src * div)) / (w_src / w_dst)) / 2.0f; } else { /* fit Y */ const float div = asp_dst / asp_src; - this->relY /= div; - this->offsetY += ((h_src - (h_src * div)) / (h_src / h_dst)) / 2.0f; + this->m_relY /= div; + this->m_offsetY += ((h_src - (h_src * div)) / (h_src / h_dst)) / 2.0f; } - this->is_offset = true; + this->m_is_offset = true; } } /* *** end framing options *** */ @@ -240,7 +240,7 @@ void ScaleFixedSizeOperation::initExecution() void ScaleFixedSizeOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } @@ -250,13 +250,13 @@ void ScaleFixedSizeOperation::executePixel(float *color, float x, float y, Pixel sampler = COM_PS_BICUBIC; #endif - if (this->is_offset) { - float nx = ((x - this->offsetX) * relX); - float ny = ((y - this->offsetY) * relY); - this->inputOperation->read(color, nx, ny, sampler, inputBuffers); + if (this->m_is_offset) { + float nx = ((x - this->m_offsetX) * this->m_relX); + float ny = ((y - this->m_offsetY) * this->m_relY); + this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers); } else { - this->inputOperation->read(color, x * relX, y * relY, sampler, inputBuffers); + this->m_inputOperation->read(color, x * this->m_relX, y * this->m_relY, sampler, inputBuffers); } } @@ -264,10 +264,10 @@ bool ScaleFixedSizeOperation::determineDependingAreaOfInterest(rcti *input, Read { rcti newInput; - newInput.xmax = input->xmax * relX; - newInput.xmin = input->xmin * relX; - newInput.ymax = input->ymax * relY; - newInput.ymin = input->ymin * relY; + newInput.xmax = input->xmax * this->m_relX; + newInput.xmin = input->xmin * this->m_relX; + newInput.ymax = input->ymax * this->m_relY; + newInput.ymin = input->ymin * this->m_relY; return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } @@ -275,9 +275,9 @@ bool ScaleFixedSizeOperation::determineDependingAreaOfInterest(rcti *input, Read void ScaleFixedSizeOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) { unsigned int nr[2]; - nr[0] = newWidth; - nr[1] = newHeight; + nr[0] = this->m_newWidth; + nr[1] = this->m_newHeight; NodeOperation::determineResolution(resolution, nr); - resolution[0] = newWidth; - resolution[1] = newHeight; + resolution[0] = this->m_newWidth; + resolution[1] = this->m_newHeight; } diff --git a/source/blender/compositor/operations/COM_ScaleOperation.h b/source/blender/compositor/operations/COM_ScaleOperation.h index 7089f6c10a4..8cd44810bbd 100644 --- a/source/blender/compositor/operations/COM_ScaleOperation.h +++ b/source/blender/compositor/operations/COM_ScaleOperation.h @@ -27,11 +27,11 @@ class ScaleOperation : public NodeOperation { private: - SocketReader *inputOperation; - SocketReader *inputXOperation; - SocketReader *inputYOperation; - float centerX; - float centerY; + SocketReader *m_inputOperation; + SocketReader *m_inputXOperation; + SocketReader *m_inputYOperation; + float m_centerX; + float m_centerY; public: ScaleOperation(); bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); @@ -42,11 +42,11 @@ public: }; class ScaleAbsoluteOperation : public NodeOperation { - SocketReader *inputOperation; - SocketReader *inputXOperation; - SocketReader *inputYOperation; - float centerX; - float centerY; + SocketReader *m_inputOperation; + SocketReader *m_inputXOperation; + SocketReader *m_inputYOperation; + float m_centerX; + float m_centerY; public: ScaleAbsoluteOperation(); @@ -58,20 +58,20 @@ public: }; class ScaleFixedSizeOperation : public NodeOperation { - SocketReader *inputOperation; - int newWidth; - int newHeight; - float relX; - float relY; + SocketReader *m_inputOperation; + int m_newWidth; + int m_newHeight; + float m_relX; + float m_relY; /* center is only used for aspect correction */ - float offsetX; - float offsetY; - bool is_aspect; - bool is_crop; + float m_offsetX; + float m_offsetY; + bool m_is_aspect; + bool m_is_crop; /* set from other properties on initialization, * check if we need to apply offset */ - bool is_offset; + bool m_is_offset; public: ScaleFixedSizeOperation(); bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); @@ -80,11 +80,11 @@ public: void initExecution(); void deinitExecution(); - void setNewWidth(int width) { this->newWidth = width; } - void setNewHeight(int height) { this->newHeight = height; } - void setIsAspect(bool is_aspect) { this->is_aspect = is_aspect; } - void setIsCrop(bool is_crop) { this->is_crop = is_crop; } - void setOffset(float x, float y) { this->offsetX = x; this->offsetY = y; } + void setNewWidth(int width) { this->m_newWidth = width; } + void setNewHeight(int height) { this->m_newHeight = height; } + void setIsAspect(bool is_aspect) { this->m_is_aspect = is_aspect; } + void setIsCrop(bool is_crop) { this->m_is_crop = is_crop; } + void setOffset(float x, float y) { this->m_offsetX = x; this->m_offsetY = y; } }; #endif diff --git a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp index da3504de971..e3abf2aa70b 100644 --- a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp +++ b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp @@ -34,19 +34,19 @@ ScreenLensDistortionOperation::ScreenLensDistortionOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); this->setComplex(true); - this->inputProgram = NULL; - this->valuesAvailable = false; - this->dispersion = 0.0f; - this->distortion = 0.0f; + this->m_inputProgram = NULL; + this->m_valuesAvailable = false; + this->m_dispersion = 0.0f; + this->m_distortion = 0.0f; } void ScreenLensDistortionOperation::initExecution() { - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void *ScreenLensDistortionOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - void *buffer = inputProgram->initializeTileData(NULL, memoryBuffers); + void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers); updateDispersionAndDistortion(memoryBuffers); return buffer; } @@ -60,29 +60,29 @@ void ScreenLensDistortionOperation::executePixel(float *outputColor, int x, int int dr = 0, dg = 0, db = 0; float d, t, ln[6] = {0, 0, 0, 0, 0, 0}; float tc[4] = {0, 0, 0, 0}; - const float v = sc * ((y + 0.5f) - cy) / cy; - const float u = sc * ((x + 0.5f) - cx) / cx; + const float v = this->m_sc * ((y + 0.5f) - this->m_cy) / this->m_cy; + const float u = this->m_sc * ((x + 0.5f) - this->m_cx) / this->m_cx; const float uv_dot = u * u + v * v; int sta = 0, mid = 0, end = 0; - if ((t = 1.f - kr4 * uv_dot) >= 0.f) { + if ((t = 1.f - this->m_kr4 * uv_dot) >= 0.f) { d = 1.f / (1.f + sqrtf(t)); ln[0] = (u * d + 0.5f) * width - 0.5f, ln[1] = (v * d + 0.5f) * height - 0.5f; sta = 1; } - if ((t = 1.f - kg4 * uv_dot) >= 0.f) { + if ((t = 1.f - this->m_kg4 * uv_dot) >= 0.f) { d = 1.f / (1.f + sqrtf(t)); ln[2] = (u * d + 0.5f) * width - 0.5f, ln[3] = (v * d + 0.5f) * height - 0.5f; mid = 1; } - if ((t = 1.f - kb4 * uv_dot) >= 0.f) { + if ((t = 1.f - this->m_kb4 * uv_dot) >= 0.f) { d = 1.f / (1.f + sqrtf(t)); ln[4] = (u * d + 0.5f) * width - 0.5f, ln[5] = (v * d + 0.5f) * height - 0.5f; end = 1; } if (sta && mid && end) { - float jit = this->data->jit; + float jit = this->m_data->jit; float z; float color[4]; { @@ -94,8 +94,8 @@ void ScreenLensDistortionOperation::executePixel(float *outputColor, int x, int for (z = 0; z < ds; ++z) { const float tz = ((float)z + (jit ? BLI_frand() : 0.5f)) * sd; - t = 1.f - (kr4 + tz * drg) * uv_dot; - d = 1.f / (1.f + sqrtf(t)); + t = 1.0f - (this->m_kr4 + tz * this->m_drg) * uv_dot; + d = 1.0f / (1.f + sqrtf(t)); const float nx = (u * d + 0.5f) * width - 0.5f; const float ny = (v * d + 0.5f) * height - 0.5f; buffer->readCubic(color, nx, ny); @@ -112,7 +112,7 @@ void ScreenLensDistortionOperation::executePixel(float *outputColor, int x, int for (z = 0; z < ds; ++z) { const float tz = ((float)z + (jit ? BLI_frand() : 0.5f)) * sd; - t = 1.f - (kg4 + tz * dgb) * uv_dot; + t = 1.f - (this->m_kg4 + tz * this->m_dgb) * uv_dot; d = 1.f / (1.f + sqrtf(t)); const float nx = (u * d + 0.5f) * width - 0.5f; const float ny = (v * d + 0.5f) * height - 0.5f; @@ -122,9 +122,9 @@ void ScreenLensDistortionOperation::executePixel(float *outputColor, int x, int } } - if (dr) outputColor[0] = 2.f * tc[0] / (float)dr; - if (dg) outputColor[1] = 2.f * tc[1] / (float)dg; - if (db) outputColor[2] = 2.f * tc[2] / (float)db; + if (dr) outputColor[0] = 2.0f * tc[0] / (float)dr; + if (dg) outputColor[1] = 2.0f * tc[1] / (float)dg; + if (db) outputColor[2] = 2.0f * tc[2] / (float)db; /* set alpha */ outputColor[3] = 1.0f; @@ -139,14 +139,14 @@ void ScreenLensDistortionOperation::executePixel(float *outputColor, int x, int void ScreenLensDistortionOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void ScreenLensDistortionOperation::determineUV(float result[2], float x, float y) const { - const float v = sc * ((y + 0.5f) - cy) / cy; - const float u = sc * ((x + 0.5f) - cx) / cx; - const float t = ABS(MIN3(kr, kg, kb) * 4); + const float v = this->m_sc * ((y + 0.5f) - this->m_cy) / this->m_cy; + const float u = this->m_sc * ((x + 0.5f) - this->m_cx) / this->m_cx; + const float t = ABS(MIN3(this->m_kr, this->m_kg, this->m_kb) * 4); float d = 1.f / (1.f + sqrtf(t)); result[0] = (u * d + 0.5f) * getWidth() - 0.5f; result[1] = (v * d + 0.5f) * getHeight() - 0.5f; @@ -157,34 +157,34 @@ bool ScreenLensDistortionOperation::determineDependingAreaOfInterest(rcti *input rcti newInput; newInput.xmin = 0; newInput.ymin = 0; - newInput.ymax = inputProgram->getHeight(); - newInput.xmax = inputProgram->getWidth(); + newInput.ymax = this->m_inputProgram->getHeight(); + newInput.xmax = this->m_inputProgram->getWidth(); return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); } void ScreenLensDistortionOperation::updateDispersionAndDistortion(MemoryBuffer **inputBuffers) { - if (!valuesAvailable) { + if (!this->m_valuesAvailable) { float result[4]; this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, inputBuffers); - this->distortion = result[0]; + this->m_distortion = result[0]; this->getInputSocketReader(2)->read(result, 0, 0, COM_PS_NEAREST, inputBuffers); - this->dispersion = result[0]; - kg = MAX2(MIN2(this->distortion, 1.f), -0.999f); + this->m_dispersion = result[0]; + this->m_kg = MAX2(MIN2(this->m_distortion, 1.f), -0.999f); // smaller dispersion range for somewhat more control - const float d = 0.25f * MAX2(MIN2(this->dispersion, 1.f), 0.f); - kr = MAX2(MIN2((kg + d), 1.f), -0.999f); - kb = MAX2(MIN2((kg - d), 1.f), -0.999f); - maxk = MAX3(kr, kg, kb); - sc = (this->data->fit && (maxk > 0.f)) ? (1.f / (1.f + 2.f * maxk)) : (1.f / (1.f + maxk)); - drg = 4.f * (kg - kr); - dgb = 4.f * (kb - kg); + const float d = 0.25f * MAX2(MIN2(this->m_dispersion, 1.f), 0.f); + this->m_kr = MAX2(MIN2((this->m_kg + d), 1.0f), -0.999f); + this->m_kb = MAX2(MIN2((this->m_kg - d), 1.0f), -0.999f); + this->m_maxk = MAX3(this->m_kr, this->m_kg, this->m_kb); + this->m_sc = (this->m_data->fit && (this->m_maxk > 0.f)) ? (1.f / (1.f + 2.f * this->m_maxk)) : (1.f / (1.f + this->m_maxk)); + this->m_drg = 4.f * (this->m_kg - this->m_kr); + this->m_dgb = 4.f * (this->m_kb - this->m_kg); - kr4 = kr * 4.f; - kg4 = kg * 4.f; - kb4 = kb * 4.f; - cx = 0.5f * (float)getWidth(); - cy = 0.5f * (float)getHeight(); - valuesAvailable = true; + this->m_kr4 = this->m_kr * 4.0f; + this->m_kg4 = this->m_kg * 4.0f; + this->m_kb4 = this->m_kb * 4.0f; + this->m_cx = 0.5f * (float)getWidth(); + this->m_cy = 0.5f * (float)getHeight(); + this->m_valuesAvailable = true; } } diff --git a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h index 21babd11295..d990651dd7d 100644 --- a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h +++ b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h @@ -30,19 +30,19 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; - NodeLensDist *data; + NodeLensDist *m_data; - float dispersion; - float distortion; - bool valuesAvailable; - float kr, kg, kb; - float kr4, kg4, kb4; - float maxk; - float drg; - float dgb; - float sc, cx, cy; + float m_dispersion; + float m_distortion; + bool m_valuesAvailable; + float m_kr, m_kg, m_kb; + float m_kr4, m_kg4, m_kb4; + float m_maxk; + float m_drg; + float m_dgb; + float m_sc, m_cx, m_cy; public: ScreenLensDistortionOperation(); @@ -62,7 +62,7 @@ public: */ void deinitExecution(); - void setData(NodeLensDist *data) { this->data = data; } + void setData(NodeLensDist *data) { this->m_data = data; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); diff --git a/source/blender/compositor/operations/COM_SeparateChannelOperation.cpp b/source/blender/compositor/operations/COM_SeparateChannelOperation.cpp index caa1387da2a..6ae4fc4cfe5 100644 --- a/source/blender/compositor/operations/COM_SeparateChannelOperation.cpp +++ b/source/blender/compositor/operations/COM_SeparateChannelOperation.cpp @@ -26,22 +26,22 @@ SeparateChannelOperation::SeparateChannelOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); this->addOutputSocket(COM_DT_VALUE); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void SeparateChannelOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void SeparateChannelOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void SeparateChannelOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float input[4]; - this->inputOperation->read(input, x, y, sampler, inputBuffers); - color[0] = input[this->channel]; + this->m_inputOperation->read(input, x, y, sampler, inputBuffers); + color[0] = input[this->m_channel]; } diff --git a/source/blender/compositor/operations/COM_SeparateChannelOperation.h b/source/blender/compositor/operations/COM_SeparateChannelOperation.h index b1a38fd8294..65a54f91252 100644 --- a/source/blender/compositor/operations/COM_SeparateChannelOperation.h +++ b/source/blender/compositor/operations/COM_SeparateChannelOperation.h @@ -27,8 +27,8 @@ class SeparateChannelOperation : public NodeOperation { private: - SocketReader *inputOperation; - int channel; + SocketReader *m_inputOperation; + int m_channel; public: SeparateChannelOperation(); void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); @@ -36,7 +36,7 @@ public: void initExecution(); void deinitExecution(); - void setChannel(int channel) { this->channel = channel; } + void setChannel(int channel) { this->m_channel = channel; } }; #endif diff --git a/source/blender/compositor/operations/COM_SetAlphaOperation.cpp b/source/blender/compositor/operations/COM_SetAlphaOperation.cpp index 5924108ed86..d383fb638ae 100644 --- a/source/blender/compositor/operations/COM_SetAlphaOperation.cpp +++ b/source/blender/compositor/operations/COM_SetAlphaOperation.cpp @@ -28,28 +28,28 @@ SetAlphaOperation::SetAlphaOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); - this->inputColor = NULL; - this->inputAlpha = NULL; + this->m_inputColor = NULL; + this->m_inputAlpha = NULL; } void SetAlphaOperation::initExecution() { - this->inputColor = getInputSocketReader(0); - this->inputAlpha = getInputSocketReader(1); + this->m_inputColor = getInputSocketReader(0); + this->m_inputAlpha = getInputSocketReader(1); } void SetAlphaOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { float alphaInput[4]; - this->inputColor->read(outputValue, x, y, sampler, inputBuffers); - this->inputAlpha->read(alphaInput, x, y, sampler, inputBuffers); + this->m_inputColor->read(outputValue, x, y, sampler, inputBuffers); + this->m_inputAlpha->read(alphaInput, x, y, sampler, inputBuffers); outputValue[3] = alphaInput[0]; } void SetAlphaOperation::deinitExecution() { - this->inputColor = NULL; - this->inputAlpha = NULL; + this->m_inputColor = NULL; + this->m_inputAlpha = NULL; } diff --git a/source/blender/compositor/operations/COM_SetAlphaOperation.h b/source/blender/compositor/operations/COM_SetAlphaOperation.h index 231b41f1697..857bd08bfbf 100644 --- a/source/blender/compositor/operations/COM_SetAlphaOperation.h +++ b/source/blender/compositor/operations/COM_SetAlphaOperation.h @@ -31,8 +31,8 @@ */ class SetAlphaOperation : public NodeOperation { private: - SocketReader *inputColor; - SocketReader *inputAlpha; + SocketReader *m_inputColor; + SocketReader *m_inputAlpha; public: /** diff --git a/source/blender/compositor/operations/COM_SetColorOperation.cpp b/source/blender/compositor/operations/COM_SetColorOperation.cpp index 5307d7abc24..55a6a3800ca 100644 --- a/source/blender/compositor/operations/COM_SetColorOperation.cpp +++ b/source/blender/compositor/operations/COM_SetColorOperation.cpp @@ -29,10 +29,10 @@ SetColorOperation::SetColorOperation() : NodeOperation() void SetColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - outputValue[0] = this->channel1; - outputValue[1] = this->channel2; - outputValue[2] = this->channel3; - outputValue[3] = this->channel4; + outputValue[0] = this->m_channel1; + outputValue[1] = this->m_channel2; + outputValue[2] = this->m_channel3; + outputValue[3] = this->m_channel4; } void SetColorOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) diff --git a/source/blender/compositor/operations/COM_SetColorOperation.h b/source/blender/compositor/operations/COM_SetColorOperation.h index 9d28f1757db..abfa2b9538a 100644 --- a/source/blender/compositor/operations/COM_SetColorOperation.h +++ b/source/blender/compositor/operations/COM_SetColorOperation.h @@ -31,10 +31,10 @@ */ class SetColorOperation : public NodeOperation { private: - float channel1; - float channel2; - float channel3; - float channel4; + float m_channel1; + float m_channel2; + float m_channel3; + float m_channel4; public: /** @@ -42,15 +42,21 @@ public: */ SetColorOperation(); - const float getChannel1() {return this->channel1;} - void setChannel1(float value) {this->channel1 = value;} - const float getChannel2() {return this->channel2;} - void setChannel2(float value) {this->channel2 = value;} - const float getChannel3() {return this->channel3;} - void setChannel3(float value) {this->channel3 = value;} - const float getChannel4() {return this->channel4;} - void setChannel4(float value) {this->channel4 = value;} - void setChannels(float value[4]) {this->channel1 = value[0];this->channel2 = value[1];this->channel3 = value[2];this->channel4 = value[3];} + const float getChannel1() { return this->m_channel1; } + void setChannel1(float value) { this->m_channel1 = value; } + const float getChannel2() { return this->m_channel2; } + void setChannel2(float value) { this->m_channel2 = value; } + const float getChannel3() { return this->m_channel3; } + void setChannel3(float value) { this->m_channel3 = value; } + const float getChannel4() { return this->m_channel4; } + void setChannel4(float value) { this->m_channel4 = value; } + void setChannels(float value[4]) + { + this->m_channel1 = value[0]; + this->m_channel2 = value[1]; + this->m_channel3 = value[2]; + this->m_channel4 = value[3]; + } /** * the inner loop of this program diff --git a/source/blender/compositor/operations/COM_SetSamplerOperation.cpp b/source/blender/compositor/operations/COM_SetSamplerOperation.cpp index dfe7fe91bf8..c235bd81e58 100644 --- a/source/blender/compositor/operations/COM_SetSamplerOperation.cpp +++ b/source/blender/compositor/operations/COM_SetSamplerOperation.cpp @@ -30,14 +30,14 @@ SetSamplerOperation::SetSamplerOperation() : NodeOperation() void SetSamplerOperation::initExecution() { - this->reader = this->getInputSocketReader(0); + this->m_reader = this->getInputSocketReader(0); } void SetSamplerOperation::deinitExecution() { - this->reader = NULL; + this->m_reader = NULL; } void SetSamplerOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - reader->read(output, x, y, this->sampler, inputBuffers); + this->m_reader->read(output, x, y, this->m_sampler, inputBuffers); } diff --git a/source/blender/compositor/operations/COM_SetSamplerOperation.h b/source/blender/compositor/operations/COM_SetSamplerOperation.h index 5dba0b3703f..24e0c5e2ef5 100644 --- a/source/blender/compositor/operations/COM_SetSamplerOperation.h +++ b/source/blender/compositor/operations/COM_SetSamplerOperation.h @@ -31,15 +31,15 @@ */ class SetSamplerOperation : public NodeOperation { private: - PixelSampler sampler; - SocketReader *reader; + PixelSampler m_sampler; + SocketReader *m_reader; public: /** * Default constructor */ SetSamplerOperation(); - void setSampler(PixelSampler sampler) { this->sampler = sampler; } + void setSampler(PixelSampler sampler) { this->m_sampler = sampler; } /** * the inner loop of this program diff --git a/source/blender/compositor/operations/COM_SetValueOperation.cpp b/source/blender/compositor/operations/COM_SetValueOperation.cpp index 483fcc97a1f..98a21112c5b 100644 --- a/source/blender/compositor/operations/COM_SetValueOperation.cpp +++ b/source/blender/compositor/operations/COM_SetValueOperation.cpp @@ -29,7 +29,7 @@ SetValueOperation::SetValueOperation() : NodeOperation() void SetValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - outputValue[0] = this->value; + outputValue[0] = this->m_value; } void SetValueOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) diff --git a/source/blender/compositor/operations/COM_SetValueOperation.h b/source/blender/compositor/operations/COM_SetValueOperation.h index 2f4a6ec0dc8..dce0c3299ac 100644 --- a/source/blender/compositor/operations/COM_SetValueOperation.h +++ b/source/blender/compositor/operations/COM_SetValueOperation.h @@ -31,7 +31,7 @@ */ class SetValueOperation : public NodeOperation { private: - float value; + float m_value; public: /** @@ -39,8 +39,8 @@ public: */ SetValueOperation(); - const float getValue() { return this->value; } - void setValue(float value) { this->value = value; } + const float getValue() { return this->m_value; } + void setValue(float value) { this->m_value = value; } /** diff --git a/source/blender/compositor/operations/COM_SetVectorOperation.cpp b/source/blender/compositor/operations/COM_SetVectorOperation.cpp index 3d15a184c4e..f37bc489e75 100644 --- a/source/blender/compositor/operations/COM_SetVectorOperation.cpp +++ b/source/blender/compositor/operations/COM_SetVectorOperation.cpp @@ -30,10 +30,10 @@ SetVectorOperation::SetVectorOperation() : NodeOperation() void SetVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - outputValue[0] = this->x; - outputValue[1] = this->y; - outputValue[2] = this->z; - outputValue[3] = this->w; + outputValue[0] = this->m_x; + outputValue[1] = this->m_y; + outputValue[2] = this->m_z; + outputValue[3] = this->m_w; } void SetVectorOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) diff --git a/source/blender/compositor/operations/COM_SetVectorOperation.h b/source/blender/compositor/operations/COM_SetVectorOperation.h index 49088027762..dc2a05ceff4 100644 --- a/source/blender/compositor/operations/COM_SetVectorOperation.h +++ b/source/blender/compositor/operations/COM_SetVectorOperation.h @@ -31,10 +31,10 @@ */ class SetVectorOperation : public NodeOperation { private: - float x; - float y; - float z; - float w; + float m_x; + float m_y; + float m_z; + float m_w; public: /** @@ -42,14 +42,14 @@ public: */ SetVectorOperation(); - const float getX() { return this->x; } - void setX(float value) { this->x = value; } - const float getY() { return this->y; } - void setY(float value) { this->y = value; } - const float getZ() { return this->z; } - void setZ(float value) { this->z = value; } - const float getW() { return this->w; } - void setW(float value) { this->w = value; } + const float getX() { return this->m_x; } + void setX(float value) { this->m_x = value; } + const float getY() { return this->m_y; } + void setY(float value) { this->m_y = value; } + const float getZ() { return this->m_z; } + void setZ(float value) { this->m_z = value; } + const float getW() { return this->m_w; } + void setW(float value) { this->m_w = value; } /** * the inner loop of this program diff --git a/source/blender/compositor/operations/COM_SocketProxyOperation.cpp b/source/blender/compositor/operations/COM_SocketProxyOperation.cpp index 55c4b68ee57..8b39406fd83 100644 --- a/source/blender/compositor/operations/COM_SocketProxyOperation.cpp +++ b/source/blender/compositor/operations/COM_SocketProxyOperation.cpp @@ -26,22 +26,22 @@ SocketProxyOperation::SocketProxyOperation(DataType type) : NodeOperation() { this->addInputSocket(type); this->addOutputSocket(type); - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void SocketProxyOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); + this->m_inputOperation = this->getInputSocketReader(0); } void SocketProxyOperation::deinitExecution() { - this->inputOperation = NULL; + this->m_inputOperation = NULL; } void SocketProxyOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - if (this->inputOperation) { - this->inputOperation->read(color, x, y, sampler, inputBuffers); + if (this->m_inputOperation) { + this->m_inputOperation->read(color, x, y, sampler, inputBuffers); } } diff --git a/source/blender/compositor/operations/COM_SocketProxyOperation.h b/source/blender/compositor/operations/COM_SocketProxyOperation.h index 5dc8f3d6f8f..a4177efbd8e 100644 --- a/source/blender/compositor/operations/COM_SocketProxyOperation.h +++ b/source/blender/compositor/operations/COM_SocketProxyOperation.h @@ -27,7 +27,7 @@ class SocketProxyOperation : public NodeOperation { private: - SocketReader *inputOperation; + SocketReader *m_inputOperation; public: SocketProxyOperation(DataType type); void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); diff --git a/source/blender/compositor/operations/COM_SplitViewerOperation.cpp b/source/blender/compositor/operations/COM_SplitViewerOperation.cpp index 2735f182406..00f854b2ba9 100644 --- a/source/blender/compositor/operations/COM_SplitViewerOperation.cpp +++ b/source/blender/compositor/operations/COM_SplitViewerOperation.cpp @@ -40,30 +40,30 @@ SplitViewerOperation::SplitViewerOperation() : ViewerBaseOperation() { this->addInputSocket(COM_DT_COLOR); this->addInputSocket(COM_DT_COLOR); - this->image1Input = NULL; - this->image2Input = NULL; + this->m_image1Input = NULL; + this->m_image2Input = NULL; } void SplitViewerOperation::initExecution() { // When initializing the tree during initial load the width and height can be zero. - this->image1Input = getInputSocketReader(0); - this->image2Input = getInputSocketReader(1); + this->m_image1Input = getInputSocketReader(0); + this->m_image2Input = getInputSocketReader(1); ViewerBaseOperation::initExecution(); } void SplitViewerOperation::deinitExecution() { - this->image1Input = NULL; - this->image2Input = NULL; + this->m_image1Input = NULL; + this->m_image2Input = NULL; ViewerBaseOperation::deinitExecution(); } void SplitViewerOperation::executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers) { - float *buffer = this->outputBuffer; - unsigned char *bufferDisplay = this->outputBufferDisplay; + float *buffer = this->m_outputBuffer; + unsigned char *bufferDisplay = this->m_outputBufferDisplay; if (!buffer) return; int x1 = rect->xmin; @@ -73,21 +73,21 @@ void SplitViewerOperation::executeRegion(rcti *rect, unsigned int tileNumber, Me int offset = (y1 * this->getWidth() + x1) * 4; int x; int y; - int perc = xSplit ? this->splitPercentage *getWidth() / 100.0f : this->splitPercentage *getHeight() / 100.0f; + int perc = this->m_xSplit ? this->m_splitPercentage * this->getWidth() / 100.0f : this->m_splitPercentage * this->getHeight() / 100.0f; for (y = y1; y < y2; y++) { for (x = x1; x < x2; x++) { bool image1; float srgb[4]; - image1 = xSplit ? x > perc : y > perc; + image1 = this->m_xSplit ? x > perc : y > perc; if (image1) { - image1Input->read(&(buffer[offset]), x, y, COM_PS_NEAREST, memoryBuffers); + this->m_image1Input->read(&(buffer[offset]), x, y, COM_PS_NEAREST, memoryBuffers); } else { - image2Input->read(&(buffer[offset]), x, y, COM_PS_NEAREST, memoryBuffers); + this->m_image2Input->read(&(buffer[offset]), x, y, COM_PS_NEAREST, memoryBuffers); } /// @todo: linear conversion only when scene color management is selected, also check predivide. - if (this->doColorManagement) { - if (this->doColorPredivide) { + if (this->m_doColorManagement) { + if (this->m_doColorPredivide) { linearrgb_to_srgb_predivide_v4(srgb, buffer + offset); } else { diff --git a/source/blender/compositor/operations/COM_SplitViewerOperation.h b/source/blender/compositor/operations/COM_SplitViewerOperation.h index aba63ff190b..92275606105 100644 --- a/source/blender/compositor/operations/COM_SplitViewerOperation.h +++ b/source/blender/compositor/operations/COM_SplitViewerOperation.h @@ -28,17 +28,17 @@ class SplitViewerOperation : public ViewerBaseOperation { private: - SocketReader *image1Input; - SocketReader *image2Input; + SocketReader *m_image1Input; + SocketReader *m_image2Input; - float splitPercentage; - bool xSplit; + float m_splitPercentage; + bool m_xSplit; public: SplitViewerOperation(); void executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers); void initExecution(); void deinitExecution(); - void setSplitPercentage(float splitPercentage) { this->splitPercentage = splitPercentage; } - void setXSplit(bool xsplit) { this->xSplit = xsplit; } + void setSplitPercentage(float splitPercentage) { this->m_splitPercentage = splitPercentage; } + void setXSplit(bool xsplit) { this->m_xSplit = xsplit; } }; #endif diff --git a/source/blender/compositor/operations/COM_TextureOperation.cpp b/source/blender/compositor/operations/COM_TextureOperation.cpp index dbdd17adbe4..6098cfc3e5c 100644 --- a/source/blender/compositor/operations/COM_TextureOperation.cpp +++ b/source/blender/compositor/operations/COM_TextureOperation.cpp @@ -29,10 +29,10 @@ TextureBaseOperation::TextureBaseOperation() : NodeOperation() { this->addInputSocket(COM_DT_VECTOR); //offset this->addInputSocket(COM_DT_VECTOR); //size - this->texture = NULL; - this->inputSize = NULL; - this->inputOffset = NULL; - this->rd = NULL; + this->m_texture = NULL; + this->m_inputSize = NULL; + this->m_inputOffset = NULL; + this->m_rd = NULL; } TextureOperation::TextureOperation() : TextureBaseOperation() { @@ -45,20 +45,20 @@ TextureAlphaOperation::TextureAlphaOperation() : TextureBaseOperation() void TextureBaseOperation::initExecution() { - this->inputOffset = getInputSocketReader(0); - this->inputSize = getInputSocketReader(1); + this->m_inputOffset = getInputSocketReader(0); + this->m_inputSize = getInputSocketReader(1); } void TextureBaseOperation::deinitExecution() { - this->inputSize = NULL; - this->inputOffset = NULL; + this->m_inputSize = NULL; + this->m_inputOffset = NULL; } void TextureBaseOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) { if (preferredResolution[0] == 0 || preferredResolution[1] == 0) { - int width = this->rd->xsch * this->rd->size / 100; - int height = this->rd->ysch * this->rd->size / 100; + int width = this->m_rd->xsch * this->m_rd->size / 100; + int height = this->m_rd->ysch * this->m_rd->size / 100; resolution[0] = width; resolution[1] = height; } @@ -89,14 +89,14 @@ void TextureBaseOperation::executePixel(float *color, float x, float y, PixelSam const float u = (cx - x) / this->getWidth() * 2; const float v = (cy - y) / this->getHeight() * 2; - this->inputSize->read(textureSize, x, y, sampler, inputBuffers); - this->inputOffset->read(textureOffset, x, y, sampler, inputBuffers); + this->m_inputSize->read(textureSize, x, y, sampler, inputBuffers); + this->m_inputOffset->read(textureOffset, x, y, sampler, inputBuffers); vec[0] = textureSize[0] * (u + textureOffset[0]); vec[1] = textureSize[1] * (v + textureOffset[1]); vec[2] = textureSize[2] * textureOffset[2]; - retval = multitex_ext(this->texture, vec, NULL, NULL, 0, &texres); + retval = multitex_ext(this->m_texture, vec, NULL, NULL, 0, &texres); if (texres.talpha) color[3] = texres.ta; diff --git a/source/blender/compositor/operations/COM_TextureOperation.h b/source/blender/compositor/operations/COM_TextureOperation.h index 14714242511..d42da697b08 100644 --- a/source/blender/compositor/operations/COM_TextureOperation.h +++ b/source/blender/compositor/operations/COM_TextureOperation.h @@ -42,10 +42,10 @@ extern "C" { */ class TextureBaseOperation : public NodeOperation { private: - Tex *texture; - const RenderData *rd; - SocketReader *inputSize; - SocketReader *inputOffset; + Tex *m_texture; + const RenderData *m_rd; + SocketReader *m_inputSize; + SocketReader *m_inputOffset; protected: @@ -62,10 +62,10 @@ protected: public: void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); - void setTexture(Tex *texture) { this->texture = texture; } + void setTexture(Tex *texture) { this->m_texture = texture; } void initExecution(); void deinitExecution(); - void setRenderData(const RenderData *rd) { this->rd = rd; } + void setRenderData(const RenderData *rd) { this->m_rd = rd; } }; class TextureOperation : public TextureBaseOperation { diff --git a/source/blender/compositor/operations/COM_TonemapOperation.cpp b/source/blender/compositor/operations/COM_TonemapOperation.cpp index 7b978e0f87c..b5daf85b390 100644 --- a/source/blender/compositor/operations/COM_TonemapOperation.cpp +++ b/source/blender/compositor/operations/COM_TonemapOperation.cpp @@ -30,14 +30,14 @@ TonemapOperation::TonemapOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE); this->addOutputSocket(COM_DT_COLOR); - this->imageReader = NULL; - this->data = NULL; - this->cachedInstance = NULL; + this->m_imageReader = NULL; + this->m_data = NULL; + this->m_cachedInstance = NULL; this->setComplex(true); } void TonemapOperation::initExecution() { - this->imageReader = this->getInputSocketReader(0); + this->m_imageReader = this->getInputSocketReader(0); NodeOperation::initMutex(); } @@ -46,11 +46,11 @@ void TonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *in AvgLogLum *avg = (AvgLogLum *)data; float output[4]; - this->imageReader->read(output, x, y, inputBuffers, NULL); + this->m_imageReader->read(output, x, y, inputBuffers, NULL); mul_v3_fl(output, avg->al); - float dr = output[0] + this->data->offset; - float dg = output[1] + this->data->offset; - float db = output[2] + this->data->offset; + float dr = output[0] + this->m_data->offset; + float dg = output[1] + this->m_data->offset; + float db = output[2] + this->m_data->offset; output[0] /= ((dr == 0.f) ? 1.0f : dr); output[1] /= ((dg == 0.f) ? 1.0f : dg); output[2] /= ((db == 0.f) ? 1.0f : db); @@ -66,14 +66,14 @@ void TonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *in void PhotoreceptorTonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) { AvgLogLum *avg = (AvgLogLum *)data; - NodeTonemap *ntm = this->data; + NodeTonemap *ntm = this->m_data; - const float f = expf(-this->data->f); + const float f = expf(-this->m_data->f); const float m = (ntm->m > 0.0f) ? ntm->m : (0.3f + 0.7f * powf(avg->auto_key, 1.4f)); const float ic = 1.0f - ntm->c, ia = 1.0f - ntm->a; float output[4]; - this->imageReader->read(output, x, y, inputBuffers, NULL); + this->m_imageReader->read(output, x, y, inputBuffers, NULL); const float L = rgb_to_luma_y(output); float I_l = output[0] + ic * (L - output[0]); @@ -94,9 +94,9 @@ void PhotoreceptorTonemapOperation::executePixel(float *color, int x, int y, Mem void TonemapOperation::deinitExecution() { - this->imageReader = NULL; - if (this->cachedInstance) { - delete cachedInstance; + this->m_imageReader = NULL; + if (this->m_cachedInstance) { + delete this->m_cachedInstance; } NodeOperation::deinitMutex(); } @@ -119,8 +119,8 @@ bool TonemapOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferO void *TonemapOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { lockMutex(); - if (this->cachedInstance == NULL) { - MemoryBuffer *tile = (MemoryBuffer *)imageReader->initializeTileData(rect, memoryBuffers); + if (this->m_cachedInstance == NULL) { + MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers); AvgLogLum *data = new AvgLogLum(); float *buffer = tile->getBuffer(); @@ -146,12 +146,12 @@ void *TonemapOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuff maxl = log((double)maxl + 1e-5); minl = log((double)minl + 1e-5); avl = lsum * sc; data->auto_key = (maxl > minl) ? ((maxl - avl) / (maxl - minl)) : 1.f; float al = exp((double)avl); - data->al = (al == 0.f) ? 0.f : (this->data->key / al); - data->igm = (this->data->gamma == 0.f) ? 1 : (1.f / this->data->gamma); - this->cachedInstance = data; + data->al = (al == 0.0f) ? 0.0f : (this->m_data->key / al); + data->igm = (this->m_data->gamma == 0.f) ? 1 : (1.f / this->m_data->gamma); + this->m_cachedInstance = data; } unlockMutex(); - return this->cachedInstance; + return this->m_cachedInstance; } void TonemapOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data) diff --git a/source/blender/compositor/operations/COM_TonemapOperation.h b/source/blender/compositor/operations/COM_TonemapOperation.h index 005f0862443..ed9018d0a09 100644 --- a/source/blender/compositor/operations/COM_TonemapOperation.h +++ b/source/blender/compositor/operations/COM_TonemapOperation.h @@ -46,17 +46,17 @@ protected: /** * @brief Cached reference to the reader */ - SocketReader *imageReader; + SocketReader *m_imageReader; /** * @brief settings of the Tonemap */ - NodeTonemap *data; + NodeTonemap *m_data; /** * @brief temporarily cache of the execution storage */ - AvgLogLum *cachedInstance; + AvgLogLum *m_cachedInstance; public: TonemapOperation(); @@ -79,7 +79,7 @@ public: */ void deinitExecution(); - void setData(NodeTonemap *data) { this->data = data; } + void setData(NodeTonemap *data) { this->m_data = data; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); diff --git a/source/blender/compositor/operations/COM_TranslateOperation.cpp b/source/blender/compositor/operations/COM_TranslateOperation.cpp index c41e2c7f156..e43a8e55130 100644 --- a/source/blender/compositor/operations/COM_TranslateOperation.cpp +++ b/source/blender/compositor/operations/COM_TranslateOperation.cpp @@ -29,31 +29,31 @@ TranslateOperation::TranslateOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); this->setResolutionInputSocketIndex(0); - this->inputOperation = NULL; - this->inputXOperation = NULL; - this->inputYOperation = NULL; - this->isDeltaSet = false; + this->m_inputOperation = NULL; + this->m_inputXOperation = NULL; + this->m_inputYOperation = NULL; + this->m_isDeltaSet = false; } void TranslateOperation::initExecution() { - this->inputOperation = this->getInputSocketReader(0); - this->inputXOperation = this->getInputSocketReader(1); - this->inputYOperation = this->getInputSocketReader(2); + this->m_inputOperation = this->getInputSocketReader(0); + this->m_inputXOperation = this->getInputSocketReader(1); + this->m_inputYOperation = this->getInputSocketReader(2); } void TranslateOperation::deinitExecution() { - this->inputOperation = NULL; - this->inputXOperation = NULL; - this->inputYOperation = NULL; + this->m_inputOperation = NULL; + this->m_inputXOperation = NULL; + this->m_inputYOperation = NULL; } void TranslateOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { ensureDelta(); - this->inputOperation->read(color, x - this->getDeltaX(), y - this->getDeltaY(), sampler, inputBuffers); + this->m_inputOperation->read(color, x - this->getDeltaX(), y - this->getDeltaY(), sampler, inputBuffers); } bool TranslateOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) diff --git a/source/blender/compositor/operations/COM_TranslateOperation.h b/source/blender/compositor/operations/COM_TranslateOperation.h index bf3121bec11..8af4ffe8967 100644 --- a/source/blender/compositor/operations/COM_TranslateOperation.h +++ b/source/blender/compositor/operations/COM_TranslateOperation.h @@ -27,12 +27,12 @@ class TranslateOperation : public NodeOperation { private: - SocketReader *inputOperation; - SocketReader *inputXOperation; - SocketReader *inputYOperation; - float deltaX; - float deltaY; - bool isDeltaSet; + SocketReader *m_inputOperation; + SocketReader *m_inputXOperation; + SocketReader *m_inputYOperation; + float m_deltaX; + float m_deltaY; + bool m_isDeltaSet; public: TranslateOperation(); bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); @@ -41,17 +41,17 @@ public: void initExecution(); void deinitExecution(); - float getDeltaX() { return this->deltaX; } - float getDeltaY() { return this->deltaY; } + float getDeltaX() { return this->m_deltaX; } + float getDeltaY() { return this->m_deltaY; } inline void ensureDelta() { - if (!isDeltaSet) { + if (!this->m_isDeltaSet) { float tempDelta[4]; - this->inputXOperation->read(tempDelta, 0, 0, COM_PS_NEAREST, NULL); - this->deltaX = tempDelta[0]; - this->inputYOperation->read(tempDelta, 0, 0, COM_PS_NEAREST, NULL); - this->deltaY = tempDelta[0]; - this->isDeltaSet = true; + this->m_inputXOperation->read(tempDelta, 0, 0, COM_PS_NEAREST, NULL); + this->m_deltaX = tempDelta[0]; + this->m_inputYOperation->read(tempDelta, 0, 0, COM_PS_NEAREST, NULL); + this->m_deltaY = tempDelta[0]; + this->m_isDeltaSet = true; } } }; diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp index c17e51e6391..9eb004b3686 100644 --- a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp @@ -36,21 +36,21 @@ VariableSizeBokehBlurOperation::VariableSizeBokehBlurOperation() : NodeOperation this->addOutputSocket(COM_DT_COLOR); this->setComplex(true); - this->inputProgram = NULL; - this->inputBokehProgram = NULL; - this->inputSizeProgram = NULL; - this->inputDepthProgram = NULL; - this->maxBlur = 32.0f; - this->threshold = 1.0f; + this->m_inputProgram = NULL; + this->m_inputBokehProgram = NULL; + this->m_inputSizeProgram = NULL; + this->m_inputDepthProgram = NULL; + this->m_maxBlur = 32.0f; + this->m_threshold = 1.0f; } void VariableSizeBokehBlurOperation::initExecution() { - this->inputProgram = getInputSocketReader(0); - this->inputBokehProgram = getInputSocketReader(1); - this->inputSizeProgram = getInputSocketReader(2); - this->inputDepthProgram = getInputSocketReader(3); + this->m_inputProgram = getInputSocketReader(0); + this->m_inputBokehProgram = getInputSocketReader(1); + this->m_inputSizeProgram = getInputSocketReader(2); + this->m_inputDepthProgram = getInputSocketReader(3); QualityStepHelper::initExecution(COM_QH_INCREASE); } @@ -63,27 +63,27 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me float multiplier_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; float color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f}; - int miny = y - maxBlur; - int maxy = y + maxBlur; - int minx = x - maxBlur; - int maxx = x + maxBlur; + int miny = y - this->m_maxBlur; + int maxy = y + this->m_maxBlur; + int minx = x - this->m_maxBlur; + int maxx = x + this->m_maxBlur; { - inputSizeProgram->read(tempSize, x, y, COM_PS_NEAREST, inputBuffers); - inputDepthProgram->read(tempDepth, x, y, COM_PS_NEAREST, inputBuffers); - inputProgram->read(readColor, x, y, COM_PS_NEAREST, inputBuffers); + this->m_inputSizeProgram->read(tempSize, x, y, COM_PS_NEAREST, inputBuffers); + this->m_inputDepthProgram->read(tempDepth, x, y, COM_PS_NEAREST, inputBuffers); + this->m_inputProgram->read(readColor, x, y, COM_PS_NEAREST, inputBuffers); add_v4_v4(color_accum, readColor); add_v4_fl(multiplier_accum, 1.0f); float sizeCenter = tempSize[0]; - float centerDepth = tempDepth[0]+threshold; + float centerDepth = tempDepth[0] + this->m_threshold; for (int ny = miny; ny < maxy; ny += QualityStepHelper::getStep()) { for (int nx = minx; nx < maxx; nx += QualityStepHelper::getStep()) { if (nx >= 0 && nx < this->getWidth() && ny >= 0 && ny < getHeight()) { - inputDepthProgram->read(tempDepth, nx, ny, COM_PS_NEAREST, inputBuffers); - inputSizeProgram->read(tempSize, nx, ny, COM_PS_NEAREST, inputBuffers); + this->m_inputDepthProgram->read(tempDepth, nx, ny, COM_PS_NEAREST, inputBuffers); + this->m_inputSizeProgram->read(tempSize, nx, ny, COM_PS_NEAREST, inputBuffers); float size = tempSize[0]; if (tempDepth[0] < centerDepth) { - if ((sizeCenter > threshold && size > threshold) || size <= threshold) { + if ((sizeCenter > this->m_threshold && size > this->m_threshold) || size <= this->m_threshold) { float dx = nx - x; float dy = ny - y; if (nx == x && ny == y) { @@ -91,8 +91,8 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me else if (size >= fabsf(dx) && size >= fabsf(dy)) { float u = 256 + dx * 256 / size; float v = 256 + dy * 256 / size; - inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST, inputBuffers); - inputProgram->read(readColor, nx, ny, COM_PS_NEAREST, inputBuffers); + this->m_inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST, inputBuffers); + this->m_inputProgram->read(readColor, nx, ny, COM_PS_NEAREST, inputBuffers); madd_v4_v4v4(color_accum, bokeh, readColor); add_v4_v4(multiplier_accum, bokeh); } @@ -112,9 +112,9 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me void VariableSizeBokehBlurOperation::deinitExecution() { - this->inputProgram = NULL; - this->inputBokehProgram = NULL; - this->inputSizeProgram = NULL; + this->m_inputProgram = NULL; + this->m_inputBokehProgram = NULL; + this->m_inputSizeProgram = NULL; } bool VariableSizeBokehBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) @@ -122,10 +122,10 @@ bool VariableSizeBokehBlurOperation::determineDependingAreaOfInterest(rcti *inpu rcti newInput; rcti bokehInput; - newInput.xmax = input->xmax + maxBlur + 2; - newInput.xmin = input->xmin - maxBlur + 2; - newInput.ymax = input->ymax + maxBlur - 2; - newInput.ymin = input->ymin - maxBlur - 2; + newInput.xmax = input->xmax + this->m_maxBlur + 2; + newInput.xmin = input->xmin - this->m_maxBlur + 2; + newInput.ymax = input->ymax + this->m_maxBlur - 2; + newInput.ymin = input->ymin - this->m_maxBlur - 2; bokehInput.xmax = 512; bokehInput.xmin = 0; bokehInput.ymax = 512; diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h index d04bf08405f..8e59a43fcb1 100644 --- a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h +++ b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h @@ -27,12 +27,12 @@ class VariableSizeBokehBlurOperation : public NodeOperation, public QualityStepHelper { private: - int maxBlur; - float threshold; - SocketReader *inputProgram; - SocketReader *inputBokehProgram; - SocketReader *inputSizeProgram; - SocketReader *inputDepthProgram; + int m_maxBlur; + float m_threshold; + SocketReader *m_inputProgram; + SocketReader *m_inputBokehProgram; + SocketReader *m_inputSizeProgram; + SocketReader *m_inputDepthProgram; public: VariableSizeBokehBlurOperation(); @@ -54,9 +54,9 @@ public: bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); - void setMaxBlur(int maxRadius) { this->maxBlur = maxRadius; } + void setMaxBlur(int maxRadius) { this->m_maxBlur = maxRadius; } - void setThreshold(float threshold) { this->threshold = threshold; } + void setThreshold(float threshold) { this->m_threshold = threshold; } }; diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.cpp b/source/blender/compositor/operations/COM_VectorBlurOperation.cpp index 3efae2c4e3d..48be72561ba 100644 --- a/source/blender/compositor/operations/COM_VectorBlurOperation.cpp +++ b/source/blender/compositor/operations/COM_VectorBlurOperation.cpp @@ -34,20 +34,20 @@ VectorBlurOperation::VectorBlurOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); // ZBUF this->addInputSocket(COM_DT_COLOR); //SPEED this->addOutputSocket(COM_DT_COLOR); - this->settings = NULL; - this->cachedInstance = NULL; - this->inputImageProgram = NULL; - this->inputSpeedProgram = NULL; - this->inputZProgram = NULL; + this->m_settings = NULL; + this->m_cachedInstance = NULL; + this->m_inputImageProgram = NULL; + this->m_inputSpeedProgram = NULL; + this->m_inputZProgram = NULL; setComplex(true); } void VectorBlurOperation::initExecution() { initMutex(); - this->inputImageProgram = getInputSocketReader(0); - this->inputZProgram = getInputSocketReader(1); - this->inputSpeedProgram = getInputSocketReader(2); - this->cachedInstance = NULL; + this->m_inputImageProgram = getInputSocketReader(0); + this->m_inputZProgram = getInputSocketReader(1); + this->m_inputSpeedProgram = getInputSocketReader(2); + this->m_cachedInstance = NULL; QualityStepHelper::initExecution(COM_QH_INCREASE); } @@ -56,44 +56,43 @@ void VectorBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer { float *buffer = (float *) data; int index = (y * this->getWidth() + x) * COM_NUMBER_OF_CHANNELS; - color[0] = buffer[index]; - color[1] = buffer[index + 1]; - color[2] = buffer[index + 2]; - color[3] = buffer[index + 3]; + copy_v4_v4(color, &buffer[index]); } void VectorBlurOperation::deinitExecution() { deinitMutex(); - this->inputImageProgram = NULL; - this->inputSpeedProgram = NULL; - this->inputZProgram = NULL; - if (this->cachedInstance) { - delete cachedInstance; - this->cachedInstance = NULL; + this->m_inputImageProgram = NULL; + this->m_inputSpeedProgram = NULL; + this->m_inputZProgram = NULL; + if (this->m_cachedInstance) { + delete this->m_cachedInstance; + this->m_cachedInstance = NULL; } } void *VectorBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { - if (this->cachedInstance) return this->cachedInstance; + if (this->m_cachedInstance) { + return this->m_cachedInstance; + } lockMutex(); - if (this->cachedInstance == NULL) { - MemoryBuffer *tile = (MemoryBuffer *)inputImageProgram->initializeTileData(rect, memoryBuffers); - MemoryBuffer *speed = (MemoryBuffer *)inputSpeedProgram->initializeTileData(rect, memoryBuffers); - MemoryBuffer *z = (MemoryBuffer *)inputZProgram->initializeTileData(rect, memoryBuffers); + if (this->m_cachedInstance == NULL) { + MemoryBuffer *tile = (MemoryBuffer *)this->m_inputImageProgram->initializeTileData(rect, memoryBuffers); + MemoryBuffer *speed = (MemoryBuffer *)this->m_inputSpeedProgram->initializeTileData(rect, memoryBuffers); + MemoryBuffer *z = (MemoryBuffer *)this->m_inputZProgram->initializeTileData(rect, memoryBuffers); float *data = new float[this->getWidth() * this->getHeight() * COM_NUMBER_OF_CHANNELS]; memcpy(data, tile->getBuffer(), this->getWidth() * this->getHeight() * COM_NUMBER_OF_CHANNELS * sizeof(float)); this->generateVectorBlur(data, tile, speed, z); - this->cachedInstance = data; + this->m_cachedInstance = data; } unlockMutex(); - return this->cachedInstance; + return this->m_cachedInstance; } bool VectorBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) { - if (this->cachedInstance == NULL) { + if (this->m_cachedInstance == NULL) { rcti newInput; newInput.xmax = this->getWidth(); newInput.xmin = 0; @@ -110,11 +109,11 @@ void VectorBlurOperation::generateVectorBlur(float *data, MemoryBuffer *inputIma { float *zbuf = inputZ->convertToValueBuffer(); NodeBlurData blurdata; - blurdata.samples = this->settings->samples / QualityStepHelper::getStep(); - blurdata.maxspeed = this->settings->maxspeed; - blurdata.minspeed = this->settings->minspeed; - blurdata.curved = this->settings->curved; - blurdata.fac = this->settings->fac; + blurdata.samples = this->m_settings->samples / QualityStepHelper::getStep(); + blurdata.maxspeed = this->m_settings->maxspeed; + blurdata.minspeed = this->m_settings->minspeed; + blurdata.curved = this->m_settings->curved; + blurdata.fac = this->m_settings->fac; RE_zbuf_accumulate_vecblur(&blurdata, this->getWidth(), this->getHeight(), data, inputImage->getBuffer(), inputSpeed->getBuffer(), zbuf); delete zbuf; return; diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.h b/source/blender/compositor/operations/COM_VectorBlurOperation.h index 30821cdd8b2..a2e72fa3232 100644 --- a/source/blender/compositor/operations/COM_VectorBlurOperation.h +++ b/source/blender/compositor/operations/COM_VectorBlurOperation.h @@ -31,16 +31,16 @@ private: /** * @brief Cached reference to the inputProgram */ - SocketReader *inputImageProgram; - SocketReader *inputSpeedProgram; - SocketReader *inputZProgram; + SocketReader *m_inputImageProgram; + SocketReader *m_inputSpeedProgram; + SocketReader *m_inputZProgram; /** * @brief settings of the glare node. */ - NodeBlurData *settings; + NodeBlurData *m_settings; - float *cachedInstance; + float *m_cachedInstance; public: VectorBlurOperation(); @@ -62,7 +62,7 @@ public: void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers); - void setVectorBlurSettings(NodeBlurData *settings) { this->settings = settings; } + void setVectorBlurSettings(NodeBlurData *settings) { this->m_settings = settings; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); protected: diff --git a/source/blender/compositor/operations/COM_VectorCurveOperation.cpp b/source/blender/compositor/operations/COM_VectorCurveOperation.cpp index 3173599ece6..ee3f44d8979 100644 --- a/source/blender/compositor/operations/COM_VectorCurveOperation.cpp +++ b/source/blender/compositor/operations/COM_VectorCurveOperation.cpp @@ -35,12 +35,12 @@ VectorCurveOperation::VectorCurveOperation() : CurveBaseOperation() this->addInputSocket(COM_DT_VECTOR); this->addOutputSocket(COM_DT_VECTOR); - this->inputProgram = NULL; + this->m_inputProgram = NULL; } void VectorCurveOperation::initExecution() { CurveBaseOperation::initExecution(); - this->inputProgram = this->getInputSocketReader(0); + this->m_inputProgram = this->getInputSocketReader(0); } void VectorCurveOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -48,13 +48,13 @@ void VectorCurveOperation::executePixel(float *output, float x, float y, PixelSa float input[4]; - this->inputProgram->read(input, x, y, sampler, inputBuffers); + this->m_inputProgram->read(input, x, y, sampler, inputBuffers); - curvemapping_evaluate_premulRGBF(this->curveMapping, output, input); + curvemapping_evaluate_premulRGBF(this->m_curveMapping, output, input); output[3] = input[3]; } void VectorCurveOperation::deinitExecution() { - this->inputProgram = NULL; + this->m_inputProgram = NULL; } diff --git a/source/blender/compositor/operations/COM_VectorCurveOperation.h b/source/blender/compositor/operations/COM_VectorCurveOperation.h index 41faee7acf6..2fbaf170986 100644 --- a/source/blender/compositor/operations/COM_VectorCurveOperation.h +++ b/source/blender/compositor/operations/COM_VectorCurveOperation.h @@ -30,7 +30,7 @@ private: /** * Cached reference to the inputProgram */ - SocketReader *inputProgram; + SocketReader *m_inputProgram; public: VectorCurveOperation(); diff --git a/source/blender/compositor/operations/COM_ViewerBaseOperation.cpp b/source/blender/compositor/operations/COM_ViewerBaseOperation.cpp index a8aa84e84f9..446b169763c 100644 --- a/source/blender/compositor/operations/COM_ViewerBaseOperation.cpp +++ b/source/blender/compositor/operations/COM_ViewerBaseOperation.cpp @@ -42,10 +42,10 @@ ViewerBaseOperation::ViewerBaseOperation() : NodeOperation() { this->setImage(NULL); this->setImageUser(NULL); - this->outputBuffer = NULL; - this->outputBufferDisplay = NULL; - this->active = false; - this->doColorManagement = true; + this->m_outputBuffer = NULL; + this->m_outputBufferDisplay = NULL; + this->m_active = false; + this->m_doColorManagement = true; } void ViewerBaseOperation::initExecution() @@ -57,8 +57,8 @@ void ViewerBaseOperation::initExecution() void ViewerBaseOperation::initImage() { - Image *anImage = this->image; - ImBuf *ibuf = BKE_image_acquire_ibuf(anImage, this->imageUser, &this->lock); + Image *anImage = this->m_image; + ImBuf *ibuf = BKE_image_acquire_ibuf(anImage, this->m_imageUser, &this->m_lock); if (!ibuf) return; if (ibuf->x != (int)getWidth() || ibuf->y != (int)getHeight()) { @@ -73,10 +73,10 @@ void ViewerBaseOperation::initImage() } /* now we combine the input with ibuf */ - this->outputBuffer = ibuf->rect_float; - this->outputBufferDisplay = (unsigned char *)ibuf->rect; + this->m_outputBuffer = ibuf->rect_float; + this->m_outputBufferDisplay = (unsigned char *)ibuf->rect; - BKE_image_release_ibuf(this->image, this->lock); + BKE_image_release_ibuf(this->m_image, this->m_lock); } void ViewerBaseOperation:: updateImage(rcti *rect) { @@ -85,7 +85,7 @@ void ViewerBaseOperation:: updateImage(rcti *rect) void ViewerBaseOperation::deinitExecution() { - this->outputBuffer = NULL; + this->m_outputBuffer = NULL; } const CompositorPriority ViewerBaseOperation::getRenderPriority() const diff --git a/source/blender/compositor/operations/COM_ViewerBaseOperation.h b/source/blender/compositor/operations/COM_ViewerBaseOperation.h index 2aaa7d20966..f3fd1e9c9df 100644 --- a/source/blender/compositor/operations/COM_ViewerBaseOperation.h +++ b/source/blender/compositor/operations/COM_ViewerBaseOperation.h @@ -28,35 +28,35 @@ class ViewerBaseOperation : public NodeOperation { protected: - float *outputBuffer; - unsigned char *outputBufferDisplay; - Image *image; - ImageUser *imageUser; - void *lock; - bool active; - float centerX; - float centerY; - OrderOfChunks chunkOrder; - bool doColorManagement; - bool doColorPredivide; + float *m_outputBuffer; + unsigned char *m_outputBufferDisplay; + Image *m_image; + ImageUser *m_imageUser; + void *m_lock; + bool m_active; + float m_centerX; + float m_centerY; + OrderOfChunks m_chunkOrder; + bool m_doColorManagement; + bool m_doColorPredivide; public: bool isOutputOperation(bool rendering) const { return isActiveViewerOutput(); } void initExecution(); void deinitExecution(); - void setImage(Image *image) { this->image = image; } - void setImageUser(ImageUser *imageUser) { this->imageUser = imageUser; } - const bool isActiveViewerOutput() const { return active; } - void setActive(bool active) { this->active = active; } - void setCenterX(float centerX) { this->centerX = centerX;} - void setCenterY(float centerY) { this->centerY = centerY;} - void setChunkOrder(OrderOfChunks tileOrder) { this->chunkOrder = tileOrder; } - float getCenterX() { return this->centerX; } - float getCenterY() { return this->centerY; } - OrderOfChunks getChunkOrder() { return this->chunkOrder; } + void setImage(Image *image) { this->m_image = image; } + void setImageUser(ImageUser *imageUser) { this->m_imageUser = imageUser; } + const bool isActiveViewerOutput() const { return this->m_active; } + void setActive(bool active) { this->m_active = active; } + void setCenterX(float centerX) { this->m_centerX = centerX;} + void setCenterY(float centerY) { this->m_centerY = centerY;} + void setChunkOrder(OrderOfChunks tileOrder) { this->m_chunkOrder = tileOrder; } + float getCenterX() { return this->m_centerX; } + float getCenterY() { return this->m_centerY; } + OrderOfChunks getChunkOrder() { return this->m_chunkOrder; } const CompositorPriority getRenderPriority() const; - void setColorManagement(bool doColorManagement) { this->doColorManagement = doColorManagement; } - void setColorPredivide(bool doColorPredivide) { this->doColorPredivide = doColorPredivide; } + void setColorManagement(bool doColorManagement) { this->m_doColorManagement = doColorManagement; } + void setColorPredivide(bool doColorPredivide) { this->m_doColorPredivide = doColorPredivide; } bool isViewerOperation() { return true; } protected: diff --git a/source/blender/compositor/operations/COM_ViewerOperation.cpp b/source/blender/compositor/operations/COM_ViewerOperation.cpp index cf7bf3fdc9d..9278ddd6ead 100644 --- a/source/blender/compositor/operations/COM_ViewerOperation.cpp +++ b/source/blender/compositor/operations/COM_ViewerOperation.cpp @@ -44,30 +44,30 @@ ViewerOperation::ViewerOperation() : ViewerBaseOperation() this->addInputSocket(COM_DT_COLOR); this->addInputSocket(COM_DT_VALUE); - this->imageInput = NULL; - this->alphaInput = NULL; + this->m_imageInput = NULL; + this->m_alphaInput = NULL; } void ViewerOperation::initExecution() { // When initializing the tree during initial load the width and height can be zero. - this->imageInput = getInputSocketReader(0); - this->alphaInput = getInputSocketReader(1); + this->m_imageInput = getInputSocketReader(0); + this->m_alphaInput = getInputSocketReader(1); ViewerBaseOperation::initExecution(); } void ViewerOperation::deinitExecution() { - this->imageInput = NULL; - this->alphaInput = NULL; + this->m_imageInput = NULL; + this->m_alphaInput = NULL; ViewerBaseOperation::deinitExecution(); } void ViewerOperation::executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers) { - float *buffer = this->outputBuffer; - unsigned char *bufferDisplay = this->outputBufferDisplay; + float *buffer = this->m_outputBuffer; + unsigned char *bufferDisplay = this->m_outputBufferDisplay; if (!buffer) return; const int x1 = rect->xmin; const int y1 = rect->ymin; @@ -82,14 +82,14 @@ void ViewerOperation::executeRegion(rcti *rect, unsigned int tileNumber, MemoryB for (y = y1; y < y2 && (!breaked); y++) { for (x = x1; x < x2; x++) { - imageInput->read(&(buffer[offset]), x, y, COM_PS_NEAREST, memoryBuffers); - if (alphaInput != NULL) { - alphaInput->read(alpha, x, y, COM_PS_NEAREST, memoryBuffers); + this->m_imageInput->read(&(buffer[offset]), x, y, COM_PS_NEAREST, memoryBuffers); + if (this->m_alphaInput != NULL) { + this->m_alphaInput->read(alpha, x, y, COM_PS_NEAREST, memoryBuffers); buffer[offset + 3] = alpha[0]; } /// @todo: linear conversion only when scene color management is selected, also check predivide. - if (this->doColorManagement) { - if (this->doColorPredivide) { + if (this->m_doColorManagement) { + if (this->m_doColorPredivide) { linearrgb_to_srgb_predivide_v4(srgb, buffer + offset); } else { diff --git a/source/blender/compositor/operations/COM_ViewerOperation.h b/source/blender/compositor/operations/COM_ViewerOperation.h index 49ef5ad4bb7..fd83c3957f1 100644 --- a/source/blender/compositor/operations/COM_ViewerOperation.h +++ b/source/blender/compositor/operations/COM_ViewerOperation.h @@ -29,8 +29,8 @@ class ViewerOperation : public ViewerBaseOperation { private: - SocketReader *imageInput; - SocketReader *alphaInput; + SocketReader *m_imageInput; + SocketReader *m_alphaInput; public: ViewerOperation(); diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.cpp b/source/blender/compositor/operations/COM_WriteBufferOperation.cpp index 356ba452185..7259db34134 100644 --- a/source/blender/compositor/operations/COM_WriteBufferOperation.cpp +++ b/source/blender/compositor/operations/COM_WriteBufferOperation.cpp @@ -28,42 +28,42 @@ WriteBufferOperation::WriteBufferOperation() : NodeOperation() { this->addInputSocket(COM_DT_COLOR); - this->memoryProxy = new MemoryProxy(); - this->memoryProxy->setWriteBufferOperation(this); - this->memoryProxy->setExecutor(NULL); + this->m_memoryProxy = new MemoryProxy(); + this->m_memoryProxy->setWriteBufferOperation(this); + this->m_memoryProxy->setExecutor(NULL); } WriteBufferOperation::~WriteBufferOperation() { - if (this->memoryProxy) { - delete this->memoryProxy; - this->memoryProxy = NULL; + if (this->m_memoryProxy) { + delete this->m_memoryProxy; + this->m_memoryProxy = NULL; } } void WriteBufferOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) { - input->read(color, x, y, sampler, inputBuffers); + this->m_input->read(color, x, y, sampler, inputBuffers); } void WriteBufferOperation::initExecution() { - this->input = this->getInputOperation(0); - this->memoryProxy->allocate(this->width, this->height); + this->m_input = this->getInputOperation(0); + this->m_memoryProxy->allocate(this->m_width, this->m_height); } void WriteBufferOperation::deinitExecution() { - this->input = NULL; - this->memoryProxy->free(); + this->m_input = NULL; + this->m_memoryProxy->free(); } void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers) { //MemoryBuffer *memoryBuffer = MemoryManager::getMemoryBuffer(this->getMemoryProxy(), tileNumber); - MemoryBuffer *memoryBuffer = this->memoryProxy->getBuffer(); + MemoryBuffer *memoryBuffer = this->m_memoryProxy->getBuffer(); float *buffer = memoryBuffer->getBuffer(); - if (this->input->isComplex()) { - void *data = this->input->initializeTileData(rect, memoryBuffers); + if (this->m_input->isComplex()) { + void *data = this->m_input->initializeTileData(rect, memoryBuffers); int x1 = rect->xmin; int y1 = rect->ymin; int x2 = rect->xmax; @@ -74,7 +74,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber, Me for (y = y1; y < y2 && (!breaked); y++) { int offset4 = (y * memoryBuffer->getWidth() + x1) * COM_NUMBER_OF_CHANNELS; for (x = x1; x < x2; x++) { - input->read(&(buffer[offset4]), x, y, memoryBuffers, data); + this->m_input->read(&(buffer[offset4]), x, y, memoryBuffers, data); offset4 += COM_NUMBER_OF_CHANNELS; } @@ -84,7 +84,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber, Me } if (data) { - this->input->deinitializeTileData(rect, memoryBuffers, data); + this->m_input->deinitializeTileData(rect, memoryBuffers, data); data = NULL; } } @@ -100,7 +100,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber, Me for (y = y1; y < y2 && (!breaked); y++) { int offset4 = (y * memoryBuffer->getWidth() + x1) * COM_NUMBER_OF_CHANNELS; for (x = x1; x < x2; x++) { - input->read(&(buffer[offset4]), x, y, COM_PS_NEAREST, memoryBuffers); + this->m_input->read(&(buffer[offset4]), x, y, COM_PS_NEAREST, memoryBuffers); offset4 += COM_NUMBER_OF_CHANNELS; } if (isBreaked()) { @@ -140,7 +140,7 @@ void WriteBufferOperation::executeOpenCLRegion(OpenCLDevice* device, rcti *rect, clMemToCleanUp->push_back(clOutputBuffer); list *clKernelsToCleanUp = new list(); - this->input->executeOpenCL(device, outputBuffer, clOutputBuffer, inputMemoryBuffers, clMemToCleanUp, clKernelsToCleanUp); + this->m_input->executeOpenCL(device, outputBuffer, clOutputBuffer, inputMemoryBuffers, clMemToCleanUp, clKernelsToCleanUp); // STEP 3 diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.h b/source/blender/compositor/operations/COM_WriteBufferOperation.h index ccc20584186..24bfdecd124 100644 --- a/source/blender/compositor/operations/COM_WriteBufferOperation.h +++ b/source/blender/compositor/operations/COM_WriteBufferOperation.h @@ -31,13 +31,13 @@ * @ingroup Operation */ class WriteBufferOperation : public NodeOperation { - MemoryProxy *memoryProxy; - NodeOperation *input; + MemoryProxy *m_memoryProxy; + NodeOperation *m_input; public: WriteBufferOperation(); ~WriteBufferOperation(); int isBufferOperation() { return true; } - MemoryProxy *getMemoryProxy() { return this->memoryProxy; } + MemoryProxy *getMemoryProxy() { return this->m_memoryProxy; } void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]); const bool isWriteBufferOperation() const { return true; } diff --git a/source/blender/compositor/operations/COM_ZCombineOperation.cpp b/source/blender/compositor/operations/COM_ZCombineOperation.cpp index eb02b150fa4..c1ea63432b9 100644 --- a/source/blender/compositor/operations/COM_ZCombineOperation.cpp +++ b/source/blender/compositor/operations/COM_ZCombineOperation.cpp @@ -31,19 +31,19 @@ ZCombineOperation::ZCombineOperation() : NodeOperation() this->addInputSocket(COM_DT_VALUE); this->addOutputSocket(COM_DT_COLOR); - this->image1Reader = NULL; - this->depth1Reader = NULL; - this->image2Reader = NULL; - this->depth2Reader = NULL; + this->m_image1Reader = NULL; + this->m_depth1Reader = NULL; + this->m_image2Reader = NULL; + this->m_depth2Reader = NULL; } void ZCombineOperation::initExecution() { - this->image1Reader = this->getInputSocketReader(0); - this->depth1Reader = this->getInputSocketReader(1); - this->image2Reader = this->getInputSocketReader(2); - this->depth2Reader = this->getInputSocketReader(3); + this->m_image1Reader = this->getInputSocketReader(0); + this->m_depth1Reader = this->getInputSocketReader(1); + this->m_image2Reader = this->getInputSocketReader(2); + this->m_depth2Reader = this->getInputSocketReader(3); } void ZCombineOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -51,13 +51,13 @@ void ZCombineOperation::executePixel(float *color, float x, float y, PixelSample float depth1[4]; float depth2[4]; - this->depth1Reader->read(depth1, x, y, sampler, inputBuffers); - this->depth2Reader->read(depth2, x, y, sampler, inputBuffers); + this->m_depth1Reader->read(depth1, x, y, sampler, inputBuffers); + this->m_depth2Reader->read(depth2, x, y, sampler, inputBuffers); if (depth1[0] < depth2[0]) { - this->image1Reader->read(color, x, y, sampler, inputBuffers); + this->m_image1Reader->read(color, x, y, sampler, inputBuffers); } else { - this->image2Reader->read(color, x, y, sampler, inputBuffers); + this->m_image2Reader->read(color, x, y, sampler, inputBuffers); } } void ZCombineAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) @@ -67,15 +67,15 @@ void ZCombineAlphaOperation::executePixel(float *color, float x, float y, PixelS float color1[4]; float color2[4]; - this->depth1Reader->read(depth1, x, y, sampler, inputBuffers); - this->depth2Reader->read(depth2, x, y, sampler, inputBuffers); + this->m_depth1Reader->read(depth1, x, y, sampler, inputBuffers); + this->m_depth2Reader->read(depth2, x, y, sampler, inputBuffers); if (depth1[0] < depth2[0]) { - this->image1Reader->read(color1, x, y, sampler, inputBuffers); - this->image2Reader->read(color2, x, y, sampler, inputBuffers); + this->m_image1Reader->read(color1, x, y, sampler, inputBuffers); + this->m_image2Reader->read(color2, x, y, sampler, inputBuffers); } else { - this->image1Reader->read(color2, x, y, sampler, inputBuffers); - this->image2Reader->read(color1, x, y, sampler, inputBuffers); + this->m_image1Reader->read(color2, x, y, sampler, inputBuffers); + this->m_image2Reader->read(color1, x, y, sampler, inputBuffers); } float fac = color1[3]; float ifac = 1.0f - fac; @@ -87,8 +87,8 @@ void ZCombineAlphaOperation::executePixel(float *color, float x, float y, PixelS void ZCombineOperation::deinitExecution() { - this->image1Reader = NULL; - this->depth1Reader = NULL; - this->image2Reader = NULL; - this->depth2Reader = NULL; + this->m_image1Reader = NULL; + this->m_depth1Reader = NULL; + this->m_image2Reader = NULL; + this->m_depth2Reader = NULL; } diff --git a/source/blender/compositor/operations/COM_ZCombineOperation.h b/source/blender/compositor/operations/COM_ZCombineOperation.h index 56ad950a3aa..2ade3f599ad 100644 --- a/source/blender/compositor/operations/COM_ZCombineOperation.h +++ b/source/blender/compositor/operations/COM_ZCombineOperation.h @@ -31,10 +31,10 @@ */ class ZCombineOperation : public NodeOperation { protected: - SocketReader *image1Reader; - SocketReader *depth1Reader; - SocketReader *image2Reader; - SocketReader *depth2Reader; + SocketReader *m_image1Reader; + SocketReader *m_depth1Reader; + SocketReader *m_image2Reader; + SocketReader *m_depth2Reader; public: /** * Default constructor -- cgit v1.2.3