svn merge ^/trunk/blender -r48288:48302
authorCampbell Barton <ideasman42@gmail.com>
Tue, 26 Jun 2012 07:44:59 +0000 (07:44 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 26 Jun 2012 07:44:59 +0000 (07:44 +0000)
339 files changed:
source/blender/compositor/intern/COM_ChannelInfo.cpp
source/blender/compositor/intern/COM_ChannelInfo.h
source/blender/compositor/intern/COM_ChunkOrder.cpp
source/blender/compositor/intern/COM_ChunkOrder.h
source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp
source/blender/compositor/intern/COM_ChunkOrderHotspot.h
source/blender/compositor/intern/COM_CompositorContext.cpp
source/blender/compositor/intern/COM_CompositorContext.h
source/blender/compositor/intern/COM_Converter.cpp
source/blender/compositor/intern/COM_Converter.h
source/blender/compositor/intern/COM_ExecutionGroup.cpp
source/blender/compositor/intern/COM_ExecutionGroup.h
source/blender/compositor/intern/COM_ExecutionSystem.cpp
source/blender/compositor/intern/COM_ExecutionSystem.h
source/blender/compositor/intern/COM_ExecutionSystemHelper.cpp
source/blender/compositor/intern/COM_ExecutionSystemHelper.h
source/blender/compositor/intern/COM_InputSocket.cpp
source/blender/compositor/intern/COM_InputSocket.h
source/blender/compositor/intern/COM_MemoryBuffer.cpp
source/blender/compositor/intern/COM_MemoryBuffer.h
source/blender/compositor/intern/COM_MemoryProxy.cpp
source/blender/compositor/intern/COM_MemoryProxy.h
source/blender/compositor/intern/COM_Node.cpp
source/blender/compositor/intern/COM_Node.h
source/blender/compositor/intern/COM_NodeBase.cpp
source/blender/compositor/intern/COM_NodeBase.h
source/blender/compositor/intern/COM_NodeOperation.cpp
source/blender/compositor/intern/COM_NodeOperation.h
source/blender/compositor/intern/COM_OpenCLDevice.cpp
source/blender/compositor/intern/COM_OpenCLDevice.h
source/blender/compositor/intern/COM_OutputSocket.cpp
source/blender/compositor/intern/COM_OutputSocket.h
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
source/blender/compositor/intern/COM_Socket.cpp
source/blender/compositor/intern/COM_Socket.h
source/blender/compositor/intern/COM_SocketConnection.cpp
source/blender/compositor/intern/COM_SocketConnection.h
source/blender/compositor/intern/COM_SocketReader.h
source/blender/compositor/intern/COM_WorkPackage.cpp
source/blender/compositor/intern/COM_WorkPackage.h
source/blender/compositor/intern/COM_WorkScheduler.cpp
source/blender/compositor/nodes/COM_AlphaOverNode.h
source/blender/compositor/nodes/COM_BlurNode.h
source/blender/compositor/nodes/COM_BokehBlurNode.h
source/blender/compositor/nodes/COM_ChannelMatteNode.h
source/blender/compositor/nodes/COM_ChromaMatteNode.h
source/blender/compositor/nodes/COM_ColorBalanceNode.h
source/blender/compositor/nodes/COM_ColorMatteNode.h
source/blender/compositor/nodes/COM_ColorRampNode.h
source/blender/compositor/nodes/COM_ColorSpillNode.h
source/blender/compositor/nodes/COM_ColorToBWNode.h
source/blender/compositor/nodes/COM_CombineHSVANode.h
source/blender/compositor/nodes/COM_CombineRGBANode.h
source/blender/compositor/nodes/COM_CombineYCCANode.h
source/blender/compositor/nodes/COM_CombineYUVANode.h
source/blender/compositor/nodes/COM_CompositorNode.h
source/blender/compositor/nodes/COM_ConvertAlphaNode.h
source/blender/compositor/nodes/COM_CropNode.h
source/blender/compositor/nodes/COM_DefocusNode.h
source/blender/compositor/nodes/COM_DifferenceMatteNode.h
source/blender/compositor/nodes/COM_DilateErodeNode.cpp
source/blender/compositor/nodes/COM_DilateErodeNode.h
source/blender/compositor/nodes/COM_DisplaceNode.h
source/blender/compositor/nodes/COM_DistanceMatteNode.h
source/blender/compositor/nodes/COM_FilterNode.h
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
source/blender/compositor/nodes/COM_HueSaturationValueNode.h
source/blender/compositor/nodes/COM_ImageNode.h
source/blender/compositor/nodes/COM_KeyingNode.cpp
source/blender/compositor/nodes/COM_KeyingNode.h
source/blender/compositor/nodes/COM_KeyingScreenNode.h
source/blender/compositor/nodes/COM_LuminanceMatteNode.h
source/blender/compositor/nodes/COM_MapUVNode.h
source/blender/compositor/nodes/COM_MapValueNode.h
source/blender/compositor/nodes/COM_MaskNode.h
source/blender/compositor/nodes/COM_MathNode.h
source/blender/compositor/nodes/COM_MixNode.h
source/blender/compositor/nodes/COM_MovieClipNode.h
source/blender/compositor/nodes/COM_NormalNode.h
source/blender/compositor/nodes/COM_OutputFileNode.h
source/blender/compositor/nodes/COM_SeparateHSVANode.h
source/blender/compositor/nodes/COM_SeparateRGBANode.h
source/blender/compositor/nodes/COM_SeparateYCCANode.h
source/blender/compositor/nodes/COM_SeparateYUVANode.h
source/blender/compositor/nodes/COM_SetAlphaNode.h
source/blender/compositor/nodes/COM_SplitViewerNode.h
source/blender/compositor/nodes/COM_Stabilize2dNode.h
source/blender/compositor/nodes/COM_SwitchNode.h
source/blender/compositor/nodes/COM_TrackPositionNode.h
source/blender/compositor/nodes/COM_TransformNode.h
source/blender/compositor/nodes/COM_ViewerNode.h
source/blender/compositor/nodes/COM_ZCombineNode.h
source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp
source/blender/compositor/operations/COM_AlphaOverMixedOperation.h
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
source/blender/editors/gpencil/gpencil_buttons.c

index f2fa62006d52d99269c41af830fe0d2dd2be72d9..557075cdc80bceb75f7684733fa49c4a5a838f68 100644 (file)
@@ -29,7 +29,7 @@
  */
 ChannelInfo::ChannelInfo()
 {
-       this->number = 0;
-       this->premultiplied = true;
-       this->type = COM_CT_UNUSED;
+       this->m_number = 0;
+       this->m_premultiplied = true;
+       this->m_type = COM_CT_UNUSED;
 }
index 399fdc62fa231f40a3e0f5bc445e9078016805ee..446644423596a89676a1a8aaabe9a84c3b0ee550 100644 (file)
@@ -61,23 +61,23 @@ private:
        /**
         * @brief the channel number, in the connection. [0-3]
         */
-       int number;
+       int m_number;
 
        /**
         * @brief type of channel
         */
-       ChannelType type;
+       ChannelType m_type;
 
        /**
         * @brieg Is this value in this channel premultiplied with its alpha
         * @note only valid if type = ColorComponent;
         */
-       bool premultiplied;
+       bool m_premultiplied;
 
 //     /**
-//       * Color space of this value.
-//       * only valid when type = ColorComponent;
-//       */
+//      * Color space of this value.
+//      * only valid when type = ColorComponent;
+//      */
 //     string colorspacename;
 
 public:
@@ -89,32 +89,32 @@ public:
        /**
         * @brief set the index of this channel in the SocketConnection
         */
-       void setNumber(const int number) { this->number = number; }
+       void setNumber(const int number) { this->m_number = number; }
 
        /**
         * @brief get the index of this channel in the SocketConnection
         */
-       const int getNumber() const { return this->number; }
+       const int getNumber() const { return this->m_number; }
 
        /**
         * @brief set the type of channel
         */
-       void setType(const ChannelType type) { this->type = type; }
+       void setType(const ChannelType type) { this->m_type = type; }
 
        /**
         * @brief get the type of channel
         */
-       const ChannelType getType() const { return this->type; }
+       const ChannelType getType() const { return this->m_type; }
 
        /**
         * @brief set the premultiplicatioin of this channel
         */
-       void setPremultiplied(const bool premultiplied) { this->premultiplied = premultiplied; }
+       void setPremultiplied(const bool premultiplied) { this->m_premultiplied = premultiplied; }
 
        /**
         * @brief is this channel premultiplied
         */
-       const bool isPremultiplied() const { return this->premultiplied; }
+       const bool isPremultiplied() const { return this->m_premultiplied; }
 };
 
 
index 02c28a1997ae45017475f33316738d1a4d6b52c8..38a3350c2635decbab0478bf23fb216163aa3b38 100644 (file)
 
 ChunkOrder::ChunkOrder()
 {
-       this->distance = 0.0;
-       this->number = 0;
-       this->x = 0;
-       this->y = 0;
+       this->m_distance = 0.0;
+       this->m_number = 0;
+       this->m_x = 0;
+       this->m_y = 0;
 }
 
 void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots)
@@ -37,15 +37,15 @@ void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int nu
        double distance = MAXFLOAT;
        for (index = 0; index < numberOfHotspots; index++) {
                ChunkOrderHotspot *hotspot = hotspots[index];
-               double ndistance = hotspot->determineDistance(this->x, this->y);
+               double ndistance = hotspot->determineDistance(this->m_x, this->m_y);
                if (ndistance < distance) {
                        distance = ndistance;
                }
        }
-       this->distance = distance;
+       this->m_distance = distance;
 }
 
 bool operator<(const ChunkOrder& a, const ChunkOrder& b)
 {
-       return a.distance < b.distance;
+       return a.m_distance < b.m_distance;
 }
index f096ebeebfeee58c19ff038968cbbb6f27919377..190ecb9c380f2c347ca0e85c7161d9ccae257993 100644 (file)
 #include "COM_ChunkOrderHotspot.h"
 class ChunkOrder {
 private:
-       unsigned int number;
-       int x;
-       int y;
-       double distance;
+       unsigned int m_number;
+       int m_x;
+       int m_y;
+       double m_distance;
 public:
        ChunkOrder();
        void determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots);
        friend bool operator<(const ChunkOrder& a, const ChunkOrder& b);
        
-       void setChunkNumber(unsigned int chunknumber) { this->number = chunknumber; }
-       void setX(int x) { this->x = x; }
-       void setY(int y) { this->y = y; }
-       unsigned int getChunkNumber() { return this->number; }
-       double getDistance() { return this->distance; }
+       void setChunkNumber(unsigned int chunknumber) { this->m_number = chunknumber; }
+       void setX(int x) { this->m_x = x; }
+       void setY(int y) { this->m_y = y; }
+       unsigned int getChunkNumber() { return this->m_number; }
+       double getDistance() { return this->m_distance; }
 };
 
 #endif
index 96568092b7250ae16766bb84fbe8232ea09c8200..1e64e0b9ea0c9d6ca5c224743a7101b391a4570e 100644 (file)
 
 ChunkOrderHotspot::ChunkOrderHotspot(int x, int y, float addition)
 {
-       this->x = x;
-       this->y = y;
-       this->addition = addition;
+       this->m_x = x;
+       this->m_y = y;
+       this->m_addition = addition;
 }
 
 double ChunkOrderHotspot::determineDistance(int x, int y)
 {
-       int dx = x - this->x;
-       int dy = y - this->y;
+       int dx = x - this->m_x;
+       int dy = y - this->m_y;
        double result = sqrt((double)(dx * dx + dy * dy));
-       result += (double)this->addition;
+       result += (double)this->m_addition;
        return result;
 }
index 68140745f8b900616b6df9f1cfda958b2ba544df..b166a7af57f39ff957916b1132f482326a1ca475 100644 (file)
@@ -29,9 +29,9 @@
 
 class ChunkOrderHotspot {
 private:
-       int x;
-       int y;
-       float addition;
+       int m_x;
+       int m_y;
+       float m_addition;
 
 public:
        ChunkOrderHotspot(int x, int y, float addition);
index c3470f0a16eb8a39c02b25b210d23d1f390641f4..56335630b8065890e5621929251adaa3cc7f927c 100644 (file)
 
 CompositorContext::CompositorContext()
 {
-       this->rd = NULL;
-       this->quality = COM_QUALITY_HIGH;
-       this->hasActiveOpenCLDevices = false;
-       this->activegNode = NULL;
+       this->m_rd = NULL;
+       this->m_quality = COM_QUALITY_HIGH;
+       this->m_hasActiveOpenCLDevices = false;
+       this->m_activegNode = NULL;
 }
 
 const int CompositorContext::getFramenumber() const
 {
-       if (this->rd) {
-               return this->rd->cfra;
+       if (this->m_rd) {
+               return this->m_rd->cfra;
        }
        else {
                return -1; /* this should never happen */
@@ -44,8 +44,8 @@ const int CompositorContext::getFramenumber() const
 
 const int CompositorContext::isColorManaged() const
 {
-       if (this->rd) {
-               return this->rd->color_mgt_flag & R_COLOR_MANAGEMENT;
+       if (this->m_rd) {
+               return this->m_rd->color_mgt_flag & R_COLOR_MANAGEMENT;
        }
        else {
                return 0; /* this should never happen */
index 81fd81b4117a62a43ba5950497051832b0491ce2..49acda811f109be7d757bd835e1c3b07bdd74c94 100644 (file)
@@ -41,38 +41,38 @@ private:
         * This field is initialized in ExecutionSystem and must only be read from that point on.
         * @see ExecutionSystem
         */
-       bool rendering;
+       bool m_rendering;
 
        /**
         * @brief The quality of the composite.
         * This field is initialized in ExecutionSystem and must only be read from that point on.
         * @see ExecutionSystem
         */
-       CompositorQuality quality;
+       CompositorQuality m_quality;
 
        /**
         * @brief Reference to the render data that is being composited.
         * This field is initialized in ExecutionSystem and must only be read from that point on.
         * @see ExecutionSystem
         */
-       RenderData *rd;
+       RenderData *m_rd;
 
        /**
         * @brief reference to the bNodeTree
         * This field is initialized in ExecutionSystem and must only be read from that point on.
         * @see ExecutionSystem
         */
-       bNodeTree *bnodetree;
+       bNodeTree *m_bnodetree;
        
        /**
         * @brief activegNode the group node that is currently being edited.
         */
-       bNode *activegNode;
+       bNode *m_activegNode;
 
        /**
         * @brief does this system have active opencl devices?
         */
-       bool hasActiveOpenCLDevices;
+       bool m_hasActiveOpenCLDevices;
 
 public:
        /**
@@ -83,56 +83,52 @@ public:
        /**
         * @brief set the rendering field of the context
         */
-       void setRendering(bool rendering) { this->rendering = rendering; }
+       void setRendering(bool rendering) { this->m_rendering = rendering; }
 
        /**
         * @brief get the rendering field of the context
         */
-       bool isRendering() const { return this->rendering; }
+       bool isRendering() const { return this->m_rendering; }
 
        /**
         * @brief set the scene of the context
         */
-       void setRenderData(RenderData *rd) { this->rd = rd; }
+       void setRenderData(RenderData *rd) { this->m_rd = rd; }
 
        /**
         * @brief set the bnodetree of the context
         */
-       void setbNodeTree(bNodeTree *bnodetree) { this->bnodetree = bnodetree; }
+       void setbNodeTree(bNodeTree *bnodetree) { this->m_bnodetree = bnodetree; }
 
        /**
         * @brief get the bnodetree of the context
         */
-       const bNodeTree *getbNodeTree() const { return this->bnodetree; }
+       const bNodeTree *getbNodeTree() const { return this->m_bnodetree; }
 
        /**
         * @brief set the active groupnode of the context
         */
-       void setActivegNode(bNode *gnode) { this->activegNode = gnode; }
+       void setActivegNode(bNode *gnode) { this->m_activegNode = gnode; }
 
        /**
         * @brief get the active groupnode of the context
         */
-       const bNode *getActivegNode() const { return this->activegNode; }
+       const bNode *getActivegNode() const { return this->m_activegNode; }
 
        /**
         * @brief get the scene of the context
         */
-       const RenderData *getRenderData() const { return this->rd; }
+       const RenderData *getRenderData() const { return this->m_rd; }
 
        /**
         * @brief set the quality
         */
-       void setQuality(CompositorQuality quality) {
-               this->quality = quality;
-       }
+       void setQuality(CompositorQuality quality) { this->m_quality = quality; }
 
        /**
         * @brief get the quality
         */
-       const CompositorQuality getQuality() const {
-               return quality;
-       }
+       const CompositorQuality getQuality() const { return this->m_quality; }
 
        /**
         * @brief get the current framenumber of the scene in this context
@@ -142,16 +138,12 @@ public:
        /**
         * @brief has this system active openclDevices?
         */
-       const bool getHasActiveOpenCLDevices() const {
-               return this->hasActiveOpenCLDevices;
-       }
+       const bool getHasActiveOpenCLDevices() const { return this->m_hasActiveOpenCLDevices; }
 
        /**
         * @brief set has this system active openclDevices?
         */
-       void setHasActiveOpenCLDevices(bool hasAvtiveOpenCLDevices) {
-               this->hasActiveOpenCLDevices = hasAvtiveOpenCLDevices;
-       }
+       void setHasActiveOpenCLDevices(bool hasAvtiveOpenCLDevices) { this->m_hasActiveOpenCLDevices = hasAvtiveOpenCLDevices; }
        
        int getChunksize() { return this->getbNodeTree()->chunksize; }
        
index 926276c09a7683e15ad9923f3af457bdfb3e9b9e..c8b6503c9c5d24b5bd4236c9c9e285e5b948f276 100644 (file)
 #include "COM_ViewerNode.h"
 #include "COM_ZCombineNode.h"
 
-Node *Converter::convert(bNode *bNode)
+Node *Converter::convert(bNode *b_node)
 {
        Node *node;
 
-       if (bNode->flag & NODE_MUTED) {
-               node = new MuteNode(bNode);
+       if (b_node->flag & NODE_MUTED) {
+               node = new MuteNode(b_node);
                return node;
        }
 
-       switch (bNode->type) {
+       switch (b_node->type) {
                case CMP_NODE_COMPOSITE:
-                       node = new CompositorNode(bNode);
+                       node = new CompositorNode(b_node);
                        break;
                case CMP_NODE_R_LAYERS:
-                       node = new RenderLayersNode(bNode);
+                       node = new RenderLayersNode(b_node);
                        break;
                case CMP_NODE_TEXTURE:
-                       node = new TextureNode(bNode);
+                       node = new TextureNode(b_node);
                        break;
                case CMP_NODE_RGBTOBW:
-                       node = new ColourToBWNode(bNode);
+                       node = new ColourToBWNode(b_node);
                        break;
                case CMP_NODE_MIX_RGB:
-                       node = new MixNode(bNode);
+                       node = new MixNode(b_node);
                        break;
                case CMP_NODE_TRANSLATE:
-                       node = new TranslateNode(bNode);
+                       node = new TranslateNode(b_node);
                        break;
                case CMP_NODE_SCALE:
-                       node = new ScaleNode(bNode);
+                       node = new ScaleNode(b_node);
                        break;
                case CMP_NODE_ROTATE:
-                       node = new RotateNode(bNode);
+                       node = new RotateNode(b_node);
                        break;
                case CMP_NODE_FLIP:
-                       node = new FlipNode(bNode);
+                       node = new FlipNode(b_node);
                        break;
                case CMP_NODE_FILTER:
-                       node = new FilterNode(bNode);
+                       node = new FilterNode(b_node);
                        break;
                case CMP_NODE_ID_MASK:
-                       node = new IDMaskNode(bNode);
+                       node = new IDMaskNode(b_node);
                        break;
                case CMP_NODE_BRIGHTCONTRAST:
-                       node = new BrightnessNode(bNode);
+                       node = new BrightnessNode(b_node);
                        break;
                case CMP_NODE_SEPRGBA:
-                       node = new SeparateRGBANode(bNode);
+                       node = new SeparateRGBANode(b_node);
                        break;
                case CMP_NODE_COMBRGBA:
-                       node = new CombineRGBANode(bNode);
+                       node = new CombineRGBANode(b_node);
                        break;
                case CMP_NODE_SEPHSVA:
-                       node = new SeparateHSVANode(bNode);
+                       node = new SeparateHSVANode(b_node);
                        break;
                case CMP_NODE_COMBHSVA:
-                       node = new CombineHSVANode(bNode);
+                       node = new CombineHSVANode(b_node);
                        break;
                case CMP_NODE_SEPYUVA:
-                       node = new SeparateYUVANode(bNode);
+                       node = new SeparateYUVANode(b_node);
                        break;
                case CMP_NODE_COMBYUVA:
-                       node = new CombineYUVANode(bNode);
+                       node = new CombineYUVANode(b_node);
                        break;
                case CMP_NODE_SEPYCCA:
-                       node = new SeparateYCCANode(bNode);
+                       node = new SeparateYCCANode(b_node);
                        break;
                case CMP_NODE_COMBYCCA:
-                       node = new CombineYCCANode(bNode);
+                       node = new CombineYCCANode(b_node);
                        break;
                case CMP_NODE_ALPHAOVER:
-                       node = new AlphaOverNode(bNode);
+                       node = new AlphaOverNode(b_node);
                        break;
                case CMP_NODE_COLORBALANCE:
-                       node = new ColorBalanceNode(bNode);
+                       node = new ColorBalanceNode(b_node);
                        break;
                case CMP_NODE_VIEWER:
-                       node = new ViewerNode(bNode);
+                       node = new ViewerNode(b_node);
                        break;
                case CMP_NODE_SPLITVIEWER:
-                       node = new SplitViewerNode(bNode);
+                       node = new SplitViewerNode(b_node);
                        break;
                case CMP_NODE_INVERT:
-                       node = new InvertNode(bNode);
+                       node = new InvertNode(b_node);
                        break;
                case NODE_GROUP:
-                       node = new GroupNode(bNode);
+                       node = new GroupNode(b_node);
                        break;
                case CMP_NODE_NORMAL:
-                       node = new NormalNode(bNode);
+                       node = new NormalNode(b_node);
                        break;
                case CMP_NODE_NORMALIZE:
-                       node = new NormalizeNode(bNode);
+                       node = new NormalizeNode(b_node);
                        break;
                case CMP_NODE_IMAGE:
-                       node = new ImageNode(bNode);
+                       node = new ImageNode(b_node);
                        break;
                case CMP_NODE_SETALPHA:
-                       node = new SetAlphaNode(bNode);
+                       node = new SetAlphaNode(b_node);
                        break;
                case CMP_NODE_PREMULKEY:
-                       node = new ConvertAlphaNode(bNode);
+                       node = new ConvertAlphaNode(b_node);
                        break;
                case CMP_NODE_MATH:
-                       node = new MathNode(bNode);
+                       node = new MathNode(b_node);
                        break;
                case CMP_NODE_HUE_SAT:
-                       node = new HueSaturationValueNode(bNode);
+                       node = new HueSaturationValueNode(b_node);
                        break;
                case CMP_NODE_COLORCORRECTION:
-                       node = new ColorCorrectionNode(bNode);
+                       node = new ColorCorrectionNode(b_node);
                        break;
                case CMP_NODE_MASK_BOX:
-                       node = new BoxMaskNode(bNode);
+                       node = new BoxMaskNode(b_node);
                        break;
                case CMP_NODE_MASK_ELLIPSE:
-                       node = new EllipseMaskNode(bNode);
+                       node = new EllipseMaskNode(b_node);
                        break;
                case CMP_NODE_GAMMA:
-                       node = new GammaNode(bNode);
+                       node = new GammaNode(b_node);
                        break;
                case CMP_NODE_CURVE_RGB:
-                       node = new ColorCurveNode(bNode);
+                       node = new ColorCurveNode(b_node);
                        break;
                case CMP_NODE_CURVE_VEC:
-                       node = new VectorCurveNode(bNode);
+                       node = new VectorCurveNode(b_node);
                        break;
                case CMP_NODE_HUECORRECT:
-                       node = new HueSaturationValueCorrectNode(bNode);
+                       node = new HueSaturationValueCorrectNode(b_node);
                        break;
                case CMP_NODE_MAP_UV:
-                       node = new MapUVNode(bNode);
+                       node = new MapUVNode(b_node);
                        break;
                case CMP_NODE_DISPLACE:
-                       node = new DisplaceNode(bNode);
+                       node = new DisplaceNode(b_node);
                        break;
                case CMP_NODE_VALTORGB:
-                       node = new ColorRampNode(bNode);
+                       node = new ColorRampNode(b_node);
                        break;
                case CMP_NODE_DIFF_MATTE:
-                       node = new DifferenceMatteNode(bNode);
+                       node = new DifferenceMatteNode(b_node);
                        break;
                case CMP_NODE_LUMA_MATTE:
-                       node = new LuminanceMatteNode(bNode);
+                       node = new LuminanceMatteNode(b_node);
                        break;
                case CMP_NODE_DIST_MATTE:
-                       node = new DistanceMatteNode(bNode);
+                       node = new DistanceMatteNode(b_node);
                        break;
                case CMP_NODE_CHROMA_MATTE:
-                       node = new ChromaMatteNode(bNode);
+                       node = new ChromaMatteNode(b_node);
                        break;
                case CMP_NODE_COLOR_MATTE:
-                       node = new ColorMatteNode(bNode);
+                       node = new ColorMatteNode(b_node);
                        break;
                case CMP_NODE_CHANNEL_MATTE:
-                       node = new ChannelMatteNode(bNode);
+                       node = new ChannelMatteNode(b_node);
                        break;
                case CMP_NODE_BLUR:
-                       node = new BlurNode(bNode);
+                       node = new BlurNode(b_node);
                        break;
                case CMP_NODE_BOKEHIMAGE:
-                       node = new BokehImageNode(bNode);
+                       node = new BokehImageNode(b_node);
                        break;
                case CMP_NODE_BOKEHBLUR:
-                       node = new BokehBlurNode(bNode);
+                       node = new BokehBlurNode(b_node);
                        break;
                case CMP_NODE_DILATEERODE:
-                       node = new DilateErodeNode(bNode);
+                       node = new DilateErodeNode(b_node);
                        break;
                case CMP_NODE_LENSDIST:
-                       node = new LensDistortionNode(bNode);
+                       node = new LensDistortionNode(b_node);
                        break;
                case CMP_NODE_RGB:
-                       node = new ColorNode(bNode);
+                       node = new ColorNode(b_node);
                        break;
                case CMP_NODE_VALUE:
-                       node = new ValueNode(bNode);
+                       node = new ValueNode(b_node);
                        break;
                case CMP_NODE_TIME:
-                       node = new TimeNode(bNode);
+                       node = new TimeNode(b_node);
                        break;
                case CMP_NODE_DBLUR:
-                       node = new DirectionalBlurNode(bNode);
+                       node = new DirectionalBlurNode(b_node);
                        break;
                case CMP_NODE_ZCOMBINE:
-                       node = new ZCombineNode(bNode);
+                       node = new ZCombineNode(b_node);
                        break;
                case CMP_NODE_TONEMAP:
-                       node = new TonemapNode(bNode);
+                       node = new TonemapNode(b_node);
                        break;
                case CMP_NODE_SWITCH:
-                       node = new SwitchNode(bNode);
+                       node = new SwitchNode(b_node);
                        break;
                case CMP_NODE_GLARE:
-                       node = new GlareNode(bNode);
+                       node = new GlareNode(b_node);
                        break;
                case CMP_NODE_MOVIECLIP:
-                       node = new MovieClipNode(bNode);
+                       node = new MovieClipNode(b_node);
                        break;
                case CMP_NODE_COLOR_SPILL:
-                       node = new ColorSpillNode(bNode);
+                       node = new ColorSpillNode(b_node);
                        break;
                case CMP_NODE_OUTPUT_FILE:
-                       node = new OutputFileNode(bNode);
+                       node = new OutputFileNode(b_node);
                        break;
                case CMP_NODE_MAP_VALUE:
-                       node = new MapValueNode(bNode);
+                       node = new MapValueNode(b_node);
                        break;
                case CMP_NODE_TRANSFORM:
-                       node = new TransformNode(bNode);
+                       node = new TransformNode(b_node);
                        break;
                case CMP_NODE_STABILIZE2D:
-                       node = new Stabilize2dNode(bNode);
+                       node = new Stabilize2dNode(b_node);
                        break;
                case CMP_NODE_BILATERALBLUR:
-                       node = new BilateralBlurNode(bNode);
+                       node = new BilateralBlurNode(b_node);
                        break;
                case CMP_NODE_VECBLUR:
-                       node = new VectorBlurNode(bNode);
+                       node = new VectorBlurNode(b_node);
                        break;
                case CMP_NODE_MOVIEDISTORTION:
-                       node = new MovieDistortionNode(bNode);
+                       node = new MovieDistortionNode(b_node);
                        break;
                case CMP_NODE_VIEW_LEVELS:
-                       node = new ViewLevelsNode(bNode);
+                       node = new ViewLevelsNode(b_node);
                        break;
                case CMP_NODE_DEFOCUS:
-                       node = new DefocusNode(bNode);
+                       node = new DefocusNode(b_node);
                        break;
                case CMP_NODE_DOUBLEEDGEMASK:
-                       node = new DoubleEdgeMaskNode(bNode);
+                       node = new DoubleEdgeMaskNode(b_node);
                        break;
                case CMP_NODE_CROP:
-                       node = new CropNode(bNode);
+                       node = new CropNode(b_node);
                        break;
                case CMP_NODE_MASK:
-                       node = new MaskNode(bNode);
+                       node = new MaskNode(b_node);
                        break;
                case CMP_NODE_KEYINGSCREEN:
-                       node = new KeyingScreenNode(bNode);
+                       node = new KeyingScreenNode(b_node);
                        break;
                case CMP_NODE_KEYING:
-                       node = new KeyingNode(bNode);
+                       node = new KeyingNode(b_node);
                        break;
                case CMP_NODE_TRACKPOS:
-                       node = new TrackPositionNode(bNode);
+                       node = new TrackPositionNode(b_node);
                        break;
                /* not inplemented yet */
                default:
-                       node = new MuteNode(bNode);
+                       node = new MuteNode(b_node);
                        break;
        }
        return node;
index d129898ab3fddc15ab2c2635f7ade9b8411c2819..6cf22a1e2a4dcd78a37a5de451cdc5b0e52fa392 100644 (file)
@@ -42,7 +42,7 @@ public:
         * @see Node
         * @see MuteNode
         */
-       static Node *convert(bNode *bNode);
+       static Node *convert(bNode *b_node);
        
        /**
         * @brief This method will add a datetype conversion rule when the to-socket does not support the from-socket actual data type.
index 4dfb9c7d26c2b24e21bbb4883bca4eed25e8552a..1a0bd95b7d66b762540aa17f55faea80820ccc4d 100644 (file)
 
 ExecutionGroup::ExecutionGroup()
 {
-       this->isOutput = false;
-       this->complex = false;
-       this->chunkExecutionStates = NULL;
-       this->bTree = NULL;
-       this->height = 0;
-       this->width = 0;
-       this->cachedMaxReadBufferOffset = 0;
-       this->numberOfXChunks = 0;
-       this->numberOfYChunks = 0;
-       this->numberOfChunks = 0;
-       this->initialized = false;
-       this->openCL = false;
-       this->singleThreaded = false;
-       this->chunksFinished = 0;
+       this->m_isOutput = false;
+       this->m_complex = false;
+       this->m_chunkExecutionStates = NULL;
+       this->m_bTree = NULL;
+       this->m_height = 0;
+       this->m_width = 0;
+       this->m_cachedMaxReadBufferOffset = 0;
+       this->m_numberOfXChunks = 0;
+       this->m_numberOfYChunks = 0;
+       this->m_numberOfChunks = 0;
+       this->m_initialized = false;
+       this->m_openCL = false;
+       this->m_singleThreaded = false;
+       this->m_chunksFinished = 0;
 }
 
 CompositorPriority ExecutionGroup::getRenderPriotrity()
@@ -66,7 +66,7 @@ CompositorPriority ExecutionGroup::getRenderPriotrity()
 
 bool ExecutionGroup::containsOperation(NodeOperation *operation)
 {
-       for (vector<NodeOperation *>::const_iterator iterator = this->operations.begin(); iterator != this->operations.end(); ++iterator) {
+       for (vector<NodeOperation *>::const_iterator iterator = this->m_operations.begin(); iterator != this->m_operations.end(); ++iterator) {
                NodeOperation *inListOperation = *iterator;
                if (inListOperation == operation) {
                        return true;
@@ -77,12 +77,12 @@ bool ExecutionGroup::containsOperation(NodeOperation *operation)
 
 const bool ExecutionGroup::isComplex() const
 {
-       return this->complex;
+       return this->m_complex;
 }
 
 bool ExecutionGroup::canContainOperation(NodeOperation *operation)
 {
-       if (!this->initialized) { return true; }
+       if (!this->m_initialized) { return true; }
        if (operation->isReadBufferOperation()) { return true; }
        if (operation->isWriteBufferOperation()) { return false; }
        if (operation->isSetOperation()) { return true; }
@@ -100,12 +100,12 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
        if (containsOperation(operation)) return;
        if (canContainOperation(operation)) {
                if (!operation->isBufferOperation()) {
-                       this->complex = operation->isComplex();
-                       this->openCL = operation->isOpenCL();
-                       this->singleThreaded = operation->isSingleThreaded();
-                       this->initialized = true;
+                       this->m_complex = operation->isComplex();
+                       this->m_openCL = operation->isOpenCL();
+                       this->m_singleThreaded = operation->isSingleThreaded();
+                       this->m_initialized = true;
                }
-               this->operations.push_back(operation);
+               this->m_operations.push_back(operation);
                if (operation->isReadBufferOperation()) {
                        ReadBufferOperation *readOperation = (ReadBufferOperation *)operation;
                        WriteBufferOperation *writeOperation = readOperation->getMemoryProxy()->getWriteBufferOperation();
@@ -137,52 +137,52 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
 
 NodeOperation *ExecutionGroup::getOutputNodeOperation() const
 {
-       return this->operations[0]; // the first operation of the group is always the output operation.
+       return this->m_operations[0]; // the first operation of the group is always the output operation.
 }
 
 void ExecutionGroup::initExecution()
 {
-       if (this->chunkExecutionStates != NULL) {
-               delete[] this->chunkExecutionStates;
+       if (this->m_chunkExecutionStates != NULL) {
+               delete[] this->m_chunkExecutionStates;
        }
        unsigned int index;
        determineNumberOfChunks();
 
-       this->chunkExecutionStates = NULL;
-       if (this->numberOfChunks != 0) {
-               this->chunkExecutionStates = new ChunkExecutionState[numberOfChunks];
-               for (index = 0; index < numberOfChunks; index++) {
-                       this->chunkExecutionStates[index] = COM_ES_NOT_SCHEDULED;
+       this->m_chunkExecutionStates = NULL;
+       if (this->m_numberOfChunks != 0) {
+               this->m_chunkExecutionStates = new ChunkExecutionState[this->m_numberOfChunks];
+               for (index = 0; index < this->m_numberOfChunks; index++) {
+                       this->m_chunkExecutionStates[index] = COM_ES_NOT_SCHEDULED;
                }
        }
 
 
        unsigned int maxNumber = 0;
 
-       for (index = 0; index < this->operations.size(); index++) {
-               NodeOperation *operation = this->operations[index];
+       for (index = 0; index < this->m_operations.size(); index++) {
+               NodeOperation *operation = this->m_operations[index];
                if (operation->isReadBufferOperation()) {
                        ReadBufferOperation *readOperation = (ReadBufferOperation *)operation;
-                       this->cachedReadOperations.push_back(readOperation);
+                       this->m_cachedReadOperations.push_back(readOperation);
                        maxNumber = max(maxNumber, readOperation->getOffset());
                }
        }
        maxNumber++;
-       this->cachedMaxReadBufferOffset = maxNumber;
+       this->m_cachedMaxReadBufferOffset = maxNumber;
 
 }
 
 void ExecutionGroup::deinitExecution()
 {
-       if (this->chunkExecutionStates != NULL) {
-               delete[] this->chunkExecutionStates;
-               this->chunkExecutionStates = NULL;
-       }
-       this->numberOfChunks = 0;
-       this->numberOfXChunks = 0;
-       this->numberOfYChunks = 0;
-       this->cachedReadOperations.clear();
-       this->bTree = NULL;
+       if (this->m_chunkExecutionStates != NULL) {
+               delete[] this->m_chunkExecutionStates;
+               this->m_chunkExecutionStates = NULL;
+       }
+       this->m_numberOfChunks = 0;
+       this->m_numberOfXChunks = 0;
+       this->m_numberOfYChunks = 0;
+       this->m_cachedReadOperations.clear();
+       this->m_bTree = NULL;
 }
 void ExecutionGroup::determineResolution(unsigned int resolution[])
 {
@@ -194,16 +194,16 @@ void ExecutionGroup::determineResolution(unsigned int resolution[])
 
 void ExecutionGroup::determineNumberOfChunks()
 {
-       if (singleThreaded) {
-               this->numberOfXChunks = 1;
-               this->numberOfYChunks = 1;
-               this->numberOfChunks = 1;
+       if (this->m_singleThreaded) {
+               this->m_numberOfXChunks = 1;
+               this->m_numberOfYChunks = 1;
+               this->m_numberOfChunks = 1;
        } 
        else {
-               const float chunkSizef = this->chunkSize;
-               this->numberOfXChunks = ceil(this->width / chunkSizef);
-               this->numberOfYChunks = ceil(this->height / chunkSizef);
-               this->numberOfChunks = this->numberOfXChunks * this->numberOfYChunks;
+               const float chunkSizef = this->m_chunkSize;
+               this->m_numberOfXChunks = ceil(this->m_width / chunkSizef);
+               this->m_numberOfYChunks = ceil(this->m_height / chunkSizef);
+               this->m_numberOfChunks = this->m_numberOfXChunks * this->m_numberOfYChunks;
        }
 }
 
@@ -214,17 +214,17 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 {
        CompositorContext& context = graph->getContext();
        const bNodeTree *bTree = context.getbNodeTree();
-       if (this->width == 0 || this->height == 0) {return; } /// @note: break out... no pixels to calculate.
+       if (this->m_width == 0 || this->m_height == 0) {return; } /// @note: break out... no pixels to calculate.
        if (bTree->test_break && bTree->test_break(bTree->tbh)) {return; } /// @note: early break out for blur and preview nodes
-       if (this->numberOfChunks == 0) {return; } /// @note: early break out
+       if (this->m_numberOfChunks == 0) {return; } /// @note: early break out
        unsigned int chunkNumber;
 
-       this->chunksFinished = 0;
-       this->bTree = bTree;
+       this->m_chunksFinished = 0;
+       this->m_bTree = bTree;
        unsigned int index;
-       unsigned int *chunkOrder = new unsigned int[this->numberOfChunks];
+       unsigned int *chunkOrder = new unsigned int[this->m_numberOfChunks];
 
-       for (chunkNumber = 0; chunkNumber < this->numberOfChunks; chunkNumber++) {
+       for (chunkNumber = 0; chunkNumber < this->m_numberOfChunks; chunkNumber++) {
                chunkOrder[chunkNumber] = chunkNumber;
        }
        NodeOperation *operation = this->getOutputNodeOperation();
@@ -241,9 +241,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 
        switch (chunkorder) {
                case COM_TO_RANDOM:
-                       for (index = 0; index < 2 * numberOfChunks; index++) {
-                               int index1 = rand() % numberOfChunks;
-                               int index2 = rand() % numberOfChunks;
+                       for (index = 0; index < 2 * this->m_numberOfChunks; index++) {
+                               int index1 = rand() % this->m_numberOfChunks;
+                               int index2 = rand() % this->m_numberOfChunks;
                                int s = chunkOrder[index1];
                                chunkOrder[index1] = chunkOrder[index2];
                                chunkOrder[index2] = s;
@@ -252,10 +252,10 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
                case COM_TO_CENTER_OUT:
                {
                        ChunkOrderHotspot **hotspots = new ChunkOrderHotspot *[1];
-                       hotspots[0] = new ChunkOrderHotspot(this->width * centerX, this->height * centerY, 0.0f);
+                       hotspots[0] = new ChunkOrderHotspot(this->m_width * centerX, this->m_height * centerY, 0.0f);
                        rcti rect;
-                       ChunkOrder *chunkOrders = new ChunkOrder[this->numberOfChunks];
-                       for (index = 0; index < this->numberOfChunks; index++) {
+                       ChunkOrder *chunkOrders = new ChunkOrder[this->m_numberOfChunks];
+                       for (index = 0; index < this->m_numberOfChunks; index++) {
                                determineChunkRect(&rect, index);
                                chunkOrders[index].setChunkNumber(index);
                                chunkOrders[index].setX(rect.xmin);
@@ -263,8 +263,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
                                chunkOrders[index].determineDistance(hotspots, 1);
                        }
 
-                       sort(&chunkOrders[0], &chunkOrders[numberOfChunks - 1]);
-                       for (index = 0; index < numberOfChunks; index++) {
+                       sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks - 1]);
+                       for (index = 0; index < this->m_numberOfChunks; index++) {
                                chunkOrder[index] = chunkOrders[index].getChunkNumber();
                        }
 
@@ -276,14 +276,14 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
                case COM_TO_RULE_OF_THIRDS:
                {
                        ChunkOrderHotspot **hotspots = new ChunkOrderHotspot *[9];
-                       unsigned int tx = this->width / 6;
-                       unsigned int ty = this->height / 6;
-                       unsigned int mx = this->width / 2;
-                       unsigned int my = this->height / 2;
+                       unsigned int tx = this->m_width / 6;
+                       unsigned int ty = this->m_height / 6;
+                       unsigned int mx = this->m_width / 2;
+                       unsigned int my = this->m_height / 2;
                        unsigned int bx = mx + 2 * tx;
                        unsigned int by = my + 2 * ty;
 
-                       float addition = numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER;
+                       float addition = this->m_numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER;
                        hotspots[0] = new ChunkOrderHotspot(mx, my, addition * 0);
                        hotspots[1] = new ChunkOrderHotspot(tx, my, addition * 1);
                        hotspots[2] = new ChunkOrderHotspot(bx, my, addition * 2);
@@ -294,8 +294,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
                        hotspots[7] = new ChunkOrderHotspot(mx, ty, addition * 7);
                        hotspots[8] = new ChunkOrderHotspot(mx, by, addition * 8);
                        rcti rect;
-                       ChunkOrder *chunkOrders = new ChunkOrder[this->numberOfChunks];
-                       for (index = 0; index < this->numberOfChunks; index++) {
+                       ChunkOrder *chunkOrders = new ChunkOrder[this->m_numberOfChunks];
+                       for (index = 0; index < this->m_numberOfChunks; index++) {
                                determineChunkRect(&rect, index);
                                chunkOrders[index].setChunkNumber(index);
                                chunkOrders[index].setX(rect.xmin);
@@ -303,9 +303,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
                                chunkOrders[index].determineDistance(hotspots, 9);
                        }
 
-                       sort(&chunkOrders[0], &chunkOrders[numberOfChunks]);
+                       sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks]);
 
-                       for (index = 0; index < numberOfChunks; index++) {
+                       for (index = 0; index < this->m_numberOfChunks; index++) {
                                chunkOrder[index] = chunkOrders[index].getChunkNumber();
                        }
 
@@ -333,16 +333,15 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
        const int maxNumberEvaluated = BLI_system_thread_count() * 2;
 
        while (!finished && !breaked) {
-               unsigned int index;
                bool startEvaluated = false;
                finished = true;
                int numberEvaluated = 0;
 
-               for (index = startIndex; index < numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) {
-                       int chunkNumber = chunkOrder[index];
-                       int yChunk = chunkNumber / this->numberOfXChunks;
-                       int xChunk = chunkNumber - (yChunk * this->numberOfXChunks);
-                       const ChunkExecutionState state = this->chunkExecutionStates[chunkNumber];
+               for (index = startIndex; index < this->m_numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) {
+                       chunkNumber = chunkOrder[index];
+                       int yChunk = chunkNumber / this->m_numberOfXChunks;
+                       int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
+                       const ChunkExecutionState state = this->m_chunkExecutionStates[chunkNumber];
                        if (state == COM_ES_NOT_SCHEDULED) {
                                scheduleChunkWhenPossible(graph, xChunk, yChunk);
                                finished = false;
@@ -375,12 +374,12 @@ MemoryBuffer **ExecutionGroup::getInputBuffersCPU()
        unsigned int index;
 
        this->determineDependingMemoryProxies(&memoryproxies);
-       MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->cachedMaxReadBufferOffset];
-       for (index = 0; index < this->cachedMaxReadBufferOffset; index++) {
+       MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->m_cachedMaxReadBufferOffset];
+       for (index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
                memoryBuffers[index] = NULL;
        }
-       for (index = 0; index < this->cachedReadOperations.size(); index++) {
-               ReadBufferOperation *readOperation = (ReadBufferOperation *)this->cachedReadOperations[index];
+       for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
+               ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
                memoryBuffers[readOperation->getOffset()] = readOperation->getMemoryProxy()->getBuffer();
        }
        return memoryBuffers;
@@ -394,13 +393,13 @@ MemoryBuffer **ExecutionGroup::getInputBuffersOpenCL(int chunkNumber)
        determineChunkRect(&rect, chunkNumber);
 
        this->determineDependingMemoryProxies(&memoryproxies);
-       MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->cachedMaxReadBufferOffset];
-       for (index = 0; index < this->cachedMaxReadBufferOffset; index++) {
+       MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->m_cachedMaxReadBufferOffset];
+       for (index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
                memoryBuffers[index] = NULL;
        }
        rcti output;
-       for (index = 0; index < this->cachedReadOperations.size(); index++) {
-               ReadBufferOperation *readOperation = (ReadBufferOperation *)this->cachedReadOperations[index];
+       for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
+               ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
                MemoryProxy *memoryProxy = readOperation->getMemoryProxy();
                this->determineDependingAreaOfInterest(&rect, readOperation, &output);
                MemoryBuffer *memoryBuffer = memoryProxy->getExecutor()->constructConsolidatedMemoryBuffer(memoryProxy, &output);
@@ -419,12 +418,12 @@ MemoryBuffer *ExecutionGroup::constructConsolidatedMemoryBuffer(MemoryProxy *mem
 
 void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers)
 {
-       if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED)
-               this->chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED;
+       if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED)
+               this->m_chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED;
        
-       this->chunksFinished++;
+       this->m_chunksFinished++;
        if (memoryBuffers) {
-               for (unsigned int index = 0; index < this->cachedMaxReadBufferOffset; index++) {
+               for (unsigned int index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
                        MemoryBuffer *buffer = memoryBuffers[index];
                        if (buffer) {
                                if (buffer->isTemporarily()) {
@@ -435,30 +434,30 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
                }
                delete[] memoryBuffers;
        }
-       if (bTree) {
+       if (this->m_bTree) {
                // status report is only performed for top level Execution Groups.
-               float progress = chunksFinished;
-               progress /= numberOfChunks;
-               bTree->progress(bTree->prh, progress);
+               float progress = this->m_chunksFinished;
+               progress /= this->m_numberOfChunks;
+               this->m_bTree->progress(this->m_bTree->prh, progress);
        }
 }
 
 inline void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk) const
 {
-       if (singleThreaded) {
-               BLI_init_rcti(rect, 0, this->width, 0, this->height);
+       if (this->m_singleThreaded) {
+               BLI_init_rcti(rect, 0, this->m_width, 0, this->m_height);
        }
        else {
-               const unsigned int minx = xChunk * chunkSize;
-               const unsigned int miny = yChunk * chunkSize;
-               BLI_init_rcti(rect, minx, min(minx + this->chunkSize, this->width), miny, min(miny + this->chunkSize, this->height));
+               const unsigned int minx = xChunk * this->m_chunkSize;
+               const unsigned int miny = yChunk * this->m_chunkSize;
+               BLI_init_rcti(rect, minx, min(minx + this->m_chunkSize, this->m_width), miny, min(miny + this->m_chunkSize, this->m_height));
        }
 }
 
 void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int chunkNumber) const
 {
-       const unsigned int yChunk = chunkNumber / numberOfXChunks;
-       const unsigned int xChunk = chunkNumber - (yChunk * numberOfXChunks);
+       const unsigned int yChunk = chunkNumber / this->m_numberOfXChunks;
+       const unsigned int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
        determineChunkRect(rect, xChunk, yChunk);
 }
 
@@ -477,13 +476,13 @@ MemoryBuffer *ExecutionGroup::allocateOutputBuffer(int chunkNumber, rcti *rect)
 
 bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area)
 {
-       if (singleThreaded) {
+       if (this->m_singleThreaded) {
                return scheduleChunkWhenPossible(graph, 0, 0);
        }
        // find all chunks inside the rect
        // determine minxchunk, minychunk, maxxchunk, maxychunk where x and y are chunknumbers
 
-       float chunkSizef = this->chunkSize;
+       float chunkSizef = this->m_chunkSize;
 
        int indexx, indexy;
        const int minxchunk = floor(area->xmin / chunkSizef);
@@ -505,8 +504,8 @@ bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area
 
 bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
 {
-       if (this->chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) {
-               this->chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED;
+       if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) {
+               this->m_chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED;
                WorkScheduler::schedule(this, chunkNumber);
                return true;
        }
@@ -515,20 +514,20 @@ bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
 
 bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk)
 {
-       if (xChunk < 0 || xChunk >= (int)this->numberOfXChunks) {
+       if (xChunk < 0 || xChunk >= (int)this->m_numberOfXChunks) {
                return true;
        }
-       if (yChunk < 0 || yChunk >= (int)this->numberOfYChunks) {
+       if (yChunk < 0 || yChunk >= (int)this->m_numberOfYChunks) {
                return true;
        }
-       int chunkNumber = yChunk * this->numberOfXChunks + xChunk;
+       int chunkNumber = yChunk * this->m_numberOfXChunks + xChunk;
        // chunk is already executed
-       if (this->chunkExecutionStates[chunkNumber] == COM_ES_EXECUTED) {
+       if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_EXECUTED) {
                return true;
        }
 
        // chunk is scheduled, but not executed
-       if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) {
+       if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) {
                return false;
        }
 
@@ -542,8 +541,8 @@ bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChun
        bool canBeExecuted = true;
        rcti area;
 
-       for (index = 0; index < cachedReadOperations.size(); index++) {
-               ReadBufferOperation *readOperation = (ReadBufferOperation *)cachedReadOperations[index];
+       for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
+               ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
                BLI_init_rcti(&area, 0, 0, 0, 0);
                MemoryProxy *memoryProxy = memoryProxies[index];
                determineDependingAreaOfInterest(&rect, readOperation, &area);
@@ -574,13 +573,13 @@ void ExecutionGroup::determineDependingAreaOfInterest(rcti *input, ReadBufferOpe
 void ExecutionGroup::determineDependingMemoryProxies(vector<MemoryProxy *> *memoryProxies)
 {
        unsigned int index;
-       for (index = 0; index < this->cachedReadOperations.size(); index++) {
-               ReadBufferOperation *readOperation = (ReadBufferOperation *) this->cachedReadOperations[index];
+       for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
+               ReadBufferOperation *readOperation = (ReadBufferOperation *) this->m_cachedReadOperations[index];
                memoryProxies->push_back(readOperation->getMemoryProxy());
        }
 }
 
 bool ExecutionGroup::isOpenCL()
 {
-       return this->openCL;
+       return this->m_openCL;
 }
index 53c2e890bea17951686acdc7a9b42ce39a96c348..43c2bfac52e929a5313a6181d04c28a1a1bd37f8 100644 (file)
@@ -67,81 +67,81 @@ private:
        /**
         * @brief list of operations in this ExecutionGroup
         */
-       vector<NodeOperation *> operations;
+       vector<NodeOperation *> m_operations;
        
        /**
         * @brief is this ExecutionGroup an input ExecutionGroup
         * an input execution group is a group that is at the end of the calculation (the output is important for the user)
         */
-       int isOutput;
+       int m_isOutput;
        
        /**
         * @brief Width of the output
         */
-       unsigned int width;
+       unsigned int m_width;
        
        /**
         * @brief Height of the output
         */
-       unsigned int height;
+       unsigned int m_height;
        
        /**
         * @brief size of a single chunk, being Width or of height
         * a chunk is always a square, except at the edges of the MemoryBuffer
         */
-       unsigned int chunkSize;
+       unsigned int m_chunkSize;
        
        /**
         * @brief number of chunks in the x-axis
         */
-       unsigned int numberOfXChunks;
+       unsigned int m_numberOfXChunks;
        
        /**
         * @brief number of chunks in the y-axis
         */
-       unsigned int numberOfYChunks;
+       unsigned int m_numberOfYChunks;
        
        /**
         * @brief total number of chunks
         */
-       unsigned int numberOfChunks;
+       unsigned int m_numberOfChunks;
        
        /**
         * @brief contains this ExecutionGroup a complex NodeOperation.
         */
-       bool complex;
+       bool m_complex;
        
        /**
         * @brief can this ExecutionGroup be scheduled on an OpenCLDevice
         */
-       bool openCL;
+       bool m_openCL;
        
        /**
         * @brief Is this Execution group SingleThreaded
         */
-       bool singleThreaded;
+       bool m_singleThreaded;
        
        /**
         * @brief what is the maximum number field of all ReadBufferOperation in this ExecutionGroup.
         * @note this is used to construct the MemoryBuffers that will be passed during execution.
         */
-       unsigned int cachedMaxReadBufferOffset;
+       unsigned int m_cachedMaxReadBufferOffset;
        
        /**
         * @brief a cached vector of all read operations in the execution group.
         */
-       vector<NodeOperation *> cachedReadOperations;
+       vector<NodeOperation *> m_cachedReadOperations;
        
        /**
         * @brief reference to the original bNodeTree, this field is only set for the 'top' execution group.
         * @note can only be used to call the callbacks for progress, status and break
         */
-       const bNodeTree *bTree;
+       const bNodeTree *m_bTree;
        
        /**
         * @brief total number of chunks that have been calculated for this ExecutionGroup
         */
-       unsigned int chunksFinished;
+       unsigned int m_chunksFinished;
        
        /**
         * @brief the chunkExecutionStates holds per chunk the execution state. this state can be
@@ -149,7 +149,7 @@ private:
         *   - COM_ES_SCHEDULED: scheduled
         *   - COM_ES_EXECUTED: executed
         */
-       ChunkExecutionState *chunkExecutionStates;
+       ChunkExecutionState *m_chunkExecutionStates;
        
        /**
         * @brief indicator when this ExecutionGroup has valid NodeOperations in its vector for Execution
@@ -160,7 +160,7 @@ private:
         * @see complex
         * @see openCL
         */
-       bool initialized;
+       bool m_initialized;
        
        // methods
        /**
@@ -258,13 +258,13 @@ public:
         * @note ViewerOperation, CompositeOperation, PreviewOperation.
         * @see NodeOperation.isOutputOperation
         */
-       const int isOutputExecutionGroup() const { return this->isOutput; }
+       const int isOutputExecutionGroup() const { return this->m_isOutput; }
 
        /**
         * @brief set whether this ExecutionGroup is an output
         * @param isOutput
         */
-       void setOutputExecutionGroup(int isOutput) { this->isOutput = isOutput; }
+       void setOutputExecutionGroup(int isOutput) { this->m_isOutput = isOutput; }
 
        /**
         * @brief determine the resolution of this ExecutionGroup
@@ -276,17 +276,17 @@ public:
         * @brief set the resolution of this executiongroup
         * @param resolution
         */
-       void setResolution(unsigned int resolution[]) { this->width = resolution[0]; this->height = resolution[1]; }
+       void setResolution(unsigned int resolution[]) { this->m_width = resolution[0]; this->m_height = resolution[1]; }
        
        /**
         * @brief get the width of this execution group
         */
-       const unsigned int getWidth() { return this->width; }
+       const unsigned int getWidth() { return this->m_width; }
        
        /**
         * @brief get the height of this execution group
         */
-       const unsigned int getHeight() { return this->height; }
+       const unsigned int getHeight() { return this->m_height; }
        
        /**
         * @brief does this ExecutionGroup contains a complex NodeOperation
@@ -387,7 +387,7 @@ public:
         */
        bool isOpenCL();
 
-       void setChunksize(int chunksize) { this->chunkSize = chunksize; }
+       void setChunksize(int chunksize) { this->m_chunkSize = chunksize; }
 
        /**
         * @brief get the Render priority of this ExecutionGroup
index 5001cabbd9f4094ecef8983cc9385b525393db06..23e243187d52a69f41b296e8ddcf88c3c9eef6c1 100644 (file)
@@ -23,7 +23,6 @@
 #include "COM_ExecutionSystem.h"
 
 #include <sstream>
-#include <stdio.h>
 
 #include "PIL_time.h"
 #include "BKE_node.h"
 
 ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool rendering)
 {
-       context.setbNodeTree(editingtree);
+       this->m_context.setbNodeTree(editingtree);
        bNode *gnode;
        for (gnode = (bNode *)editingtree->nodes.first; gnode; gnode = (bNode *)gnode->next) {
                if (gnode->type == NODE_GROUP && gnode->typeinfo->group_edit_get(gnode)) {
-                       context.setActivegNode(gnode);
+                       this->m_context.setActivegNode(gnode);
                        break;
                }
        }
 
        /* initialize the CompositorContext */
        if (rendering) {
-               context.setQuality((CompositorQuality)editingtree->render_quality);
+               this->m_context.setQuality((CompositorQuality)editingtree->render_quality);
        }
        else {
-               context.setQuality((CompositorQuality)editingtree->edit_quality);
+               this->m_context.setQuality((CompositorQuality)editingtree->edit_quality);
        }
-       context.setRendering(rendering);
-       context.setHasActiveOpenCLDevices(WorkScheduler::hasGPUDevices() && (editingtree->flag & NTREE_COM_OPENCL));
+       this->m_context.setRendering(rendering);
+       this->m_context.setHasActiveOpenCLDevices(WorkScheduler::hasGPUDevices() && (editingtree->flag & NTREE_COM_OPENCL));
 
        ExecutionSystemHelper::addbNodeTree(*this, 0, editingtree, NULL);
 
-       context.setRenderData(rd);
+       this->m_context.setRenderData(rd);
        this->convertToOperations();
        this->groupOperations(); /* group operations in ExecutionGroups */
        unsigned int index;
        unsigned int resolution[2];
-       for (index = 0; index < this->groups.size(); index++) {
+       for (index = 0; index < this->m_groups.size(); index++) {
                resolution[0] = 0;
                resolution[1] = 0;
-               ExecutionGroup *executionGroup = groups[index];
+               ExecutionGroup *executionGroup = this->m_groups[index];
                executionGroup->determineResolution(resolution);
        }
 
@@ -88,32 +87,32 @@ ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool re
 ExecutionSystem::~ExecutionSystem()
 {
        unsigned int index;
-       for (index = 0; index < this->connections.size(); index++) {
-               SocketConnection *connection = this->connections[index];
+       for (index = 0; index < this->m_connections.size(); index++) {
+               SocketConnection *connection = this->m_connections[index];
                delete connection;
        }
-       this->connections.clear();
-       for (index = 0; index < this->nodes.size(); index++) {
-               Node *node = this->nodes[index];
+       this->m_connections.clear();
+       for (index = 0; index < this->m_nodes.size(); index++) {
+               Node *node = this->m_nodes[index];
                delete node;
        }
-       this->nodes.clear();
-       for (index = 0; index < this->operations.size(); index++) {
-               NodeOperation *operation = this->operations[index];
+       this->m_nodes.clear();
+       for (index = 0; index < this->m_operations.size(); index++) {
+               NodeOperation *operation = this->m_operations[index];
                delete operation;
        }
-       this->operations.clear();
-       for (index = 0; index < this->groups.size(); index++) {
-               ExecutionGroup *group = this->groups[index];
+       this->m_operations.clear();
+       for (index = 0; index < this->m_groups.size(); index++) {
+               ExecutionGroup *group = this->m_groups[index];
                delete group;
        }
-       this->groups.clear();
+       this->m_groups.clear();
 }
 
 void ExecutionSystem::execute()
 {
        unsigned int order = 0;
-       for (vector<NodeOperation *>::iterator iter = this->operations.begin(); iter != operations.end(); ++iter) {
+       for (vector<NodeOperation *>::iterator iter = this->m_operations.begin(); iter != this->m_operations.end(); ++iter) {
                NodeBase *node = *iter;
                NodeOperation *operation = (NodeOperation *) node;
                if (operation->isReadBufferOperation()) {
@@ -124,18 +123,18 @@ void ExecutionSystem::execute()
        }
        unsigned int index;
 
-       for (index = 0; index < this->operations.size(); index++) {
-               NodeOperation *operation = this->operations[index];
-               operation->setbNodeTree(this->context.getbNodeTree());
+       for (index = 0; index < this->m_operations.size(); index++) {
+               NodeOperation *operation = this->m_operations[index];
+               operation->setbNodeTree(this->m_context.getbNodeTree());
                operation->initExecution();
        }
-       for (index = 0; index < this->groups.size(); index++) {
-               ExecutionGroup *executionGroup = this->groups[index];
-               executionGroup->setChunksize(context.getChunksize());
+       for (index = 0; index < this->m_groups.size(); index++) {
+               ExecutionGroup *executionGroup = this->m_groups[index];
+               executionGroup->setChunksize(this->m_context.getChunksize());
                executionGroup->initExecution();
        }
 
-       WorkScheduler::start(this->context);
+       WorkScheduler::start(this->m_context);
 
        executeGroups(COM_PRIORITY_HIGH);
        executeGroups(COM_PRIORITY_MEDIUM);
@@ -144,12 +143,12 @@ void ExecutionSystem::execute()
        WorkScheduler::finish();
        WorkScheduler::stop();
 
-       for (index = 0; index < this->operations.size(); index++) {
-               NodeOperation *operation = this->operations[index];
+       for (index = 0; index < this->m_operations.size(); index++) {
+               NodeOperation *operation = this->m_operations[index];
                operation->deinitExecution();
        }
-       for (index = 0; index < this->groups.size(); index++) {
-               ExecutionGroup *executionGroup = this->groups[index];
+       for (index = 0; index < this->m_groups.size(); index++) {
+               ExecutionGroup *executionGroup = this->m_groups[index];
                executionGroup->deinitExecution();
        }
 }
@@ -168,7 +167,7 @@ void ExecutionSystem::executeGroups(CompositorPriority priority)
 
 void ExecutionSystem::addOperation(NodeOperation *operation)
 {
-       ExecutionSystemHelper::addOperation(this->operations, operation);
+       ExecutionSystemHelper::addOperation(this->m_operations, operation);
 //     operation->setBTree
 }
 
@@ -209,7 +208,6 @@ void ExecutionSystem::addReadWriteBufferOperations(NodeOperation *operation)
         */
        OutputSocket *outputsocket = operation->getOutputSocket();
        if (outputsocket->isConnected()) {
-               int index;
                WriteBufferOperation *writeOperation;
                writeOperation = new WriteBufferOperation();
                writeOperation->setbNodeTree(this->getContext().getbNodeTree());
@@ -231,13 +229,13 @@ void ExecutionSystem::addReadWriteBufferOperations(NodeOperation *operation)
 void ExecutionSystem::convertToOperations()
 {
        unsigned int index;
-       for (index = 0; index < this->nodes.size(); index++) {
-               Node *node = (Node *)this->nodes[index];
-               node->convertToOperations(this, &this->context);
+       for (index = 0; index < this->m_nodes.size(); index++) {
+               Node *node = (Node *)this->m_nodes[index];
+               node->convertToOperations(this, &this->m_context);
        }
 
-       for (index = 0; index < this->connections.size(); index++) {
-               SocketConnection *connection = this->connections[index];
+       for (index = 0; index < this->m_connections.size(); index++) {
+               SocketConnection *connection = this->m_connections[index];
                if (connection->isValid()) {
                        if (connection->getFromSocket()->getDataType() != connection->getToSocket()->getDataType()) {
                                Converter::convertDataType(connection, this);
@@ -246,18 +244,18 @@ void ExecutionSystem::convertToOperations()
        }
 
        // determine all resolutions of the operations (Width/Height)
-       for (index = 0; index < this->operations.size(); index++) {
-               NodeOperation *operation = this->operations[index];
-               if (operation->isOutputOperation(context.isRendering()) && !operation->isPreviewOperation()) {
+       for (index = 0; index < this->m_operations.size(); index++) {
+               NodeOperation *operation = this->m_operations[index];
+               if (operation->isOutputOperation(this->m_context.isRendering()) && !operation->isPreviewOperation()) {
                        unsigned int resolution[2] = {0, 0};
                        unsigned int preferredResolution[2] = {0, 0};
                        operation->determineResolution(resolution, preferredResolution);
                        operation->setResolution(resolution);
                }
        }
-       for (index = 0; index < this->operations.size(); index++) {
-               NodeOperation *operation = this->operations[index];
-               if (operation->isOutputOperation(context.isRendering()) && operation->isPreviewOperation()) {
+       for (index = 0; index < this->m_operations.size(); index++) {
+               NodeOperation *operation = this->m_operations[index];
+               if (operation->isOutputOperation(this->m_context.isRendering()) && operation->isPreviewOperation()) {
                        unsigned int resolution[2] = {0, 0};
                        unsigned int preferredResolution[2] = {0, 0};
                        operation->determineResolution(resolution, preferredResolution);
@@ -266,8 +264,8 @@ void ExecutionSystem::convertToOperations()
        }
 
        // add convert resolution operations when needed.
-       for (index = 0; index < this->connections.size(); index++) {
-               SocketConnection *connection = this->connections[index];
+       for (index = 0; index < this->m_connections.size(); index++) {
+               SocketConnection *connection = this->m_connections[index];
                if (connection->isValid()) {
                        if (connection->needsResolutionConversion()) {
                                Converter::convertResolution(connection, this);
@@ -282,13 +280,13 @@ void ExecutionSystem::groupOperations()
        NodeOperation *operation;
        unsigned int index;
        // surround complex operations with ReadBufferOperation and WriteBufferOperation
-       for (index = 0; index < this->operations.size(); index++) {
-               operation = this->operations[index];
+       for (index = 0; index < this->m_operations.size(); index++) {
+               operation = this->m_operations[index];
                if (operation->isComplex()) {
                        this->addReadWriteBufferOperations(operation);
                }
        }
-       ExecutionSystemHelper::findOutputNodeOperations(&outputOperations, this->getOperations(), this->context.isRendering());
+       ExecutionSystemHelper::findOutputNodeOperations(&outputOperations, this->getOperations(), this->m_context.isRendering());
        for (vector<NodeOperation *>::iterator iter = outputOperations.begin(); iter != outputOperations.end(); ++iter) {
                operation = *iter;
                ExecutionGroup *group = new ExecutionGroup();
@@ -300,15 +298,15 @@ void ExecutionSystem::groupOperations()
 
 void ExecutionSystem::addSocketConnection(SocketConnection *connection)
 {
-       this->connections.push_back(connection);
+       this->m_connections.push_back(connection);
 }
 
 
 void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result, CompositorPriority priority) const
 {
        unsigned int index;
-       for (index = 0; index < this->groups.size(); index++) {
-               ExecutionGroup *group = this->groups[index];
+       for (index = 0; index < this->m_groups.size(); index++) {
+               ExecutionGroup *group = this->m_groups[index];
                if (group->isOutputExecutionGroup() && group->getRenderPriotrity() == priority) {
                        result->push_back(group);
                }
@@ -318,8 +316,8 @@ void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result,
 void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result) const
 {
        unsigned int index;
-       for (index = 0; index < this->groups.size(); index++) {
-               ExecutionGroup *group = this->groups[index];
+       for (index = 0; index < this->m_groups.size(); index++) {
+               ExecutionGroup *group = this->m_groups[index];
                if (group->isOutputExecutionGroup()) {
                        result->push_back(group);
                }
index 293a35b3518fa7fcab442dc24c8bc6136125d95c..e51bd7f3026b0c5915c868620d437889f7b421f0 100644 (file)
@@ -108,27 +108,27 @@ private:
        /**
         * @brief the context used during execution
         */
-       CompositorContext context;
+       CompositorContext m_context;
 
        /**
         * @brief vector of nodes
         */
-       vector<Node *> nodes;
+       vector<Node *> m_nodes;
 
        /**
         * @brief vector of operations
         */
-       vector<NodeOperation *> operations;
+       vector<NodeOperation *> m_operations;
 
        /**
         * @brief vector of groups
         */
-       vector<ExecutionGroup *> groups
+       vector<ExecutionGroup *> m_groups;
 
        /**
         * @brief vector of connections
-        */;
-       vector<SocketConnection *> connections;
+        */
+       vector<SocketConnection *> m_connections;
 
 private: //methods
        /**
@@ -200,27 +200,27 @@ public:
        /**
         * @brief get the reference to the compositor context
         */
-       CompositorContext& getContext() { return this->context; }
+       CompositorContext& getContext() { return this->m_context; }
 
        /**
         * @brief get the reference to the compositor nodes
         */
-       vector<Node *>& getNodes() { return this->nodes; }
+       vector<Node *>& getNodes() { return this->m_nodes; }
 
        /**
         * @brief get the reference to the compositor connections
         */
-       vector<SocketConnection *>& getConnections() { return this->connections; }
+       vector<SocketConnection *>& getConnections() { return this->m_connections; }
 
        /**
         * @brief get the reference to the list of execution groups
         */
-       vector<ExecutionGroup *>& getExecutionGroups() { return this->groups; }
+       vector<ExecutionGroup *>& getExecutionGroups() { return this->m_groups; }
 
        /**
         * @brief get the reference to the list of operations
         */
-       vector<NodeOperation *>& getOperations() { return this->operations; }
+       vector<NodeOperation *>& getOperations() { return this->m_operations; }
 
 private:
 
index e5376567077b20c9a9310fc59a395a997d668673..0f6ba1f4ac9fbeeb4b14e4856a632f18a96a6e88 100644 (file)
@@ -77,11 +77,11 @@ void ExecutionSystemHelper::addNode(vector<Node *>& nodes, Node *node)
        nodes.push_back(node);
 }
 
-Node *ExecutionSystemHelper::addNode(vector<Node *>& nodes, bNode *bNode, bool inActiveGroup)
+Node *ExecutionSystemHelper::addNode(vector<Node *>& nodes, bNode *b_node, bool inActiveGroup)
 {
        Converter converter;
        Node *node;
-       node = converter.convert(bNode);
+       node = converter.convert(b_node);
        node->setIsInActiveGroup(inActiveGroup);
        if (node != NULL) {
                addNode(nodes, node);
@@ -153,17 +153,17 @@ static OutputSocket *find_output(NodeRange &node_range, bNode *bnode, bNodeSocke
        }
        return NULL;
 }
-SocketConnection *ExecutionSystemHelper::addNodeLink(NodeRange &node_range, vector<SocketConnection *>& links, bNodeLink *bNodeLink)
+SocketConnection *ExecutionSystemHelper::addNodeLink(NodeRange &node_range, vector<SocketConnection *>& links, bNodeLink *b_nodelink)
 {
        /// @note: cyclic lines will be ignored. This has been copied from node.c
-       if (bNodeLink->tonode != 0 && bNodeLink->fromnode != 0) {
-               if (!(bNodeLink->fromnode->level >= bNodeLink->tonode->level && bNodeLink->tonode->level != 0xFFF)) { // only add non cyclic lines! so execution will procede
+       if (b_nodelink->tonode != 0 && b_nodelink->fromnode != 0) {
+               if (!(b_nodelink->fromnode->level >= b_nodelink->tonode->level && b_nodelink->tonode->level != 0xFFF)) { // only add non cyclic lines! so execution will procede
                        return NULL;
                }
        }
 
-       InputSocket *inputSocket = find_input(node_range, bNodeLink->tonode, bNodeLink->tosock);
-       OutputSocket *outputSocket = find_output(node_range, bNodeLink->fromnode, bNodeLink->fromsock);
+       InputSocket *inputSocket = find_input(node_range, b_nodelink->tonode, b_nodelink->tosock);
+       OutputSocket *outputSocket = find_output(node_range, b_nodelink->fromnode, b_nodelink->fromsock);
        if (inputSocket == NULL || outputSocket == NULL) {
                return NULL;
        }
index 31ff97614daf6d2eeea3a9346d765aff9f8fef18..4b65ed1557778f0e60bc06e56498f9ec30af66db 100644 (file)
@@ -58,7 +58,7 @@ public:
         * @param bNode node to add
         * @return Node that represents the bNode or null when not able to convert.
         */
-       static Node *addNode(vector<Node *>& nodes, bNode *bNode, bool isInActiveGroup);
+       static Node *addNode(vector<Node *>& nodes, bNode *b_node, bool isInActiveGroup);
 
        /**
         * @brief Add a Node to a list
index 3ca74f157b4ac473f659cc1ef2ace3a10a51db77..94cb5ff539643eb301183649480394af8f2149d0 100644 (file)
 
 InputSocket::InputSocket(DataType datatype) : Socket(datatype)
 {
-       this->connection = NULL;
-       this->resizeMode = COM_SC_CENTER;
+       this->m_connection = NULL;
+       this->m_resizeMode = COM_SC_CENTER;
 }
 InputSocket::InputSocket(DataType datatype, InputSocketResizeMode resizeMode) : Socket(datatype)
 {
-       this->connection = NULL;
-       this->resizeMode = resizeMode;
+       this->m_connection = NULL;
+       this->m_resizeMode = resizeMode;
 }
 
 InputSocket::InputSocket(InputSocket *from) : Socket(from->getDataType())
 {
-       this->connection = NULL;
-       this->resizeMode = from->getResizeMode();
+       this->m_connection = NULL;
+       this->m_resizeMode = from->getResizeMode();
 }
 
 int InputSocket::isInputSocket() const { return true; }
-const int InputSocket::isConnected() const { return this->connection != NULL; }
+const int InputSocket::isConnected() const { return this->m_connection != NULL; }
 
 void InputSocket::setConnection(SocketConnection *connection)
 {
-       this->connection = connection;
+       this->m_connection = connection;
 }
 SocketConnection *InputSocket::getConnection()
 {
-       return this->connection;
+       return this->m_connection;
 }
 
 void InputSocket::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
 {
        if (this->isConnected()) {
-               this->connection->getFromSocket()->determineResolution(resolution, preferredResolution);
+               this->m_connection->getFromSocket()->determineResolution(resolution, preferredResolution);
        }
        else {
                return;
@@ -140,7 +140,7 @@ SocketReader *InputSocket::getReader()
 NodeOperation *InputSocket::getOperation() const
 {
        if (isConnected()) {
-               return (NodeOperation *)this->connection->getFromSocket()->getNode();
+               return (NodeOperation *)this->m_connection->getFromSocket()->getNode();
        }
        else {
                return NULL;
index c066b5d8303878e0ea7631d1a1b3c822554dda27..5d0923ff204d8ed034e7e80ba82d9e782883d1a7 100644 (file)
@@ -65,12 +65,12 @@ private:
         * @brief connection connected to this InputSocket.
         * An input socket can only have a single connection
         */
-       SocketConnection *connection;
+       SocketConnection *m_connection;
        
        /**
         * @brief resize mode of this socket
         */
-       InputSocketResizeMode resizeMode;
+       InputSocketResizeMode m_resizeMode;
        
        
 public:
@@ -126,7 +126,7 @@ public:
         * @param resizeMode the new resize mode.
         */
        void setResizeMode(InputSocketResizeMode resizeMode) {
-               this->resizeMode = resizeMode;
+               this->m_resizeMode = resizeMode;
        }
        
        /**
@@ -134,7 +134,7 @@ public:
         * @return InputSocketResizeMode
         */
        InputSocketResizeMode getResizeMode() const {
-               return this->resizeMode;
+               return this->m_resizeMode;
        }
        
        const ChannelInfo *getChannelInfo(const int channelnumber);
index ceed53c4c0d51bc1749568560b8923d8f0f851ef..8dd1e55274fc32a24aa85afdbb9763b2adde9668 100644 (file)
@@ -32,43 +32,43 @@ unsigned int MemoryBuffer::determineBufferSize()
 
 int MemoryBuffer::getWidth() const
 {
-       return this->rect.xmax - this->rect.xmin;
+       return this->m_rect.xmax - this->m_rect.xmin;
 }
 int MemoryBuffer::getHeight() const
 {
-       return this->rect.ymax - this->rect.ymin;
+       return this->m_rect.ymax - this->m_rect.ymin;
 }
 
 MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti *rect)
 {
-       BLI_init_rcti(&this->rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
-       this->memoryProxy = memoryProxy;
-       this->chunkNumber = chunkNumber;
-       this->buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
-       this->state = COM_MB_ALLOCATED;
-       this->datatype = COM_DT_COLOR;
-       this->chunkWidth = this->rect.xmax - this->rect.xmin;
+       BLI_init_rcti(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
+       this->m_memoryProxy = memoryProxy;
+       this->m_chunkNumber = chunkNumber;
+       this->m_buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
+       this->m_state = COM_MB_ALLOCATED;
+       this->m_datatype = COM_DT_COLOR;
+       this->m_chunkWidth = this->m_rect.xmax - this->m_rect.xmin;
 }
 
 MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, rcti *rect)
 {
-       BLI_init_rcti(&this->rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
-       this->memoryProxy = memoryProxy;
-       this->chunkNumber = -1;
-       this->buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
-       this->state = COM_MB_TEMPORARILY;
-       this->datatype = COM_DT_COLOR;
-       this->chunkWidth = this->rect.xmax - this->rect.xmin;
+       BLI_init_rcti(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
+       this->m_memoryProxy = memoryProxy;
+       this->m_chunkNumber = -1;
+       this->m_buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
+       this->m_state = COM_MB_TEMPORARILY;
+       this->m_datatype = COM_DT_COLOR;
+       this->m_chunkWidth = this->m_rect.xmax - this->m_rect.xmin;
 }
 MemoryBuffer *MemoryBuffer::duplicate()
 {
-       MemoryBuffer *result = new MemoryBuffer(this->memoryProxy, &this->rect);
-       memcpy(result->buffer, this->buffer, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+       MemoryBuffer *result = new MemoryBuffer(this->m_memoryProxy, &this->m_rect);
+       memcpy(result->m_buffer, this->m_buffer, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
        return result;
 }
 void MemoryBuffer::clear()
 {
-       memset(this->buffer, 0, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+       memset(this->m_buffer, 0, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
 }
 
 float *MemoryBuffer::convertToValueBuffer()
@@ -78,7 +78,7 @@ float *MemoryBuffer::convertToValueBuffer()
 
        float *result = new float[size];
 
-       const float *fp_src = this->buffer;
+       const float *fp_src = this->m_buffer;
        float       *fp_dst = result;
 
        for (i = 0; i < size; i++, fp_dst++, fp_src += COM_NUMBER_OF_CHANNELS) {
@@ -90,9 +90,9 @@ float *MemoryBuffer::convertToValueBuffer()
 
 MemoryBuffer::~MemoryBuffer()
 {
-       if (this->buffer) {
-               MEM_freeN(this->buffer);
-               this->buffer = NULL;
+       if (this->m_buffer) {
+               MEM_freeN(this->m_buffer);
+               this->m_buffer = NULL;
        }
 }
 
@@ -102,30 +102,30 @@ void MemoryBuffer::copyContentFrom(MemoryBuffer *otherBuffer)
                return;
        }
        unsigned int otherY;
-       unsigned int minX = max(this->rect.xmin, otherBuffer->rect.xmin);
-       unsigned int maxX = min(this->rect.xmax, otherBuffer->rect.xmax);
-       unsigned int minY = max(this->rect.ymin, otherBuffer->rect.ymin);
-       unsigned int maxY = min(this->rect.ymax, otherBuffer->rect.ymax);
+       unsigned int minX = max(this->m_rect.xmin, otherBuffer->m_rect.xmin);
+       unsigned int maxX = min(this->m_rect.xmax, otherBuffer->m_rect.xmax);
+       unsigned int minY = max(this->m_rect.ymin, otherBuffer->m_rect.ymin);
+       unsigned int maxY = min(this->m_rect.ymax, otherBuffer->m_rect.ymax);
        int offset;
        int otherOffset;
 
 
        for (otherY = minY; otherY < maxY; otherY++) {
-               otherOffset = ((otherY - otherBuffer->rect.ymin) * otherBuffer->chunkWidth + minX - otherBuffer->rect.xmin) * COM_NUMBER_OF_CHANNELS;
-               offset = ((otherY - this->rect.ymin) * this->chunkWidth + minX - this->rect.xmin) * COM_NUMBER_OF_CHANNELS;
-               memcpy(&this->buffer[offset], &otherBuffer->buffer[otherOffset], (maxX - minX) * COM_NUMBER_OF_CHANNELS * sizeof(float));
+               otherOffset = ((otherY - otherBuffer->m_rect.ymin) * otherBuffer->m_chunkWidth + minX - otherBuffer->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
+               offset = ((otherY - this->m_rect.ymin) * this->m_chunkWidth + minX - this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
+               memcpy(&this->m_buffer[offset], &otherBuffer->m_buffer[otherOffset], (maxX - minX) * COM_NUMBER_OF_CHANNELS * sizeof(float));
        }
 }
 
 void MemoryBuffer::read(float result[4], int x, int y)
 {
-       if (x >= this->rect.xmin && x < this->rect.xmax &&
-           y >= this->rect.ymin && y < this->rect.ymax)
+       if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
+           y >= this->m_rect.ymin && y < this->m_rect.ymax)
        {
-               const int dx = x - this->rect.xmin;
-               const int dy = y - this->rect.ymin;
-               const int offset = (this->chunkWidth * dy + dx) * COM_NUMBER_OF_CHANNELS;
-               copy_v4_v4(result, &this->buffer[offset]);
+               const int dx = x - this->m_rect.xmin;
+               const int dy = y - this->m_rect.ymin;
+               const int offset = (this->m_chunkWidth * dy + dx) * COM_NUMBER_OF_CHANNELS;
+               copy_v4_v4(result, &this->m_buffer[offset]);
        }
        else {
                zero_v4(result);
@@ -133,21 +133,21 @@ void MemoryBuffer::read(float result[4], int x, int y)
 }
 void MemoryBuffer::writePixel(int x, int y, const float color[4])
 {
-       if (x >= this->rect.xmin && x < this->rect.xmax &&
-           y >= this->rect.ymin && y < this->rect.ymax)
+       if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
+           y >= this->m_rect.ymin && y < this->m_rect.ymax)
        {
-               const int offset = (this->chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
-               copy_v4_v4(&this->buffer[offset], color);
+               const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
+               copy_v4_v4(&this->m_buffer[offset], color);
        }
 }
 
 void MemoryBuffer::addPixel(int x, int y, const float color[4])
 {
-       if (x >= this->rect.xmin && x < this->rect.xmax &&
-           y >= this->rect.ymin && y < this->rect.ymax)
+       if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
+           y >= this->m_rect.ymin && y < this->m_rect.ymax)
        {
-               const int offset = (this->chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
-               add_v4_v4(&this->buffer[offset], color);
+               const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
+               add_v4_v4(&this->m_buffer[offset], color);
        }
 }
 
index 63d9d54bcee8ee2351767c2e396c79e14d582422..63b41aeddde4ad57e84d288621b5781162fb0287 100644 (file)
@@ -56,39 +56,39 @@ private:
        /**
         * @brief proxy of the memory (same for all chunks in the same buffer)
         */
-       MemoryProxy *memoryProxy;
+       MemoryProxy *m_memoryProxy;
        
        /**
         * @brief the type of buffer COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR
         */
-       DataType datatype;
+       DataType m_datatype;
        
        
        /**
         * @brief region of this buffer inside reative to the MemoryProxy
         */
-       rcti rect;
+       rcti m_rect;
        
        /**
         * brief refers to the chunknumber within the executiongroup where related to the MemoryProxy
         * @see memoryProxy
         */
-       unsigned int chunkNumber;
+       unsigned int m_chunkNumber;
        
        /**
         * @brief width of the chunk
         */
-       unsigned int chunkWidth;
+       unsigned int m_chunkWidth;
        
        /**
         * @brief state of the buffer
         */
-       MemoryBufferState state;
+       MemoryBufferState m_state;
        
        /**
         * @brief the actual float buffer/data
         */
-       float *buffer;
+       float *m_buffer;
 
 public:
        /**
@@ -109,19 +109,19 @@ public:
        /**
         * @brief read the ChunkNumber of this MemoryBuffer
         */
-       unsigned int getChunkNumber() { return this->chunkNumber; }
+       unsigned int getChunkNumber() { return this->m_chunkNumber; }
        
        /**
         * @brief get the data of this MemoryBuffer
         * @note buffer should already be available in memory
         */
-       float *getBuffer() { return this->buffer; }
+       float *getBuffer() { return this->m_buffer; }
        
        /**
         * @brief after execution the state will be set to available by calling this method
         */
        void setCreatedState() {
-               this->state = COM_MB_AVAILABLE;
+               this->m_state = COM_MB_AVAILABLE;
        }
        
        void read(float result[4], int x, int y);
@@ -133,7 +133,7 @@ public:
        /**
         * @brief is this MemoryBuffer a temporarily buffer (based on an area, not on a chunk)
         */
-       inline const bool isTemporarily() const { return this->state == COM_MB_TEMPORARILY; }
+       inline const bool isTemporarily() const { return this->m_state == COM_MB_TEMPORARILY; }
        
        /**
         * @brief add the content from otherBuffer to this MemoryBuffer
@@ -144,7 +144,7 @@ public:
        /**
         * @brief get the rect of this MemoryBuffer
         */
-       rcti *getRect() { return &this->rect; }
+       rcti *getRect() { return &this->m_rect; }
        
        /**
         * @brief get the width of this MemoryBuffer
index 3a2c690d7de7c3db082a47148d58b760672fce03..90ca0baea06e5fbe256af689ba1adc51bb6649ad 100644 (file)
@@ -25,8 +25,8 @@
 
 MemoryProxy::MemoryProxy()
 {
-       this->writeBufferOperation = NULL;
-       this->executor = NULL;
+       this->m_writeBufferOperation = NULL;
+       this->m_executor = NULL;
 }
 
 void MemoryProxy::allocate(unsigned int width, unsigned int height)
@@ -37,14 +37,14 @@ void MemoryProxy::allocate(unsigned int width, unsigned int height)
        result.ymin = 0;
        result.ymax = height;
 
-       buffer = new MemoryBuffer(this, 1, &result);
+       this->m_buffer = new MemoryBuffer(this, 1, &result);
 }
 
 void MemoryProxy::free()
 {
-       if (buffer) {
-               delete buffer;
-               buffer = NULL;
+       if (this->m_buffer) {
+               delete this->m_buffer;
+               this->m_buffer = NULL;
        }
 }
 
index 8ac817ffe7bdf85fffa1bef55d09e29abcc0055a..f02da215b5f53d8742a482bf65372f81c7b1ed27 100644 (file)
@@ -23,8 +23,8 @@
 class MemoryProxy;
 
 
-#ifndef _COM_MemoryProxy_h
-#define _COM_MemoryProxy_h
+#ifndef _COM_MemoryProxy_h_
+#define _COM_MemoryProxy_h_
 #include "COM_ExecutionGroup.h"
 
 class ExecutionGroup;
@@ -40,27 +40,27 @@ private:
        /**
         * @brief reference to the ouput operation of the executiongroup
         */
-       WriteBufferOperation *writeBufferOperation;
+       WriteBufferOperation *m_writeBufferOperation;
        
        /**
         * @brief reference to the executor. the Execution group that can fill a chunk
         */
-       ExecutionGroup *executor;
+       ExecutionGroup *m_executor;
        
        /**
         * @brief datatype of this MemoryProxy
         */
-       DataType datatype;
+       DataType m_datatype;
        
        /**
         * @brief channel information of this buffer
         */
-       ChannelInfo channelInfo[COM_NUMBER_OF_CHANNELS];
+       ChannelInfo m_channelInfo[COM_NUMBER_OF_CHANNELS];
 
        /**
         * @brief the allocated memory
         */
-       MemoryBuffer *buffer;
+       MemoryBuffer *m_buffer;
 
 public:
        MemoryProxy();
@@ -69,24 +69,24 @@ public:
         * @brief set the ExecutionGroup that can be scheduled to calculate a certain chunk.
         * @param group the ExecutionGroup to set
         */
-       void setExecutor(ExecutionGroup *executor) { this->executor = executor; }
+       void setExecutor(ExecutionGroup *executor) { this->m_executor = executor; }
 
        /**
         * @brief get the ExecutionGroup that can be scheduled to calculate a certain chunk.
         */
-       ExecutionGroup *getExecutor() { return this->executor; }
+       ExecutionGroup *getExecutor() { return this->m_executor; }
 
        /**
         * @brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy
         * @param operation
         */
-       void setWriteBufferOperation(WriteBufferOperation *operation) { this->writeBufferOperation = operation; }
+       void setWriteBufferOperation(WriteBufferOperation *operation) { this->m_writeBufferOperation = operation; }
 
        /**
         * @brief get the WriteBufferOperation that is responsible for writing to this MemoryProxy
         * @return WriteBufferOperation
         */
-       WriteBufferOperation *getWriteBufferOperation() { return this->writeBufferOperation; }
+       WriteBufferOperation *getWriteBufferOperation() { return this->m_writeBufferOperation; }
 
        /**
         * @brief allocate memory of size widht x height
@@ -101,7 +101,7 @@ public:
        /**
         * @brief get the allocated memory
         */
-       inline MemoryBuffer *getBuffer() { return this->buffer; }
+       inline MemoryBuffer *getBuffer() { return this->m_buffer; }
 
 #ifdef WITH_CXX_GUARDEDALLOC
        MEM_CXX_CLASS_ALLOC_FUNCS("COM:MemoryProxy")
index 06b6164be3cc22c4f9e8eb1bae369f5287e0c15c..15b8a3933a7baed97691092a68e084944ed2d405 100644 (file)
@@ -41,7 +41,7 @@
 
 Node::Node(bNode *editorNode, bool create_sockets)
 {
-       this->editorNode = editorNode;
+       this->m_editorNode = editorNode;
        
        if (create_sockets) {
                bNodeSocket *input = (bNodeSocket *)editorNode->inputs.first;
@@ -66,12 +66,12 @@ Node::Node(bNode *editorNode, bool create_sockets)
 }
 Node::Node()
 {
-       this->editorNode = NULL;
+       this->m_editorNode = NULL;
 }
 
 bNode *Node::getbNode()
 {
-       return this->editorNode;
+       return this->m_editorNode;
 }
 
 void Node::addSetValueOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex)
index 090b14554407ec83e11815cd7ffec3f569d61f6b..5d6d232f37aa06b44ab0a37f8ca93ab9dda270c6 100644 (file)
@@ -51,12 +51,12 @@ private:
        /**
         * @brief stores the reference to the SDNA bNode struct
         */
-       bNode *editorNode;
+       bNode *m_editorNode;
 
        /**
         * @brief Is this node part of the active group
         */
-       bool inActiveGroup;
+       bool m_inActiveGroup;
 
 public:
        Node(bNode *editorNode, bool create_sockets = true);
@@ -70,7 +70,7 @@ public:
         * @brief Is this node in the active group (the group that is being edited)
         * @param isInActiveGroup
         */
-       void setIsInActiveGroup(bool isInActiveGroup) { this->inActiveGroup = isInActiveGroup; }
+       void setIsInActiveGroup(bool value) { this->m_inActiveGroup = value; }
        
        /**
         * @brief Is this node part of the active group
@@ -78,7 +78,7 @@ public:
         * the active group will be the main tree (all nodes that are not part of a group will be active)
         * @return bool [false:true]
         */
-       inline bool isInActiveGroup() { return this->inActiveGroup; }
+       inline bool isInActiveGroup() { return this->m_inActiveGroup; }
 
        /**
         * @brief convert node to operation
index 1a895cf93b1d9596e63589e35fd36ad66fac8c42..8dbda5f649c8979548be723381342400684650e9 100644 (file)
@@ -39,13 +39,13 @@ NodeBase::NodeBase()
 
 NodeBase::~NodeBase()
 {
-       while (!this->outputsockets.empty()) {
-               delete (this->outputsockets.back());
-               this->outputsockets.pop_back();
+       while (!this->m_outputsockets.empty()) {
+               delete (this->m_outputsockets.back());
+               this->m_outputsockets.pop_back();
        }
-       while (!this->inputsockets.empty()) {
-               delete (this->inputsockets.back());
-               this->inputsockets.pop_back();
+       while (!this->m_inputsockets.empty()) {
+               delete (this->m_inputsockets.back());
+               this->m_inputsockets.pop_back();
        }
 }
 
@@ -63,7 +63,7 @@ void NodeBase::addInputSocket(DataType datatype, InputSocketResizeMode resizeMod
        InputSocket *socket = new InputSocket(datatype, resizeMode);
        socket->setEditorSocket(bSocket);
        socket->setNode(this);
-       this->inputsockets.push_back(socket);
+       this->m_inputsockets.push_back(socket);
 }
 
 void NodeBase::addOutputSocket(DataType datatype)
@@ -76,21 +76,21 @@ void NodeBase::addOutputSocket(DataType datatype, bNodeSocket *bSocket)
        OutputSocket *socket = new OutputSocket(datatype);
        socket->setEditorSocket(bSocket);
        socket->setNode(this);
-       this->outputsockets.push_back(socket);
+       this->m_outputsockets.push_back(socket);
 }
 const bool NodeBase::isInputNode() const
 {
-       return this->inputsockets.size() == 0;
+       return this->m_inputsockets.size() == 0;
 }
 
 OutputSocket *NodeBase::getOutputSocket(unsigned int index)
 {
-       BLI_assert(index < this->outputsockets.size());
-       return this->outputsockets[index];
+       BLI_assert(index < this->m_outputsockets.size());
+       return this->m_outputsockets[index];
 }
 
 InputSocket *NodeBase::getInputSocket(unsigned int index)
 {
-       BLI_assert(index < this->inputsockets.size());
-       return this->inputsockets[index];
+       BLI_assert(index < this->m_inputsockets.size());
+       return this->m_inputsockets[index];
 }
index fc9f79d26869dd2ae3870a0e769deaa86438c535..7095cda39e322929c18740ada5b31863b969aa5e 100644 (file)
@@ -47,23 +47,23 @@ private:
        /**
         * @brief the list of actual inputsockets @see InputSocket
         */
-       vector<InputSocket *> inputsockets;
+       vector<InputSocket *> m_inputsockets;
 
        /**
         * @brief the list of actual outputsockets @see OutputSocket
         */
-       vector<OutputSocket *> outputsockets;
+       vector<OutputSocket *> m_outputsockets;
 
 protected:
        /**
         * @brief get access to the vector of input sockets
         */
-       inline vector<InputSocket *>& getInputSockets() { return this->inputsockets; }
+       inline vector<InputSocket *>& getInputSockets() { return this->m_inputsockets; }
        
        /**
         * @brief get access to the vector of input sockets
         */
-       inline vector<OutputSocket *>& getOutputSockets() { return this->outputsockets; }
+       inline vector<OutputSocket *>& getOutputSockets() { return this->m_outputsockets; }
 
 
 public:
@@ -91,12 +91,12 @@ public:
        /**
         * @brief Return the number of input sockets of this node.
         */
-       const unsigned int getNumberOfInputSockets() const { return this->inputsockets.size(); }
+       const unsigned int getNumberOfInputSockets() const { return this->m_inputsockets.size(); }
 
        /**
         * @brief Return the number of output sockets of this node.
         */
-       const unsigned int getNumberOfOutputSockets() const { return this->outputsockets.size(); }
+       const unsigned int getNumberOfOutputSockets() const { return this->m_outputsockets.size(); }
 
        /**
         * get the reference to a certain outputsocket
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 c9d27b8543c3a32895331af8eda0a5beaebd3a9c..2dd44f8140f6b5da81e4667fe76e9986af2dc154 100644 (file)
@@ -27,24 +27,24 @@ typedef enum COM_VendorID  {NVIDIA=0x10DE, AMD=0x1002} COM_VendorID;
 
 OpenCLDevice::OpenCLDevice(cl_context context, cl_device_id device, cl_program program, cl_int vendorId)
 {
-       this->device = device;
-       this->context = context;
-       this->program = program;
-       this->queue = NULL;
-       this->vendorID = vendorId;
+       this->m_device = device;
+       this->m_context = context;
+       this->m_program = program;
+       this->m_queue = NULL;
+       this->m_vendorID = vendorId;
 }
 
 bool OpenCLDevice::initialize()
 {
        cl_int error;
-       queue = clCreateCommandQueue(context, device, 0, &error);
+       this->m_queue = clCreateCommandQueue(this->m_context, this->m_device, 0, &error);
        return false;
 }
 
 void OpenCLDevice::deinitialize()
 {
-       if (queue) {
-               clReleaseCommandQueue(queue);
+       if (this->m_queue) {
+               clReleaseCommandQueue(this->m_queue);
        }
 }
 
@@ -76,8 +76,8 @@ cl_mem OpenCLDevice::COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel,
                CL_FLOAT
        };
 
-       cl_mem clBuffer = clCreateImage2D(this->context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &imageFormat, result->getWidth(),
-                                                                         result->getHeight(), 0, result->getBuffer(), &error);
+       cl_mem clBuffer = clCreateImage2D(this->m_context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &imageFormat, result->getWidth(),
+                                         result->getHeight(), 0, result->getBuffer(), &error);
 
        if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
        if (error == CL_SUCCESS) cleanup->push_back(clBuffer);
@@ -124,7 +124,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
        cl_int error;
        const size_t size[] = {outputMemoryBuffer->getWidth(), outputMemoryBuffer->getHeight()};
 
-       error = clEnqueueNDRangeKernel(this->queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
+       error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
        if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
 }
 
@@ -139,7 +139,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
        size_t size[2];
        cl_int2 offset;
 
-       if (this->vendorID == NVIDIA){localSize = 32;}
+       if (this->m_vendorID == NVIDIA) {localSize = 32;}
        bool breaked = false;
        for (offsety = 0; offsety < height && (!breaked); offsety += localSize) {
                offset[1] = offsety;
@@ -160,9 +160,9 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
 
                        error = clSetKernelArg(kernel, offsetIndex, sizeof(cl_int2), &offset);
                        if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
-                       error = clEnqueueNDRangeKernel(this->queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
+                       error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
                        if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
-                       clFlush(this->queue);
+                       clFlush(this->m_queue);
                        if (operation->isBreaked()) {
                                breaked = false;
                        }
@@ -173,7 +173,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
 cl_kernel OpenCLDevice::COM_clCreateKernel(const char *kernelname, list<cl_kernel> *clKernelsToCleanUp)
 {
        cl_int error;
-       cl_kernel kernel = clCreateKernel(this->program, kernelname, &error);
+       cl_kernel kernel = clCreateKernel(this->m_program, kernelname, &error);
        if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
        else {
                if (clKernelsToCleanUp) clKernelsToCleanUp->push_back(kernel);
index d132f330651ad828726ffc2365b1bce3d22aa275..30a90dabc3e0cca279a8b6abb197039690f0b451 100644 (file)
@@ -38,27 +38,27 @@ private:
        /**
         * @brief opencl context
         */
-       cl_context context;
+       cl_context m_context;
        
        /**
         * @brief opencl device
         */
-       cl_device_id device;
+       cl_device_id m_device;
        
        /**
         * @brief opencl program
         */
-       cl_program program;
+       cl_program m_program;
        
        /**
         * @brief opencl command queue
         */
-       cl_command_queue queue;
+       cl_command_queue m_queue;
 
        /**
         * @brief opencl vendor ID
         */
-       cl_int vendorID;
+       cl_int m_vendorID;
 
 public:
        /**
@@ -91,9 +91,9 @@ public:
         */
        void execute(WorkPackage *work);
 
-       cl_context getContext(){return this->context;}
+       cl_context getContext(){ return this->m_context; }
 
-       cl_command_queue getQueue(){return this->queue;}
+       cl_command_queue getQueue(){ return this->m_queue; }
 
        cl_mem COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel, int parameterIndex, int offsetIndex, list<cl_mem> *cleanup, MemoryBuffer **inputMemoryBuffers, SocketReader *reader);
        void COM_clAttachMemoryBufferOffsetToKernelParameter(cl_kernel kernel, int offsetIndex, MemoryBuffer *memoryBuffers);
index 484254fe6de571cd8eb34a72a77c603c621afee4..865ab0472e8e795eb88981add3200f1f7d6d72c3 100644 (file)
@@ -31,7 +31,7 @@ OutputSocket::OutputSocket(DataType datatype) : Socket(datatype)
 }
 
 int OutputSocket::isOutputSocket() const { return true; }
-const int OutputSocket::isConnected() const { return this->connections.size() != 0; }
+const int OutputSocket::isConnected() const { return this->m_connections.size() != 0; }
 
 void OutputSocket::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
 {
@@ -51,37 +51,37 @@ void OutputSocket::determineResolution(unsigned int resolution[], unsigned int p
 
 void OutputSocket::addConnection(SocketConnection *connection)
 {
-       this->connections.push_back(connection);
+       this->m_connections.push_back(connection);
 }
 
 void OutputSocket::relinkConnections(OutputSocket *relinkToSocket, bool single)
 {
        if (isConnected()) {
                if (single) {
-                       SocketConnection *connection = this->connections[0];
+                       SocketConnection *connection = this->m_connections[0];
                        connection->setFromSocket(relinkToSocket);
                        relinkToSocket->addConnection(connection);
-                       this->connections.erase(this->connections.begin());
+                       this->m_connections.erase(this->m_connections.begin());
                }
                else {
                        unsigned int index;
-                       for (index = 0; index < this->connections.size(); index++) {
-                               SocketConnection *connection = this->connections[index];
+                       for (index = 0; index < this->m_connections.size(); index++) {
+                               SocketConnection *connection = this->m_connections[index];
                                connection->setFromSocket(relinkToSocket);
                                relinkToSocket->addConnection(connection);
                        }
-                       this->connections.clear();
+                       this->m_connections.clear();
                }
        }
 }
 void OutputSocket::removeFirstConnection()
 {
-       SocketConnection *connection = this->connections[0];
+       SocketConnection *connection = this->m_connections[0];
        InputSocket *inputSocket = connection->getToSocket();
        if (inputSocket != NULL) {
                inputSocket->setConnection(NULL);
        }
-       this->connections.erase(this->connections.begin());
+       this->m_connections.erase(this->m_connections.begin());
 }
 
 void OutputSocket::clearConnections()
@@ -94,8 +94,8 @@ void OutputSocket::clearConnections()
 WriteBufferOperation *OutputSocket::findAttachedWriteBufferOperation() const
 {
        unsigned int index;
-       for (index = 0; index < this->connections.size(); index++) {
-               SocketConnection *connection = this->connections[index];
+       for (index = 0; index < this->m_connections.size(); index++) {
+               SocketConnection *connection = this->m_connections[index];
                NodeBase *node = connection->getToNode();
                if (node->isOperation()) {
                        NodeOperation *operation = (NodeOperation *)node;
index c073703c42321a7a302e6aa896183eb60d96746f..4810e1ae065b690a99a959c55ccb6b7e7aaf0b5f 100644 (file)
@@ -42,7 +42,7 @@ class WriteBufferOperation;
  */
 class OutputSocket : public Socket {
 private:
-       vector<SocketConnection *> connections;
+       vector<SocketConnection *> m_connections;
                
        void removeFirstConnection();
 public:
@@ -50,7 +50,7 @@ public:
        OutputSocket(DataType datatype, int inputSocketDataTypeDeterminatorIndex);
        OutputSocket(OutputSocket *from);
        void addConnection(SocketConnection *connection);
-       SocketConnection *getConnection(unsigned int index) { return this->connections[index]; }
+       SocketConnection *getConnection(unsigned int index) { return this->m_connections[index]; }
        const int isConnected() const;
        int isOutputSocket() const;
        
@@ -66,7 +66,7 @@ public:
         */
        void relinkConnections(OutputSocket *relinkToSocket) { this->relinkConnections(relinkToSocket, false); };
        void relinkConnections(OutputSocket *relinkToSocket, bool single);
-       const int getNumberOfConnections() { return connections.size(); }
+       const int getNumberOfConnections() { return this->m_connections.size(); }
        
        void clearConnections();
        
index 01043664412f6c0fcfc1b38e2fdfb5031e357f4a..a6f81410b74ed4cfbc2dc0f51fa120bc5d5db649 100644 (file)
@@ -24,7 +24,7 @@
 
 SingleThreadedNodeOperation::SingleThreadedNodeOperation() : NodeOperation()
 {
-       this->cachedInstance = NULL;
+       this->m_cachedInstance = NULL;
        setComplex(true);
 }
 
@@ -35,26 +35,26 @@ void SingleThreadedNodeOperation::initExecution()
 
 void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
 {
-       this->cachedInstance->read(color, x, y);
+       this->m_cachedInstance->read(color, x, y);
 }
 
 void SingleThreadedNodeOperation::deinitExecution()
 {
        deinitMutex();
-       if (this->cachedInstance) {
-               delete cachedInstance;
-               this->cachedInstance = NULL;
+       if (this->m_cachedInstance) {
+               delete this->m_cachedInstance;
+               this->m_cachedInstance = NULL;
        }
 }
 void *SingleThreadedNodeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
 {
-       if (this->cachedInstance) return this->cachedInstance;
+       if (this->m_cachedInstance) return this->m_cachedInstance;
        
        lockMutex();
-       if (this->cachedInstance == NULL) {
+       if (this->m_cachedInstance == NULL) {
                //
-               this->cachedInstance = createMemoryBuffer(rect, memoryBuffers);
+               this->m_cachedInstance = createMemoryBuffer(rect, memoryBuffers);
        }
        unlockMutex();
-       return this->cachedInstance;
+       return this->m_cachedInstance;
 }
index b1bf28c9c07b32f95e2de5f602cd7a8e511d7967..c6db5381f487022dfc5db193ec66bcbaae259161 100644 (file)
 
 class SingleThreadedNodeOperation : public NodeOperation {
 private:
-       MemoryBuffer *cachedInstance;
+       MemoryBuffer *m_cachedInstance;
        
 protected:
        inline bool isCached() {
-               return cachedInstance != NULL;
+               return this->m_cachedInstance != NULL;
        }
 
 public:
index 11739a4e9c52898c5af20f09bfe3a70132108794..30f28f9dddb9b8552b92f68bd894b4f1a941c34a 100644 (file)
 
 Socket::Socket(DataType datatype)
 {
-       this->datatype = datatype;
-       this->editorSocket = NULL;
-       this->node = NULL;
+       this->m_datatype = datatype;
+       this->m_editorSocket = NULL;
+       this->m_node = NULL;
 }
 
 DataType Socket::getDataType() const
 {
-       return this->datatype;
+       return this->m_datatype;
 }
 
 int Socket::isInputSocket() const { return false; }
 int Socket::isOutputSocket() const { return false; }
 const int Socket::isConnected() const { return false; }
-void Socket::setNode(NodeBase *node) { this->node = node; }
-NodeBase *Socket::getNode() const { return this->node; }
+void Socket::setNode(NodeBase *node) { this->m_node = node; }
+NodeBase *Socket::getNode() const { return this->m_node; }
index 9feef1bae939d370174a1865be850f8e520b7878..5607d2f456996cfd080bed29f1a0444c3287fe03 100644 (file)
@@ -53,15 +53,15 @@ private:
        /**
         * Reference to the node where this Socket belongs to
         */
-       NodeBase *node;
+       NodeBase *m_node;
        
        /**
         * the datatype of this socket. Is used for automatically data transformation.
         * @section data-conversion
         */
-       DataType datatype;
+       DataType m_datatype;
        
-       bNodeSocket *editorSocket;
+       bNodeSocket *m_editorSocket;
 public:
        Socket(DataType datatype);
        
@@ -75,8 +75,8 @@ public:
        int isOutputSocket() const;
        virtual void determineResolution(int resolution[], unsigned int preferredResolution[]) {}
 
-       void setEditorSocket(bNodeSocket *editorSocket) { this->editorSocket = editorSocket; }
-       bNodeSocket *getbNodeSocket() const { return this->editorSocket; }
+       void setEditorSocket(bNodeSocket *editorSocket) { this->m_editorSocket = editorSocket; }
+       bNodeSocket *getbNodeSocket() const { return this->m_editorSocket; }
        
 #ifdef WITH_CXX_GUARDEDALLOC
        MEM_CXX_CLASS_ALLOC_FUNCS("COM:Socket")
index 1edeb6158b9d24237612214034612be7c9b878e4..1f2cba72dc0acc77d8e5e86e7a5e3a71ef316d8f 100644 (file)
@@ -25,8 +25,8 @@
 
 SocketConnection::SocketConnection()
 {
-       this->fromSocket = NULL;
-       this->toSocket = NULL;
+       this->m_fromSocket = NULL;
+       this->m_toSocket = NULL;
        this->setIgnoreResizeCheck(false);
 }
 
@@ -35,19 +35,19 @@ void SocketConnection::setFromSocket(OutputSocket *fromsocket)
        if (fromsocket == NULL) {
                throw "ERROR";
        }
-       this->fromSocket = fromsocket;
+       this->m_fromSocket = fromsocket;
 }
 
-OutputSocket *SocketConnection::getFromSocket() const { return this->fromSocket; }
+OutputSocket *SocketConnection::getFromSocket() const { return this->m_fromSocket; }
 void SocketConnection::setToSocket(InputSocket *tosocket)
 {
        if (tosocket == NULL) {
                throw "ERROR";
        }
-       this->toSocket = tosocket;
+       this->m_toSocket = tosocket;
 }
 
-InputSocket *SocketConnection::getToSocket() const { return this->toSocket; }
+InputSocket *SocketConnection::getToSocket() const { return this->m_toSocket; }
 
 NodeBase *SocketConnection::getFromNode() const
 {
@@ -79,10 +79,10 @@ bool SocketConnection::isValid() const
 
 bool SocketConnection::needsResolutionConversion() const
 {
-       if (this->ignoreResizeCheck) { return false; }
+       if (this->m_ignoreResizeCheck) { return false; }
        NodeOperation *fromOperation = (NodeOperation *)this->getFromNode();
        NodeOperation *toOperation = (NodeOperation *)this->getToNode();
-       if (this->toSocket->getResizeMode() == COM_SC_NO_RESIZE) { return false; }
+       if (this->m_toSocket->getResizeMode() == COM_SC_NO_RESIZE) { return false; }
        const unsigned int fromWidth = fromOperation->getWidth();
        const unsigned int fromHeight = fromOperation->getHeight();
        const unsigned int toWidth = toOperation->getWidth();
index 101e06af61cd143879dc616bc7eecf3c50127905..9777bd45be2600945e49d93d9c37f3556bfe629e 100644 (file)
@@ -48,17 +48,17 @@ private:
        /**
         * @brief Startpoint of the connection
         */
-       OutputSocket *fromSocket;
+       OutputSocket *m_fromSocket;
        
        /**
         * @brief Endpoint of the connection
         */
-       InputSocket *toSocket;
+       InputSocket *m_toSocket;
        
        /**
         * @brief has the resize already been done for this connection
         */
-       bool ignoreResizeCheck;
+       bool m_ignoreResizeCheck;
 public:
        SocketConnection();
        
@@ -104,12 +104,12 @@ public:
        /**
         * @brief set, whether the resize has already been done for this SocketConnection
         */
-       void setIgnoreResizeCheck(bool check) { this->ignoreResizeCheck = check; }
+       void setIgnoreResizeCheck(bool check) { this->m_ignoreResizeCheck = check; }
        
        /**
         * @brief has the resize already been done for this SocketConnection
         */
-       bool isIgnoreResizeCheck() const { return this->ignoreResizeCheck; }
+       bool isIgnoreResizeCheck() const { return this->m_ignoreResizeCheck; }
        
        /**
         * @brief does this SocketConnection need resolution conversion
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 07974b9aafcb95bb07b9ba50c4ae8ce809082d30..fa332ffa23ec3470b054df4c8e6272567c92d840 100644 (file)
@@ -24,6 +24,6 @@
 
 WorkPackage::WorkPackage(ExecutionGroup *group, unsigned int chunkNumber)
 {
-       this->executionGroup = group;
-       this->chunkNumber = chunkNumber;
+       this->m_executionGroup = group;
+       this->m_chunkNumber = chunkNumber;
 }
index 6ee9d616a34f8191d9f6f0966beb8f39cad3faee..953a164e95efd2bbff05e91c29f3d37f43daaa19 100644 (file)
@@ -36,12 +36,12 @@ private:
        /**
         * @brief executionGroup with the operations-setup to be evaluated
         */
-       ExecutionGroup *executionGroup;
+       ExecutionGroup *m_executionGroup;
 
        /**
         * @brief number of the chunk to be executed
         */
-       unsigned int chunkNumber;
+       unsigned int m_chunkNumber;
 public:
        /**
         * @constructor
@@ -53,12 +53,12 @@ public:
        /**
         * @brief get the ExecutionGroup
         */
-       ExecutionGroup *getExecutionGroup() const { return this->executionGroup; }
+       ExecutionGroup *getExecutionGroup() const { return this->m_executionGroup; }
 
        /**
         * @brief get the number of the chunk
         */
-       unsigned int getChunkNumber() const { return this->chunkNumber; }
+       unsigned int getChunkNumber() const { return this->m_chunkNumber; }
 
 #ifdef WITH_CXX_GUARDEDALLOC
        MEM_CXX_CLASS_ALLOC_FUNCS("COM:WorkPackage")
index 73c60d29ed62bb5bd820eb5b3825b061ef4e31e0..c49ac24e018f353f00833c5d39b91c1a77f97ccf 100644 (file)
 
 
 /// @brief list of all CPUDevices. for every hardware thread an instance of CPUDevice is created
-static vector<CPUDevice *> cpudevices;
+static vector<CPUDevice *> g_cpudevices;
 
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
 /// @brief list of all thread for every CPUDevice in cpudevices a thread exists
-static ListBase cputhreads;
+static ListBase g_cputhreads;
 /// @brief all scheduled work for the cpu
-static ThreadQueue *cpuqueue;
-static ThreadQueue *gpuqueue;
+static ThreadQueue *g_cpuqueue;
+static ThreadQueue *g_gpuqueue;
 #ifdef COM_OPENCL_ENABLED
-static cl_context context;
-static cl_program program;
+static cl_context g_context;
+static cl_program g_program;
 /// @brief list of all OpenCLDevices. for every OpenCL GPU device an instance of OpenCLDevice is created
-static vector<OpenCLDevice *> gpudevices;
+static vector<OpenCLDevice *> g_gpudevices;
 /// @brief list of all thread for every GPUDevice in cpudevices a thread exists
-static ListBase gputhreads;
+static ListBase g_gputhreads;
 /// @brief all scheduled work for the gpu
 #ifdef COM_OPENCL_ENABLED
-static bool openclActive = false;
+static bool g_openclActive = false;
 #endif
 #endif
 #endif
@@ -72,7 +72,7 @@ void *WorkScheduler::thread_execute_cpu(void *data)
        Device *device = (Device *)data;
        WorkPackage *work;
        
-       while ((work = (WorkPackage *)BLI_thread_queue_pop(cpuqueue))) {
+       while ((work = (WorkPackage *)BLI_thread_queue_pop(g_cpuqueue))) {
                device->execute(work);
                delete work;
        }
@@ -85,7 +85,7 @@ void *WorkScheduler::thread_execute_gpu(void *data)
        Device *device = (Device *)data;
        WorkPackage *work;
        
-       while ((work = (WorkPackage *)BLI_thread_queue_pop(gpuqueue))) {
+       while ((work = (WorkPackage *)BLI_thread_queue_pop(g_gpuqueue))) {
                device->execute(work);
                delete work;
        }
@@ -105,11 +105,11 @@ void WorkScheduler::schedule(ExecutionGroup *group, int chunkNumber)
        delete package;
 #elif COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
 #ifdef COM_OPENCL_ENABLED
-       if (group->isOpenCL() && openclActive) {
-               BLI_thread_queue_push(gpuqueue, package);
+       if (group->isOpenCL() && g_openclActive) {
+               BLI_thread_queue_push(g_gpuqueue, package);
        }
        else {
-               BLI_thread_queue_push(cpuqueue, package);
+               BLI_thread_queue_push(g_cpuqueue, package);
        }
 #else
        BLI_thread_queue_push(cpuqueue, package);
@@ -121,24 +121,24 @@ void WorkScheduler::start(CompositorContext &context)
 {
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
        unsigned int index;
-       cpuqueue = BLI_thread_queue_init();
-       BLI_init_threads(&cputhreads, thread_execute_cpu, cpudevices.size());
-       for (index = 0; index < cpudevices.size(); index++) {
-               Device *device = cpudevices[index];
-               BLI_insert_thread(&cputhreads, device);
+       g_cpuqueue = BLI_thread_queue_init();
+       BLI_init_threads(&g_cputhreads, thread_execute_cpu, g_cpudevices.size());
+       for (index = 0; index < g_cpudevices.size(); index++) {
+               Device *device = g_cpudevices[index];
+               BLI_insert_thread(&g_cputhreads, device);
        }
 #ifdef COM_OPENCL_ENABLED
        if (context.getHasActiveOpenCLDevices()) {
-               gpuqueue = BLI_thread_queue_init();
-               BLI_init_threads(&gputhreads, thread_execute_gpu, gpudevices.size());
-               for (index = 0; index < gpudevices.size(); index++) {
-                       Device *device = gpudevices[index];
-                       BLI_insert_thread(&gputhreads, device);
+               g_gpuqueue = BLI_thread_queue_init();
+               BLI_init_threads(&g_gputhreads, thread_execute_gpu, g_gpudevices.size());
+               for (index = 0; index < g_gpudevices.size(); index++) {
+                       Device *device = g_gpudevices[index];
+                       BLI_insert_thread(&g_gputhreads, device);
                }
-               openclActive = true;
+               g_openclActive = true;
        }
        else {
-               openclActive = false;
+               g_openclActive = false;
        }
 #endif
 #endif
@@ -147,12 +147,12 @@ void WorkScheduler::finish()
 {
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
 #ifdef COM_OPENCL_ENABLED
-       if (openclActive) {
-               BLI_thread_queue_wait_finish(gpuqueue);
-               BLI_thread_queue_wait_finish(cpuqueue);
+       if (g_openclActive) {
+               BLI_thread_queue_wait_finish(g_gpuqueue);
+               BLI_thread_queue_wait_finish(g_cpuqueue);
        }
        else {
-               BLI_thread_queue_wait_finish(cpuqueue);
+               BLI_thread_queue_wait_finish(g_cpuqueue);
        }
 #else
        BLI_thread_queue_wait_finish(cpuqueue);
@@ -162,16 +162,16 @@ void WorkScheduler::finish()
 void WorkScheduler::stop()
 {
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
-       BLI_thread_queue_nowait(cpuqueue);
-       BLI_end_threads(&cputhreads);
-       BLI_thread_queue_free(cpuqueue);
-       cpuqueue = NULL;
+       BLI_thread_queue_nowait(g_cpuqueue);
+       BLI_end_threads(&g_cputhreads);
+       BLI_thread_queue_free(g_cpuqueue);
+       g_cpuqueue = NULL;
 #ifdef COM_OPENCL_ENABLED
-       if (openclActive) {
-               BLI_thread_queue_nowait(gpuqueue);
-               BLI_end_threads(&gputhreads);
-               BLI_thread_queue_free(gpuqueue);
-               gpuqueue = NULL;
+       if (g_openclActive) {
+               BLI_thread_queue_nowait(g_gpuqueue);
+               BLI_end_threads(&g_gputhreads);
+               BLI_thread_queue_free(g_gpuqueue);
+               g_gpuqueue = NULL;
        }
 #endif
 #endif
@@ -181,7 +181,7 @@ bool WorkScheduler::hasGPUDevices()
 {
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
 #ifdef COM_OPENCL_ENABLED
-       return gpudevices.size() > 0;
+       return g_gpudevices.size() > 0;
 #else
        return 0;
 #endif
@@ -203,11 +203,11 @@ void WorkScheduler::initialize()
        for (int index = 0; index < numberOfCPUThreads; index++) {
                CPUDevice *device = new CPUDevice();
                device->initialize();
-               cpudevices.push_back(device);
+               g_cpudevices.push_back(device);
        }
 #ifdef COM_OPENCL_ENABLED
-       context = NULL;
-       program = NULL;
+       g_context = NULL;
+       g_program = NULL;
        if (clCreateContextFromType) {
                cl_uint numberOfPlatforms = 0;
                cl_int error;
@@ -225,18 +225,18 @@ void WorkScheduler::initialize()
                                cl_device_id *cldevices = new cl_device_id[numberOfDevices];
                                clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numberOfDevices, cldevices, 0);
 
-                               context = clCreateContext(NULL, numberOfDevices, cldevices, clContextError, NULL, &error);
+                               g_context = clCreateContext(NULL, numberOfDevices, cldevices, clContextError, NULL, &error);
                                if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
-                               program = clCreateProgramWithSource(context, 1, &clkernelstoh_COM_OpenCLKernels_cl, 0, &error);
-                               error = clBuildProgram(program, numberOfDevices, cldevices, 0, 0, 0);
+                               g_program = clCreateProgramWithSource(g_context, 1, &clkernelstoh_COM_OpenCLKernels_cl, 0, &error);
+                               error = clBuildProgram(g_program, numberOfDevices, cldevices, 0, 0, 0);
                                if (error != CL_SUCCESS) { 
                                        cl_int error2;
                                        size_t ret_val_size = 0;
                                        printf("CLERROR[%d]: %s\n", error, clewErrorString(error));     
-                                       error2 = clGetProgramBuildInfo(program, cldevices[0], CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
+                                       error2 = clGetProgramBuildInfo(g_program, cldevices[0], CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
                                        if (error2 != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
                                        char *build_log =  new char[ret_val_size + 1];
-                                       error2 = clGetProgramBuildInfo(program, cldevices[0], CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
+                                       error2 = clGetProgramBuildInfo(g_program, cldevices[0], CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
                                        if (error2 != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
                                        build_log[ret_val_size] = '\0';
                                        printf("%s", build_log);
@@ -247,11 +247,11 @@ void WorkScheduler::initialize()
                                        for (indexDevices = 0; indexDevices < numberOfDevices; indexDevices++) {
                                                cl_device_id device = cldevices[indexDevices];
                                                cl_int vendorID = 0;
-                                               cl_int error = clGetDeviceInfo(device, CL_DEVICE_VENDOR_ID, sizeof(cl_int), &vendorID, NULL);
-                                               if (error!= CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
-                                               OpenCLDevice *clDevice = new OpenCLDevice(context, device, program, vendorID);
+                                               cl_int error2 = clGetDeviceInfo(device, CL_DEVICE_VENDOR_ID, sizeof(cl_int), &vendorID, NULL);
+                                               if (error2 != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error2, clewErrorString(error2)); }
+                                               OpenCLDevice *clDevice = new OpenCLDevice(g_context, device, g_program, vendorID);
                                                clDevice->initialize();
-                                               gpudevices.push_back(clDevice);
+                                               g_gpudevices.push_back(clDevice);
                                        }
                                }
                                delete[] cldevices;
@@ -267,26 +267,26 @@ void WorkScheduler::deinitialize()
 {
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
        Device *device;
-       while (cpudevices.size() > 0) {
-               device = cpudevices.back();
-               cpudevices.pop_back();
+       while (g_cpudevices.size() > 0) {
+               device = g_cpudevices.back();
+               g_cpudevices.pop_back();
                device->deinitialize();
                delete device;
        }
 #ifdef COM_OPENCL_ENABLED
-       while (gpudevices.size() > 0) {
-               device = gpudevices.back();
-               gpudevices.pop_back();
+       while (g_gpudevices.size() > 0) {
+               device = g_gpudevices.back();
+               g_gpudevices.pop_back();
                device->deinitialize();
                delete device;
        }
-       if (program) {
-               clReleaseProgram(program);
-               program = NULL;
+       if (g_program) {
+               clReleaseProgram(g_program);
+               g_program = NULL;
        }
-       if (context) {
-               clReleaseContext(context);
-               context = NULL;
+       if (g_context) {
+               clReleaseContext(g_context);
+               g_context = NULL;
        }
 #endif
 #endif
index f7375d9a7c5b790d3cdd26d22949f63dcf538f80..e25e9e119753c68b1e737240eeafafa67a6a9e2b 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_AlphaOverNode_h
-#define _COM_AlphaOverNode_h
+#ifndef _COM_AlphaOverNode_h_
+#define _COM_AlphaOverNode_h_
 
 #include "COM_Node.h"
 
index e7daff1c41415a8568bd03277ddd38d85387a83c..95b0516dae02d77d0a38625c5ac1b938a4d19490 100644 (file)
@@ -29,7 +29,6 @@
  * @brief BlurNode
  * @ingroup Node
  */
-
 class BlurNode : public Node {
 public:
        BlurNode(bNode *editorNode);
index 5ce75a7d42b64d2e4d853e850c3402cf87480bbb..c2bc7552ac0b5b633a3731df61546b8ef0b33dc1 100644 (file)
@@ -29,7 +29,6 @@
  * @brief BokehBlurNode
  * @ingroup Node
  */
-
 class BokehBlurNode : public Node {
 public:
        BokehBlurNode(bNode *editorNode);
index 45d03e18a6af039bb4ff7d6ffa508e467a7940ad..4efb06c9f875b6b2772a3991b9a95b913f046627 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef COM_ChannelMatteNODE_H
-#define COM_ChannelMatteNODE_H
+#ifndef _COM_ChannelMatteNode_h_
+#define _COM_ChannelMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,8 +28,7 @@
  * @brief ChannelMatteNode
  * @ingroup Node
  */
-class ChannelMatteNode : public Node
-{
+class ChannelMatteNode : public Node {
 public:
        ChannelMatteNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index ed8250b03296c248f96900c5e9dc7b3b31d78758..ddd350aab40b6b61fc1d5e47bcaf27434baf592c 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef COM_ChromaMatteNODE_H
-#define COM_ChromaMatteNODE_H
+#ifndef _COM_ChromaMatteNode_h_
+#define _COM_ChromaMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,8 +28,7 @@
  * @brief ChromaMatteNode
  * @ingroup Node
  */
-class ChromaMatteNode : public Node
-{
+class ChromaMatteNode : public Node {
 public:
        ChromaMatteNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index c2bdc306e2026c93775b709e7a151dcba9ef0950..cdad02fc8311c6bb75a77e6c5d0d9646d9edaf5b 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef COM_ColorBalanceNODE_H
-#define COM_ColorBalanceNODE_H
+#ifndef _COM_ColorBalanceNode_h_
+#define _COM_ColorBalanceNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief ColorBalanceNode
  * @ingroup Node
  */
-class ColorBalanceNode : public Node
-{
+class ColorBalanceNode : public Node {
 public:
        ColorBalanceNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index 375c914a122794d0cc2fa9f9e9dc628438c58d1b..92a4fa794085591e30c5d487b760e25e44797176 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef COM_ColorMatteNODE_H
-#define COM_ColorMatteNODE_H
+#ifndef _COM_ColorMatteNode_h_
+#define _COM_ColorMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,8 +28,7 @@
  * @brief ColorMatteNode
  * @ingroup Node
  */
-class ColorMatteNode : public Node
-{
+class ColorMatteNode : public Node {
 public:
        ColorMatteNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index 4d706e126e19915db0b7708389f9877c4b4c6cfd..6c256c09e68918ab40293ecd2dd6224e927a06a4 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef COM_ColorRampNODE_H
-#define COM_ColorRampNODE_H
+#ifndef _COM_ColorRampNode_h_
+#define _COM_ColorRampNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief ColorRampNode
  * @ingroup Node
  */
-class ColorRampNode : public Node
-{
+class ColorRampNode : public Node {
 public:
        ColorRampNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index d8ce6878fa0f4f3349f2a16a1117a55ddc2fa8d2..1d976fc65ae377a01c6aac7cf617ecb4b47a674f 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef COM_ColorSpillNODE_H
-#define COM_ColorSpillNODE_H
+#ifndef _COM_ColorSpillNode_h_
+#define _COM_ColorSpillNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief ColorSpillNode
  * @ingroup Node
  */
-class ColorSpillNode : public Node
-{
+class ColorSpillNode : public Node {
 public:
        ColorSpillNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index 34a157c73d82587ee979168545f66f3f778b8146..9262634eddaa58baa9b656707c146ac98e700fae 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_ColourToBWNode_h
-#define _COM_ColourToBWNode_h
+#ifndef _COM_ColourToBWNode_h_
+#define _COM_ColourToBWNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index d8aba71d456eff3f38d2cc8788ade8b132a42750..95d3cf9ecdd4a461d24dc72b3149352685b2727c 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_CombineHSVANode_h
-#define _COM_CombineHSVANode_h
+#ifndef _COM_CombineHSVANode_h_
+#define _COM_CombineHSVANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index 1f25d8deed90300fb49fb84c7d55d93fd4ac0bc1..5cc0b1ea6da3f1ea54265c0da60471c2d687749b 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_CombineRGBANode_h
-#define _COM_CombineRGBANode_h
+#ifndef _COM_CombineRGBANode_h_
+#define _COM_CombineRGBANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index 3b143aabc7f6215b8946c56287e1782e0f24f514..6ff2938c16136f6bf4051d0433fbe10cc8e90226 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef _COM_CombineYCCANode_h
-#define _COM_CombineYCCANode_h
+#ifndef _COM_CombineYCCANode_h_
+#define _COM_CombineYCCANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index 1eae44c83a5fb6013c4bdd3bf94ee839c54d1baf..e3d8f36a5ddf3e98509e6618382468275d021f45 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef _COM_CombineYUVANode_h
-#define _COM_CombineYUVANode_h
+#ifndef _COM_CombineYUVANode_h_
+#define _COM_CombineYUVANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index 585dae7761e5db116a287e86a36a8e0eb37af7a7..54d52d7db9e7a032ce74a375c6af4326e05b1db1 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_CompositorNode_h
-#define _COM_CompositorNode_h
+#ifndef _COM_CompositorNode_h_
+#define _COM_CompositorNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index d9077c23a0288082c96a46b6c80647e140247c51..a80f8de1607db54c8cb6c6d97690ae827e01890c 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef _COM_ConvertAlphaNode_h
-#define _COM_ConvertAlphaNode_h
+#ifndef _COM_ConvertAlphaNode_h_
+#define _COM_ConvertAlphaNode_h_
 
 #include "COM_Node.h"
 
index 44fdeecc1802ae0aabc9deae680eb24f241a9758..1003728a9d4bb070bb0a42c127b28c33c69cfab4 100644 (file)
 
 #include "COM_Node.h"
 
+/**
+ * @brief CropNode
+ * @ingroup Node
+ */
 class CropNode : public Node {
 public:
        CropNode(bNode *editorNode);
index a3cffbd98c47f3b037bb71a79f03d48e0c607678..7d69b6413bb7a4bd694f90d51a779469151999a7 100644 (file)
@@ -29,7 +29,6 @@
  * @brief DefocusNode
  * @ingroup Node
  */
-
 class DefocusNode : public Node {
 public:
        DefocusNode(bNode *editorNode);
index faaf235bf34db5615e45bfa50e79bc012d62c031..191b7361c3cc88ac723a60ce556df6e355a1b6bf 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef COM_DifferenceMatteNODE_H
-#define COM_DifferenceMatteNODE_H
+#ifndef _COM_DifferenceMatteNode_h_
+#define _COM_DifferenceMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief DifferenceMatteNode
  * @ingroup Node
  */
-class DifferenceMatteNode : public Node
-{
+class DifferenceMatteNode : public Node {
 public:
        DifferenceMatteNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index 285bfa0470e2ee17077f41599a2d7be8da06e22d..3f4e3736bbe965ddc455ce21f6b6d35ed1daf5a6 100644 (file)
@@ -77,7 +77,7 @@ void DilateErodeNode::convertToOperations(ExecutionSystem *graph, CompositorCont
                CompositorQuality quality = context->getQuality();
 
                /* initialize node data */
-               NodeBlurData *data = (NodeBlurData *)&this->alpha_blur;
+               NodeBlurData *data = (NodeBlurData *)&this->m_alpha_blur;
                memset(data, 0, sizeof(*data));
                data->filtertype = R_FILTER_GAUSS;
 
@@ -119,9 +119,9 @@ void DilateErodeNode::convertToOperations(ExecutionSystem *graph, CompositorCont
                operationy->setSubtract(editorNode->custom2 < 0);
 
                if (editorNode->storage) {
-                       NodeDilateErode *data = (NodeDilateErode *)editorNode->storage;
-                       operationx->setFalloff(data->falloff);
-                       operationy->setFalloff(data->falloff);
+                       NodeDilateErode *data_storage = (NodeDilateErode *)editorNode->storage;
+                       operationx->setFalloff(data_storage->falloff);
+                       operationy->setFalloff(data_storage->falloff);
                }
        }
        else {
index ac374d7375b36994a90eafdd01bc9a7904689c67..4b02042ffc9c241f8ea1e6dc1f02365150b3432f 100644 (file)
@@ -30,7 +30,7 @@
  * @ingroup Node
  */
 class DilateErodeNode : public Node {
-       NodeBlurData alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
+       NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
 public:
        DilateErodeNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index ecbe07b06b942f1901cd1ece16c988fae44bf0ca..af6afc2536694a16e9188499db484a45d25bc7f7 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef _COM_DisplaceNode_h
-#define _COM_DisplaceNode_h
+#ifndef _COM_DisplaceNode_h_
+#define _COM_DisplaceNode_h_
 
 #include "COM_Node.h"
 
index 42582ef10a0a0fe6a8fe16a8a9295f7d4655a70e..4e6682424e84ae82ec46a0e182487db5acfe1298 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef COM_DistanceMatteNODE_H
-#define COM_DistanceMatteNODE_H
+#ifndef _COM_DistanceMatteNode_h_
+#define _COM_DistanceMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,8 +28,7 @@
  * @brief DistanceMatteNode
  * @ingroup Node
  */
-class DistanceMatteNode : public Node
-{
+class DistanceMatteNode : public Node {
 public:
        DistanceMatteNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index 17f590b9cfc4c06bdd812b576d5ebe2c933e87d4..d65166944d88d5d5ad8943c60230aaed7101d5fa 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef COM_FILTERNODE_H
-#define COM_FILTERNODE_H
+#ifndef _COM_FilterNode_h_
+#define _COM_FilterNode_h_
 
 #include "COM_Node.h"
 
  * @brief FilterNode
  * @ingroup Node
  */
-class FilterNode : public Node
-{
+class FilterNode : public Node {
 public:
        FilterNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
 
-#endif // COM_FILTERNODE_H
+#endif // _COM_FilterNode_h_
index ed5f2b51ce3dba741fb6ce8c852340b48526bdcc..dd5f70f657993d9bafb24442c57dd24c121a17e2 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_HueSaturationValueCorrectNode_h
-#define _COM_HueSaturationValueCorrectNode_h
+#ifndef _COM_HueSaturationValueCorrectNode_h_
+#define _COM_HueSaturationValueCorrectNode_h_
 
 #include "COM_Node.h"
 
index 92c180191963e1444e395c03842f011d3a2a821c..47b89a352692cc4cd3dbaeab817b5d9a990a0365 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_HueSaturationValueNode_h
-#define _COM_HueSaturationValueNode_h
+#ifndef _COM_HueSaturationValueNode_h_
+#define _COM_HueSaturationValueNode_h_
 
 #include "COM_Node.h"
 
index 384dd6c09ff7f96fa5e9be8439c21ec8b7b293cc..49006efbed57cfe6c945595538fe554405e9658b 100644 (file)
@@ -34,7 +34,6 @@ extern "C" {
  * @ingroup Node
  */
 class ImageNode : public Node {
-
 private:
        NodeOperation *doMultilayerCheck(ExecutionSystem *system, RenderLayer *rl, Image *image, ImageUser *user, int framenumber, int outputsocketIndex, int pass, DataType datatype);
 public:
index be5fd773b608a1e92b97c31d1a74e45e38fc7f7b..cc6fc6e12365ad424ded29c194d8f4f054586317 100644 (file)
@@ -144,7 +144,7 @@ OutputSocket *KeyingNode::setupFeather(ExecutionSystem *graph, CompositorContext
        CompositorQuality quality = context->getQuality();
 
        /* initialize node data */
-       NodeBlurData *data = (NodeBlurData *)&this->alpha_blur;
+       NodeBlurData *data = (NodeBlurData *)&this->m_alpha_blur;
        memset(data, 0, sizeof(*data));
        data->filtertype = R_FILTER_GAUSS;
 
index fefcfa46d49dc5bb5cf8dafb975d453b928ebf47..294a27bb52ce05157e1a19771f8ad6801073564a 100644 (file)
 #include "COM_Node.h"
 
 /**
 * @brief KeyingNode
 * @ingroup Node
 */
+ * @brief KeyingNode
+ * @ingroup Node
+ */
 class KeyingNode : public Node {
 protected:
-       NodeBlurData alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
+       NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
 
        OutputSocket *setupPreBlur(ExecutionSystem *graph, InputSocket *inputImage, int size, OutputSocket **originalImage);
        OutputSocket *setupPostBlur(ExecutionSystem *graph, OutputSocket *postBlurInput, int size);
index 7c87219ef6e832f1d8d886d4442e3fcf35cb2c53..9b8ac88bb6e2dd421338310b5af8fd58074ead72 100644 (file)
@@ -25,9 +25,9 @@
 #include "DNA_node_types.h"
 
 /**
 * @brief KeyingScreenNode
 * @ingroup Node
 */
+ * @brief KeyingScreenNode
+ * @ingroup Node
+ */
 class KeyingScreenNode : public Node {
 public:
        KeyingScreenNode(bNode *editorNode);
index c699a0d11686f65e6a3648e2a93e7f2f6d348fd8..37f3c31113f1d74962d239afa8b503945b54c47a 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef COM_LuminanceMatteNODE_H
-#define COM_LuminanceMatteNODE_H
+#ifndef _COM_LuminanceMatteNode_h_
+#define _COM_LuminanceMatteNode_h_
 
 #include "COM_Node.h"
 
  * @brief LuminanceMatteNode
  * @ingroup Node
  */
-class LuminanceMatteNode : public Node
-{
+class LuminanceMatteNode : public Node {
 public:
        LuminanceMatteNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
 
-#endif // COM_LuminanceMatteNODE_H
+#endif // _COM_LuminanceMatteNode_h_
index a1df790f192ba53a1d331238d0d08f0c86f25efb..2e5616e0bd0d9f0b03c110efe9a59b8c09f63360 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef _COM_MapUVNode_h
-#define _COM_MapUVNode_h
+#ifndef _COM_MapUVNode_h_
+#define _COM_MapUVNode_h_
 
 #include "COM_Node.h"
 
index c7a842dff95a08edad35d10dbdf690e9e0f22aff..22aa5459ec054c811d3b61e631c680ee3586579f 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_MapValueNode_h
-#define _COM_MapValueNode_h
+#ifndef _COM_MapValueNode_h_
+#define _COM_MapValueNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
@@ -34,4 +34,5 @@ public:
        MapValueNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
-#endif
+
+#endif // _COM_MapValueNode_h_
index 8a9bc50eac70e86c5d794c67055925a88fad4b33..cdd5d3c362e9a0c7496d48a1e09ecabaffe13646 100644 (file)
@@ -21,6 +21,9 @@
  *             Sergey Sharybin
  */
 
+#ifndef _COM_MaskNode_h_
+#define _COM_MaskNode_h_
+
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 
  * @ingroup Node
  */
 class MaskNode : public Node {
-
-
 public:
        MaskNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 
 };
+
+#endif // _COM_MaskNode_h_
index 16d65843b0d15cdf6fb747afd38020a60b8322e9..4f8e64754e77a4d57276a7d6090c5dd52ce5540f 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_MathNode_h
-#define _COM_MathNode_h
+#ifndef _COM_MathNode_h_
+#define _COM_MathNode_h_
 
 #include "COM_Node.h"
 
index 99e8b4d48f08029c503afb2bedd2ade9cf1578a9..76076d014272481667820084092eb07a856ce32d 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_MixNode_h
-#define _COM_MixNode_h
+#ifndef _COM_MixNode_h_
+#define _COM_MixNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index d70881a67254267d427c4d4b0c5b4327ac45c696..52ea11ea8e9bdfa3340440d5d11df2d8572f3508 100644 (file)
@@ -20,6 +20,9 @@
  *             Monique Dewanchand
  */
 
+#ifndef _COM_MovieClipNode_h_
+#define _COM_MovieClipNode_h_
+
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 
  * @ingroup Node
  */
 class MovieClipNode : public Node {
-
-
 public:
        MovieClipNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
-
 };
+
+#endif // _COM_MovieClipNode_h_
index bf684298e6552a2b8c1d635a8d7e21b5ac3b7712..660d90040bdbb964e7a2f1776b2aea46120d07eb 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef COM_NORMALNODE_H
-#define COM_NORMALNODE_H
+#ifndef _COM_NormalNode_h_
+#define _COM_NormalNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief NormalNode
  * @ingroup Node
  */
-class NormalNode : public Node
-{
+class NormalNode : public Node {
 public:
        NormalNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
index 79c9b57764351e15c39eededd1522ee260162a7f..e3194436f7fa6f7721b8b5a439b55c3d35e971cc 100644 (file)
@@ -21,8 +21,8 @@
  *             Lukas Tönne
  */
 
-#ifndef _COM_OutputFileNode_h
-#define _COM_OutputFileNode_h
+#ifndef _COM_OutputFileNode_h_
+#define _COM_OutputFileNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index 4a7e86849dc19bd430e45a62bd77191f371beb46..6199237ebdac5110b19fd07006da8f2178d9ad03 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_SeparateHSVANode_h
-#define _COM_SeparateHSVANode_h
+#ifndef _COM_SeparateHSVANode_h_
+#define _COM_SeparateHSVANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index c1be02753da2cca52e4222b66559a74b17267477..35321304d9908426529df5dbfa98c3393f09a781 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_SeparateRGBANode_h
-#define _COM_SeparateRGBANode_h
+#ifndef _COM_SeparateRGBANode_h_
+#define _COM_SeparateRGBANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index 4b216841e2a84ca6b2cbd3d9fb97fad1c6bfb30c..542e1693932af86d991c323e5c168c2ff1199db0 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef _COM_SeparateYCCANode_h
-#define _COM_SeparateYCCANode_h
+#ifndef _COM_SeparateYCCANode_h_
+#define _COM_SeparateYCCANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index e1763e37dff907c97591b003903194d665b5d6b8..e51c0ce4fa663a42b12d20640bd9a71612994b32 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef _COM_SeparateYUVANode_h
-#define _COM_SeparateYUVANode_h
+#ifndef _COM_SeparateYUVANode_h_
+#define _COM_SeparateYUVANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index 0707cf5dac1f7c58e2062ef25e7d519e47c705f9..e82fa210a890269efdd0d21672b565e492c101e6 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_SetAlphaNode_h
-#define _COM_SetAlphaNode_h
+#ifndef _COM_SetAlphaNode_h_
+#define _COM_SetAlphaNode_h_
 
 #include "COM_Node.h"
 
index 6c532d4e813508a4070fe4fe725e3060f3b30375..f17cfd57cbfbfa25ae1f09868191656b2b525e0c 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_SplitViewerNode_h
-#define _COM_SplitViewerNode_h
+#ifndef _COM_SplitViewerNode_h_
+#define _COM_SplitViewerNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index 589e090b48cec4a557c572963451c7647be1961e..3363ff4142ca0ade294c2520849ffa4d165fe568 100644 (file)
@@ -20,6 +20,9 @@
  *             Monique Dewanchand
  */
 
+#ifndef _COM_Stabilize2dNode_h_
+#define _COM_Stabilize2dNode_h_
+
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 
@@ -32,3 +35,5 @@ public:
        Stabilize2dNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
+
+#endif
index be3d54c3000bac7cdb1bc186bbb7acb45ce49c09..16d9e18885bcca18583f0193989289f7b7dbc5aa 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_SwitchNode_h
-#define _COM_SwitchNode_h
+#ifndef _COM_SwitchNode_h_
+#define _COM_SwitchNode_h_
 
 #include "COM_Node.h"
 #include "COM_NodeOperation.h"
index 55fd162243724e967fa6499674b0bace3385a00b..3d92ec3978cbce904e397dbf558ca1e61ef860a0 100644 (file)
@@ -25,9 +25,9 @@
 #include "DNA_node_types.h"
 
 /**
 * @brief TrackPositionNode
 * @ingroup Node
 */
+ * @brief TrackPositionNode
+ * @ingroup Node
+ */
 class TrackPositionNode : public Node {
 public:
        TrackPositionNode(bNode *editorNode);
index da40b655f29107cedd7f0a8d2080bb4f9ffaecf6..57a7a0229ec31805da8f93221e690f39d4bdc101 100644 (file)
@@ -20,6 +20,9 @@
  *             Monique Dewanchand
  */
 
+#ifndef _COM_TransformNode_h_
+#define _COM_TransformNode_h_
+
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 
@@ -32,3 +35,5 @@ public:
        TransformNode(bNode *editorNode);
        void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
+
+#endif // _COM_TransformNode_h_
index e1f1226f1f1925938ab938eac06a364eb18a630b..3a9954b8aea2713b111471f1cc1a823aadd96e6b 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_ViewerNode_h
-#define _COM_ViewerNode_h
+#ifndef _COM_ViewerNode_h_
+#define _COM_ViewerNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
index a2ceedfc2cd6f92a76bc16da64c0cff020c1df1c..61f4037be9039c96af0bc9da8dc749c74c259333 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_ZCombineNode_h
-#define _COM_ZCombineNode_h
+#ifndef _COM_ZCombineNode_h_
+#define _COM_ZCombineNode_h_
 
 #include "COM_Node.h"
 
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..e56fb9151f2880d4432c68b335fffee6864856b5 100644 (file)
@@ -24,7 +24,7 @@
 
 AlphaOverMixedOperation::AlphaOverMixedOperation() : MixBaseOperation()
 {
-       this->x = 0.0f;
+       this->m_x = 0.0f;
 }
 
 void AlphaOverMixedOperation::executePixel(float outputValue[4], float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
@@ -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);
@@ -44,7 +44,7 @@ void AlphaOverMixedOperation::executePixel(float outputValue[4], float x, float
                copy_v4_v4(outputValue, inputOverColor);
        }
        else {
-               float addfac = 1.0f - this->x + inputOverColor[3] * this->x;
+               float addfac = 1.0f - this->m_x + inputOverColor[3] * this->m_x;
                float premul = value[0] * addfac;
                float mul = 1.0f - value[0] * inputOverColor[3];
 
index 2807b3b489a22010026f8fa5de8f20426a848d4d..24a991da17be74bfa954f58f2bc36e57388c9538 100644 (file)
@@ -20,8 +20,8 @@
  *             Monique Dewanchand
  */
 
-#ifndef _COM_AlphaOverMixedOperation_h
-#define _COM_AlphaOverMixedOperation_h
+#ifndef _COM_AlphaOverMixedOperation_h_
+#define _COM_AlphaOverMixedOperation_h_
 #include "COM_MixBaseOperation.h"
 
 
@@ -31,7 +31,7 @@
  */
 class AlphaOverMixedOperation : public MixBaseOperation {
 private:
-       float x;
+       float m_x;
 public:
        /**
         * Default constructor
@@ -43,6 +43,6 @@ public:
         */
        void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
        
-       void setX(float x) { this->x = x; }
+       void setX(float x) { this->m_x = x; }
 };
 #endif
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();