use m_ prefix for compositor class members (all compositor operations).
authorCampbell Barton <ideasman42@gmail.com>
Tue, 26 Jun 2012 01:22:05 +0000 (01:22 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 26 Jun 2012 01:22:05 +0000 (01:22 +0000)
247 files changed:
source/blender/compositor/intern/COM_NodeOperation.cpp
source/blender/compositor/intern/COM_NodeOperation.h
source/blender/compositor/intern/COM_SocketReader.h
source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp
source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp
source/blender/compositor/operations/COM_AntiAliasOperation.cpp
source/blender/compositor/operations/COM_AntiAliasOperation.h
source/blender/compositor/operations/COM_BilateralBlurOperation.cpp
source/blender/compositor/operations/COM_BilateralBlurOperation.h
source/blender/compositor/operations/COM_BlurBaseOperation.cpp
source/blender/compositor/operations/COM_BlurBaseOperation.h
source/blender/compositor/operations/COM_BokehBlurOperation.cpp
source/blender/compositor/operations/COM_BokehBlurOperation.h
source/blender/compositor/operations/COM_BokehImageOperation.cpp
source/blender/compositor/operations/COM_BokehImageOperation.h
source/blender/compositor/operations/COM_BoxMaskOperation.cpp
source/blender/compositor/operations/COM_BoxMaskOperation.h
source/blender/compositor/operations/COM_BrightnessOperation.cpp
source/blender/compositor/operations/COM_BrightnessOperation.h
source/blender/compositor/operations/COM_CalculateMeanOperation.cpp
source/blender/compositor/operations/COM_CalculateMeanOperation.h
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h
source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
source/blender/compositor/operations/COM_ChangeHSVOperation.h
source/blender/compositor/operations/COM_ChannelMatteOperation.cpp
source/blender/compositor/operations/COM_ChannelMatteOperation.h
source/blender/compositor/operations/COM_ChromaMatteOperation.cpp
source/blender/compositor/operations/COM_ChromaMatteOperation.h
source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h
source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp
source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h
source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
source/blender/compositor/operations/COM_ColorCorrectionOperation.h
source/blender/compositor/operations/COM_ColorCurveOperation.cpp
source/blender/compositor/operations/COM_ColorCurveOperation.h
source/blender/compositor/operations/COM_ColorMatteOperation.cpp
source/blender/compositor/operations/COM_ColorMatteOperation.h
source/blender/compositor/operations/COM_ColorRampOperation.cpp
source/blender/compositor/operations/COM_ColorRampOperation.h
source/blender/compositor/operations/COM_ColorSpillOperation.cpp
source/blender/compositor/operations/COM_ColorSpillOperation.h
source/blender/compositor/operations/COM_CombineChannelsOperation.cpp
source/blender/compositor/operations/COM_CombineChannelsOperation.h
source/blender/compositor/operations/COM_CompositorOperation.cpp
source/blender/compositor/operations/COM_CompositorOperation.h
source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp
source/blender/compositor/operations/COM_ConvertColorProfileOperation.h
source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp
source/blender/compositor/operations/COM_ConvertColorToBWOperation.h
source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp
source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h
source/blender/compositor/operations/COM_ConvertColourToValueProg.cpp
source/blender/compositor/operations/COM_ConvertColourToValueProg.h
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h
source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h
source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp
source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h
source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp
source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h
source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h
source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h
source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h
source/blender/compositor/operations/COM_ConvertValueToColourProg.cpp
source/blender/compositor/operations/COM_ConvertValueToColourProg.h
source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp
source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h
source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp
source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h
source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp
source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h
source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h
source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h
source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp
source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp
source/blender/compositor/operations/COM_ConvolutionFilterOperation.h
source/blender/compositor/operations/COM_CropOperation.cpp
source/blender/compositor/operations/COM_CropOperation.h
source/blender/compositor/operations/COM_CurveBaseOperation.cpp
source/blender/compositor/operations/COM_CurveBaseOperation.h
source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
source/blender/compositor/operations/COM_DifferenceMatteOperation.h
source/blender/compositor/operations/COM_DilateErodeOperation.cpp
source/blender/compositor/operations/COM_DilateErodeOperation.h
source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
source/blender/compositor/operations/COM_DirectionalBlurOperation.h
source/blender/compositor/operations/COM_DisplaceOperation.cpp
source/blender/compositor/operations/COM_DisplaceOperation.h
source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp
source/blender/compositor/operations/COM_DisplaceSimpleOperation.h
source/blender/compositor/operations/COM_DistanceMatteOperation.cpp
source/blender/compositor/operations/COM_DistanceMatteOperation.h
source/blender/compositor/operations/COM_DotproductOperation.cpp
source/blender/compositor/operations/COM_DotproductOperation.h
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h
source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
source/blender/compositor/operations/COM_EllipseMaskOperation.h
source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
source/blender/compositor/operations/COM_FlipOperation.cpp
source/blender/compositor/operations/COM_FlipOperation.h
source/blender/compositor/operations/COM_GammaCorrectOperation.cpp
source/blender/compositor/operations/COM_GammaCorrectOperation.h
source/blender/compositor/operations/COM_GammaOperation.cpp
source/blender/compositor/operations/COM_GammaOperation.h
source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h
source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h
source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianXBlurOperation.h
source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianYBlurOperation.h
source/blender/compositor/operations/COM_GlareBaseOperation.cpp
source/blender/compositor/operations/COM_GlareBaseOperation.h
source/blender/compositor/operations/COM_GlareFogGlowOperation.h
source/blender/compositor/operations/COM_GlareGhostOperation.h
source/blender/compositor/operations/COM_GlareSimpleStarOperation.h
source/blender/compositor/operations/COM_GlareStreaksOperation.h
source/blender/compositor/operations/COM_GlareThresholdOperation.cpp
source/blender/compositor/operations/COM_GlareThresholdOperation.h
source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h
source/blender/compositor/operations/COM_IDMaskOperation.cpp
source/blender/compositor/operations/COM_IDMaskOperation.h
source/blender/compositor/operations/COM_ImageOperation.cpp
source/blender/compositor/operations/COM_ImageOperation.h
source/blender/compositor/operations/COM_InvertOperation.cpp
source/blender/compositor/operations/COM_InvertOperation.h
source/blender/compositor/operations/COM_KeyingBlurOperation.cpp
source/blender/compositor/operations/COM_KeyingBlurOperation.h
source/blender/compositor/operations/COM_KeyingClipOperation.cpp
source/blender/compositor/operations/COM_KeyingClipOperation.h
source/blender/compositor/operations/COM_KeyingDespillOperation.cpp
source/blender/compositor/operations/COM_KeyingDespillOperation.h
source/blender/compositor/operations/COM_KeyingOperation.cpp
source/blender/compositor/operations/COM_KeyingOperation.h
source/blender/compositor/operations/COM_KeyingScreenOperation.cpp
source/blender/compositor/operations/COM_KeyingScreenOperation.h
source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp
source/blender/compositor/operations/COM_LuminanceMatteOperation.h
source/blender/compositor/operations/COM_MapUVOperation.cpp
source/blender/compositor/operations/COM_MapUVOperation.h
source/blender/compositor/operations/COM_MapValueOperation.cpp
source/blender/compositor/operations/COM_MapValueOperation.h
source/blender/compositor/operations/COM_MaskOperation.cpp
source/blender/compositor/operations/COM_MaskOperation.h
source/blender/compositor/operations/COM_MathBaseOperation.cpp
source/blender/compositor/operations/COM_MathBaseOperation.h
source/blender/compositor/operations/COM_MixAddOperation.cpp
source/blender/compositor/operations/COM_MixBaseOperation.cpp
source/blender/compositor/operations/COM_MixBaseOperation.h
source/blender/compositor/operations/COM_MixBlendOperation.cpp
source/blender/compositor/operations/COM_MixBurnOperation.cpp
source/blender/compositor/operations/COM_MixColorOperation.cpp
source/blender/compositor/operations/COM_MixDarkenOperation.cpp
source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
source/blender/compositor/operations/COM_MixDivideOperation.cpp
source/blender/compositor/operations/COM_MixDodgeOperation.cpp
source/blender/compositor/operations/COM_MixGlareOperation.cpp
source/blender/compositor/operations/COM_MixHueOperation.cpp
source/blender/compositor/operations/COM_MixLightenOperation.cpp
source/blender/compositor/operations/COM_MixLinearLightOperation.cpp
source/blender/compositor/operations/COM_MixMultiplyOperation.cpp
source/blender/compositor/operations/COM_MixOverlayOperation.cpp
source/blender/compositor/operations/COM_MixSaturationOperation.cpp
source/blender/compositor/operations/COM_MixScreenOperation.cpp
source/blender/compositor/operations/COM_MixSoftLightOperation.cpp
source/blender/compositor/operations/COM_MixSubtractOperation.cpp
source/blender/compositor/operations/COM_MixValueOperation.cpp
source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp
source/blender/compositor/operations/COM_MovieClipAttributeOperation.h
source/blender/compositor/operations/COM_MovieClipOperation.cpp
source/blender/compositor/operations/COM_MovieClipOperation.h
source/blender/compositor/operations/COM_MovieDistortionOperation.cpp
source/blender/compositor/operations/COM_MovieDistortionOperation.h
source/blender/compositor/operations/COM_MultilayerImageOperation.cpp
source/blender/compositor/operations/COM_MultilayerImageOperation.h
source/blender/compositor/operations/COM_NormalizeOperation.cpp
source/blender/compositor/operations/COM_NormalizeOperation.h
source/blender/compositor/operations/COM_OutputFileOperation.cpp
source/blender/compositor/operations/COM_OutputFileOperation.h
source/blender/compositor/operations/COM_PreviewOperation.cpp
source/blender/compositor/operations/COM_PreviewOperation.h
source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp
source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h
source/blender/compositor/operations/COM_QualityStepHelper.cpp
source/blender/compositor/operations/COM_QualityStepHelper.h
source/blender/compositor/operations/COM_ReadBufferOperation.cpp
source/blender/compositor/operations/COM_ReadBufferOperation.h
source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp
source/blender/compositor/operations/COM_RenderLayersBaseProg.h
source/blender/compositor/operations/COM_RenderLayersMistOperation.h
source/blender/compositor/operations/COM_RotateOperation.cpp
source/blender/compositor/operations/COM_RotateOperation.h
source/blender/compositor/operations/COM_ScaleOperation.cpp
source/blender/compositor/operations/COM_ScaleOperation.h
source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp
source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h
source/blender/compositor/operations/COM_SeparateChannelOperation.cpp
source/blender/compositor/operations/COM_SeparateChannelOperation.h
source/blender/compositor/operations/COM_SetAlphaOperation.cpp
source/blender/compositor/operations/COM_SetAlphaOperation.h
source/blender/compositor/operations/COM_SetColorOperation.cpp
source/blender/compositor/operations/COM_SetColorOperation.h
source/blender/compositor/operations/COM_SetSamplerOperation.cpp
source/blender/compositor/operations/COM_SetSamplerOperation.h
source/blender/compositor/operations/COM_SetValueOperation.cpp
source/blender/compositor/operations/COM_SetValueOperation.h
source/blender/compositor/operations/COM_SetVectorOperation.cpp
source/blender/compositor/operations/COM_SetVectorOperation.h
source/blender/compositor/operations/COM_SocketProxyOperation.cpp
source/blender/compositor/operations/COM_SocketProxyOperation.h
source/blender/compositor/operations/COM_SplitViewerOperation.cpp
source/blender/compositor/operations/COM_SplitViewerOperation.h
source/blender/compositor/operations/COM_TextureOperation.cpp
source/blender/compositor/operations/COM_TextureOperation.h
source/blender/compositor/operations/COM_TonemapOperation.cpp
source/blender/compositor/operations/COM_TonemapOperation.h
source/blender/compositor/operations/COM_TranslateOperation.cpp
source/blender/compositor/operations/COM_TranslateOperation.h
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h
source/blender/compositor/operations/COM_VectorBlurOperation.cpp
source/blender/compositor/operations/COM_VectorBlurOperation.h
source/blender/compositor/operations/COM_VectorCurveOperation.cpp
source/blender/compositor/operations/COM_VectorCurveOperation.h
source/blender/compositor/operations/COM_ViewerBaseOperation.cpp
source/blender/compositor/operations/COM_ViewerBaseOperation.h
source/blender/compositor/operations/COM_ViewerOperation.cpp
source/blender/compositor/operations/COM_ViewerOperation.h
source/blender/compositor/operations/COM_WriteBufferOperation.cpp
source/blender/compositor/operations/COM_WriteBufferOperation.h
source/blender/compositor/operations/COM_ZCombineOperation.cpp
source/blender/compositor/operations/COM_ZCombineOperation.h

index 33989fa5787c22408a915926468da78f6d72c817..6ef8a5ff07871f2ba44325dad2da9493129854b9 100644 (file)
 
 NodeOperation::NodeOperation()
 {
-       this->resolutionInputSocketIndex = 0;
-       this->complex = false;
-       this->width = 0;
-       this->height = 0;
-       this->openCL = false;
-       this->btree = NULL;
+       this->m_resolutionInputSocketIndex = 0;
+       this->m_complex = false;
+       this->m_width = 0;
+       this->m_height = 0;
+       this->m_openCL = false;
+       this->m_btree = NULL;
 }
 
 void NodeOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
@@ -47,7 +47,7 @@ void NodeOperation::determineResolution(unsigned int resolution[], unsigned int
        for (unsigned int index = 0; index < inputsockets.size(); index++) {
                InputSocket *inputSocket = inputsockets[index];
                if (inputSocket->isConnected()) {
-                       if (index == this->resolutionInputSocketIndex) {
+                       if (index == this->m_resolutionInputSocketIndex) {
                                inputSocket->determineResolution(resolution, preferredResolution);
                                temp2[0] = resolution[0];
                                temp2[1] = resolution[1];
@@ -58,7 +58,7 @@ void NodeOperation::determineResolution(unsigned int resolution[], unsigned int
        for (unsigned int index = 0; index < inputsockets.size(); index++) {
                InputSocket *inputSocket = inputsockets[index];
                if (inputSocket->isConnected()) {
-                       if (index != resolutionInputSocketIndex) {
+                       if (index != this->m_resolutionInputSocketIndex) {
                                inputSocket->determineResolution(temp, temp2);
                        }
                }
@@ -66,7 +66,7 @@ void NodeOperation::determineResolution(unsigned int resolution[], unsigned int
 }
 void NodeOperation::setResolutionInputSocketIndex(unsigned int index)
 {
-       this->resolutionInputSocketIndex = index;
+       this->m_resolutionInputSocketIndex = index;
 }
 void NodeOperation::initExecution()
 {
@@ -75,22 +75,22 @@ void NodeOperation::initExecution()
 
 void NodeOperation::initMutex()
 {
-       BLI_mutex_init(&mutex);
+       BLI_mutex_init(&this->m_mutex);
 }
 
 void NodeOperation::lockMutex()
 {
-       BLI_mutex_lock(&mutex);
+       BLI_mutex_lock(&this->m_mutex);
 }
 
 void NodeOperation::unlockMutex()
 {
-       BLI_mutex_unlock(&mutex);
+       BLI_mutex_unlock(&this->m_mutex);
 }
 
 void NodeOperation::deinitMutex()
 {
-       BLI_mutex_end(&mutex);
+       BLI_mutex_end(&this->m_mutex);
 }
 
 void NodeOperation::deinitExecution()
index bf2dbd8c9c0a723499883756a471391351d9fdf4..d316cfa0aa44856ad0086a84ebb9eb683611b5ad 100644 (file)
@@ -49,7 +49,7 @@ private:
        /**
         * @brief the index of the input socket that will be used to determine the resolution
         */
-       unsigned int resolutionInputSocketIndex;
+       unsigned int m_resolutionInputSocketIndex;
 
        /**
         * @brief is this operation a complex one.
@@ -57,13 +57,13 @@ private:
         * Complex operations are typically doing many reads to calculate the output of a single pixel.
         * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
         */
-       bool complex;
+       bool m_complex;
 
        /**
         * @brief can this operation be scheduled on an OpenCL device.
         * @note Only applicable if complex is True
         */
-       bool openCL;
+       bool m_openCL;
 
        /**
         * @brief mutex reference for very special node initializations
@@ -74,12 +74,12 @@ private:
         * @see NodeOperation.deinitMutex deinitializes this mutex
         * @see NodeOperation.getMutex retrieve a pointer to this mutex.
         */
-       ThreadMutex mutex;
+       ThreadMutex m_mutex;
        
        /**
         * @brief reference to the editing bNodeTree only used for break callback
         */
-       const bNodeTree *btree;
+       const bNodeTree *m_btree;
 
 public:
        /**
@@ -124,7 +124,7 @@ public:
        virtual int isBufferOperation() { return false; }
        virtual int isSingleThreaded() { return false; }
 
-       void setbNodeTree(const bNodeTree *tree) { this->btree = tree; }
+       void setbNodeTree(const bNodeTree *tree) { this->m_btree = tree; }
        virtual void initExecution();
        
        /**
@@ -167,7 +167,7 @@ public:
        virtual void deinitExecution();
 
        bool isResolutionSet() {
-               return this->width != 0 && height != 0;
+               return this->m_width != 0 && this->m_height != 0;
        }
 
        /**
@@ -176,8 +176,8 @@ public:
         */
        void setResolution(unsigned int resolution[]) {
                if (!isResolutionSet()) {
-                       this->width = resolution[0];
-                       this->height = resolution[1];
+                       this->m_width = resolution[0];
+                       this->m_height = resolution[1];
                }
        }
        
@@ -190,7 +190,7 @@ public:
         * Complex operations are typically doing many reads to calculate the output of a single pixel.
         * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
         */
-       const bool isComplex() const { return this->complex; }
+       const bool isComplex() const { return this->m_complex; }
        virtual const bool isSetOperation() const { return false; }
 
        /**
@@ -235,20 +235,20 @@ public:
         * @see WorkScheduler.schedule
         * @see ExecutionGroup.addOperation
         */
-       bool isOpenCL() { return this->openCL; }
+       bool isOpenCL() { return this->m_openCL; }
        
        virtual bool isViewerOperation() { return false; }
        virtual bool isPreviewOperation() { return false; }
        
        inline bool isBreaked() {
-               return btree->test_break(btree->tbh);
+               return this->m_btree->test_break(this->m_btree->tbh);
        }
 
 protected:
        NodeOperation();
 
-       void setWidth(unsigned int width) { this->width = width; }
-       void setHeight(unsigned int height) { this->height = height; }
+       void setWidth(unsigned int width) { this->m_width = width; }
+       void setHeight(unsigned int height) { this->m_height = height; }
        SocketReader *getInputSocketReader(unsigned int inputSocketindex);
        NodeOperation *getInputOperation(unsigned int inputSocketindex);
 
@@ -264,12 +264,12 @@ protected:
         * Complex operations are typically doing many reads to calculate the output of a single pixel.
         * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
         */
-       void setComplex(bool complex) { this->complex = complex; }
+       void setComplex(bool complex) { this->m_complex = complex; }
 
        /**
         * @brief set if this NodeOperation can be scheduled on a OpenCLDevice
         */
-       void setOpenCL(bool openCL) { this->openCL = openCL; }
+       void setOpenCL(bool openCL) { this->m_openCL = openCL; }
 
 #ifdef WITH_CXX_GUARDEDALLOC
        MEM_CXX_CLASS_ALLOC_FUNCS("COM:NodeOperation")
index df8899e8eeabf740a7b7dbfa0b84befe53c43fe0..0f35fcfb0dfe329d9040cd3788e7a10138f5d96e 100644 (file)
@@ -47,12 +47,12 @@ protected:
        /**
         * @brief Holds the width of the output of this operation.
         */
-       unsigned int width;
+       unsigned int m_width;
 
        /**
         * @brief Holds the height of the output of this operation.
         */
-       unsigned int height;
+       unsigned int m_height;
 
 
        /**
@@ -108,8 +108,8 @@ public:
        virtual MemoryBuffer *getInputMemoryBuffer(MemoryBuffer **memoryBuffers) { return 0; }
 
 
-       inline const unsigned int getWidth() const { return this->width; }
-       inline const unsigned int getHeight() const { return this->height; }
+       inline const unsigned int getWidth() const { return this->m_width; }
+       inline const unsigned int getHeight() const { return this->m_height; }
 
 #ifdef WITH_CXX_GUARDEDALLOC
        MEM_CXX_CLASS_ALLOC_FUNCS("COM:SocketReader")
index e614e1fa15ad0ff18e0dfc9aa6591fae1f0623f1..e688332a039726c1cc52fd3eb81a2825c9c718c2 100644 (file)
@@ -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);
index 81c1e4d258754a0b92114143faa060212cc262cf..b521a2a541511f1e29ae0f1b8c9a206d8524c166 100644 (file)
@@ -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);
index a6bf8b8834c4295e252568609e01bca446a6232e..b2c40a058baa4d9006e26819063795363cdaa101 100644 (file)
@@ -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) {
index 458d11f26169700e8b6ad7dca86e4d28047117d3..46fa07893e89738a49c6345f6ebe387ebb9f681c 100644 (file)
@@ -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;
 }
index 906da598da1deba03aecc844757e087800a4e975..3d9bcf6d90a87d9b31b01bac9ce4a5bb50ae6fcd 100644 (file)
@@ -35,8 +35,8 @@ protected:
        /**
         * @brief Cached reference to the reader
         */
-       SocketReader *valueReader;
-       char *buffer;
+       SocketReader *m_valueReader;
+       char *m_buffer;
 public:
        AntiAliasOperation();
        
index 3628c3995812a642b4b3ecba72a374bad53bd6f5..4f7f5eea8a0a3e4cfddf04367ae286c9bd51a5df 100644 (file)
@@ -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);
index 08b379dc4eabcead5ad8ea38884a3c093f274365..be6ce7a221e888b15a7d19891b03b7e27433e8aa 100644 (file)
 
 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
index df64b7c8ddcfc7f75f016ebec75e1b17ef6f0317..d1ddecc0df6ab14fa2ed3a726671789769362974 100644 (file)
@@ -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;
        }
 }
index 8f7208274dbcb5a393b05ca3f38673e5a6f7d2de..6d60abf09bffc0b059d1e3b4cb6189ddeda31424 100644 (file)
@@ -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
index 9fe5abcb07515d809e37a85a140e2441a44bebf8..fb06f6d37614fe9f3f3e1f2e73d599ab13e93854 100644 (file)
@@ -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);
index 853855d5c34fcfc843b23dd8e2ae47225ff4b935..0433a4156a82914b9de0e7a4bdf67c89e8a2bcce 100644 (file)
 
 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<cl_mem> *clMemToCleanUp, list<cl_kernel> *clKernelsToCleanUp);
 };
index abb378e2adb995164df469e965959abaf413d7cc..90e272438d618c017f58e8e4efd5b8dec0c7931c 100644 (file)
 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;
                }
        }
 }
index 8edd32a4f77adb8ce7a6b6a79d271cadf4443b6c..085aaa471f008c74c35d89fd6da8a5443cd74a71 100644 (file)
 
 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
index 3b99fc9a2a0d430a62c9321697e3f2f04b5447f3..96738a2920aaf491163b22bc3ec9e1dac913e38d 100644 (file)
@@ -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;
 }
 
index 65327abc9a666fe08c0e0234b9526baa287b804e..cec680ef6c3202a325dbf59f78dab1fd04d78764 100644 (file)
@@ -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
index 95862a1fd831c1bb92ea040863c9cc85f197f249..8c9fb6394a72e05a9a29ad69dc8d0bb0980cf6d7 100644 (file)
@@ -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;
 }
 
index 74c648fd8fb95153a9bd8f693a365fd4b0b0c5bd..61f667aa1be174508fe0539df4d76654175f118e 100644 (file)
@@ -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();
index fe6be55e2372318b0b3b32112682b333a17f6fa7..a1c679b3e154a2ef393495f972878795e80d6b9e 100644 (file)
@@ -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;
 }
index 7a28eb3774a17c770c9197965ffea1d6da803795..2bd723c40a350ecd1e8b73c7da918895506dd8eb 100644 (file)
@@ -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);
index 811975c5e1348686b8eefe9ea9a7760aa67cf442..2d860df449c4071df32e2c11a5c352f64beb931f 100644 (file)
@@ -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;
index d3163d4cc32a81dfdbccc88a214b34cc197af82a..506c5d6fe3a77bc3faaa6586a1db562742579f44 100644 (file)
@@ -31,7 +31,7 @@
  */
 class CalculateStandardDeviationOperation : public CalculateMeanOperation {
 protected:
-       float standardDeviation;
+       float m_standardDeviation;
 
 public:
        CalculateStandardDeviationOperation();
index 487c1869782d49d077856b7911db8e9da0fa6d5a..0812dd45bf66202b63a873929f8ce297ca1afb80 100644 (file)
@@ -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];
 }
 
index a2a6c034a823a6296bba738eaca8eae39b792600..9c343db9c3cc200dbbe3ca354d791649f91f26ed 100644 (file)
  */
 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
index 24af1a3aa53072fd6edecdec8159d0a470842a03..b2de934e6d8f1815db89e0c76948829dcdcb069e 100644 (file)
@@ -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) {
index 17db0f9ffe29957a37ab6219d5c107397f369606..859df2000201aed254f79ba043010ce77d22a281 100644 (file)
  */
 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
index 0ce1a585598522278652f490c9e7961b2276ef12..e88feb6db9c781d72af31a91a3844cc628f2fc9d 100644 (file)
@@ -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
index a09203f29b3e3b92b9edb9faf75946814c86dc9a..472a797fa2830db9a93f88e83f775bb7f634279d 100644 (file)
@@ -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
index a48fe169fd70cdca7e8889824bcd8e9b15833d52..66ce86234b799d36068e3ff35880102a3507bcef 100644 (file)
@@ -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;
 }
index 9e7db59d99da0524731866b9fd98812e7b3cc8d8..479927d30d174531dfcef86c56e09bdcd8959dd2 100644 (file)
@@ -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
index 7a8d62dfe21316129e816ac1a80c70d24775bb40..13863a9ec5a083d991ccb40505e1ab05a857f659 100644 (file)
@@ -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;
 }
index 54cfb49327f076b2f3fcb0ef723634a4d0b66421..ec3652da09e1b4977a2d8e377cb497e15e9f2afa 100644 (file)
@@ -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
index 5f62f9ec403f7ed6096317345421aa89939e6c18..8008866752ff2bfacd89179f8bfbf4bc49050bc9 100644 (file)
@@ -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;
 }
 
index c0c33f7f2fa277b214e69155b8a771b9f61fc0d5..8db3870709e7e19bd91365bc474b10fc954327cf 100644 (file)
@@ -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
index 4feac3e72735753dd093c6a6efb1310326527079..9848d191c04c911782814582c490e21d3aff1537 100644 (file)
@@ -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);
 }
index fcd78be8372eb817f8f181908fd66512e023cbf9..3bcbc31650cfe3fc184642b4c934bbe3b59aaa8f 100644 (file)
@@ -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
index afb362dbdcd41708a2a7f7dc9a9eea7f68dd984d..4a01499b0601c267416cec3cca21620bbacda71d 100644 (file)
@@ -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
index e5dd9efd820fc87b3014d912c55dbd84d0997ac7..ae904f8f938475a7fff239a37f547a536015e41c 100644 (file)
@@ -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
index 9af70ddc5a7f5d55445af2b0fd3f88efdc241ffd..95dca0dc410200093dea171f28c9adb25ad14033 100644 (file)
@@ -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;
 }
index eef5321eb19d1d2aab989d90b71221c1b9de1173..42bc6b943b7f906e7fc8a5d4588f72056e1d8323 100644 (file)
@@ -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;
        }
 
 
index 1a534d778c0c0691797d7e302cb3b68c77fbe3c3..e2773f3a6b40bb1fae1446dc41d628424b35e617 100644 (file)
@@ -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])));
 }
index e890a1e15649314b5c33edab31fd467c42c68286..6e3156819b2aadfe821212a912c1f67643a5c811 100644 (file)
  */
 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);
 };
index fb4e6f03e76dfa36a3be7e079b534cdb7f194399..9f175a381a40b3f8727325dd2faf648b41ad0d8a 100644 (file)
@@ -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];
        }
 }
index cc71f44b4f58fc18d882a77b9031075291a16278..8e4c2120614564a44cadf5b5e95dbdc601d7febf 100644 (file)
 
 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[]);
index 936cbaadd8479ae29b748458ded68792cf0ff4ab..717b6ce76cce192c6e675673e2cbdd940567562c 100644 (file)
@@ -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) {
index 280f39b772936c3ba492a2681d6ba09a2ea64c3b..2719d376339a97282557f191e1d5cfd1a49992db 100644 (file)
@@ -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();
index 2e8fc9005b8ca269f9d12fb1d087d7082e2f6861..4d829eae7a0b5fdc931a1c0f7e565f2af84050cd 100644 (file)
@@ -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;
 }
index b11a06f774976041ad65c29045628d184d2003e2..0b9a07a57cad206751a3b5b69391637beef65be2 100644 (file)
@@ -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
index 0e2c1e29a1d55fe467246bea857b7795da681665..a8c57449a2ea0d0007488f24b43c0a81a34fa16d 100644 (file)
@@ -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;
 }
index 814c0c2e8081d5f273c53813f8f0618f6510eaf1..2a57c997196340aca854ab9004cabc336d44190e 100644 (file)
@@ -34,7 +34,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index 613bfe68fbb3fa06930b2f254f80456cbf4e868b..6c79c4ea6a3be30ac94e0d9aeb68457879da5f12 100644 (file)
@@ -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;
 }
index 1167b565a8e05fdc7af0c968b68170781c1aff1d..f9170dfc7aa4999658c26c6f9c3004042e95bf81 100644 (file)
@@ -34,7 +34,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index 2c8caec6f619e8ae86b1a8a6bb564cfc9ed39903..c872f3e85bb0f3dc378968d09f854696388c8f97 100644 (file)
@@ -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;
 }
index 9c43ec476045e1c4e9f582fcd25e27ffea520122..ebd4bcbd59b18a03b8a5ea61490333fc9cb16f5a 100644 (file)
@@ -34,7 +34,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index 1746afea713d8ec2081641fc7685a6e358a98c18..91b68a90126d5c359b665faefaf72aa34620c97d 100644 (file)
@@ -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;
 }
index c6da6bc94a967246f1d13111470ec9558b8ba6b3..966a74c04ad3de3695b40a5e83e4e9e1a2fe94af 100644 (file)
@@ -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
index e8c0061319c8a0906656db292075962bd33aa6e2..5149e37020805fe34386b02cea2041c3180d8732 100644 (file)
@@ -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;
 }
 
index 29c82361d12aa7401a3ce8bb712161cf76d0d7eb..f8b6a4c11fabba1ec35e40c7acf215b95c97c9d0 100644 (file)
@@ -34,7 +34,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index 842546a2755423e88c9617b0278059014b79a761..b7db0a6a2c71c0a74e6c48f12563195c75660650 100644 (file)
@@ -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;
 }
index fe0586f7a889b9b6728ea8ae70713c508aefc417..2b5e1871972b694fbba4a1e3b4c824e62c3bdef8 100644 (file)
@@ -30,7 +30,7 @@
  */
 class ConvertKeyToPremulOperation : public NodeOperation {
 private:
-       SocketReader *inputColor;
+       SocketReader *m_inputColor;
 public:
        /**
         * Default constructor
index 3554be53e3f4fd303939d509e1a7676037e1cf20..0ba23b2ec2ec8e694128919cba3aff244ef2a03e 100644 (file)
@@ -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;
 }
index 093f28df3e5df6ebd93c2d49e7ef089ed75d0e33..05c6b26b171fb7b0115ab18d75ab5dc216b7e0dc 100644 (file)
@@ -30,7 +30,7 @@
  */
 class ConvertPremulToKeyOperation : public NodeOperation {
 private:
-       SocketReader *inputColor;
+       SocketReader *m_inputColor;
 public:
        /**
         * Default constructor
index 051d9d2b8f9f110fa8cb1f689f68b7f4c234b3a6..dd5e99076429b2c4f5a099218819c365ddbada62 100644 (file)
@@ -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;
 }
index 61270539e707a1fa4d742fc477adf93994fd94ff..af8a7f78a6119ef83e6ba9cbe92c2858d5becffe 100644 (file)
@@ -34,7 +34,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index d984a1ab943ff7a6ffa651a79afe0a706b9cb27f..e4322ae728fe69b4eddfc55bc8787d99882f62e3 100644 (file)
@@ -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;
 }
index 33075cda509b12feed7a3b2985080dec469f4fda..97fbdb29874ef7112c3c428b4c3515ee3d63c975 100644 (file)
@@ -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
index e5a8e7de1bb441936bf504e1b514cd98267ef65a..e87a765f2eb844856e3eb8c392beef730fb66e3a 100644 (file)
@@ -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;
 }
index 4fc525456f890dcac035654d4dbe93ef20cdd8d7..89998897782188e703c64981b170a7333f623dd6 100644 (file)
@@ -33,7 +33,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index 9d95c51a546a70bf56703cdfa747c33c92176201..a29a381938fd34ba5db23ac3d41771885a9cdc86 100644 (file)
@@ -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;
 }
index ff1d1aaeae7851e2063824b7460d68fa7d962500..69ce7e9afea95f6a44c73dc44329355589cccb92 100644 (file)
@@ -30,7 +30,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputProgram;
+       SocketReader *m_inputProgram;
 public:
        ConvertValueToColourProg();
        
index 5ba3f6ef4a96f961cb3298b607446d8b72ee9cba..37760fe26d7d9bf06fb3a1ded7ce2642283d0ba2 100644 (file)
@@ -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;
 }
index fbb294d6a26ac8229ec4b7a125836a36c93f74cd..781b31f7fcecd6c8ed17e6b2cacd8919309b21ec 100644 (file)
@@ -34,7 +34,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index f6a2072932ccbaaaa69406b75b79ebbaf827eecc..395b96e8b253ac7c2d57bcb4a64ac190b8e71a52 100644 (file)
@@ -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;
 }
index c26adc5a6b10ddc2851adcbc5dbd068d3d59868f..2f1173ba4e86c34006e909dcbf4f52e5b1b2f38d 100644 (file)
@@ -34,7 +34,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index ef2d45eea03ea1c78ab3bf08dbd3c1ecce12680d..68842c5a055bfd585c2806daae8f6a35e42529ac 100644 (file)
@@ -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;
 }
index dd29d1bb9a9b5572b11095331637cd5a1d658a55..8770992c69ce1b210229951272e80a563544786a 100644 (file)
@@ -34,7 +34,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index 373de25a276b89daf9e0493938413ceee0cb064e..11f4dd5a2d669b4a275b000708bcc986888f4ea6 100644 (file)
@@ -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;
 }
 
index d7ddd910ed7d7d810f481b12fa08e515dda86123..a595fc19bc7bf4f2c2b514de6366d9ea0470c77b 100644 (file)
@@ -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
index a77806d16d04bc320a81089e719b59d7646bbf4a..b4393c53b920e92ddb6b447880274b88b6a84475 100644 (file)
@@ -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;
 }
 
index f77954606cfa5512a42a2512b08fe7c96cff8e83..e89f1500d69ec0cd90e1468b9b65d7c28041f065 100644 (file)
@@ -33,7 +33,7 @@ private:
        /**
         * Cached reference to the inputProgram
         */
-       SocketReader *inputOperation;
+       SocketReader *m_inputOperation;
 public:
        /**
         * Default constructor
index 5ac8c2254dc83d5dc037d50197ae0afec69ccba7..cf3ffe6d8f49bea017dcc4f825101af221b53db8 100644 (file)
@@ -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]);
index b4f2714360ec4f2058798196b1986522cd5d5441..3840e775fe37812cdba1f38f33538ca8e580e0fb 100644 (file)
@@ -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;
index f3347eb583a15de2850e45bcb354f22579d4a3a3..0b5dfb4d75a2bb1c999796c6b84340d2d93725ce 100644 (file)
 
 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();
index 0bdd2cfcb516f38b29eb4224b135a8cf44a8b823..0a40f2370c8e9c6588b89e94f84df877863dd06c 100644 (file)
@@ -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);
 }
index 48e5ab7f75bf885c94864817b10a8317ef00fdba..39dbb8aa873335eef3adedd3f5db34f014b044ef 100644 (file)
 
 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 {
index 6aa8bc2a0dffac895584a4174798d05f6138ffa1..48d2bcd0ef9211d56da76c5ff35f273e20323672 100644 (file)
@@ -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);
 }
index 9cddb3be46b1727d75776f00839dfaa7b38eb20e..1636c13a571a52b5773bb1a3aea30a29e6352472 100644 (file)
@@ -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
index c27e699f6274a1c060860e12e6a57aac6af1e94f..75f909e21982a3c8682810ef313bbb409526d13d 100644 (file)
@@ -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]) +
index 3bdc3384556a8a5290ddd57f2b0a0c41a410ccd2..48eb2626f02471438b3dbbe91013c09b243d72e7 100644 (file)
@@ -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
index 80d1c6444eb7c94f842399616eeaa674a9d24c19..338a3a0b59ba88275b53c545aadcd9a6c570a712 100644 (file)
@@ -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;
 }
index 4d0bf9de0ec57a9ca5618fafccce81e9dad96d0a..bc6049bf992b4bd8ce03e4edd0ffa1089a239af8 100644 (file)
@@ -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);
 };
index 271a165f0ff6599c7e4d0f0b6821aaecd7482c6a..da7336afc0705af2692b1dbd62608c2c3ac5bbb0 100644 (file)
@@ -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)
index 9cc0a4361f19c3097c886d09e33e93ca652dd79c..329f855871e6237b02cf909b621614392059d617 100644 (file)
 
 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
index be50641a1253047531fedb87c509fbb776365dc2..c7df53770c522fcebea2a4cd24f98962bbd4a678 100644 (file)
@@ -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)
index 82788e37e3abd2f2dfec328186fbc85d47fa6414..e01c919039642965936fb966b292e855d689cca5 100644 (file)
@@ -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();
index 716646e9c36025101626a5989fae0422cc977eb6..d21fc62abd7b5ef6bf2cde3d3f213445ee086b09 100644 (file)
@@ -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)
index 1ebb238855ba8f39be4175c6ae45a34668a417b9..25afbafe3358bbc0df23dd94c33dfbf9872ca56a 100644 (file)
@@ -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();
index ec01ba922b562a5d8116ebd3330fb74c605eeff0..19cca3d25bbe07ead6e6aebcb786cf5373de4c60 100644 (file)
@@ -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) +
index cf1172a8c111a097242697f799cf1b8a98bb082b..51e139d179e1bd6eb35e08f974589725f59e12fb 100644 (file)
@@ -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&