style cleanup: compositor, pointer syntax, function brace placement, line length
authorCampbell Barton <ideasman42@gmail.com>
Thu, 17 May 2012 22:55:28 +0000 (22:55 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Thu, 17 May 2012 22:55:28 +0000 (22:55 +0000)
441 files changed:
source/blender/compositor/COM_compositor.h
source/blender/compositor/intern/COM_CPUDevice.cpp
source/blender/compositor/intern/COM_ChannelInfo.cpp
source/blender/compositor/intern/COM_ChunkOrder.cpp
source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp
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_MemoryManager.cpp
source/blender/compositor/intern/COM_MemoryManager.h
source/blender/compositor/intern/COM_MemoryManagerState.cpp
source/blender/compositor/intern/COM_MemoryManagerState.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_OutputSocket.cpp
source/blender/compositor/intern/COM_OutputSocket.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/intern/COM_WorkScheduler.h
source/blender/compositor/intern/COM_compositor.cpp
source/blender/compositor/nodes/COM_AlphaOverNode.cpp
source/blender/compositor/nodes/COM_AlphaOverNode.h
source/blender/compositor/nodes/COM_BilateralBlurNode.cpp
source/blender/compositor/nodes/COM_BilateralBlurNode.h
source/blender/compositor/nodes/COM_BlurNode.cpp
source/blender/compositor/nodes/COM_BlurNode.h
source/blender/compositor/nodes/COM_BokehBlurNode.cpp
source/blender/compositor/nodes/COM_BokehBlurNode.h
source/blender/compositor/nodes/COM_BokehImageNode.cpp
source/blender/compositor/nodes/COM_BokehImageNode.h
source/blender/compositor/nodes/COM_BoxMaskNode.cpp
source/blender/compositor/nodes/COM_BoxMaskNode.h
source/blender/compositor/nodes/COM_BrightnessNode.cpp
source/blender/compositor/nodes/COM_BrightnessNode.h
source/blender/compositor/nodes/COM_ChannelMatteNode.cpp
source/blender/compositor/nodes/COM_ChromaMatteNode.cpp
source/blender/compositor/nodes/COM_ColorBalanceNode.cpp
source/blender/compositor/nodes/COM_ColorBalanceNode.h
source/blender/compositor/nodes/COM_ColorCorrectionNode.cpp
source/blender/compositor/nodes/COM_ColorCorrectionNode.h
source/blender/compositor/nodes/COM_ColorCurveNode.cpp
source/blender/compositor/nodes/COM_ColorCurveNode.h
source/blender/compositor/nodes/COM_ColorMatteNode.cpp
source/blender/compositor/nodes/COM_ColorNode.cpp
source/blender/compositor/nodes/COM_ColorNode.h
source/blender/compositor/nodes/COM_ColorRampNode.cpp
source/blender/compositor/nodes/COM_ColorRampNode.h
source/blender/compositor/nodes/COM_ColorSpillNode.cpp
source/blender/compositor/nodes/COM_ColorToBWNode.cpp
source/blender/compositor/nodes/COM_CombineHSVANode.cpp
source/blender/compositor/nodes/COM_CombineRGBANode.cpp
source/blender/compositor/nodes/COM_CombineYCCANode.cpp
source/blender/compositor/nodes/COM_CombineYUVANode.cpp
source/blender/compositor/nodes/COM_CompositorNode.cpp
source/blender/compositor/nodes/COM_ConvertAlphaNode.cpp
source/blender/compositor/nodes/COM_ConvertAlphaNode.h
source/blender/compositor/nodes/COM_CropNode.cpp
source/blender/compositor/nodes/COM_CropNode.h
source/blender/compositor/nodes/COM_DefocusNode.cpp
source/blender/compositor/nodes/COM_DefocusNode.h
source/blender/compositor/nodes/COM_DifferenceMatteNode.cpp
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_DirectionalBlurNode.cpp
source/blender/compositor/nodes/COM_DirectionalBlurNode.h
source/blender/compositor/nodes/COM_DisplaceNode.cpp
source/blender/compositor/nodes/COM_DistanceMatteNode.cpp
source/blender/compositor/nodes/COM_DoubleEdgeMaskNode.cpp
source/blender/compositor/nodes/COM_DoubleEdgeMaskNode.h
source/blender/compositor/nodes/COM_EllipseMaskNode.cpp
source/blender/compositor/nodes/COM_EllipseMaskNode.h
source/blender/compositor/nodes/COM_FilterNode.cpp
source/blender/compositor/nodes/COM_FilterNode.h
source/blender/compositor/nodes/COM_FlipNode.cpp
source/blender/compositor/nodes/COM_FlipNode.h
source/blender/compositor/nodes/COM_GammaNode.cpp
source/blender/compositor/nodes/COM_GammaNode.h
source/blender/compositor/nodes/COM_GlareNode.cpp
source/blender/compositor/nodes/COM_GlareNode.h
source/blender/compositor/nodes/COM_GroupNode.cpp
source/blender/compositor/nodes/COM_GroupNode.h
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.cpp
source/blender/compositor/nodes/COM_HueSaturationValueNode.cpp
source/blender/compositor/nodes/COM_IDMaskNode.cpp
source/blender/compositor/nodes/COM_IDMaskNode.h
source/blender/compositor/nodes/COM_ImageNode.cpp
source/blender/compositor/nodes/COM_ImageNode.h
source/blender/compositor/nodes/COM_InvertNode.cpp
source/blender/compositor/nodes/COM_InvertNode.h
source/blender/compositor/nodes/COM_LensDistortionNode.cpp
source/blender/compositor/nodes/COM_LensDistortionNode.h
source/blender/compositor/nodes/COM_LuminanceMatteNode.cpp
source/blender/compositor/nodes/COM_MapUVNode.cpp
source/blender/compositor/nodes/COM_MapValueNode.cpp
source/blender/compositor/nodes/COM_MathNode.cpp
source/blender/compositor/nodes/COM_MathNode.h
source/blender/compositor/nodes/COM_MixNode.cpp
source/blender/compositor/nodes/COM_MovieClipNode.cpp
source/blender/compositor/nodes/COM_MovieClipNode.h
source/blender/compositor/nodes/COM_MovieDistortionNode.cpp
source/blender/compositor/nodes/COM_MovieDistortionNode.h
source/blender/compositor/nodes/COM_MuteNode.cpp
source/blender/compositor/nodes/COM_MuteNode.h
source/blender/compositor/nodes/COM_NormalNode.cpp
source/blender/compositor/nodes/COM_NormalNode.h
source/blender/compositor/nodes/COM_NormalizeNode.cpp
source/blender/compositor/nodes/COM_NormalizeNode.h
source/blender/compositor/nodes/COM_OutputFileNode.cpp
source/blender/compositor/nodes/COM_RenderLayersNode.cpp
source/blender/compositor/nodes/COM_RenderLayersNode.h
source/blender/compositor/nodes/COM_RotateNode.cpp
source/blender/compositor/nodes/COM_RotateNode.h
source/blender/compositor/nodes/COM_ScaleNode.cpp
source/blender/compositor/nodes/COM_ScaleNode.h
source/blender/compositor/nodes/COM_SeparateHSVANode.cpp
source/blender/compositor/nodes/COM_SeparateRGBANode.cpp
source/blender/compositor/nodes/COM_SeparateYCCANode.cpp
source/blender/compositor/nodes/COM_SeparateYUVANode.cpp
source/blender/compositor/nodes/COM_SetAlphaNode.cpp
source/blender/compositor/nodes/COM_SetAlphaNode.h
source/blender/compositor/nodes/COM_SocketProxyNode.cpp
source/blender/compositor/nodes/COM_SocketProxyNode.h
source/blender/compositor/nodes/COM_SplitViewerNode.cpp
source/blender/compositor/nodes/COM_Stabilize2dNode.cpp
source/blender/compositor/nodes/COM_Stabilize2dNode.h
source/blender/compositor/nodes/COM_SwitchNode.cpp
source/blender/compositor/nodes/COM_TextureNode.cpp
source/blender/compositor/nodes/COM_TextureNode.h
source/blender/compositor/nodes/COM_TimeNode.cpp
source/blender/compositor/nodes/COM_TimeNode.h
source/blender/compositor/nodes/COM_TonemapNode.cpp
source/blender/compositor/nodes/COM_TonemapNode.h
source/blender/compositor/nodes/COM_TransformNode.cpp
source/blender/compositor/nodes/COM_TransformNode.h
source/blender/compositor/nodes/COM_TranslateNode.cpp
source/blender/compositor/nodes/COM_TranslateNode.h
source/blender/compositor/nodes/COM_ValueNode.cpp
source/blender/compositor/nodes/COM_ValueNode.h
source/blender/compositor/nodes/COM_VectorBlurNode.cpp
source/blender/compositor/nodes/COM_VectorBlurNode.h
source/blender/compositor/nodes/COM_VectorCurveNode.cpp
source/blender/compositor/nodes/COM_VectorCurveNode.h
source/blender/compositor/nodes/COM_ViewLevelsNode.cpp
source/blender/compositor/nodes/COM_ViewLevelsNode.h
source/blender/compositor/nodes/COM_ViewerNode.cpp
source/blender/compositor/nodes/COM_ZCombineNode.cpp
source/blender/compositor/nodes/COM_ZCombineNode.h
source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
source/blender/compositor/operations/COM_AlphaOverKeyOperation.h
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_AlphaOverPremultiplyOperation.h
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_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_ConvolutionEdgeFilterOperation.h
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_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_FogGlowImageOperation.cpp
source/blender/compositor/operations/COM_FogGlowImageOperation.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_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_GlareSimpleStarOperation.cpp
source/blender/compositor/operations/COM_GlareStreaksOperation.cpp
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_LensGhostOperation.cpp
source/blender/compositor/operations/COM_LensGhostOperation.h
source/blender/compositor/operations/COM_LensGlowImageOperation.cpp
source/blender/compositor/operations/COM_LensGlowImageOperation.h
source/blender/compositor/operations/COM_LensGlowOperation.cpp
source/blender/compositor/operations/COM_LensGlowOperation.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_MathBaseOperation.cpp
source/blender/compositor/operations/COM_MathBaseOperation.h
source/blender/compositor/operations/COM_MixAddOperation.cpp
source/blender/compositor/operations/COM_MixAddOperation.h
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_MixBlendOperation.h
source/blender/compositor/operations/COM_MixBurnOperation.cpp
source/blender/compositor/operations/COM_MixBurnOperation.h
source/blender/compositor/operations/COM_MixColorOperation.cpp
source/blender/compositor/operations/COM_MixColorOperation.h
source/blender/compositor/operations/COM_MixDarkenOperation.cpp
source/blender/compositor/operations/COM_MixDarkenOperation.h
source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
source/blender/compositor/operations/COM_MixDifferenceOperation.h
source/blender/compositor/operations/COM_MixDivideOperation.cpp
source/blender/compositor/operations/COM_MixDivideOperation.h
source/blender/compositor/operations/COM_MixDodgeOperation.cpp
source/blender/compositor/operations/COM_MixDodgeOperation.h
source/blender/compositor/operations/COM_MixHueOperation.cpp
source/blender/compositor/operations/COM_MixHueOperation.h
source/blender/compositor/operations/COM_MixLightenOperation.cpp
source/blender/compositor/operations/COM_MixLightenOperation.h
source/blender/compositor/operations/COM_MixLinearLightOperation.cpp
source/blender/compositor/operations/COM_MixLinearLightOperation.h
source/blender/compositor/operations/COM_MixMultiplyOperation.cpp
source/blender/compositor/operations/COM_MixMultiplyOperation.h
source/blender/compositor/operations/COM_MixOverlayOperation.cpp
source/blender/compositor/operations/COM_MixOverlayOperation.h
source/blender/compositor/operations/COM_MixSaturationOperation.cpp
source/blender/compositor/operations/COM_MixSaturationOperation.h
source/blender/compositor/operations/COM_MixScreenOperation.cpp
source/blender/compositor/operations/COM_MixScreenOperation.h
source/blender/compositor/operations/COM_MixSoftLightOperation.cpp
source/blender/compositor/operations/COM_MixSoftLightOperation.h
source/blender/compositor/operations/COM_MixSubtractOperation.cpp
source/blender/compositor/operations/COM_MixSubtractOperation.h
source/blender/compositor/operations/COM_MixValueOperation.cpp
source/blender/compositor/operations/COM_MixValueOperation.h
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_OpenCLKernels.cl.cpp
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_RenderLayersAOOperation.cpp
source/blender/compositor/operations/COM_RenderLayersAlphaProg.cpp
source/blender/compositor/operations/COM_RenderLayersAlphaProg.h
source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp
source/blender/compositor/operations/COM_RenderLayersBaseProg.h
source/blender/compositor/operations/COM_RenderLayersColorOperation.cpp
source/blender/compositor/operations/COM_RenderLayersCyclesOperation.cpp
source/blender/compositor/operations/COM_RenderLayersDepthProg.cpp
source/blender/compositor/operations/COM_RenderLayersDiffuseOperation.cpp
source/blender/compositor/operations/COM_RenderLayersEmitOperation.cpp
source/blender/compositor/operations/COM_RenderLayersEnvironmentOperation.cpp
source/blender/compositor/operations/COM_RenderLayersImageProg.cpp
source/blender/compositor/operations/COM_RenderLayersIndirectOperation.cpp
source/blender/compositor/operations/COM_RenderLayersMaterialIndexOperation.cpp
source/blender/compositor/operations/COM_RenderLayersMistOperation.cpp
source/blender/compositor/operations/COM_RenderLayersNormalOperation.cpp
source/blender/compositor/operations/COM_RenderLayersObjectIndexOperation.cpp
source/blender/compositor/operations/COM_RenderLayersReflectionOperation.cpp
source/blender/compositor/operations/COM_RenderLayersRefractionOperation.cpp
source/blender/compositor/operations/COM_RenderLayersShadowOperation.cpp
source/blender/compositor/operations/COM_RenderLayersSpecularOperation.cpp
source/blender/compositor/operations/COM_RenderLayersSpeedOperation.cpp
source/blender/compositor/operations/COM_RenderLayersUVOperation.cpp
source/blender/compositor/operations/COM_RotateOperation.cpp
source/blender/compositor/operations/COM_ScaleOperation.cpp
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_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_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_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/sculpt_paint/paint_hide.c

index 2891d8cdfa02c2485f5ed1e12a985868f9199c0d..b33a48464e14374b73217af0ea13c849758c9e11 100644 (file)
@@ -26,7 +26,6 @@
 
 #include "DNA_node_types.h"
 
-
 /**
   * @defgroup Model The data model of the compositor
   * @defgroup Memory The memory management stuff
@@ -38,7 +37,8 @@
   * @mainpage Introduction of the Blender Compositor
   *
   * @section bcomp Blender compositor
-  * This project redesigns the interals of Blender's compositor. The project has been executed in 2011 by At Mind. At Mind is a technology company located in Amsterdam, The Netherlands.
+  * This project redesigns the interals of Blender's compositor. The project has been executed in 2011 by At Mind.
+  * At Mind is a technology company located in Amsterdam, The Netherlands.
   * The project has been crowdfunded. This code has been released under GPL2 to be used in Blender.
   *
   * @section goals The goals of the project
   *   - Make the compositor work faster for you (workflow)
   *
   * @section speed Faster compositor
-  * The speedup has been done by making better use of the hardware Blenders is working on. The previous compositor only used a single threaded model to calculate a node. The only exception to this is the Defocus node.
-  * Only when it is possible to calculate two full nodes in parallel a second thread was used. Current workstations have 8-16 threads available, and most of the time these are idle.
+  * The speedup has been done by making better use of the hardware Blenders is working on. The previous compositor only
+  * used a single threaded model to calculate a node. The only exception to this is the Defocus node.
+  * Only when it is possible to calculate two full nodes in parallel a second thread was used.
+  * Current workstations have 8-16 threads available, and most of the time these are idle.
   *
-  * In the new compositor we want to use as much of threads as possible. Even new OpenCL capable GPU-hardware can be used for calculation.
+  * In the new compositor we want to use as much of threads as possible. Even new OpenCL capable GPU-hardware can be
+  * used for calculation.
   *
   * @section workflow Work faster
-  * The previous compositor only showed the final image. The compositor could wait a long time before seeing the result of his work. The new compositor will work in a way that it will focus on getting information back to the user.
+  * The previous compositor only showed the final image. The compositor could wait a long time before seeing the result
+  * of his work. The new compositor will work in a way that it will focus on getting information back to the user.
   * It will prioritise its work to get earlier user feedback.
   *
   * @page memory Memory model
-  * The main issue is the type of memory model to use. Blender is used by consumers and professionals. Ranging from low-end machines to very high-end machines. The system should work on high-end machines and on low-end machines.
+  * The main issue is the type of memory model to use. Blender is used by consumers and professionals.
+  * Ranging from low-end machines to very high-end machines.
+  * The system should work on high-end machines and on low-end machines.
   *
   *
   * @page executing Executing
   * @section prepare Prepare execution
   *
-  * during the preparation of the execution All ReadBufferOperation will receive an offset. this offset is used during execution as an optimization trick
+  * during the preparation of the execution All ReadBufferOperation will receive an offset.
+  * This offset is used during execution as an optimization trick
   * Next all operations will be initialized for execution @see NodeOperation.initExecution
   * Next all ExecutionGroup's will be initialized for execution @see ExecutionGroup.initExecution
   * this all is controlled from @see ExecutionSystem.execute
   *
   * @section priority Render priority
-  * Render priority is an priority of an output node. A user has a different need of Render priorities of output nodes than during editing.
+  * Render priority is an priority of an output node. A user has a different need of Render priorities of output nodes
+  * than during editing.
   * for example. the Active ViewerNode has top priority during editing, but during rendering a CompositeNode has.
   * All NodeOperation has a setting for their renderpriority, but only for output NodeOperation these have effect.
-  * In ExecutionSystem.execute all priorities are checked. For every priority the ExecutionGroup's are check if the priority do match.
+  * In ExecutionSystem.execute all priorities are checked. For every priority the ExecutionGroup's are check if the
+  * priority do match.
   * When match the ExecutionGroup will be executed (this happens in serial)
   *
   * @see ExecutionSystem.execute control of the Render priority
@@ -82,7 +91,8 @@
   * @section order Chunk order
   *
   * When a ExecutionGroup is executed, first the order of chunks are determined.
-  * The settings are stored in the ViewerNode inside the ExecutionGroup. ExecutionGroups that have no viewernode, will use a default one.
+  * The settings are stored in the ViewerNode inside the ExecutionGroup. ExecutionGroups that have no viewernode,
+  * will use a default one.
   * There are several possible chunk orders
   *  - [@ref OrderOfChunks.COM_TO_CENTER_OUT]: Start calculating from a configurable point and order by nearest chunk
   *  - [@ref OrderOfChunks.COM_TO_RANDOM]: Randomize all chunks.
   * @see OrderOfChunks
   *
   * @section interest Area of interest
-  * An ExecutionGroup can have dependancies to other ExecutionGroup's. Data passing from one ExecutionGroup to another one are stored in 'chunks'.
+  * An ExecutionGroup can have dependancies to other ExecutionGroup's. Data passing from one ExecutionGroup to another
+  * one are stored in 'chunks'.
   * If not all input chunks are available the chunk execution will not be scheduled.
   * <pre>
   * +-------------------------------------+              +--------------------------------------+
   * </pre>
   *
   * In the above example ExecutionGroup B has an outputoperation (ViewerOperation) and is being executed.
-  * The first chunk is evaluated [@ref ExecutionGroup.scheduleChunkWhenPossible], but not all input chunks are available. The relevant ExecutionGroup (that can calculate the missing chunks; ExecutionGroup A) is
-  * Asked to calculate the area ExecutionGroup B is missing. [@ref ExecutionGroup.scheduleAreaWhenPossible]
-  * ExecutionGroup B checks what chunks the area spans, and tries to schedule these chunks. If all input data is available these chunks are scheduled [@ref ExecutionGroup.scheduleChunk]
+  * The first chunk is evaluated [@ref ExecutionGroup.scheduleChunkWhenPossible],
+  * but not all input chunks are available. The relevant ExecutionGroup (that can calculate the missing chunks;
+  * ExecutionGroup A) is asked to calculate the area ExecutionGroup B is missing.
+  * [@ref ExecutionGroup.scheduleAreaWhenPossible]
+  * ExecutionGroup B checks what chunks the area spans, and tries to schedule these chunks.
+  * If all input data is available these chunks are scheduled [@ref ExecutionGroup.scheduleChunk]
   *
   * <pre>
   *
   *
   * This happens until all chunks of (ExecutionGroup B) are finished executing or the user break's the process.
   *
-  * NodeOperation like the ScaleOperation can influence the area of interest by reimplementing the [@ref NodeOperation.determineAreaOfInterest] method
+  * NodeOperation like the ScaleOperation can influence the area of interest by reimplementing the
+  * [@ref NodeOperation.determineAreaOfInterest] method
   *
   * <pre>
   *
   * </pre>
   *
   * @see ExecutionGroup.execute Execute a complete ExecutionGroup. Halts until finished or breaked by user
-  * @see ExecutionGroup.scheduleChunkWhenPossible Tries to schedule a single chunk, checks if all input data is available. Can trigger dependant chunks to be calculated
-  * @see ExecutionGroup.scheduleAreaWhenPossible Tries to schedule an area. This can be multiple chunks (is called from [@ref ExecutionGroup.scheduleChunkWhenPossible])
+  * @see ExecutionGroup.scheduleChunkWhenPossible Tries to schedule a single chunk,
+  * checks if all input data is available. Can trigger dependant chunks to be calculated
+  * @see ExecutionGroup.scheduleAreaWhenPossible Tries to schedule an area. This can be multiple chunks
+  * (is called from [@ref ExecutionGroup.scheduleChunkWhenPossible])
   * @see ExecutionGroup.scheduleChunk Schedule a chunk on the WorkScheduler
   * @see NodeOperation.determineDependingAreaOfInterest Influence the area of interest of a chunk.
   * @see WriteBufferOperation NodeOperation to write to a MemoryProxy/MemoryBuffer
   * @see MemoryBuffer Allocated memory for a single chunk
   *
   * @section workscheduler WorkScheduler
-  * the WorkScheduler is implemented as a static class. the responsibility of the WorkScheduler is to balance WorkPackages to the available and free devices.
+  * the WorkScheduler is implemented as a static class. the responsibility of the WorkScheduler is to balance
+  * WorkPackages to the available and free devices.
   * the workscheduler can work in 2 states. For witching these between the state you need to recompile blender
   *
   * @subsection multithread Multi threaded
   * Default the workscheduler will place all work as WorkPackage in a queue.
-  * For every CPUcore a working thread is created. These working threads will ask the WorkScheduler if there is work for a specific Device.
+  * For every CPUcore a working thread is created. These working threads will ask the WorkScheduler if there is work
+  * for a specific Device.
   * the workscheduler will find work for the device and the device will be asked to execute the WorkPackage
 
   * @subsection singlethread Single threaded
-  * For debugging reasons the multi-threading can be disabled. This is done by changing the COM_CURRENT_THREADING_MODEL to COM_TM_NOTHREAD. When compiling the workscheduler
+  * For debugging reasons the multi-threading can be disabled. This is done by changing the COM_CURRENT_THREADING_MODEL
+  * to COM_TM_NOTHREAD. When compiling the workscheduler
   * will be changes to support no threading and run everything on the CPU.
   *
   * @section devices Devices
-  * A Device within the compositor context is a Hardware component that can used to calculate chunks. This chunk is encapseled in a WorkPackage.
+  * A Device within the compositor context is a Hardware component that can used to calculate chunks.
+  * This chunk is encapseled in a WorkPackage.
   * the WorkScheduler controls the devices and selects the device where a WorkPackage will be calculated.
   *
   * @subsection WS_Devices Workscheduler
-  * The WorkScheduler controls all Devices. When initializing the compositor the WorkScheduler selects all devices that will be used during compositor.
+  * The WorkScheduler controls all Devices. When initializing the compositor the WorkScheduler selects
+  * all devices that will be used during compositor.
   * There are two types of Devices, CPUDevice and OpenCLDevice.
   * When an ExecutionGroup schedules a Chunk the schedule method of the WorkScheduler
-  * The Workscheduler determines if the chunk can be run on an OpenCLDevice (and that there are available OpenCLDevice). If this is the case the chunk will be added to the worklist for OpenCLDevice's
+  * The Workscheduler determines if the chunk can be run on an OpenCLDevice
+  * (and that there are available OpenCLDevice). If this is the case the chunk will be added to the worklist for
+  * OpenCLDevice's
   * otherwise the chunk will be added to the worklist of CPUDevices.
   * 
   * A thread will read the work-list and sends a workpackage to its device.
   * @see Device.execute method called to execute a chunk
   *
   * @subsection CPUDevice CPUDevice
-  * When a CPUDevice gets a WorkPackage the Device will get the inputbuffer that is needed to calculate the chunk. Allocation is already done by the ExecutionGroup.
+  * When a CPUDevice gets a WorkPackage the Device will get the inputbuffer that is needed to calculate the chunk.
+  * Allocation is already done by the ExecutionGroup.
   * The outputbuffer of the chunk is being created.
   * The OutputOperation of the ExecutionGroup is called to execute the area of the outputbuffer.
   *
  * @see bNodeTree.edit_quality
  * @see bNodeTree.render_quality
  *
- *     - output nodes can have different priorities in the WorkScheduler. This is implemented in the COM_execute function.
+ *     - output nodes can have different priorities in the WorkScheduler.
+ * This is implemented in the COM_execute function.
  */
 void COM_execute(bNodeTree *editingtree, int rendering);
 
index 2e74fbf19b3e692cbe836a2ae0db1388284dc6f5..43ec892985af2165198ee9cabdc3239cc82f4809 100644 (file)
@@ -22,7 +22,8 @@
 
 #include "COM_CPUDevice.h"
 
-void CPUDevice::execute(WorkPackage *work) {
+void CPUDevice::execute(WorkPackage *work)
+{
        const unsigned int chunkNumber = work->getChunkNumber();
        ExecutionGroup * executionGroup = work->getExecutionGroup();
        rcti rect;
index e945babe9c30f2c1146253cc6d7075fd5c130f8e..7dafee5f9552d3d04e12145c7c65257dd7ec494f 100644 (file)
@@ -27,7 +27,8 @@
 /**
   * @brief create new ChannelInfo instance and sets the defaults.
   */
-ChannelInfo::ChannelInfo() {
+ChannelInfo::ChannelInfo()
+{
        this->number = 0;
        this->premultiplied = true;
        this->type = COM_CT_UNUSED;
index 784b848a2f9fd0301dafe3e782914ce9d5350465..387e4a6ba70582c3c41d1bb7b45ddb92ec77d8f4 100644 (file)
 #include "COM_ChunkOrder.h"
 #include "BLI_math.h"
 
-ChunkOrder::ChunkOrder() {
+ChunkOrder::ChunkOrder()
+{
        this->distance = 0.0;
        this->number = 0;
        this->x = 0;
        this->y = 0;
 }
 
-void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots) {
+void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots)
+{
        unsigned int index;
        double distance = MAXFLOAT;
        for (index = 0 ; index < numberOfHotspots ; index ++) {
-               ChunkOrderHotspothotspot = hotspots[index];
+               ChunkOrderHotspot *hotspot = hotspots[index];
                double ndistance = hotspot->determineDistance(this->x, this->y);
                if (ndistance < distance) {
                        distance = ndistance;
@@ -43,6 +45,7 @@ void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int nu
        this->distance = distance;
 }
 
-bool operator<(const ChunkOrder& a, const ChunkOrder& b) {
+bool operator<(const ChunkOrder& a, const ChunkOrder& b)
+{
        return a.distance < b.distance;
 }
index 11079878b4f93ae672df9aa9add862f5cd8f75e8..94110f0bcfe1ebbdc3c60bac7c2d33928c7a2f15 100644 (file)
 #include "COM_ChunkOrderHotspot.h"
 #include <math.h>
 
-ChunkOrderHotspot::ChunkOrderHotspot(int x, int y, float addition) {
+ChunkOrderHotspot::ChunkOrderHotspot(int x, int y, float addition)
+{
        this->x = x;
        this->y = y;
        this->addition = addition;
 }
 
-double ChunkOrderHotspot::determineDistance(int x, int y) {
+double ChunkOrderHotspot::determineDistance(int x, int y)
+{
        int dx = x-this->x;
        int dy = y-this->y;
        double result = sqrt((double)(dx*dx+dy*dy));
index abab4edfc3fc610819651dbd1d10d54ee12f6e0c..911de822f80d01d260eb24159e5cd486fd1a5c73 100644 (file)
 #include "COM_defines.h"
 #include <stdio.h>
 
-CompositorContext::CompositorContext() {
+CompositorContext::CompositorContext()
+{
        this->scene = NULL;
        this->quality = COM_QUALITY_HIGH;
        this->hasActiveOpenCLDevices = false;
 }
 
-const int CompositorContext::getFramenumber() const {
+const int CompositorContext::getFramenumber() const
+{
        if (this->scene) {
                return this->scene->r.cfra;
        }
@@ -39,7 +41,8 @@ const int CompositorContext::getFramenumber() const {
        }
 }
 
-const int CompositorContext::isColorManaged() const {
+const int CompositorContext::isColorManaged() const
+{
        if (this->scene) {
                return this->scene->r.color_mgt_flag & R_COLOR_MANAGEMENT;
        }
index dc5b248f777c84d3a9a8d6c68702e825a3eda44f..2889f43290e41fdce7d161c2c0091f61b09d8f04 100644 (file)
@@ -55,14 +55,14 @@ private:
          * This field is initialized in ExecutionSystem and must only be read from that point on.
          * @see ExecutionSystem
          */
-       Scenescene;
+       Scene *scene;
 
        /**
          * @brief reference to the bNodeTree
          * This field is initialized in ExecutionSystem and must only be read from that point on.
          * @see ExecutionSystem
          */
-       bNodeTreebnodetree;
+       bNodeTree *bnodetree;
 
        /**
          * @brief does this system have active opencl devices?
@@ -88,12 +88,12 @@ public:
        /**
          * @brief set the scene of the context
          */
-       void setScene(Scenescene) {this->scene = scene;}
+       void setScene(Scene *scene) {this->scene = scene;}
 
        /**
          * @brief set the bnodetree of the context
          */
-       void setbNodeTree(bNodeTreebnodetree) {this->bnodetree = bnodetree;}
+       void setbNodeTree(bNodeTree *bnodetree) {this->bnodetree = bnodetree;}
 
        /**
          * @brief get the bnodetree of the context
@@ -103,7 +103,7 @@ public:
        /**
          * @brief get the scene of the context
          */
-       const ScenegetScene() const {return this->scene;}
+       const Scene *getScene() const {return this->scene;}
 
        /**
          * @brief set the quality
index ac57bf1cadcab9ebdd7fe63e24f381912a43ad66..3cb297801caa65ed4cd8c58724f80c97af2f6b1c 100644 (file)
 #include "COM_DoubleEdgeMaskNode.h"
 #include "COM_CropNode.h"
 
-Node* Converter::convert(bNode *bNode) {
+Node *Converter::convert(bNode *bNode)
+{
        Node * node;
 
        if (bNode->flag & NODE_MUTED) {
@@ -353,9 +354,10 @@ case CMP_NODE_OUTPUT_FILE:
        }
        return node;
 }
-void Converter::convertDataType(SocketConnection* connection, ExecutionSystem *system) {
-       OutputSocket* outputSocket = connection->getFromSocket();
-       InputSocket* inputSocket = connection->getToSocket();
+void Converter::convertDataType(SocketConnection *connection, ExecutionSystem *system)
+{
+       OutputSocket *outputSocket = connection->getFromSocket();
+       InputSocket *inputSocket = connection->getToSocket();
        DataType fromDatatype = outputSocket->getActualDataType();
        DataType toDatatype = inputSocket->getActualDataType();
        NodeOperation * converter = NULL;
@@ -384,7 +386,8 @@ void Converter::convertDataType(SocketConnection* connection, ExecutionSystem *s
        }
 }
 
-void Converter::convertResolution(SocketConnection *connection, ExecutionSystem *system) {
+void Converter::convertResolution(SocketConnection *connection, ExecutionSystem *system)
+{
        InputSocketResizeMode mode = connection->getToSocket()->getResizeMode();
 
        NodeOperation * toOperation = (NodeOperation*)connection->getToNode();
index f5144d1bfededaac333ceea6d6dade289d88a2b6..fa12be4e79a7768150227f86527db6cbfe94bb52 100644 (file)
@@ -42,7 +42,7 @@ public:
          * @see Node
          * @see MuteNode
          */
-       static Node* convert(bNode* bNode);
+       static Node *convert(bNode *bNode);
        
        /**
          * @brief This method will add a datetype conversion rule when the to-socket does not support the from-socket actual data type.
@@ -53,7 +53,7 @@ public:
          * @param system the ExecutionSystem to add the conversion to.
          * @see SocketConnection - a link between two sockets
          */
-       static void convertDataType(SocketConnectionconnection, ExecutionSystem *system);
+       static void convertDataType(SocketConnection *connection, ExecutionSystem *system);
        
        /**
          * @brief This method will add a resolution rule based on the settings of the InputSocket.
@@ -65,6 +65,6 @@ public:
          * @param system the ExecutionSystem to add the conversion to.
          * @see SocketConnection - a link between two sockets
          */
-       static void convertResolution(SocketConnectionconnection, ExecutionSystem *system);
+       static void convertResolution(SocketConnection *connection, ExecutionSystem *system);
 };
 #endif
index bce31658a8dfde9ee7633e23830167ded272e728..e4fefa6a904b51ab1b95dda41133431140e9c157 100644 (file)
@@ -41,7 +41,8 @@
 #include "BLI_math.h"
 #include "COM_ExecutionSystemHelper.h"
 
-ExecutionGroup::ExecutionGroup() {
+ExecutionGroup::ExecutionGroup()
+{
        this->isOutput = false;
        this->complex = false;
        this->chunkExecutionStates = NULL;
@@ -57,13 +58,15 @@ ExecutionGroup::ExecutionGroup() {
        this->chunksFinished = 0;
 }
 
-int ExecutionGroup::getRenderPriotrity() {
+int ExecutionGroup::getRenderPriotrity()
+{
        return this->getOutputNodeOperation()->getRenderPriority();
 }
 
-bool ExecutionGroup::containsOperation(NodeOperation* operation) {
+bool ExecutionGroup::containsOperation(NodeOperation *operation)
+{
        for (vector<NodeOperation*>::const_iterator iterator = this->operations.begin() ; iterator != this->operations.end() ; ++iterator) {
-               NodeOperationinListOperation = *iterator;
+               NodeOperation *inListOperation = *iterator;
                if (inListOperation == operation) {
                        return true;
                }
@@ -71,11 +74,13 @@ bool ExecutionGroup::containsOperation(NodeOperation* operation) {
        return false;
 }
 
-const bool ExecutionGroup::isComplex() const {
+const bool ExecutionGroup::isComplex() const
+{
        return this->complex;
 }
 
-bool ExecutionGroup::canContainOperation(NodeOperation* operation) {
+bool ExecutionGroup::canContainOperation(NodeOperation *operation)
+{
        if (!this->initialized) {return true;}
        if (operation->isReadBufferOperation()) {return true;}
        if (operation->isWriteBufferOperation()) {return false;}
@@ -89,7 +94,8 @@ bool ExecutionGroup::canContainOperation(NodeOperation* operation) {
        }
 }
 
-void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operation) {
+void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operation)
+{
        if (containsOperation(operation)) return;
        if (canContainOperation(operation)) {
                if (!operation->isBufferOperation()) {
@@ -99,8 +105,8 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
                }
                this->operations.push_back(operation);
                if (operation->isReadBufferOperation()) {
-                       ReadBufferOperationreadOperation = (ReadBufferOperation*)operation;
-                       WriteBufferOperationwriteOperation = readOperation->getMemoryProxy()->getWriteBufferOperation();
+                       ReadBufferOperation *readOperation = (ReadBufferOperation*)operation;
+                       WriteBufferOperation *writeOperation = readOperation->getMemoryProxy()->getWriteBufferOperation();
                        this->addOperation(system, writeOperation);
                }
                else {
@@ -108,7 +114,7 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
                        for (index = 0 ; index < operation->getNumberOfInputSockets(); index ++) {
                                InputSocket * inputSocket = operation->getInputSocket(index);
                                if (inputSocket->isConnected()) {
-                                       NodeOperationnode = (NodeOperation*)inputSocket->getConnection()->getFromNode();
+                                       NodeOperation *node = (NodeOperation*)inputSocket->getConnection()->getFromNode();
                                        this->addOperation(system, node);
                                }
                        }
@@ -118,7 +124,7 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
                if (operation->isWriteBufferOperation()) {
                        WriteBufferOperation * writeoperation = (WriteBufferOperation*)operation;
                        if (writeoperation->getMemoryProxy()->getExecutor() == NULL) {
-                               ExecutionGroupnewGroup = new ExecutionGroup();
+                               ExecutionGroup *newGroup = new ExecutionGroup();
                                writeoperation->getMemoryProxy()->setExecutor(newGroup);
                                newGroup->addOperation(system, operation);
                                ExecutionSystemHelper::addExecutionGroup(system->getExecutionGroups(), newGroup);
@@ -127,7 +133,8 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
        }
 }
 
-NodeOperation* ExecutionGroup::getOutputNodeOperation() const {
+NodeOperation *ExecutionGroup::getOutputNodeOperation() const
+{
        return this->operations[0]; // the first operation of the group is always the output operation.
 }
 
@@ -151,7 +158,7 @@ void ExecutionGroup::initExecution()
        unsigned int maxNumber = 0;
 
        for (index = 0 ; index < this->operations.size(); index ++) {
-               NodeOperationoperation = this->operations[index];
+               NodeOperation *operation = this->operations[index];
                if (operation->isReadBufferOperation()) {
                        ReadBufferOperation *readOperation = (ReadBufferOperation*)operation;
                        this->cachedReadOperations.push_back(readOperation);
@@ -163,7 +170,8 @@ void ExecutionGroup::initExecution()
 
 }
 
-void ExecutionGroup::deinitExecution() {
+void ExecutionGroup::deinitExecution()
+{
        if (this->chunkExecutionStates != NULL) {
                delete[] this->chunkExecutionStates;
                this->chunkExecutionStates = NULL;
@@ -174,8 +182,9 @@ void ExecutionGroup::deinitExecution() {
        this->cachedReadOperations.clear();
        this->bTree = NULL;
 }
-void ExecutionGroup::determineResolution(unsigned int resolution[]) {
-       NodeOperation* operation = this->getOutputNodeOperation();
+void ExecutionGroup::determineResolution(unsigned int resolution[])
+{
+       NodeOperation *operation = this->getOutputNodeOperation();
        unsigned int preferredResolution[2];
        preferredResolution[0] = 0;
        preferredResolution[1] = 0;
@@ -184,7 +193,8 @@ void ExecutionGroup::determineResolution(unsigned int resolution[]) {
        this->setResolution(resolution);
 }
 
-void ExecutionGroup::determineNumberOfChunks() {
+void ExecutionGroup::determineNumberOfChunks()
+{
        const float chunkSizef = this->chunkSize;
        this->numberOfXChunks = ceil(this->width / chunkSizef);
        this->numberOfYChunks = ceil(this->height / chunkSizef);
@@ -194,9 +204,10 @@ void ExecutionGroup::determineNumberOfChunks() {
 /**
   * this method is called for the top execution groups. containing the compositor node or the preview node or the viewer node)
   */
-void ExecutionGroup::execute(ExecutionSystem* graph) {
+void ExecutionGroup::execute(ExecutionSystem *graph)
+{
        CompositorContext& context = graph->getContext();
-       const bNodeTreebTree = context.getbNodeTree();
+       const bNodeTree *bTree = context.getbNodeTree();
        if (this->width == 0 || this->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
@@ -216,7 +227,7 @@ void ExecutionGroup::execute(ExecutionSystem* graph) {
        int chunkorder = COM_TO_CENTER_OUT;
 
        if (operation->isViewerOperation()) {
-               ViewerBaseOperationviewer = (ViewerBaseOperation*)operation;
+               ViewerBaseOperation *viewer = (ViewerBaseOperation*)operation;
                centerX = viewer->getCenterX();
                centerY = viewer->getCenterY();
                chunkorder = viewer->getChunkOrder();
@@ -224,7 +235,7 @@ void ExecutionGroup::execute(ExecutionSystem* graph) {
 
        switch (chunkorder) {
        case COM_TO_RANDOM:
-               for (index = 0 ; index < 2* numberOfChunks ; index ++) {
+               for (index = 0 ; index < 2 * numberOfChunks ; index ++) {
                        int index1 = rand()%numberOfChunks;
                        int index2 = rand()%numberOfChunks;
                        int s = chunkOrder[index1];
@@ -351,7 +362,8 @@ void ExecutionGroup::execute(ExecutionSystem* graph) {
        delete[] chunkOrder;
 }
 
-MemoryBuffer** ExecutionGroup::getInputBuffers(int chunkNumber) {
+MemoryBuffer** ExecutionGroup::getInputBuffers(int chunkNumber)
+{
        rcti rect;
        vector<MemoryProxy*> memoryproxies;
        unsigned int index;
@@ -359,7 +371,7 @@ MemoryBuffer** ExecutionGroup::getInputBuffers(int chunkNumber) {
 
        this->determineDependingMemoryProxies(&memoryproxies);
        MemoryBuffer **memoryBuffers = new MemoryBuffer*[this->cachedMaxReadBufferOffset];
-       for (index= 0 ; index < this->cachedMaxReadBufferOffset ; index ++) {
+       for (index = 0 ; index < this->cachedMaxReadBufferOffset ; index ++) {
                memoryBuffers[index] = NULL;
        }
        rcti output;
@@ -367,13 +379,14 @@ MemoryBuffer** ExecutionGroup::getInputBuffers(int chunkNumber) {
                ReadBufferOperation *readOperation = (ReadBufferOperation*)this->cachedReadOperations[index];
                MemoryProxy * memoryProxy = readOperation->getMemoryProxy();
                this->determineDependingAreaOfInterest(&rect, readOperation, &output);
-               MemoryBuffermemoryBuffer = memoryProxy->getExecutor()->constructConsolidatedMemoryBuffer(memoryProxy, &output);
+               MemoryBuffer *memoryBuffer = memoryProxy->getExecutor()->constructConsolidatedMemoryBuffer(memoryProxy, &output);
                memoryBuffers[readOperation->getOffset()] = memoryBuffer;
        }
        return memoryBuffers;
 }
 
-MemoryBuffer* ExecutionGroup::constructConsolidatedMemoryBuffer(MemoryProxy *memoryProxy, rcti *rect) {
+MemoryBuffer *ExecutionGroup::constructConsolidatedMemoryBuffer(MemoryProxy *memoryProxy, rcti *rect)
+{
        // find all chunks inside the rect
        // determine minxchunk, minychunk, maxxchunk, maxychunk where x and y are chunknumbers
        float chunkSizef = this->chunkSize;
@@ -415,7 +428,8 @@ MemoryBuffer* ExecutionGroup::constructConsolidatedMemoryBuffer(MemoryProxy *mem
        return result;
 }
 
-void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer** memoryBuffers) {
+void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer** memoryBuffers)
+{
        if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED)
                this->chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED;
        else 
@@ -442,31 +456,35 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer** memo
        }
 }
 
-inline void ExecutionGroup::determineChunkRect(rcti* rect, const unsigned int xChunk, const unsigned int yChunk ) const {
+inline void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk ) const
+{
        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));
 }
 
-void ExecutionGroup::determineChunkRect(rcti* rect, const unsigned int chunkNumber) const {
+void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int chunkNumber) const
+{
        const unsigned int yChunk = chunkNumber / numberOfXChunks;
        const unsigned int xChunk = chunkNumber - (yChunk * numberOfXChunks);
        determineChunkRect(rect, xChunk, yChunk);
 }
 
-MemoryBuffer* ExecutionGroup::allocateOutputBuffer(int chunkNumber, rcti* rect) {
-       MemoryBuffer* outputBuffer = NULL;
+MemoryBuffer *ExecutionGroup::allocateOutputBuffer(int chunkNumber, rcti *rect)
+{
+       MemoryBuffer *outputBuffer = NULL;
        // output allocation is only valid when our outputoperation is a memorywriter
        NodeOperation * operation = this->getOutputNodeOperation();
        if (operation->isWriteBufferOperation()) {
-               WriteBufferOperationwriteOperation = (WriteBufferOperation*)operation;
+               WriteBufferOperation *writeOperation = (WriteBufferOperation*)operation;
                outputBuffer = MemoryManager::allocateMemoryBuffer(writeOperation->getMemoryProxy(), chunkNumber, rect);
        }
        return outputBuffer;
 }
 
 
-bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem * graph, rcti *area) {
+bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem * graph, rcti *area)
+{
        // find all chunks inside the rect
        // determine minxchunk, minychunk, maxxchunk, maxychunk where x and y are chunknumbers
 
@@ -490,7 +508,8 @@ bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem * graph, rcti *are
        return result;
 }
 
-bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber) {
+bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
+{
        if (this->chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) {
                this->chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED;
                WorkScheduler::schedule(this, chunkNumber);
@@ -499,7 +518,8 @@ bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber) {
        return false;
 }
 
-bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem * graph, int xChunk, int yChunk) {
+bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem * graph, int xChunk, int yChunk)
+{
        if (xChunk < 0 || xChunk >= (int)this->numberOfXChunks) {
                return true;
        }
@@ -551,11 +571,13 @@ bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem * graph, int xChu
        return false;
 }
 
-void ExecutionGroup::determineDependingAreaOfInterest(rcti * input, ReadBufferOperation* readOperation, rcti* output) {
+void ExecutionGroup::determineDependingAreaOfInterest(rcti * input, ReadBufferOperation *readOperation, rcti *output)
+{
        this->getOutputNodeOperation()->determineDependingAreaOfInterest(input, readOperation, output);
 }
 
-void ExecutionGroup::determineDependingMemoryProxies(vector<MemoryProxy*> *memoryProxies) {
+void ExecutionGroup::determineDependingMemoryProxies(vector<MemoryProxy*> *memoryProxies)
+{
        unsigned int index;
        for (index = 0 ; index < this->cachedReadOperations.size() ; index ++) {
                ReadBufferOperation * readOperation = (ReadBufferOperation*) this->cachedReadOperations[index];
@@ -563,10 +585,12 @@ void ExecutionGroup::determineDependingMemoryProxies(vector<MemoryProxy*> *memor
        }
 }
 
-bool ExecutionGroup::operator ==(const ExecutionGroup & executionGroup) const {
+bool ExecutionGroup::operator ==(const ExecutionGroup & executionGroup) const
+{
        return this->getOutputNodeOperation() == executionGroup.getOutputNodeOperation();
 }
 
-bool ExecutionGroup::isOpenCL() {
+bool ExecutionGroup::isOpenCL()
+{
        return this->openCL;
 }
index 2d5e0965297b3d71a758acb33c90f57c42750a4a..adab7df46906cc560bea478979151d8e3c7019db 100644 (file)
@@ -166,7 +166,7 @@ private:
          * @brief check whether parameter operation can be added to the execution group
          * @param operation the operation to be added
          */
-       bool canContainOperation(NodeOperationoperation);
+       bool canContainOperation(NodeOperation *operation);
        
        /**
          * @brief get the Render priority of this ExecutionGroup
@@ -188,7 +188,7 @@ private:
          * @note Only gives usefull results ater the determination of the chunksize
          * @see determineChunkSize()
          */
-       void determineChunkRect(rctirect, const unsigned int xChunk, const unsigned int yChunk) const;
+       void determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk) const;
        
        /**
          * @brief determine the number of chunks, based on the chunkSize, width and height.
@@ -233,7 +233,7 @@ private:
          * @param readOperation The ReadBufferOperation where the area needs to be evaluated
          * @param output the area needed of the ReadBufferOperation. Result
          */
-       void determineDependingAreaOfInterest(rcti * input, ReadBufferOperation* readOperation, rcti* output);
+       void determineDependingAreaOfInterest(rcti * input, ReadBufferOperation *readOperation, rcti *output);
 
 
 public:
@@ -257,7 +257,7 @@ public:
          * @param operation the NodeOperation to check
          * @return [true,false]
          */
-       bool containsOperation(NodeOperationoperation);
+       bool containsOperation(NodeOperation *operation);
        
        /**
          * @brief add an operation to this ExecutionGroup
@@ -266,7 +266,7 @@ public:
          * @param system
          * @param operation
          */
-       void addOperation(ExecutionSystemsystem, NodeOperation *operation);
+       void addOperation(ExecutionSystem *system, NodeOperation *operation);
        
        /**
          * @brief is this ExecutionGroup an output ExecutionGroup
@@ -312,15 +312,15 @@ public:
        
        /**
          * @brief get the output operation of this ExecutionGroup
-         * @return NodeOperationoutput operation
+         * @return NodeOperation *output operation
          */
-               NodeOperationgetOutputNodeOperation() const;
+               NodeOperation *getOutputNodeOperation() const;
        
        /**
          * @brief compose multiple chunks into a single chunk
-         * @return Memorybufferconsolidated chunk
+         * @return Memorybuffer *consolidated chunk
          */
-       MemoryBufferconstructConsolidatedMemoryBuffer(MemoryProxy *memoryProxy, rcti *output);
+       MemoryBuffer *constructConsolidatedMemoryBuffer(MemoryProxy *memoryProxy, rcti *output);
        
        /**
          * @brief initExecution is called just before the execution of the whole graph will be done.
@@ -342,7 +342,7 @@ public:
          * @param rect the rect of that chunk
          * @see determineChunkRect
          */
-       MemoryBufferallocateOutputBuffer(int chunkNumber, rcti *rect);
+       MemoryBuffer *allocateOutputBuffer(int chunkNumber, rcti *rect);
        
        /**
          * @brief after a chunk is executed the needed resources can be freed or unlocked.
@@ -372,7 +372,7 @@ public:
          * @see ViewerOperation
          * @param system
          */
-       void execute(ExecutionSystemsystem);
+       void execute(ExecutionSystem *system);
        
        /**
          * @brief this method determines the MemoryProxy's where this execution group depends on.
@@ -387,7 +387,7 @@ public:
          * @note Only gives usefull results ater the determination of the chunksize
          * @see determineChunkSize()
          */
-       void determineChunkRect(rctirect, const unsigned int chunkNumber) const;
+       void determineChunkRect(rcti *rect, const unsigned int chunkNumber) const;
        
        
                bool operator ==(const ExecutionGroup &executionGroup) const;
index b66a6a036b59237c986ff5dcb28c4712eaa4b1dc..84b5bb8f5fcd993697f847318cb2e35ddcdc553e 100644 (file)
@@ -40,7 +40,8 @@
 
 #include "BKE_global.h"
 
-ExecutionSystem::ExecutionSystem(bNodeTree* editingtree, bool rendering) {
+ExecutionSystem::ExecutionSystem(bNodeTree *editingtree, bool rendering)
+{
        this->context.setbNodeTree(editingtree);
 
        /* initialize the CompositorContext */
@@ -53,7 +54,7 @@ ExecutionSystem::ExecutionSystem(bNodeTree* editingtree, bool rendering) {
        context.setRendering(rendering);
        context.setHasActiveOpenCLDevices(WorkScheduler::hasGPUDevices() && (editingtree->flag & NTREE_COM_OPENCL));
 
-       NodemainOutputNode=NULL;
+       Node *mainOutputNode=NULL;
 
        mainOutputNode = ExecutionSystemHelper::addbNodeTree(*this, 0, editingtree);
 
@@ -68,7 +69,7 @@ ExecutionSystem::ExecutionSystem(bNodeTree* editingtree, bool rendering) {
                for (index = 0 ; index < executionGroups.size(); index ++) {
                        resolution[0]=0;
                        resolution[1]=0;
-                       ExecutionGroupexecutionGroup = executionGroups[index];
+                       ExecutionGroup *executionGroup = executionGroups[index];
                        executionGroup->determineResolution(resolution);
                }
        }
@@ -76,34 +77,36 @@ ExecutionSystem::ExecutionSystem(bNodeTree* editingtree, bool rendering) {
        if (G.f & G_DEBUG) ExecutionSystemHelper::debugDump(this);
 }
 
-ExecutionSystem::~ExecutionSystem() {
+ExecutionSystem::~ExecutionSystem()
+{
        unsigned int index;
        for (index = 0; index < this->connections.size(); index++) {
-               SocketConnectionconnection = this->connections[index];
+               SocketConnection *connection = this->connections[index];
                delete connection;
        }
        this->connections.clear();
        for (index = 0; index < this->nodes.size(); index++) {
-               Nodenode = this->nodes[index];
+               Node *node = this->nodes[index];
                delete node;
        }
        this->nodes.clear();
        for (index = 0; index < this->operations.size(); index++) {
-               NodeOperationoperation = this->operations[index];
+               NodeOperation *operation = this->operations[index];
                delete operation;
        }
        this->operations.clear();
        for (index = 0; index < this->groups.size(); index++) {
-               ExecutionGroupgroup = this->groups[index];
+               ExecutionGroup *group = this->groups[index];
                delete group;
        }
        this->groups.clear();
 }
 
-void ExecutionSystem::execute() {
+void ExecutionSystem::execute()
+{
        unsigned int order = 0;
        for ( vector<NodeOperation*>::iterator iter = this->operations.begin(); iter != operations.end(); ++iter ) {
-               NodeBasenode = *iter;
+               NodeBase *node = *iter;
                NodeOperation *operation = (NodeOperation*) node;
                if (operation->isReadBufferOperation()) {
                        ReadBufferOperation * readOperation = (ReadBufferOperation*)operation;
@@ -134,8 +137,8 @@ void ExecutionSystem::execute() {
        /* start execution of the ExecutionGroups based on priority of their output node */
        for (int priority = 9 ; priority>=0 ; priority--) {
                for (index = 0 ; index < executionGroups.size(); index ++) {
-                       ExecutionGroupgroup = executionGroups[index];
-                       NodeOperationoutput = group->getOutputNodeOperation();
+                       ExecutionGroup *group = executionGroups[index];
+                       NodeOperation *output = group->getOutputNodeOperation();
                        if (output->getRenderPriority() == priority) {
                                group->execute(this);
                        }
@@ -156,19 +159,21 @@ void ExecutionSystem::execute() {
        MemoryManager::clear();
 }
 
-void ExecutionSystem::addOperation(NodeOperation *operation) {
+void ExecutionSystem::addOperation(NodeOperation *operation)
+{
        ExecutionSystemHelper::addOperation(this->operations, operation);
 }
 
-void ExecutionSystem::addReadWriteBufferOperations(NodeOperation *operation) {
+void ExecutionSystem::addReadWriteBufferOperations(NodeOperation *operation)
+{
        // for every input add write and read operation if input is not a read operation
        // only add read operation to other links when they are attached to buffered operations.
        unsigned int index;
        for (index = 0 ; index < operation->getNumberOfInputSockets();index++) {
-               InputSocketinputsocket = operation->getInputSocket(index);
+               InputSocket *inputsocket = operation->getInputSocket(index);
                if (inputsocket->isConnected()) {
                        SocketConnection *connection = inputsocket->getConnection();
-                       NodeOperationotherEnd = (NodeOperation*)connection->getFromNode();
+                       NodeOperation *otherEnd = (NodeOperation*)connection->getFromNode();
                        if (!otherEnd->isReadBufferOperation()) {
                                // check of other end already has write operation
                                OutputSocket *fromsocket = connection->getFromSocket();
@@ -201,7 +206,7 @@ void ExecutionSystem::addReadWriteBufferOperations(NodeOperation *operation) {
                this->addOperation(writeOperation);
                for (index = 0 ; index < outputsocket->getNumberOfConnections();index ++) {
                        SocketConnection * connection = outputsocket->getConnection(index);
-                       ReadBufferOperationreadoperation = new ReadBufferOperation();
+                       ReadBufferOperation *readoperation = new ReadBufferOperation();
                        readoperation->setMemoryProxy(writeOperation->getMemoryProxy());
                        connection->setFromSocket(readoperation->getOutputSocket());
                        readoperation->getOutputSocket()->addConnection(connection);
@@ -211,12 +216,13 @@ void ExecutionSystem::addReadWriteBufferOperations(NodeOperation *operation) {
        }
 }
 
-void ExecutionSystem::convertToOperations() {
+void ExecutionSystem::convertToOperations()
+{
        unsigned int index;
        // first determine data types of the nodes, this can be used by the node to convert to a different operation system
        this->determineActualSocketDataTypes((vector<NodeBase*>&)this->nodes);
        for (index = 0; index < this->nodes.size(); index++) {
-               Nodenode = (Node*)this->nodes[index];
+               Node *node = (Node*)this->nodes[index];
                node->convertToOperations(this, &this->context);
        }
 
@@ -233,7 +239,7 @@ void ExecutionSystem::convertToOperations() {
 
        // determine all resolutions of the operations (Width/Height)
        for (index = 0 ; index < this->operations.size(); index ++) {
-               NodeOperation* operation= this->operations[index];
+               NodeOperation *operation = this->operations[index];
                if (operation->isOutputOperation(context.isRendering())) {
                        unsigned int resolution[2] = {0,0};
                        unsigned int preferredResolution[2] = {0,0};
@@ -254,7 +260,8 @@ void ExecutionSystem::convertToOperations() {
 
 }
 
-void ExecutionSystem::groupOperations() {
+void ExecutionSystem::groupOperations()
+{
        vector<NodeOperation*> outputOperations;
        NodeOperation * operation;
        unsigned int index;
@@ -281,11 +288,12 @@ void ExecutionSystem::addSocketConnection(SocketConnection *connection)
 }
 
 
-void ExecutionSystem::determineActualSocketDataTypes(vector<NodeBase*> &nodes) {
+void ExecutionSystem::determineActualSocketDataTypes(vector<NodeBase*> &nodes)
+{
        unsigned int index;
        /* first do all input nodes */
        for (index = 0; index < nodes.size(); index++) {
-               NodeBasenode = nodes[index];
+               NodeBase *node = nodes[index];
                if (node->isInputNode()) {
                        node->determineActualSocketDataTypes();
                }
@@ -293,17 +301,18 @@ void ExecutionSystem::determineActualSocketDataTypes(vector<NodeBase*> &nodes) {
 
        /* then all other nodes */
        for (index = 0; index < nodes.size(); index++) {
-               NodeBasenode = nodes[index];
+               NodeBase *node = nodes[index];
                if (!node->isInputNode()) {
                        node->determineActualSocketDataTypes();
                }
        }
 }
 
-void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup*> *result) const {
+void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup*> *result) const
+{
        unsigned int index;
        for (index = 0 ; index < this->groups.size() ; index ++) {
-               ExecutionGroupgroup = this->groups[index];
+               ExecutionGroup *group = this->groups[index];
                if (group->isOutputExecutionGroup()) {
                        result->push_back(group);
                }
index 7d0830491f3a5331141408e02adc6f92a2a0a17b..85fec8b6145ae4290b589993e17d073f96c6467e 100644 (file)
@@ -135,7 +135,7 @@ private: //methods
          * @brief add ReadBufferOperation and WriteBufferOperation around an operation
          * @param operation the operation to add the bufferoperations around.
          */
-       void addReadWriteBufferOperations(NodeOperationoperation);
+       void addReadWriteBufferOperations(NodeOperation *operation);
 
 
        /**
@@ -151,7 +151,7 @@ public:
          * @param editingtree [bNodeTree*]
          * @param rendering [true false]
          */
-       ExecutionSystem(bNodeTreeeditingtree, bool rendering);
+       ExecutionSystem(bNodeTree *editingtree, bool rendering);
 
        /**
          * Destructor
@@ -172,14 +172,14 @@ public:
          *
          * @param operation the operation to add
          */
-       void addOperation(NodeOperationoperation);
+       void addOperation(NodeOperation *operation);
 
        /**
          * Add an editor link to the system. convert it to an socketconnection (CPP-representative)
          * this converted socket is returned.
          */
-       SocketConnection* addNodeLink(bNodeLink* bNodeLink);
-       void addSocketConnection(SocketConnectionconnection);
+       SocketConnection *addNodeLink(bNodeLink *bNodeLink);
+       void addSocketConnection(SocketConnection *connection);
 
        /**
          * @brief Convert all nodes to operations
index 4a739ba6a9def355b93603d894f01efacc5e24f4..94376f73de91b89f1805f6d7c3c1e9b0dd2d926e 100644 (file)
 #include "COM_WriteBufferOperation.h"
 #include "COM_ReadBufferOperation.h"
 
-Node* ExecutionSystemHelper::addbNodeTree(ExecutionSystem &system, int nodes_start, bNodeTree *tree) {
+Node *ExecutionSystemHelper::addbNodeTree(ExecutionSystem &system, int nodes_start, bNodeTree *tree)
+{
        vector<Node*>& nodes = system.getNodes();
        vector<SocketConnection*>& links = system.getConnections();
-       Nodemainnode = NULL;
+       Node *mainnode = NULL;
        /* add all nodes of the tree to the node list */
-       bNodenode = (bNode*)tree->nodes.first;
+       bNode *node = (bNode*)tree->nodes.first;
        while (node != NULL) {
-               Nodeexecnode = addNode(nodes, node);
+               Node *execnode = addNode(nodes, node);
                if (node->type == CMP_NODE_COMPOSITE) {
                        mainnode = execnode;
                }
@@ -54,7 +55,7 @@ Node* ExecutionSystemHelper::addbNodeTree(ExecutionSystem &system, int nodes_sta
        NodeRange node_range(nodes.begin()+nodes_start, nodes.end());
 
        /* add all nodelinks of the tree to the link list */
-       bNodeLinknodelink = (bNodeLink*)tree->links.first;
+       bNodeLink *nodelink = (bNodeLink*)tree->links.first;
        while (nodelink != NULL) {
                addNodeLink(node_range, links, nodelink);
                nodelink = (bNodeLink*)nodelink->next;
@@ -72,11 +73,13 @@ Node* ExecutionSystemHelper::addbNodeTree(ExecutionSystem &system, int nodes_sta
        return mainnode;
 }
 
-void ExecutionSystemHelper::addNode(vector<Node*>& nodes, Node *node) {
+void ExecutionSystemHelper::addNode(vector<Node*>& nodes, Node *node)
+{
        nodes.push_back(node);
 }
 
-Node* ExecutionSystemHelper::addNode(vector<Node*>& nodes, bNode *bNode) {
+Node *ExecutionSystemHelper::addNode(vector<Node*>& nodes, bNode *bNode)
+{
        Converter converter;
        Node * node;
        node = converter.convert(bNode);
@@ -86,36 +89,40 @@ Node* ExecutionSystemHelper::addNode(vector<Node*>& nodes, bNode *bNode) {
        }
        return NULL;
 }
-void ExecutionSystemHelper::addOperation(vector<NodeOperation*>& operations, NodeOperation *operation) {
+void ExecutionSystemHelper::addOperation(vector<NodeOperation*>& operations, NodeOperation *operation)
+{
        operations.push_back(operation);
 }
 
-void ExecutionSystemHelper::addExecutionGroup(vector<ExecutionGroup*>& executionGroups, ExecutionGroup *executionGroup) {
+void ExecutionSystemHelper::addExecutionGroup(vector<ExecutionGroup*>& executionGroups, ExecutionGroup *executionGroup)
+{
        executionGroups.push_back(executionGroup);
 }
 
-void ExecutionSystemHelper::findOutputNodeOperations(vector<NodeOperation*>* result, vector<NodeOperation*>& operations, bool rendering) {
+void ExecutionSystemHelper::findOutputNodeOperations(vector<NodeOperation*>* result, vector<NodeOperation*>& operations, bool rendering)
+{
        unsigned int index;
 
        for (index = 0 ; index < operations.size() ; index ++) {
-               NodeOperationoperation = operations[index];
+               NodeOperation *operation = operations[index];
                if (operation->isOutputOperation(rendering)) {
                        result->push_back(operation);
-                }
+               }
        }
 }
 
-static InputSocket* find_input(NodeRange &node_range, bNode *bnode, bNodeSocket* bsocket) {
+static InputSocket *find_input(NodeRange &node_range, bNode *bnode, bNodeSocket *bsocket)
+{
        if (bnode != NULL) {
                for (NodeIterator it=node_range.first; it!=node_range.second; ++it) {
-                       Nodenode = *it;
+                       Node *node = *it;
                        if (node->getbNode() == bnode)
                                return node->findInputSocketBybNodeSocket(bsocket);
                }
        }
        else {
                for (NodeIterator it=node_range.first; it!=node_range.second; ++it) {
-                       Nodenode = *it;
+                       Node *node = *it;
                        if (node->isProxyNode()) {
                                InputSocket *proxySocket = node->getInputSocket(0);
                                if (proxySocket->getbNodeSocket()==bsocket)
@@ -125,17 +132,18 @@ static InputSocket* find_input(NodeRange &node_range, bNode *bnode, bNodeSocket*
        }
        return NULL;
 }
-static OutputSocket* find_output(NodeRange &node_range, bNode *bnode, bNodeSocket* bsocket) {
+static OutputSocket *find_output(NodeRange &node_range, bNode *bnode, bNodeSocket *bsocket)
+{
        if (bnode != NULL) {
                for (NodeIterator it=node_range.first; it!=node_range.second; ++it) {
-                       Nodenode = *it;
+                       Node *node = *it;
                        if (node->getbNode() == bnode)
                                return node->findOutputSocketBybNodeSocket(bsocket);
                }
        }
        else {
                for (NodeIterator it=node_range.first; it!=node_range.second; ++it) {
-                       Nodenode = *it;
+                       Node *node = *it;
                        if (node->isProxyNode()) {
                                OutputSocket *proxySocket = node->getOutputSocket(0);
                                if (proxySocket->getbNodeSocket()==bsocket)
@@ -145,7 +153,8 @@ 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 *bNodeLink)
+{
        /// @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
@@ -161,11 +170,12 @@ SocketConnection* ExecutionSystemHelper::addNodeLink(NodeRange &node_range, vect
        if (inputSocket->isConnected()) {
                return NULL;
        }
-       SocketConnectionconnection = addLink(links, outputSocket, inputSocket);
+       SocketConnection *connection = addLink(links, outputSocket, inputSocket);
        return connection;
 }
 
-SocketConnection* ExecutionSystemHelper::addLink(vector<SocketConnection*>& links, OutputSocket* fromSocket, InputSocket* toSocket) {
+SocketConnection *ExecutionSystemHelper::addLink(vector<SocketConnection*>& links, OutputSocket *fromSocket, InputSocket *toSocket)
+{
        SocketConnection * newconnection = new SocketConnection();
        newconnection->setFromSocket(fromSocket);
        newconnection->setToSocket(toSocket);
@@ -175,11 +185,12 @@ SocketConnection* ExecutionSystemHelper::addLink(vector<SocketConnection*>& link
        return newconnection;
 }
 
-void ExecutionSystemHelper::debugDump(ExecutionSystem* system) {
-       Node* node;
-       NodeOperation* operation;
-       ExecutionGroup* group;
-       SocketConnection* connection; 
+void ExecutionSystemHelper::debugDump(ExecutionSystem *system)
+{
+       Node *node;
+       NodeOperation *operation;
+       ExecutionGroup *group;
+       SocketConnection *connection;
        int tot, tot2;
        printf("-- BEGIN COMPOSITOR DUMP --\r\n");
        printf("digraph compositorexecution {\r\n");
@@ -283,7 +294,7 @@ void ExecutionSystemHelper::debugDump(ExecutionSystem* system) {
                operation = system->getOperations()[i];
                if (operation->isReadBufferOperation()) {
                        ReadBufferOperation * read = (ReadBufferOperation*)operation;
-                       WriteBufferOperation * write= read->getMemoryProxy()->getWriteBufferOperation();
+                       WriteBufferOperation * write = read->getMemoryProxy()->getWriteBufferOperation();
                        printf("\t\"O_%p\" -> \"O_%p\" [style=dotted]\r\n", write, read);
                }
        }
index e6b11c4043f410f9a9cfa46f7e45730b08f48517..a72e269115e72b20685fe4dc40a5582b5e885c23 100644 (file)
@@ -48,7 +48,7 @@ public:
          * @param tree bNodeTree to add
          * @return Node representing the "Compositor node" of the maintree. or NULL when a subtree is added
          */
-       static NodeaddbNodeTree(ExecutionSystem &system, int nodes_start, bNodeTree * tree);
+       static Node *addbNodeTree(ExecutionSystem &system, int nodes_start, bNodeTree * tree);
        
        /**
          * @brief add an editor node to the system.
@@ -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);
+       static Node *addNode(vector<Node*>& nodes, bNode *bNode);
        
        /**
          * @brief Add a Node to a list
@@ -66,7 +66,7 @@ public:
          * @param nodes the list where the node needs to be added to
          * @param node the node to be added
          */
-       static void addNode(vector<Node*>& nodes, Nodenode);
+       static void addNode(vector<Node*>& nodes, Node *node);
        
        /**
          * @brief Add an operation to the operation list
@@ -76,7 +76,7 @@ public:
          * @param operations the list where the operation need to be added to
          * @param operation the operation to add
          */
-       static void addOperation(vector<NodeOperation*> &operations, NodeOperationoperation);
+       static void addOperation(vector<NodeOperation*> &operations, NodeOperation *operation);
        
        /**
          * @brief Add an ExecutionGroup to a list
@@ -107,7 +107,7 @@ public:
          * @param bNodeLink the link to be added
          * @return the created SocketConnection or NULL
          */
-       static SocketConnectionaddNodeLink(NodeRange &node_range, vector<SocketConnection*>& links, bNodeLink *bNodeLink);
+       static SocketConnection *addNodeLink(NodeRange &node_range, vector<SocketConnection*>& links, bNodeLink *bNodeLink);
        
        /**
          * @brief create a new SocketConnection and add to a vector of links
@@ -116,12 +116,12 @@ public:
          * @param toSocket the endpoint of the connection
          * @return the new created SocketConnection
          */
-       static SocketConnection* addLink(vector<SocketConnection*>& links, OutputSocket* fromSocket, InputSocket* toSocket);
+       static SocketConnection *addLink(vector<SocketConnection*>& links, OutputSocket *fromSocket, InputSocket *toSocket);
        
        /**
          * @brief dumps the content of the execution system to standard out
          * @param system the execution system to dump
          */
-       static void debugDump(ExecutionSystemsystem);
+       static void debugDump(ExecutionSystem *system);
 };
 #endif
index 8428544cbc26fdd9450c1fa7c68342618471848a..881aa58ec6bb4152f257b8e51c53359800856382 100644 (file)
 #include "COM_SocketConnection.h"
 #include "COM_ExecutionSystem.h"
 
-InputSocket::InputSocket(DataType datatype) :Socket(datatype) {
+InputSocket::InputSocket(DataType datatype) :Socket(datatype)
+{
        this->connection = NULL;
        this->resizeMode = COM_SC_CENTER;
 }
-InputSocket::InputSocket(DataType datatype, InputSocketResizeMode resizeMode) :Socket(datatype) {
+InputSocket::InputSocket(DataType datatype, InputSocketResizeMode resizeMode) :Socket(datatype)
+{
        this->connection = NULL;
        this->resizeMode = resizeMode;
 }
 
-InputSocket::InputSocket(InputSocket* from) :Socket(from->getDataType()) {
+InputSocket::InputSocket(InputSocket *from) :Socket(from->getDataType())
+{
        this->connection = NULL;
        this->resizeMode = from->getResizeMode();
 }
@@ -42,12 +45,17 @@ InputSocket::InputSocket(InputSocket* from) :Socket(from->getDataType()) {
 int InputSocket::isInputSocket() const { return true; }
 const int InputSocket::isConnected() const { return this->connection != NULL; }
 
-void InputSocket::setConnection(SocketConnection *connection) {
+void InputSocket::setConnection(SocketConnection *connection)
+{
        this->connection = connection;
 }
-SocketConnection* InputSocket::getConnection() {return this->connection;}
+SocketConnection *InputSocket::getConnection()
+{
+       return this->connection;
+}
 
-void InputSocket::determineResolution(unsigned int resolution[],unsigned int preferredResolution[]) {
+void InputSocket::determineResolution(unsigned int resolution[],unsigned int preferredResolution[])
+{
        if (this->isConnected()) {
                this->connection->getFromSocket()->determineResolution(resolution, preferredResolution);
        }
@@ -56,7 +64,8 @@ void InputSocket::determineResolution(unsigned int resolution[],unsigned int pre
        }
 }
 
-DataType InputSocket::convertToSupportedDataType(DataType datatype) {
+DataType InputSocket::convertToSupportedDataType(DataType datatype)
+{
        int supportedDataTypes = getDataType();
        if (supportedDataTypes&datatype) {
                return datatype;
@@ -92,7 +101,8 @@ DataType InputSocket::convertToSupportedDataType(DataType datatype) {
        return this->getDataType();
 }
 
-void InputSocket::determineActualDataType() {
+void InputSocket::determineActualDataType()
+{
        /// @note: this method is only called for inputsocket that are not connected.
        /// @note: passes COM_DT_COLOR, the convertToSupportedDataType converts this to a capable DataType
        this->setActualDataType(this->convertToSupportedDataType(COM_DT_COLOR));
@@ -105,26 +115,30 @@ void InputSocket::determineActualDataType() {
        #endif
 }
 
-void InputSocket::notifyActualInputType(DataType datatype) {
+void InputSocket::notifyActualInputType(DataType datatype)
+{
        DataType supportedDataType = convertToSupportedDataType(datatype);
        this->setActualDataType(supportedDataType);
        this->fireActualDataTypeSet();
 }
 
-void InputSocket::fireActualDataTypeSet() {
+void InputSocket::fireActualDataTypeSet()
+{
        this->getNode()->notifyActualDataTypeSet(this, this->getActualDataType());
 }
-void InputSocket::relinkConnections(InputSocket *relinkToSocket) {
+void InputSocket::relinkConnections(InputSocket *relinkToSocket)
+{
        this->relinkConnections(relinkToSocket, false, -1, NULL);
 }
 
-void InputSocket::relinkConnections(InputSocket *relinkToSocket, bool autoconnect, int editorNodeInputSocketIndex, bool duplicate, ExecutionSystem* graph) {
+void InputSocket::relinkConnections(InputSocket *relinkToSocket, bool autoconnect, int editorNodeInputSocketIndex, bool duplicate, ExecutionSystem *graph)
+{
        if (!duplicate) {
                this->relinkConnections(relinkToSocket, autoconnect, editorNodeInputSocketIndex, graph);
        }
        else {
                if (!this->isConnected() && autoconnect) {
-                       Nodenode = (Node*)this->getNode();
+                       Node *node = (Node*)this->getNode();
                        switch (this->getActualDataType()) {
                        case COM_DT_UNKNOWN:
                        case COM_DT_COLOR:
@@ -149,10 +163,11 @@ void InputSocket::relinkConnections(InputSocket *relinkToSocket, bool autoconnec
        }
 }
 
-void InputSocket::relinkConnections(InputSocket *relinkToSocket, bool autoconnect, int editorNodeInputSocketIndex, ExecutionSystem* graph) {
+void InputSocket::relinkConnections(InputSocket *relinkToSocket, bool autoconnect, int editorNodeInputSocketIndex, ExecutionSystem *graph)
+{
        if (!isConnected()) {
                if (autoconnect) {
-                       Nodenode = (Node*)this->getNode();
+                       Node *node = (Node*)this->getNode();
                        switch (this->getActualDataType()) {
                        case COM_DT_UNKNOWN:
                        case COM_DT_COLOR:
@@ -174,7 +189,8 @@ void InputSocket::relinkConnections(InputSocket *relinkToSocket, bool autoconnec
        this->setConnection(NULL);
 }
 
-const ChannelInfo* InputSocket::getChannelInfo(const int channelnumber) {
+const ChannelInfo *InputSocket::getChannelInfo(const int channelnumber)
+{
        if (this->isConnected() && this->connection->getFromSocket()) {
                return this->connection->getFromSocket()->getChannelInfo(channelnumber);
        }
@@ -183,20 +199,23 @@ const ChannelInfo* InputSocket::getChannelInfo(const int channelnumber) {
        }
 }
 
-bool InputSocket::isStatic() {
+bool InputSocket::isStatic()
+{
        if (isConnected()) {
-               NodeBasenode = this->getConnection()->getFromNode();
+               NodeBase *node = this->getConnection()->getFromNode();
                if (node) {
                        return node->isStatic();
                }
        }
        return true;
 }
-SocketReader* InputSocket::getReader() {
+SocketReader *InputSocket::getReader()
+{
        return this->getOperation();
 }
 
-NodeOperation* InputSocket::getOperation() const {
+NodeOperation *InputSocket::getOperation() const
+{
        if (isConnected()) {
                return (NodeOperation*)this->connection->getFromSocket()->getNode();
        }
@@ -205,7 +224,8 @@ NodeOperation* InputSocket::getOperation() const {
        }
 }
 
-float* InputSocket::getStaticValues() {
+float *InputSocket::getStaticValues()
+{
        /* XXX only works for socket types with actual float input values.
         * currently all compositor socket types (value, rgba, vector) support this.
         */
index 340cfa98ef6ae99ea6458eab9530611f46f2ab0f..e01793317a5ec5beeca209a95ba1a8eaf97362c6 100644 (file)
@@ -65,7 +65,7 @@ private:
          * @brief connection connected to this InputSocket.
          * An input socket can only have a single connection
          */
-       SocketConnectionconnection;
+       SocketConnection *connection;
        
        /**
          * @brief resize mode of this socket
@@ -89,10 +89,10 @@ private:
 public:
        InputSocket(DataType datatype);
        InputSocket(DataType datatype, InputSocketResizeMode resizeMode);
-       InputSocket(InputSocketfrom);
+       InputSocket(InputSocket *from);
        
-       void setConnection(SocketConnectionconnection);
-       SocketConnectiongetConnection();
+       void setConnection(SocketConnection *connection);
+       SocketConnection *getConnection();
        
        const int isConnected() const;
        int isInputSocket() const;
@@ -126,7 +126,7 @@ public:
          * @param editorNodeInputSocketIndex index of the socket number of the bNode (used to retrieve the value for autoconnection)
          * @param system ExecutionSystem to update to
          */
-       void relinkConnections(InputSocket *relinkToSocket, bool autoconnect, int editorNodeInputSocketIndex, ExecutionSystemsystem);
+       void relinkConnections(InputSocket *relinkToSocket, bool autoconnect, int editorNodeInputSocketIndex, ExecutionSystem *system);
        
        /**
          * @brief move all connections of this input socket to another socket
@@ -136,7 +136,7 @@ public:
          * @param duplicate instead of move do a copy of the connection.
          * @param system ExecutionSystem to update to
          */
-       void relinkConnections(InputSocket *relinkToSocket, bool autoconnect, int editorNodeInputSocketIndex, bool duplicate, ExecutionSystemsystem);
+       void relinkConnections(InputSocket *relinkToSocket, bool autoconnect, int editorNodeInputSocketIndex, bool duplicate, ExecutionSystem *system);
        
        /**
          * @brief set the resize mode
@@ -150,13 +150,13 @@ public:
          */
        InputSocketResizeMode getResizeMode() const {return this->resizeMode;}
        
-       const ChannelInfogetChannelInfo(const int channelnumber);
+       const ChannelInfo *getChannelInfo(const int channelnumber);
        
        bool isStatic();
        
-       floatgetStaticValues();
-       SocketReadergetReader();
-       NodeOperationgetOperation() const;
+       float *getStaticValues();
+       SocketReader *getReader();
+       NodeOperation *getOperation() const;
 };
 
 #endif
index bfa206562771a07c28e877b44a68a14bbbe91543..19c2c96a8f28012472112c572be8a7f436f67807 100644 (file)
 #include "BLI_math.h"
 #include "BKE_global.h"
 
-unsigned int MemoryBuffer::determineBufferSize() {
+unsigned int MemoryBuffer::determineBufferSize()
+{
        return getWidth() * getHeight();
 }
 
-int MemoryBuffer::getWidth() const {
+int MemoryBuffer::getWidth() const
+{
        return  this->rect.xmax-this->rect.xmin;
 }
-int MemoryBuffer::getHeight() const {
+int MemoryBuffer::getHeight() const
+{
        return  this->rect.ymax-this->rect.ymin;
 }
 
-MemoryBuffer::MemoryBuffer(MemoryProxy * memoryProxy, unsigned int chunkNumber, rcti* rect) {
+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;
@@ -46,7 +50,8 @@ MemoryBuffer::MemoryBuffer(MemoryProxy * memoryProxy, unsigned int chunkNumber,
        this->chunkWidth = this->rect.xmax - this->rect.xmin;
 }
 
-MemoryBuffer::MemoryBuffer(MemoryProxy * memoryProxy, rcti* rect) {
+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;
@@ -55,20 +60,23 @@ MemoryBuffer::MemoryBuffer(MemoryProxy * memoryProxy, rcti* rect) {
        this->datatype = COM_DT_COLOR;
        this->chunkWidth = this->rect.xmax - this->rect.xmin;
 }
-MemoryBuffer* MemoryBuffer::duplicate() {
+MemoryBuffer *MemoryBuffer::duplicate()
+{
        MemoryBuffer *result = new MemoryBuffer(this->memoryProxy, &this->rect);
        memcpy(result->buffer, this->buffer, this->determineBufferSize()*4*sizeof(float));
        return result;
 }
-void MemoryBuffer::clear() {
+void MemoryBuffer::clear()
+{
        memset(this->buffer, 0, this->determineBufferSize()*4*sizeof(float));
 }
 
-float* MemoryBuffer::convertToValueBuffer() {
+float *MemoryBuffer::convertToValueBuffer()
+{
        int size = this->determineBufferSize();
        int i;
        int offset4;
-       floatresult = new float[size];
+       float *result = new float[size];
        for (i = 0, offset4 = 0 ; i < size ; i ++, offset4 +=4) {
                result[i] = this->buffer[offset4];
        }
@@ -76,14 +84,16 @@ float* MemoryBuffer::convertToValueBuffer() {
        return result;
 }
 
-MemoryBuffer::~MemoryBuffer() {
+MemoryBuffer::~MemoryBuffer()
+{
        if (this->buffer) {
                MEM_freeN(this->buffer);
                this->buffer = NULL;
        }
 }
 
-void MemoryBuffer::copyContentFrom(MemoryBuffer *otherBuffer) {
+void MemoryBuffer::copyContentFrom(MemoryBuffer *otherBuffer)
+{
        if (!otherBuffer) {
                return;
        }
@@ -103,7 +113,8 @@ void MemoryBuffer::copyContentFrom(MemoryBuffer *otherBuffer) {
        }
 }
 
-void MemoryBuffer::read(float* result, int x, int y) {
+void MemoryBuffer::read(float *result, int x, int y)
+{
        if (x>=this->rect.xmin && x < this->rect.xmax &&
                        y>=this->rect.ymin && y < this->rect.ymax) {
                int dx = x-this->rect.xmin;
@@ -121,7 +132,8 @@ void MemoryBuffer::read(float* result, int x, int y) {
                result[3] = 0.0f;
        }
 }
-void MemoryBuffer::writePixel(int x, int y, float color[4]) {
+void MemoryBuffer::writePixel(int x, int y, float color[4])
+{
        if (x>=this->rect.xmin && x < this->rect.xmax &&
                        y>=this->rect.ymin && y < this->rect.ymax) {
                int offset = (this->chunkWidth*y+x)*4;
@@ -132,7 +144,8 @@ void MemoryBuffer::writePixel(int x, int y, float color[4]) {
        }
 }
 
-void MemoryBuffer::readCubic(float* result, float x, float y) {
+void MemoryBuffer::readCubic(float *result, float x, float y)
+{
        int x1 = floor(x);
        int x2 = x1 + 1;
        int y1 = floor(y);
@@ -208,7 +221,7 @@ static float EWA_WTS[EWA_MAXIDX + 1] =
  0.00754159f, 0.00625989f, 0.00498819f, 0.00372644f, 0.00247454f, 0.00123242f, 0.f
 };
 
-static void radangle2imp(float a2, float b2, float th, float* A, float* B, float* C, float* F)
+static void radangle2imp(float a2, float b2, float th, float *A, float *B, float *C, float *F)
 {
        float ct2 = cosf(th);
        const float st2 = 1.f - ct2*ct2;        // <- sin(th)^2
@@ -220,7 +233,7 @@ static void radangle2imp(float a2, float b2, float th, float* A, float* B, float
 }
 
 // all tests here are done to make sure possible overflows are hopefully minimized
-static void imp2radangle(float A, float B, float C, float F, float* a, float* b, float* th, float* ecc)
+static void imp2radangle(float A, float B, float C, float F, float *a, float *b, float *th, float *ecc)
 {
        if (F <= 1e-5f) {       // use arbitrary major radius, zero minor, infinite eccentricity
                *a = sqrtf(A > C ? A : C);
@@ -247,12 +260,14 @@ static void imp2radangle(float A, float B, float C, float F, float* a, float* b,
        }
 }
 
-float clipuv(float x, float limit) {
+float clipuv(float x, float limit)
+{
        x = (x < 0) ? 0 : ((x >= limit) ? (limit - 1) : x);
        return x;
 }
 
-void MemoryBuffer::readEWA(float* result, float fx, float fy, float dx, float dy) {
+void MemoryBuffer::readEWA(float *result, float fx, float fy, float dx, float dy)
+{
        int width = this->getWidth(), height = this->getHeight();
        
        // scaling dxt/dyt by full resolution can cause overflow because of huge A/B/C and esp. F values,
index 78fb16a7b12bb98f3846386defd620f69ec7d2d0..bfc18424570060879ca62877609881e70498a2d2 100644 (file)
@@ -88,18 +88,18 @@ private:
        /**
          * @brief the actual float buffer/data
          */
-       floatbuffer;
+       float *buffer;
 
 public:
        /**
          * @brief construct new MemoryBuffer for a chunk
          */
-       MemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rctirect);
+       MemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti *rect);
        
        /**
          * @brief construct new temporarily MemoryBuffer for an area
          */
-       MemoryBuffer(MemoryProxy *memoryProxy, rctirect);
+       MemoryBuffer(MemoryProxy *memoryProxy, rcti *rect);
        
        /**
          * @brief destructor
@@ -115,7 +115,7 @@ public:
          * @brief get the data of this MemoryBuffer
          * @note buffer should already be available in memory
          */
-       floatgetBuffer() {return this->buffer;}
+       float *getBuffer() {return this->buffer;}
        
        /**
          * @brief after execution the state will be set to available by calling this method
@@ -124,9 +124,9 @@ public:
                this->state = COM_MB_AVAILABLE;
        }
        
-       void read(floatresult, int x, int y);
+       void read(float *result, int x, int y);
        void writePixel(int x, int y, float color[4]);
-       void readCubic(floatresult, float x, float y);
+       void readCubic(float *result, float x, float y);
        void readEWA(float *result, float fx, float fy, float dx, float dy);
        
        /**
@@ -138,12 +138,12 @@ public:
          * @brief add the content from otherBuffer to this MemoryBuffer
          * @param otherBuffer source buffer
          */
-       void copyContentFrom(MemoryBufferotherBuffer);
+       void copyContentFrom(MemoryBuffer *otherBuffer);
        
        /**
          * @brief get the rect of this MemoryBuffer
          */
-       rctigetRect() {return &this->rect;}
+       rcti *getRect() {return &this->rect;}
        
        /**
          * @brief get the width of this MemoryBuffer
@@ -160,9 +160,9 @@ public:
          */
        void clear();
        
-       MemoryBufferduplicate();
+       MemoryBuffer *duplicate();
        
-       floatconvertToValueBuffer();
+       float *convertToValueBuffer();
 private:
        unsigned int determineBufferSize();
 };
index 661afb20d53bfcf06509498da451df017a9cb422..4f97b0b1e80c8c3123a327f8c8e11240a05529b6 100644 (file)
@@ -29,7 +29,8 @@ vector<MemoryBuffer*> buffers;
 
 ThreadMutex mutex;
 
-MemoryBuffer* MemoryManager::allocateMemoryBuffer(MemoryProxy *id, unsigned int chunkNumber, rcti *rect) {
+MemoryBuffer *MemoryManager::allocateMemoryBuffer(MemoryProxy *id, unsigned int chunkNumber, rcti *rect)
+{
        MemoryBuffer *result = new MemoryBuffer(id, chunkNumber, rect);
        MemoryManagerState * state = MemoryManager::getState(id);
        state->addMemoryBuffer(result);
@@ -39,30 +40,35 @@ MemoryBuffer* MemoryManager::allocateMemoryBuffer(MemoryProxy *id, unsigned int
        return result;
 }
 
-void MemoryManager::addMemoryProxy(MemoryProxy *memoryProxy) {
+void MemoryManager::addMemoryProxy(MemoryProxy *memoryProxy)
+{
        MemoryManagerState * state = MemoryManager::getState(memoryProxy);
        if (!state) {
                state = new MemoryManagerState(memoryProxy);
                memoryProxy->setState(state);
        }
 }
-MemoryBuffer* MemoryManager::getMemoryBuffer(MemoryProxy *id, unsigned int chunkNumber) {
+MemoryBuffer *MemoryManager::getMemoryBuffer(MemoryProxy *id, unsigned int chunkNumber)
+{
        MemoryManagerState * state = MemoryManager::getState(id);
        if (!state) {
                return NULL;
        }
-       MemoryBufferbuffer = state->getMemoryBuffer(chunkNumber);
+       MemoryBuffer *buffer = state->getMemoryBuffer(chunkNumber);
        if (!buffer) return NULL;
        return buffer;
 }
 
-MemoryManagerState* MemoryManager::getState(MemoryProxy* memoryProxy) {
+MemoryManagerState *MemoryManager::getState(MemoryProxy *memoryProxy)
+{
        return memoryProxy->getState();
 }
-void MemoryManager::initialize() {
+void MemoryManager::initialize()
+{
        BLI_mutex_init(&mutex);
 }
-void MemoryManager::clear() {
+void MemoryManager::clear()
+{
        buffers.clear();
        BLI_mutex_end(&mutex);
 }
index 506bf2a8c240325512a563f4fa881e1df1a2360e..6194d40d9a5420a64df60886ad5aa25c5a043895 100644 (file)
@@ -109,7 +109,7 @@ private:
          * @brief retrieve the state of a certain MemoryProxy;
          * @param memoryProxy the MemoryProxy to retrieve the state from
          */
-       static MemoryManagerState* getState(MemoryProxy* memoryProxy);
+       static MemoryManagerState *getState(MemoryProxy *memoryProxy);
 public:
        /**
          * @brief allocate a memory buffer
@@ -117,7 +117,7 @@ public:
           * @param chunkNumber number of the chunk to receive
           * @param rect size + position of the chunk
          */
-       static MemoryBuffer* allocateMemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti* rect);
+       static MemoryBuffer *allocateMemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti *rect);
 
        /**
          * @brief get a memory buffer
@@ -125,7 +125,7 @@ public:
          * @param chunkNumber number of the chunk to receive
          * @param addUser must we add a user to the chunk.
          */
-       static MemoryBuffergetMemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber);
+       static MemoryBuffer *getMemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber);
 
        /**
          * @brief add a MemoryProxy to the scope of the memory manager
index 620092b2825f79fdfed6208e398e560f2b7749b1..b40ae146f9ef36597122b489494a89d0a01b81b8 100644 (file)
 
 #include "COM_MemoryManagerState.h"
 
-MemoryManagerState::MemoryManagerState(MemoryProxy *memoryProxy) {
+MemoryManagerState::MemoryManagerState(MemoryProxy *memoryProxy)
+{
        this->memoryProxy = memoryProxy;
        this->currentSize = 0;
        this->chunkBuffers = NULL;
        BLI_mutex_init(&this->mutex);
 }
 
-MemoryProxy * MemoryManagerState::getMemoryProxy() {
+MemoryProxy * MemoryManagerState::getMemoryProxy()
+{
        return this->memoryProxy;
 }
 
-MemoryManagerState::~MemoryManagerState() {
+MemoryManagerState::~MemoryManagerState()
+{
        this->memoryProxy = NULL;
        unsigned int index;
        for (index = 0 ; index < this->currentSize; index ++) {
-               MemoryBufferbuffer = this->chunkBuffers[index];
+               MemoryBuffer *buffer = this->chunkBuffers[index];
                if (buffer) {
                        delete buffer;
                }
@@ -46,7 +49,8 @@ MemoryManagerState::~MemoryManagerState() {
        BLI_mutex_end(&this->mutex);
 }
 
-void MemoryManagerState::addMemoryBuffer(MemoryBuffer *buffer) {
+void MemoryManagerState::addMemoryBuffer(MemoryBuffer *buffer)
+{
        BLI_mutex_lock(&this->mutex);
        unsigned int chunkNumber = buffer->getChunkNumber();
        unsigned int index;
@@ -76,8 +80,9 @@ void MemoryManagerState::addMemoryBuffer(MemoryBuffer *buffer) {
        BLI_mutex_unlock(&this->mutex);
 }
 
-MemoryBuffer* MemoryManagerState::getMemoryBuffer(unsigned int chunkNumber) {
-       MemoryBuffer* result = NULL;
+MemoryBuffer *MemoryManagerState::getMemoryBuffer(unsigned int chunkNumber)
+{
+       MemoryBuffer *result = NULL;
        if (chunkNumber< this->currentSize) {
                result = this->chunkBuffers[chunkNumber];
                if (result) {
index 4b4f0a112a8220ef0523902ec6536a1b4b4213f7..8e8cb484d1a171b04f85db71cb867cc69e3ca425 100644 (file)
@@ -75,13 +75,13 @@ public:
        /**
          * @brief add a new memorybuffer to the state
          */
-       void addMemoryBuffer(MemoryBufferbuffer);
+       void addMemoryBuffer(MemoryBuffer *buffer);
        
        /**
          * @brief get the MemoryBuffer assiciated to a chunk.
          * @param chunkNumber the chunknumber
          */
-       MemoryBuffergetMemoryBuffer(unsigned int chunkNumber);
+       MemoryBuffer *getMemoryBuffer(unsigned int chunkNumber);
 };
 
 #endif
index 0880af9833cf88a052739c6f040556e6ee6c0501..7ff4f4949f0f9a6810a607cffc4baef3e6a8b105 100644 (file)
 #include "COM_MemoryProxy.h"
 
 
-MemoryProxy::MemoryProxy() {
+MemoryProxy::MemoryProxy()
+{
        this->state = NULL;
        this->writeBufferOperation = NULL;
        this->executor = NULL;
 }
 
-MemoryProxy::~MemoryProxy() {
+MemoryProxy::~MemoryProxy()
+{
        if (this->state) {
                delete this->state;
                this->state = NULL;
index 9424ea9a3e56eb2170335048901467248a301e7c..276ebeed1e233cedc8909057f71367d693b9ddef 100644 (file)
@@ -76,19 +76,19 @@ public:
        /**
          * @brief get the ExecutionGroup that can be scheduled to calculate a certain chunk.
          */
-       ExecutionGroupgetExecutor() {return this->executor;}
+       ExecutionGroup *getExecutor() {return this->executor;}
        
        /**
          * @brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy
          * @param operation
          */
-       void setWriteBufferOperation(WriteBufferOperationoperation) {this->writeBufferOperation = operation;}
+       void setWriteBufferOperation(WriteBufferOperation *operation) {this->writeBufferOperation = operation;}
        
        /**
          * @brief get the WriteBufferOperation that is responsible for writing to this MemoryProxy
          * @return WriteBufferOperation
          */
-       WriteBufferOperationgetWriteBufferOperation() {return this->writeBufferOperation;}
+       WriteBufferOperation *getWriteBufferOperation() {return this->writeBufferOperation;}
        
        /**
          * @brief set the memorymanager state of this MemoryProxy, this is set from the MemoryManager
@@ -100,7 +100,7 @@ public:
          * @brief get the state of this MemoryProxy
          * @return MemoryManagerState reference to the state of this MemoryProxy.
          */
-       MemoryManagerStategetState() {return this->state;}
+       MemoryManagerState *getState() {return this->state;}
 };
 
 #endif
index 4e127c61d4e156c8340dfa44beb539841ae3bac7..f06672ac80b191823df23240aaa054eccd406ec4 100644 (file)
@@ -38,7 +38,8 @@
 //#include "stdio.h"
 #include "COM_defines.h"
 
-Node::Node(bNode* editorNode, bool create_sockets) {
+Node::Node(bNode *editorNode, bool create_sockets)
+{
        this->editorNode = editorNode;
        
        if (create_sockets) {
@@ -62,13 +63,18 @@ Node::Node(bNode* editorNode, bool create_sockets) {
                }
        }
 }
-Node::Node() {
+Node::Node()
+{
        this->editorNode = NULL;
 }
 
-bNode* Node::getbNode() {return this->editorNode;}
+bNode *Node::getbNode()
+{
+       return this->editorNode;
+}
 
-void Node::addSetValueOperation(ExecutionSystem *graph, InputSocket* inputsocket, int editorNodeInputSocketIndex) {
+void Node::addSetValueOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex)
+{
        bNodeSocket *bSock = (bNodeSocket*)this->getEditorInputSocket(editorNodeInputSocketIndex);
        SetValueOperation *operation = new SetValueOperation();
        bNodeSocketValueFloat *val = (bNodeSocketValueFloat*)bSock->default_value;
@@ -77,7 +83,8 @@ void Node::addSetValueOperation(ExecutionSystem *graph, InputSocket* inputsocket
        graph->addOperation(operation);
 }
 
-void Node::addPreviewOperation(ExecutionSystem *system, OutputSocket *outputSocket, int priority) {
+void Node::addPreviewOperation(ExecutionSystem *system, OutputSocket *outputSocket, int priority)
+{
 #ifdef COM_PREVIEW_ENABLED
        PreviewOperation *operation = new PreviewOperation();
        system->addOperation(operation);
@@ -88,14 +95,16 @@ void Node::addPreviewOperation(ExecutionSystem *system, OutputSocket *outputSock
 #endif
 }
 
-void Node::addPreviewOperation(ExecutionSystem *system, InputSocket *inputSocket, int priority) {
+void Node::addPreviewOperation(ExecutionSystem *system, InputSocket *inputSocket, int priority)
+{
        if (inputSocket->isConnected()) {
                OutputSocket *outputsocket = inputSocket->getConnection()->getFromSocket();
                this->addPreviewOperation(system, outputsocket, priority);
        }
 }
 
-SocketConnection* Node::addLink(ExecutionSystem *graph, OutputSocket* outputSocket, InputSocket* inputsocket) {
+SocketConnection *Node::addLink(ExecutionSystem *graph, OutputSocket *outputSocket, InputSocket *inputsocket)
+{
        if (inputsocket->isConnected()) {
                return NULL;
        }
@@ -108,7 +117,8 @@ SocketConnection* Node::addLink(ExecutionSystem *graph, OutputSocket* outputSock
        return connection;
 }
 
-void Node::addSetColorOperation(ExecutionSystem *graph, InputSocket* inputsocket, int editorNodeInputSocketIndex) {
+void Node::addSetColorOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex)
+{
        bNodeSocket *bSock = (bNodeSocket*)this->getEditorInputSocket(editorNodeInputSocketIndex);
        SetColorOperation *operation = new SetColorOperation();
        bNodeSocketValueRGBA *val = (bNodeSocketValueRGBA*)bSock->default_value;
@@ -120,7 +130,8 @@ void Node::addSetColorOperation(ExecutionSystem *graph, InputSocket* inputsocket
        graph->addOperation(operation);
 }
 
-void Node::addSetVectorOperation(ExecutionSystem *graph, InputSocket* inputsocket, int editorNodeInputSocketIndex) {
+void Node::addSetVectorOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex)
+{
        bNodeSocket *bSock = (bNodeSocket*)this->getEditorInputSocket(editorNodeInputSocketIndex);
        bNodeSocketValueVector *val = (bNodeSocketValueVector*)bSock->default_value;
        SetVectorOperation *operation = new SetVectorOperation();
@@ -132,7 +143,8 @@ void Node::addSetVectorOperation(ExecutionSystem *graph, InputSocket* inputsocke
        graph->addOperation(operation);
 }
 
-bNodeSocket* Node::getEditorInputSocket(int editorNodeInputSocketIndex) {
+bNodeSocket *Node::getEditorInputSocket(int editorNodeInputSocketIndex)
+{
        bNodeSocket *bSock = (bNodeSocket*)this->getbNode()->inputs.first;
        int index = 0;
        while (bSock != NULL) {
@@ -144,7 +156,8 @@ bNodeSocket* Node::getEditorInputSocket(int editorNodeInputSocketIndex) {
        }
        return NULL;
 }
-bNodeSocket* Node::getEditorOutputSocket(int editorNodeInputSocketIndex) {
+bNodeSocket *Node::getEditorOutputSocket(int editorNodeInputSocketIndex)
+{
        bNodeSocket *bSock = (bNodeSocket*)this->getbNode()->outputs.first;
        int index = 0;
        while (bSock != NULL) {
@@ -157,11 +170,12 @@ bNodeSocket* Node::getEditorOutputSocket(int editorNodeInputSocketIndex) {
        return NULL;
 }
 
-InputSocket* Node::findInputSocketBybNodeSocket(bNodeSocket* socket) {
+InputSocket *Node::findInputSocketBybNodeSocket(bNodeSocket *socket)
+{
        vector<InputSocket*> &inputsockets = this->getInputSockets();
        unsigned int index;
        for (index = 0 ; index < inputsockets.size(); index ++) {
-               InputSocketinput = inputsockets[index];
+               InputSocket *input = inputsockets[index];
                if (input->getbNodeSocket() == socket) {
                        return input;
                }
@@ -169,11 +183,12 @@ InputSocket* Node::findInputSocketBybNodeSocket(bNodeSocket* socket) {
        return NULL;
 }
 
-OutputSocket* Node::findOutputSocketBybNodeSocket(bNodeSocket* socket) {
+OutputSocket *Node::findOutputSocketBybNodeSocket(bNodeSocket *socket)
+{
        vector<OutputSocket*> &outputsockets = this->getOutputSockets();
        unsigned int index;
        for (index = 0 ; index < outputsockets.size(); index ++) {
-               OutputSocketoutput = outputsockets[index];
+               OutputSocket *output = outputsockets[index];
                if (output->getbNodeSocket() == socket) {
                        return output;
                }
index 3706592a585589576d38f64daed03241baa6d691..2666d0a698058a9d21b3de40402b17d1c4aaa691 100644 (file)
@@ -50,15 +50,15 @@ private:
        /**
          * @brief stores the reference to the SDNA bNode struct
          */
-       bNodeeditorNode;
+       bNode *editorNode;
 
 public:
-       Node(bNodeeditorNode, bool create_sockets=true);
+       Node(bNode *editorNode, bool create_sockets=true);
        
        /**
          * @brief get the reference to the SDNA bNode struct
          */
-       bNodegetbNode();
+       bNode *getbNode();
        
        /**
          * @brief convert node to operation
@@ -68,31 +68,31 @@ public:
          * @param system the ExecutionSystem where the operations need to be added
          * @param context reference to the CompositorContext
          */
-       virtual void convertToOperations(ExecutionSystemsystem, CompositorContext * context) =0;
+       virtual void convertToOperations(ExecutionSystem *system, CompositorContext * context) =0;
        
        /**
          * this method adds a SetValueOperation as input of the input socket.
          * This can only be used from the convertToOperation method. all other usages are not allowed
          */
-       void addSetValueOperation(ExecutionSystem *graph, InputSocketinputsocket, int editorNodeInputSocketIndex);
+       void addSetValueOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex);
        
        /**
          * this method adds a SetColorOperation as input of the input socket.
          * This can only be used from the convertToOperation method. all other usages are not allowed
          */
-       void addSetColorOperation(ExecutionSystem *graph, InputSocketinputsocket, int editorNodeInputSocketIndex);
+       void addSetColorOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex);
        
        /**
          * this method adds a SetVectorOperation as input of the input socket.
          * This can only be used from the convertToOperation method. all other usages are not allowed
          */
-       void addSetVectorOperation(ExecutionSystem *graph, InputSocketinputsocket, int editorNodeInputSocketIndex);
+       void addSetVectorOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex);
        
        /**
          * Creates a new link between an outputSocket and inputSocket and registrates the link to the graph
          * @return the new created link
          */
-       SocketConnection* addLink(ExecutionSystem *graph, OutputSocket* outputSocket, InputSocket* inputsocket);
+       SocketConnection *addLink(ExecutionSystem *graph, OutputSocket *outputSocket, InputSocket *inputsocket);
        
        /**
          * is this node a group node.
@@ -108,23 +108,23 @@ public:
          *
          * @param socket
          */
-       InputSocket* findInputSocketBybNodeSocket(bNodeSocket* socket);
+       InputSocket *findInputSocketBybNodeSocket(bNodeSocket *socket);
        
        /**
          * @brief find the OutputSocket by bNodeSocket
          *
          * @param socket
          */
-       OutputSocket* findOutputSocketBybNodeSocket(bNodeSocket* socket);
+       OutputSocket *findOutputSocketBybNodeSocket(bNodeSocket *socket);
 protected:
        
        Node();
        
-       void addPreviewOperation(ExecutionSystem *system, InputSocketinputSocket, int priority);
-       void addPreviewOperation(ExecutionSystem *system, OutputSocketinputSocket, int priority);
+       void addPreviewOperation(ExecutionSystem *system, InputSocket *inputSocket, int priority);
+       void addPreviewOperation(ExecutionSystem *system, OutputSocket *inputSocket, int priority);
        
-       bNodeSocketgetEditorInputSocket(int editorNodeInputSocketIndex);
-       bNodeSocketgetEditorOutputSocket(int editorNodeOutputSocketIndex);
+       bNodeSocket *getEditorInputSocket(int editorNodeInputSocketIndex);
+       bNodeSocket *getEditorOutputSocket(int editorNodeOutputSocketIndex);
 private:
 };
 
index b6990ec0d79f580b7038a51d62368e70c96a8568..17a623c9c817a744df8a260ede9945b575f54948 100644 (file)
 #include "COM_SocketConnection.h"
 #include "COM_ExecutionSystem.h"
 
-NodeBase::NodeBase() {
+NodeBase::NodeBase()
+{
 }
 
 
-NodeBase::~NodeBase() {
+NodeBase::~NodeBase()
+{
        while (!this->outputsockets.empty()) {
                delete (this->outputsockets.back());
                this->outputsockets.pop_back();
@@ -44,60 +46,70 @@ NodeBase::~NodeBase() {
        }
 }
 
-void NodeBase::addInputSocket(DataType datatype) {
+void NodeBase::addInputSocket(DataType datatype)
+{
        this->addInputSocket(datatype, COM_SC_CENTER, NULL);
 }
 
-void NodeBase::addInputSocket(DataType datatype, InputSocketResizeMode resizeMode) {
+void NodeBase::addInputSocket(DataType datatype, InputSocketResizeMode resizeMode)
+{
        this->addInputSocket(datatype, resizeMode, NULL);
 }
-void NodeBase::addInputSocket(DataType datatype, InputSocketResizeMode resizeMode, bNodeSocket* bSocket) {
+void NodeBase::addInputSocket(DataType datatype, InputSocketResizeMode resizeMode, bNodeSocket *bSocket)
+{
        InputSocket *socket = new InputSocket(datatype, resizeMode);
        socket->setEditorSocket(bSocket);
        socket->setNode(this);
        this->inputsockets.push_back(socket);
 }
 
-void NodeBase::addOutputSocket(DataType datatype) {
+void NodeBase::addOutputSocket(DataType datatype)
+{
        this->addOutputSocket(datatype, NULL);
        
 }
-void NodeBase::addOutputSocket(DataType datatype, bNodeSocket* bSocket) {
+void NodeBase::addOutputSocket(DataType datatype, bNodeSocket *bSocket)
+{
        OutputSocket *socket = new OutputSocket(datatype);
        socket->setEditorSocket(bSocket);
        socket->setNode(this);
        this->outputsockets.push_back(socket);
 }
-const bool NodeBase::isInputNode() const {
+const bool NodeBase::isInputNode() const
+{
        return this->inputsockets.size() == 0;
 }
 
-OutputSocket* NodeBase::getOutputSocket(int index) {
+OutputSocket *NodeBase::getOutputSocket(int index)
+{
        return this->outputsockets[index];
 }
 
-InputSocket* NodeBase::getInputSocket(int index) {
+InputSocket *NodeBase::getInputSocket(int index)
+{
        return this->inputsockets[index];
 }
 
 
-void NodeBase::determineActualSocketDataTypes() {
+void NodeBase::determineActualSocketDataTypes()
+{
        unsigned int index;
        for (index = 0 ; index < this->outputsockets.size() ; index ++) {
-               OutputSocketsocket = this->outputsockets[index];
+               OutputSocket *socket = this->outputsockets[index];
                if (socket->getActualDataType() ==COM_DT_UNKNOWN && socket->isConnected()) {
                        socket->determineActualDataType();
                }
        }
        for (index = 0 ; index < this->inputsockets.size() ; index ++) {
-               InputSocketsocket = this->inputsockets[index];
+               InputSocket *socket = this->inputsockets[index];
                if (socket->getActualDataType() ==COM_DT_UNKNOWN) {
                        socket->determineActualDataType();
                }
        }
 }
 
-DataType NodeBase::determineActualDataType(OutputSocket *outputsocket) {
+DataType NodeBase::determineActualDataType(OutputSocket *outputsocket)
+{
        const int inputIndex = outputsocket->getInputSocketDataTypeDeterminatorIndex();
        if (inputIndex != -1) {
                return this->getInputSocket(inputIndex)->getActualDataType();
@@ -107,7 +119,8 @@ DataType NodeBase::determineActualDataType(OutputSocket *outputsocket) {
        }
 }
 
-void NodeBase::notifyActualDataTypeSet(InputSocket *socket, DataType actualType) {
+void NodeBase::notifyActualDataTypeSet(InputSocket *socket, DataType actualType)
+{
        unsigned int index;
        int socketIndex = -1;
        for (index = 0 ; index < this->inputsockets.size() ; index ++) {
@@ -119,9 +132,10 @@ void NodeBase::notifyActualDataTypeSet(InputSocket *socket, DataType actualType)
        if (socketIndex == -1) return;
        
        for (index = 0 ; index < this->outputsockets.size() ; index ++) {
-               OutputSocketsocket = this->outputsockets[index];
+               OutputSocket *socket = this->outputsockets[index];
                if (socket->isActualDataTypeDeterminedByInputSocket() &&
-                               socket->getInputSocketDataTypeDeterminatorIndex() == socketIndex) {
+                   socket->getInputSocketDataTypeDeterminatorIndex() == socketIndex)
+               {
                        socket->setActualDataType(actualType);
                        socket->fireActualDataType();
                }
index 10028324d9182fc22c07daea3153245c51312d06..123797c780ad82f736e9309d4ae8c63a148b2f70 100644 (file)
@@ -124,32 +124,32 @@ public:
          * @param actualType [COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR]
          * the actual data type that is coming from the connected output socket
          */
-       virtual void notifyActualDataTypeSet(InputSocketsocket, const DataType actualType);
+       virtual void notifyActualDataTypeSet(InputSocket *socket, const DataType actualType);
        
        /**
          * get the reference to a certain outputsocket
          * @param index
          * the index of the needed outputsocket
          */
-       OutputSocketgetOutputSocket(const int index);
+       OutputSocket *getOutputSocket(const int index);
        
        /**
          * get the reference to the first outputsocket
          * @param index
          * the index of the needed outputsocket
          */
-       inline OutputSocketgetOutputSocket() {return getOutputSocket(0);}
+       inline OutputSocket *getOutputSocket() {return getOutputSocket(0);}
        
        /**
          * get the reference to a certain inputsocket
          * @param index
          * the index of the needed inputsocket
          */
-       InputSocketgetInputSocket(const int index);
+       InputSocket *getInputSocket(const int index);
        
        
        virtual bool isStatic() const {return false;}
-       void getStaticValues(floatresult) const {}
+       void getStaticValues(float *result) const {}
 protected:
        NodeBase();
        
@@ -160,7 +160,7 @@ protected:
          */
        void addInputSocket(DataType datatype);
        void addInputSocket(DataType datatype, InputSocketResizeMode resizeMode);
-       void addInputSocket(DataType datatype, InputSocketResizeMode resizeMode, bNodeSocketsocket);
+       void addInputSocket(DataType datatype, InputSocketResizeMode resizeMode, bNodeSocket *socket);
        
        /**
          * @brief add an OutputSocket to the collection of outputsockets
@@ -168,7 +168,7 @@ protected:
          * @param socket the OutputSocket to add
          */
        void addOutputSocket(DataType datatype);
-       void addOutputSocket(DataType datatype, bNodeSocketsocket);
+       void addOutputSocket(DataType datatype, bNodeSocket *socket);
 };
 
 #endif
index 71aaceb1b48e4418fa9c960c7b6053f8e274e036..fae652e39d706b76e5e860a4eaa948b1387d806e 100644 (file)
@@ -27,7 +27,8 @@
 #include "COM_defines.h"
 #include "stdio.h"
 
-NodeOperation::NodeOperation() {
+NodeOperation::NodeOperation()
+{
        this->resolutionInputSocketIndex = 0;
        this->complex = false;
        this->width = 0;
@@ -35,13 +36,14 @@ NodeOperation::NodeOperation() {
        this->openCL = false;
 }
 
-void NodeOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) {
+void NodeOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
+{
        unsigned int temp[2];
        unsigned int temp2[2];
        vector<InputSocket*> &inputsockets = this->getInputSockets();
        
        for (unsigned int index = 0 ; index < inputsockets.size();index++) {
-               InputSocketinputSocket = inputsockets[index];
+               InputSocket *inputSocket = inputsockets[index];
                if (inputSocket->isConnected()) {
                        if (index == this->resolutionInputSocketIndex) {
                                inputSocket->determineResolution(resolution, preferredResolution);
@@ -52,7 +54,7 @@ void NodeOperation::determineResolution(unsigned int resolution[], unsigned int
                }
        }
        for (unsigned int index = 0 ; index < inputsockets.size();index++) {
-               InputSocketinputSocket = inputsockets[index];
+               InputSocket *inputSocket = inputsockets[index];
                if (inputSocket->isConnected()) {
                        if (index != resolutionInputSocketIndex) {
                                inputSocket->determineResolution(temp, temp2);
@@ -60,28 +62,36 @@ void NodeOperation::determineResolution(unsigned int resolution[], unsigned int
                }
        }
 }
-void NodeOperation::setResolutionInputSocketIndex(unsigned int index) {
+void NodeOperation::setResolutionInputSocketIndex(unsigned int index)
+{
        this->resolutionInputSocketIndex = index;
 }
-void NodeOperation::initExecution() {
+void NodeOperation::initExecution()
+{
 }
 
-void NodeOperation::initMutex() {
+void NodeOperation::initMutex()
+{
        BLI_mutex_init(&mutex);
 }
-void NodeOperation::deinitMutex() {
+void NodeOperation::deinitMutex()
+{
        BLI_mutex_end(&mutex);
 }
-void NodeOperation::deinitExecution() {
+void NodeOperation::deinitExecution()
+{
 }
-SocketReader* NodeOperation::getInputSocketReader(unsigned int inputSocketIndex) {
+SocketReader *NodeOperation::getInputSocketReader(unsigned int inputSocketIndex)
+{
        return this->getInputSocket(inputSocketIndex)->getReader();
 }
-NodeOperation* NodeOperation::getInputOperation(unsigned int inputSocketIndex) {
+NodeOperation *NodeOperation::getInputOperation(unsigned int inputSocketIndex)
+{
        return this->getInputSocket(inputSocketIndex)->getOperation();
 }
 
-void NodeOperation::getConnectedInputSockets(vector<InputSocket*> *sockets) {
+void NodeOperation::getConnectedInputSockets(vector<InputSocket*> *sockets)
+{
        vector<InputSocket*> &inputsockets = this->getInputSockets();
        for (vector<InputSocket*>::iterator iterator = inputsockets.begin() ; iterator!= inputsockets.end() ; iterator++) {
                InputSocket *socket = *iterator;
@@ -91,7 +101,8 @@ void NodeOperation::getConnectedInputSockets(vector<InputSocket*> *sockets) {
        }
 }
 
-bool NodeOperation::determineDependingAreaOfInterest(rcti * input, ReadBufferOperation *readOperation, rcti* output) {
+bool NodeOperation::determineDependingAreaOfInterest(rcti * input, ReadBufferOperation *readOperation, rcti *output)
+{
        if (this->isInputNode()) {
                BLI_init_rcti(output, input->xmin, input->xmax, input->ymin, input->ymax);
                return false;
@@ -101,9 +112,9 @@ bool NodeOperation::determineDependingAreaOfInterest(rcti * input, ReadBufferOpe
                vector<InputSocket*> &inputsockets = this->getInputSockets();
        
                for (index = 0 ; index < inputsockets.size() ; index++) {
-                       InputSocketinputsocket = inputsockets[index];
+                       InputSocket *inputsocket = inputsockets[index];
                        if (inputsocket->isConnected()) {
-                               NodeOperationinputoperation = (NodeOperation*)inputsocket->getConnection()->getFromNode();
+                               NodeOperation *inputoperation = (NodeOperation*)inputsocket->getConnection()->getFromNode();
                                bool result = inputoperation->determineDependingAreaOfInterest(input, readOperation, output);
                                if (result) {
                                        return true;
index 5dabc4db8404853ba97370630e5356393c7617fe..bba3de2ec983a14d0914a17c850c881591c9f08e 100644 (file)
@@ -153,7 +153,7 @@ public:
          * @param clMemToCleanUp all created cl_mem references must be added to this list. Framework will clean this after execution
          * @param clKernelsToCleanUp all created cl_kernel references must be added to this list. Framework will clean this after execution
          */
-       virtual void executeOpenCL(cl_context context,cl_program program, cl_command_queue queue, MemoryBufferoutputMemoryBuffer, cl_mem clOutputBuffer, MemoryBuffer** inputMemoryBuffers, list<cl_mem> *clMemToCleanUp, list<cl_kernel> *clKernelsToCleanUp) {}
+       virtual void executeOpenCL(cl_context context,cl_program program, cl_command_queue queue, MemoryBuffer *outputMemoryBuffer, cl_mem clOutputBuffer, MemoryBuffer** inputMemoryBuffers, list<cl_mem> *clMemToCleanUp, list<cl_kernel> *clKernelsToCleanUp) {}
        virtual void deinitExecution();
        void deinitMutex();
 
@@ -195,7 +195,7 @@ public:
          */
        virtual const bool isActiveViewerOutput() const {return false;}
 
-       virtual bool determineDependingAreaOfInterest(rcti * input, ReadBufferOperation* readOperation, rcti* output);
+       virtual bool determineDependingAreaOfInterest(rcti * input, ReadBufferOperation *readOperation, rcti *output);
 
        /**
          * @brief set the index of the input socket that will determine the resolution of this operation
@@ -222,11 +222,11 @@ protected:
        NodeOperation();
 
        void setWidth(unsigned int width) {this->width = width;}
-       void setHeight(unsigned int height) {this->height= height;}
-       SocketReadergetInputSocketReader(unsigned int inputSocketindex);
-       NodeOperationgetInputOperation(unsigned int inputSocketindex);
+       void setHeight(unsigned int height) {this->height = height;}
+       SocketReader *getInputSocketReader(unsigned int inputSocketindex);
+       NodeOperation *getInputOperation(unsigned int inputSocketindex);
 
-       inline ThreadMutexgetMutex() {return &this->mutex;}
+       inline ThreadMutex *getMutex() {return &this->mutex;}
 
        /**
          * @brief set whether this operation is complex
index b986865ecf3fc3f59d2929a6ff595da6a04cfb35..0945b426a4e8f2025c5e71033d67995a5df72a7e 100644 (file)
 #include "COM_WorkScheduler.h"
 
 
-OpenCLDevice::OpenCLDevice(cl_context context, cl_device_id device, cl_program program) {
+OpenCLDevice::OpenCLDevice(cl_context context, cl_device_id device, cl_program program)
+{
        this->device = device;
        this->context = context;
        this->program = program;
        this->queue = NULL;
 }
 
-bool OpenCLDevice::initialize() {
+bool OpenCLDevice::initialize()
+{
        cl_int error;
        queue = clCreateCommandQueue(context, device, 0, &error);
        return false;
 }
 
-void OpenCLDevice::deinitialize() {
+void OpenCLDevice::deinitialize()
+{
        if (queue) {
                clReleaseCommandQueue(queue);
        }
 }
 
-void OpenCLDevice::execute(WorkPackage *work) {
+void OpenCLDevice::execute(WorkPackage *work)
+{
        const unsigned int chunkNumber = work->getChunkNumber();
        ExecutionGroup * executionGroup = work->getExecutionGroup();
        rcti rect;
index 5380a7ec49224a1c1a54e5fe5c550ac2770da465..00d3518cd15a28dfabfdaba0a9b8b9a020fd70af 100644 (file)
 #include "COM_SocketConnection.h"
 #include "COM_NodeOperation.h"
 
-OutputSocket::OutputSocket(DataType datatype) :Socket(datatype) {
+OutputSocket::OutputSocket(DataType datatype) :Socket(datatype)
+{
        this->inputSocketDataTypeDeterminatorIndex = -1;
 }
-OutputSocket::OutputSocket(DataType datatype, int inputSocketDataTypeDeterminatorIndex) :Socket(datatype) {
+OutputSocket::OutputSocket(DataType datatype, int inputSocketDataTypeDeterminatorIndex) :Socket(datatype)
+{
        this->inputSocketDataTypeDeterminatorIndex = inputSocketDataTypeDeterminatorIndex;
 }
 
-OutputSocket::OutputSocket(OutputSocket *from): Socket(from->getDataType()) {
+OutputSocket::OutputSocket(OutputSocket *from): Socket(from->getDataType())
+{
        this->inputSocketDataTypeDeterminatorIndex = from->getInputSocketDataTypeDeterminatorIndex();   
 }
 
 int OutputSocket::isOutputSocket() const { return true; }
 const int OutputSocket::isConnected() const { return this->connections.size()!=0; }
 
-void OutputSocket::determineResolution(unsigned int resolution[], unsigned int preferredResolution[]) {
-       NodeBase* node = this->getNode();
+void OutputSocket::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
+{
+       NodeBase *node = this->getNode();
        if (node->isOperation()) {
-               NodeOperationoperation = (NodeOperation*)node;
+               NodeOperation *operation = (NodeOperation*)node;
                operation->determineResolution(resolution, preferredResolution);
                operation->setResolution(resolution);
        }
 }
 
-void OutputSocket::determineActualDataType() {
+void OutputSocket::determineActualDataType()
+{
        DataType actualDatatype = this->getNode()->determineActualDataType(this);
 
        /** @todo: set the channel info needs to be moved after integration with OCIO */
@@ -79,18 +84,21 @@ void OutputSocket::determineActualDataType() {
        this->fireActualDataType();
 }
 
-void OutputSocket::addConnection(SocketConnection *connection) {
+void OutputSocket::addConnection(SocketConnection *connection)
+{
        this->connections.push_back(connection);
 }
 
-void OutputSocket::fireActualDataType() {
+void OutputSocket::fireActualDataType()
+{
        unsigned int index;
        for (index = 0 ; index < this->connections.size();index ++) {
                SocketConnection *connection = this->connections[index];
                connection->getToSocket()->notifyActualInputType(this->getActualDataType());
        }
 }
-void OutputSocket::relinkConnections(OutputSocket *relinkToSocket, bool single) {
+void OutputSocket::relinkConnections(OutputSocket *relinkToSocket, bool single)
+{
        if (isConnected()) {
                if (single) {
                        SocketConnection *connection = this->connections[0];
@@ -111,28 +119,31 @@ void OutputSocket::relinkConnections(OutputSocket *relinkToSocket, bool single)
                }
        }
 }
-void OutputSocket::removeFirstConnection() {
+void OutputSocket::removeFirstConnection()
+{
        SocketConnection *connection = this->connections[0];
-       InputSocketinputSocket = connection->getToSocket();
+       InputSocket *inputSocket = connection->getToSocket();
        if (inputSocket != NULL) {
                inputSocket->setConnection(NULL);
        }
        this->connections.erase(this->connections.begin());
 }
 
-void OutputSocket::clearConnections() {
+void OutputSocket::clearConnections()
+{
        while (this->isConnected()) {
                removeFirstConnection();
        }
 }
 
-WriteBufferOperation* OutputSocket::findAttachedWriteBufferOperation() const {
+WriteBufferOperation *OutputSocket::findAttachedWriteBufferOperation() const
+{
        unsigned int index;
        for (index = 0 ; index < this->connections.size();index++) {
-               SocketConnectionconnection = this->connections[index];
-               NodeBasenode = connection->getToNode();
+               SocketConnection *connection = this->connections[index];
+               NodeBase *node = connection->getToNode();
                if (node->isOperation()) {
-                       NodeOperationoperation = (NodeOperation*)node;
+                       NodeOperation *operation = (NodeOperation*)node;
                        if (operation->isWriteBufferOperation()) {
                                return (WriteBufferOperation*)operation;
                        }
@@ -141,7 +152,8 @@ WriteBufferOperation* OutputSocket::findAttachedWriteBufferOperation() const {
        return NULL;
 }
 
-ChannelInfo* OutputSocket::getChannelInfo(const int channelnumber) {
+ChannelInfo *OutputSocket::getChannelInfo(const int channelnumber)
+{
        return &this->channelinfo[channelnumber];
 }
 
index 8815f0bb3a8c9a06dc8949af3205f2fd0b4ac351..640588417b4989647a4d0a30f7ab2a31e05d6c13 100644 (file)
@@ -58,7 +58,7 @@ public:
        OutputSocket(DataType datatype, int inputSocketDataTypeDeterminatorIndex);
        OutputSocket(OutputSocket * from);
        void addConnection(SocketConnection *connection);
-       SocketConnectiongetConnection(unsigned int index) {return this->connections[index];}
+       SocketConnection *getConnection(unsigned int index) {return this->connections[index];}
        const int isConnected() const;
        int isOutputSocket() const;
        
@@ -90,8 +90,8 @@ public:
          * @brief find a connected write buffer operation to this OutputSocket
          * @return WriteBufferOperation or NULL
          */
-       WriteBufferOperationfindAttachedWriteBufferOperation() const;
-       ChannelInfogetChannelInfo(const int channelnumber);
+       WriteBufferOperation *findAttachedWriteBufferOperation() const;
+       ChannelInfo *getChannelInfo(const int channelnumber);
        
        /**
          * @brief trigger determine actual data type to all connected sockets
index cb429c9df4a6293580780de69db682d4acd4dd65..a5336ac120272a1b89471c7d8aeaa159f57897c0 100644 (file)
 #include "COM_Node.h"
 #include "COM_SocketConnection.h"
 
-Socket::Socket(DataType datatype) {
+Socket::Socket(DataType datatype)
+{
        this->datatype = datatype;
        this->actualType = COM_DT_UNKNOWN;
        this->editorSocket = NULL;
        this->node = NULL;
 }
 
-DataType Socket::getDataType() const {
+DataType Socket::getDataType() const
+{
        return this->datatype;
 }
 
@@ -39,9 +41,10 @@ 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;}
-NodeBaseSocket::getNode() const {return this->node;}
+NodeBase *Socket::getNode() const {return this->node;}
 
 DataType Socket::getActualDataType() const {return this->actualType;}
-void Socket::setActualDataType(DataType actualType) {
+void Socket::setActualDataType(DataType actualType)
+{
        this->actualType = actualType;
 }
index 3243a371cda3399f66cb68fcd775bbb8e9d7e9e5..8ad7a5c7fde358d7cf9a3d533f9e93e607943194 100644 (file)
@@ -49,7 +49,7 @@ private:
        /**
          * Reference to the node where this Socket belongs to
          */
-       NodeBasenode;
+       NodeBase *node;
        
        /**
          * the datatype of this socket. Is used for automatically data transformation.
@@ -63,13 +63,13 @@ private:
          */
        DataType actualType;
        
-       bNodeSocketeditorSocket;
+       bNodeSocket *editorSocket;
 public:
        Socket(DataType datatype);
        
        DataType getDataType() const;
-       void setNode(NodeBasenode);
-       NodeBasegetNode() const;
+       void setNode(NodeBase *node);
+       NodeBase *getNode() const;
        
        /**
          * @brief get the actual data type
@@ -91,8 +91,8 @@ public:
        virtual void determineResolution(int resolution[], unsigned int preferredResolution[]) {}
        virtual void determineActualDataType() {}
        
-       void setEditorSocket(bNodeSocketeditorSocket) {this->editorSocket = editorSocket;}
-       bNodeSocketgetbNodeSocket() const {return this->editorSocket;}
+       void setEditorSocket(bNodeSocket *editorSocket) {this->editorSocket = editorSocket;}
+       bNodeSocket *getbNodeSocket() const {return this->editorSocket;}
        
 };
 
index e3e52005add623085e4cb91f28c89f7b49e47915..9f0c736392a1e6739d0f4ed7707eec6888a9b21a 100644 (file)
 #include "COM_SocketConnection.h"
 #include "COM_NodeOperation.h"
 
-SocketConnection::SocketConnection() {
+SocketConnection::SocketConnection()
+{
        this->fromSocket = NULL;
        this->toSocket = NULL;
        this->setIgnoreResizeCheck(false);
 }
 
-void SocketConnection::setFromSocket(OutputSocket* fromsocket) {
+void SocketConnection::setFromSocket(OutputSocket *fromsocket)
+{
        if (fromsocket == NULL) {
                throw "ERROR";
        }
        this->fromSocket = fromsocket;
 }
 
-OutputSocket* SocketConnection::getFromSocket() const {return this->fromSocket;}
-void SocketConnection::setToSocket(InputSocket* tosocket) {
+OutputSocket *SocketConnection::getFromSocket() const {return this->fromSocket;}
+void SocketConnection::setToSocket(InputSocket *tosocket)
+{
        if (tosocket == NULL) {
                throw "ERROR";
        }
        this->toSocket = tosocket;
 }
 
-InputSocketSocketConnection::getToSocket() const {return this->toSocket;}
+InputSocket *SocketConnection::getToSocket() const {return this->toSocket;}
 
-NodeBase* SocketConnection::getFromNode() const {
+NodeBase *SocketConnection::getFromNode() const
+{
        if (this->getFromSocket() == NULL) {
                return NULL;
        }
@@ -54,7 +58,8 @@ NodeBase* SocketConnection::getFromNode() const {
                return this->getFromSocket()->getNode();
        }
 }
-NodeBase* SocketConnection::getToNode() const {
+NodeBase *SocketConnection::getToNode() const
+{
        if (this->getToSocket() == NULL) {
                return NULL;
        }
@@ -62,7 +67,8 @@ NodeBase* SocketConnection::getToNode() const {
                return this->getToSocket()->getNode();
        }
 }
-bool SocketConnection::isValid() const {
+bool SocketConnection::isValid() const
+{
        if ((this->getToSocket() != NULL && this->getFromSocket() != NULL)) {
                if (this->getFromNode()->isOperation() && this->getToNode()->isOperation()) {
                        return true;
@@ -71,10 +77,11 @@ bool SocketConnection::isValid() const {
        return false;
 }
 
-bool SocketConnection::needsResolutionConversion() const {
+bool SocketConnection::needsResolutionConversion() const
+{
        if (this->ignoreResizeCheck) {return false;}
-       NodeOperationfromOperation = (NodeOperation*)this->getFromNode();
-       NodeOperationtoOperation = (NodeOperation*)this->getToNode();
+       NodeOperation *fromOperation = (NodeOperation*)this->getFromNode();
+       NodeOperation *toOperation = (NodeOperation*)this->getToNode();
        if (this->toSocket->getResizeMode() == COM_SC_NO_RESIZE) {return false;}
        const unsigned int fromWidth = fromOperation->getWidth();
        const unsigned int fromHeight = fromOperation->getHeight();
index 55811cc6ebe08b9f71b802958d92536a03f92495..1c4dcebfe07eb44d3484c7d45256bbd3d38ba5f3 100644 (file)
@@ -66,25 +66,25 @@ public:
          * @brief set the startpoint of the connection
          * @param fromsocket
          */
-       void setFromSocket(OutputSocketfromsocket);
+       void setFromSocket(OutputSocket *fromsocket);
        
        /**
          * @brief get the startpoint of the connection
          * @return from OutputSocket
          */
-       OutputSocketgetFromSocket() const;
+       OutputSocket *getFromSocket() const;
        
        /**
          * @brief set the endpoint of the connection
          * @param tosocket
          */
-       void setToSocket(InputSockettosocket);
+       void setToSocket(InputSocket *tosocket);
        
        /**
          * @brief get the endpoint of the connection
          * @return to InputSocket
          */
-       InputSocketgetToSocket() const;
+       InputSocket *getToSocket() const;
        
        /**
          * @brief check if this connection is valid
index fd07726a939130cfe48be029582888204dfda887..24322847517e3415a05c3fee5f5c7193cb94b580 100644 (file)
@@ -59,7 +59,7 @@ protected:
           * @param y the y-coordinate of the pixel to calculate in image space
           * @param inputBuffers chunks that can be read by their ReadBufferOperation.
          */
-       virtual void executePixel(floatresult, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) {}
+       virtual void executePixel(float *result, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) {}
 
        /**
          * @brief calculate a single pixel
@@ -70,7 +70,7 @@ protected:
        * @param inputBuffers chunks that can be read by their ReadBufferOperation.
        * @param chunkData chunk specific data a during execution time.
          */
-       virtual void executePixel(float* result, int x, int y, MemoryBuffer *inputBuffers[], void* chunkData) {
+       virtual void executePixel(float *result, int x, int y, MemoryBuffer *inputBuffers[], void *chunkData) {
                executePixel(result, x, y, COM_PS_NEAREST, inputBuffers);
        }
 
@@ -84,26 +84,26 @@ protected:
         * @param dy
         * @param inputBuffers chunks that can be read by their ReadBufferOperation.
         */
-       virtual void executePixel(floatresult, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) {}
+       virtual void executePixel(float *result, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) {}
 
 public:
-       inline void read(floatresult, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) {
+       inline void read(float *result, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) {
                executePixel(result, x, y, sampler, inputBuffers);
        }
-       inline void read(float* result, int x, int y, MemoryBuffer *inputBuffers[], void* chunkData) {
+       inline void read(float *result, int x, int y, MemoryBuffer *inputBuffers[], void *chunkData) {
                executePixel(result, x, y, inputBuffers, chunkData);
        }
-       inline void read(floatresult, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) {
+       inline void read(float *result, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) {
                executePixel(result, x, y, dx, dy, inputBuffers);
        }
 
-       virtual voidinitializeTileData(rcti *rect, MemoryBuffer** memoryBuffers) {
+       virtual void *initializeTileData(rcti *rect, MemoryBuffer** memoryBuffers) {
                return 0;
        }
-       virtual void deinitializeTileData(rcti *rect, MemoryBuffer** memoryBuffers, voiddata) {
+       virtual void deinitializeTileData(rcti *rect, MemoryBuffer** memoryBuffers, void *data) {
        }
        
-       virtual MemoryBuffergetInputMemoryBuffer(MemoryBuffer** memoryBuffers) {return 0;}
+       virtual MemoryBuffer *getInputMemoryBuffer(MemoryBuffer** memoryBuffers) {return 0;}
 
 
        inline const unsigned int getWidth() const {return this->width;}
index d606e845b001ce095ad0824a6a1061e242a2baf2..07974b9aafcb95bb07b9ba50c4ae8ce809082d30 100644 (file)
@@ -22,7 +22,8 @@
 
 #include "COM_WorkPackage.h"
 
-WorkPackage::WorkPackage(ExecutionGroup *group, unsigned int chunkNumber) {
+WorkPackage::WorkPackage(ExecutionGroup *group, unsigned int chunkNumber)
+{
        this->executionGroup = group;
        this->chunkNumber = chunkNumber;
 }
index 3169a9dcc309b3110a7c91dc9a31115ec4556173..8bdf21499cfb8fecdfad955ee2f3c62deaa0e973 100644 (file)
@@ -36,7 +36,7 @@ private:
        /**
          * @brief executionGroup with the operations-setup to be evaluated
          */
-       ExecutionGroupexecutionGroup;
+       ExecutionGroup *executionGroup;
 
        /**
          * @brief number of the chunk to be executed
@@ -48,12 +48,12 @@ public:
          * @param group the ExecutionGroup
          * @param chunkNumber the number of the chunk
          */
-       WorkPackage(ExecutionGroupgroup, unsigned int chunkNumber);
+       WorkPackage(ExecutionGroup *group, unsigned int chunkNumber);
 
        /**
          * @brief get the ExecutionGroup
          */
-       ExecutionGroupgetExecutionGroup() const {return this->executionGroup;}
+       ExecutionGroup *getExecutionGroup() const {return this->executionGroup;}
 
        /**
          * @brief get the number of the chunk
index 5130525853bb3e082b288204dceb14d87984c704..c82a01a1e0a747169c2ed4334c87412e2e7ac6be 100644 (file)
@@ -65,14 +65,15 @@ static bool openclActive = false;
 
 
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
-void* WorkScheduler::thread_execute_cpu(void* data) {
+void *WorkScheduler::thread_execute_cpu(void *data)
+{
        bool continueLoop = true;
-       Devicedevice = (Device*)data;
+       Device *device = (Device*)data;
        while (continueLoop) {
-               WorkPackagework = (WorkPackage*)BLI_thread_queue_pop(cpuqueue);
+               WorkPackage *work = (WorkPackage*)BLI_thread_queue_pop(cpuqueue);
                if (work) {
-                  device->execute(work);
-                  delete work;
+                       device->execute(work);
+                       delete work;
                }
                PIL_sleep_ms(10);
 
@@ -83,11 +84,12 @@ void* WorkScheduler::thread_execute_cpu(void* data) {
        return NULL;
 }
 
-void* WorkScheduler::thread_execute_gpu(void* data) {
+void *WorkScheduler::thread_execute_gpu(void *data)
+{
        bool continueLoop = true;
-       Devicedevice = (Device*)data;
+       Device *device = (Device*)data;
        while (continueLoop) {
-               WorkPackagework = (WorkPackage*)BLI_thread_queue_pop(gpuqueue);
+               WorkPackage *work = (WorkPackage*)BLI_thread_queue_pop(gpuqueue);
                if (work) {
                        device->execute(work);
                        delete work;
@@ -106,8 +108,9 @@ bool WorkScheduler::isStopping() {return state == COM_WSS_STOPPING;}
 
 
 
-void WorkScheduler::schedule(ExecutionGroup *group, int chunkNumber) {
-       WorkPackage* package = new WorkPackage(group, chunkNumber);
+void WorkScheduler::schedule(ExecutionGroup *group, int chunkNumber)
+{
+       WorkPackage *package = new WorkPackage(group, chunkNumber);
 #if COM_CURRENT_THREADING_MODEL == COM_TM_NOTHREAD
        CPUDevice device;
        device.execute(package);
@@ -126,14 +129,15 @@ void WorkScheduler::schedule(ExecutionGroup *group, int chunkNumber) {
 #endif
 }
 
-void WorkScheduler::start(CompositorContext &context) {
+void WorkScheduler::start(CompositorContext &context)
+{
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
        unsigned int index;
        cpuqueue = BLI_thread_queue_init();
        BLI_thread_queue_nowait(cpuqueue);
        BLI_init_threads(&cputhreads, thread_execute_cpu, cpudevices.size());
        for (index = 0 ; index < cpudevices.size() ; index ++) {
-               Devicedevice = cpudevices[index];
+               Device *device = cpudevices[index];
                BLI_insert_thread(&cputhreads, device);
        }
 #ifdef COM_OPENCL_ENABLED
@@ -142,7 +146,7 @@ void WorkScheduler::start(CompositorContext &context) {
                BLI_thread_queue_nowait(gpuqueue);
                BLI_init_threads(&gputhreads, thread_execute_gpu, gpudevices.size());
                for (index = 0 ; index < gpudevices.size() ; index ++) {
-                       Devicedevice = gpudevices[index];
+                       Device *device = gpudevices[index];
                        BLI_insert_thread(&gputhreads, device);
                }
                openclActive = true;
@@ -154,7 +158,8 @@ void WorkScheduler::start(CompositorContext &context) {
 #endif
        state = COM_WSS_STARTED;
 }
-void WorkScheduler::finish() {
+void WorkScheduler::finish()
+{
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
 #ifdef COM_OPENCL_ENABLED
        if (openclActive) {
@@ -174,7 +179,8 @@ void WorkScheduler::finish() {
 #endif
 #endif
 }
-void WorkScheduler::stop() {
+void WorkScheduler::stop()
+{
        state = COM_WSS_STOPPING;
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
        BLI_end_threads(&cputhreads);
@@ -191,7 +197,8 @@ void WorkScheduler::stop() {
        state = COM_WSS_STOPPED;
 }
 
-bool WorkScheduler::hasGPUDevices() {
+bool WorkScheduler::hasGPUDevices()
+{
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
 #ifdef COM_OPENCL_ENABLED
        return gpudevices.size()>0;
@@ -203,11 +210,13 @@ bool WorkScheduler::hasGPUDevices() {
 #endif
 }
 
-extern void clContextError(const char *errinfo, const void *private_info, size_t cb, void *user_data) {
+extern void clContextError(const char *errinfo, const void *private_info, size_t cb, void *user_data)
+{
        printf("OPENCL error: %s\n", errinfo);
 }
 
-void WorkScheduler::initialize() {
+void WorkScheduler::initialize()
+{
        state = COM_WSS_UNKNOWN;
 
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
@@ -257,7 +266,7 @@ void WorkScheduler::initialize() {
                        printf("CLERROR[%d]: %s\n", error, clewErrorString(error));     
                        error2 = clGetProgramBuildInfo(program, cldevices[0], CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
                        if (error2 != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
-                       charbuild_log =  new char[ret_val_size+1];
+                       char *build_log =  new char[ret_val_size+1];
                        error2 = clGetProgramBuildInfo(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';
@@ -268,7 +277,7 @@ void WorkScheduler::initialize() {
                unsigned int indexDevices;
                for (indexDevices = 0 ; indexDevices < totalNumberOfDevices ; indexDevices ++) {
                        cl_device_id device = cldevices[indexDevices];
-                       OpenCLDeviceclDevice = new OpenCLDevice(context, device, program);
+                       OpenCLDevice *clDevice = new OpenCLDevice(context, device, program);
                        clDevice->initialize(),
                        gpudevices.push_back(clDevice);
                        char resultString[32];
@@ -286,9 +295,10 @@ void WorkScheduler::initialize() {
        state = COM_WSS_INITIALIZED;
 }
 
-void WorkScheduler::deinitialize() {
+void WorkScheduler::deinitialize()
+{
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
-       Devicedevice;
+       Device *device;
        while (cpudevices.size()>0) {
                device = cpudevices.back();
                cpudevices.pop_back();
index 0befa209e4753d31bd623fb8d4f7ee4437a2c2a2..0de1763749e72ec360a11b08442550e2e5821f72 100644 (file)
@@ -59,13 +59,13 @@ class WorkScheduler {
          * @brief main thread loop for cpudevices
          * inside this loop new work is queried and being executed
          */
-       static void* thread_execute_cpu(void* data);
+       static void *thread_execute_cpu(void *data);
 
        /**
          * @brief main thread loop for gpudevices
          * inside this loop new work is queried and being executed
          */
-       static void* thread_execute_gpu(void* data);
+       static void *thread_execute_gpu(void *data);
 #endif 
 public:
        /**
@@ -77,7 +77,7 @@ public:
          * @param group the execution group
          * @param chunkNumber the number of the chunk in the group to be executed
          */
-       static void schedule(ExecutionGroupgroup, int chunkNumber);
+       static void schedule(ExecutionGroup *group, int chunkNumber);
 
        /**
          * @brief initialize the WorkScheduler
index 5707fc2c2fe2258e27dee644f14e651b510608d8..bd967190987f7cf9732e4821839aa2f71c84ab13 100644 (file)
@@ -31,7 +31,8 @@ extern "C" {
 #include "COM_WorkScheduler.h"
 
 static ThreadMutex *compositorMutex;
-void COM_execute(bNodeTree *editingtree, int rendering) {
+void COM_execute(bNodeTree *editingtree, int rendering)
+{
        if (compositorMutex == NULL) { /// TODO: move to blender startup phase
                compositorMutex = new ThreadMutex();
                BLI_mutex_init(compositorMutex);
@@ -51,7 +52,7 @@ void COM_execute(bNodeTree *editingtree, int rendering) {
        editingtree->stats_draw(editingtree->sdh, (char*)"Compositing");
 
        /* initialize execution system */
-       ExecutionSystemsystem = new ExecutionSystem(editingtree, rendering);
+       ExecutionSystem *system = new ExecutionSystem(editingtree, rendering);
        system->execute();
        delete system;
 
index 23acaee7b9398fa1a79d3017b9f4834dc9d8dccc..0037480d2e986d743d651852756c937bc1ece0d7 100644 (file)
 #include "COM_SetValueOperation.h"
 #include "DNA_material_types.h" // the ramp types
 
-void AlphaOverNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void AlphaOverNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        InputSocket *valueSocket = this->getInputSocket(0);
        InputSocket *color1Socket = this->getInputSocket(1);
        InputSocket *color2Socket = this->getInputSocket(2);
        OutputSocket *outputSocket = this->getOutputSocket(0);
-       bNodeeditorNode = this->getbNode();
+       bNode *editorNode = this->getbNode();
        
        MixBaseOperation *convertProg;
-       NodeTwoFloats *ntf= (NodeTwoFloats*)editorNode->storage;
+       NodeTwoFloats *ntf = (NodeTwoFloats*)editorNode->storage;
        if (ntf->x!= 0.0f) {
                AlphaOverMixedOperation *mixOperation  = new AlphaOverMixedOperation();
                mixOperation->setX(ntf->x);
index b9840f89d3add45724f5de50815819cd2cd3ca05..64f78e76837b9b770885a48b2ceb4b4c28392255 100644 (file)
@@ -31,7 +31,7 @@
   */
 class AlphaOverNode: public Node {
 public:
-       AlphaOverNode(bNodeeditorNode) :Node(editorNode) {}
+       AlphaOverNode(bNode *editorNode) :Node(editorNode) {}
        void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
index 5302fb01f1ca54844222cd071de98c93904c21d2..436d92df7f8c8131f66bbf5a27e1698e1ca5e15c 100644 (file)
 #include "COM_ExecutionSystem.h"
 #include "COM_BilateralBlurOperation.h"
 
-BilateralBlurNode::BilateralBlurNode(bNode *editorNode): Node(editorNode) {
+BilateralBlurNode::BilateralBlurNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void BilateralBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void BilateralBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        NodeBilateralBlurData *data = (NodeBilateralBlurData*)this->getbNode()->storage;
        BilateralBlurOperation *operation = new BilateralBlurOperation();
        operation->setQuality(context->getQuality());
index d5d9b7367a466e2d12f7081e43c1573ddee49c6b..a92de0eaa62e034331a594dea921f451b6f81bdf 100644 (file)
@@ -32,7 +32,7 @@
 class BilateralBlurNode: public Node {
 public:
        BilateralBlurNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 5e29650a5ca68b79ee792fb8e9704af6095e7fa9..789a6a6eee24ef3d323d7f4c671a1da3ffd56ba5 100644 (file)
 #include "COM_GaussianBokehBlurOperation.h"
 #include "COM_FastGaussianBlurOperation.h"
 
-BlurNode::BlurNode(bNode *editorNode): Node(editorNode) {
+BlurNode::BlurNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void BlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
-       bNode* editorNode = this->getbNode();
+void BlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
+       bNode *editorNode = this->getbNode();
        NodeBlurData * data = (NodeBlurData*)editorNode->storage;
 #if 0
        const bNodeSocket *sock = this->getInputSocket(1)->getbNodeSocket();
index 087e2be208f9edc7337b72a9c4265c6273983d65..04a680c32cf6f42e73d51ebeacbd3f86e6cc52b9 100644 (file)
@@ -33,7 +33,7 @@
 class BlurNode: public Node {
 public:
        BlurNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 68e9b067f0799bb731d7ad4c98181be719ee9ff7..9e80d024bd2175c62551533ae79f3c2113c487e9 100644 (file)
 #include "COM_VariableSizeBokehBlurOperation.h"
 #include "COM_ConvertDepthToRadiusOperation.h"
 
-BokehBlurNode::BokehBlurNode(bNode *editorNode): Node(editorNode) {
+BokehBlurNode::BokehBlurNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void BokehBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
-       Object* camob = context->getScene()->camera;
+void BokehBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
+       Object *camob = context->getScene()->camera;
 
        if (this->getInputSocket(2)->isConnected()) {
                VariableSizeBokehBlurOperation *operation = new VariableSizeBokehBlurOperation();
index cb9d117c8ae41c0b1b782a2ac83d744057e0ed15..eb9fada5112d338ccc00420cde6af69ac3f5c4fe 100644 (file)
@@ -33,7 +33,7 @@
 class BokehBlurNode: public Node {
 public:
        BokehBlurNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 511727636b55d87428f142bf65cf746fc3a1e090..35511d213f51b1241af6d55dd35e11de63c38861 100644 (file)
 #include "COM_BokehImageOperation.h"
 #include "COM_ExecutionSystem.h"
 
-BokehImageNode::BokehImageNode(bNode *editorNode): Node(editorNode) {
+BokehImageNode::BokehImageNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void BokehImageNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void BokehImageNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        BokehImageOperation *operation = new BokehImageOperation();
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket(0));
        graph->addOperation(operation);
index f3322077c47d3d09cb8083e12ab27e9c3a0dbed0..d4fabf0e516a25ee5da716af7e8bf25ec4096c39 100644 (file)
@@ -32,7 +32,7 @@
 class BokehImageNode: public Node {
 public:
        BokehImageNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 7f904f1acc0c7fc56809a5a145b24fa816388879..322b5893096c1934ac38353750e36ea710bdb064 100644 (file)
 #include "COM_BoxMaskOperation.h"
 #include "COM_ExecutionSystem.h"
 
-BoxMaskNode::BoxMaskNode(bNode *editorNode): Node(editorNode) {
+BoxMaskNode::BoxMaskNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void BoxMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void BoxMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        BoxMaskOperation *operation;
        operation = new BoxMaskOperation();
        operation->setData((NodeBoxMask*)this->getbNode()->storage);
index c91730fdbb8063061a4c5a977111d5cc544ffd15..c71c6a18388ae7f020a795a44ebba7a82782de3b 100644 (file)
@@ -32,7 +32,7 @@
 class BoxMaskNode: public Node {
 public:
        BoxMaskNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 3ff5538f13e2060576143bf596d1a40f3bf98d9b..2bcf725017353bb771854a57dd94579e4bef7dd2 100644 (file)
 #include "COM_BrightnessOperation.h"
 #include "COM_ExecutionSystem.h"
 
-BrightnessNode::BrightnessNode(bNode *editorNode): Node(editorNode) {
+BrightnessNode::BrightnessNode(bNode *editorNode): Node(editorNode)
+{
 }
 /// @todo: add anti alias when not FSA
-void BrightnessNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void BrightnessNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        BrightnessOperation *operation = new BrightnessOperation();
        
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0));
index 8f1c9ccda86cb45f299ee4723b61b759885606be..4c3b6421322636c66b3cb8c0656aa44e3fd6cdc7 100644 (file)
@@ -32,7 +32,7 @@
 class BrightnessNode: public Node {
 public:
        BrightnessNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 9ab6c6250db417d08a06bfee762a531d0b27ce54..08980de8d98aa4ed5a610277fc8ba1c4712dc51b 100644 (file)
 ChannelMatteNode::ChannelMatteNode(bNode *editorNode): Node(editorNode)
 {}
 
-void ChannelMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) {
+void ChannelMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
+{
        InputSocket *inputSocketImage = this->getInputSocket(0);
        OutputSocket *outputSocketImage = this->getOutputSocket(0);
        OutputSocket *outputSocketMatte = this->getOutputSocket(1);
 
        NodeOperation *convert=NULL;
-       bNodenode = this->getbNode();
+       bNode *node = this->getbNode();
 
        /* colorspace */
        switch (node->custom1) {
index 36d315c3a4bbbe1cd08bb2e245b108d8273aa399..45176cb007c241d332caecf1ffeed56f13d5c4e4 100644 (file)
@@ -28,7 +28,8 @@
 ChromaMatteNode::ChromaMatteNode(bNode *editorNode): Node(editorNode)
 {}
 
-void ChromaMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) {
+void ChromaMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
+{
        InputSocket *inputSocketImage = this->getInputSocket(0);
        InputSocket *inputSocketKey = this->getInputSocket(1);
        OutputSocket *outputSocketImage = this->getOutputSocket(0);
@@ -40,7 +41,7 @@ void ChromaMatteNode::convertToOperations(ExecutionSystem *graph, CompositorCont
        operationRGBToYCC_Key->setMode(0); /* BLI_YCC_ITU_BT601 */
 
        ChromaMatteOperation *operation = new ChromaMatteOperation();
-       bNodeeditorsnode = getbNode();
+       bNode *editorsnode = getbNode();
        operation->setSettings((NodeChroma*)editorsnode->storage);
 
        inputSocketImage->relinkConnections(operationRGBToYCC_Image->getInputSocket(0), true, 0, graph);
index 8d5e8a2788eac97172f71523fc09118ff3a216e0..32c9e50874e8bf74f293a070b972f7a05f984918 100644 (file)
 #include "BKE_node.h"
 #include "COM_MixBlendOperation.h"
 
-ColorBalanceNode::ColorBalanceNode(bNodeeditorNode): Node(editorNode)
+ColorBalanceNode::ColorBalanceNode(bNode *editorNode): Node(editorNode)
 {
 }
-void ColorBalanceNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void ColorBalanceNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        InputSocket *inputSocket = this->getInputSocket(0);
        InputSocket *inputImageSocket = this->getInputSocket(1);
        OutputSocket *outputSocket = this->getOutputSocket(0);
        
-       bNodenode = this->getbNode();
-       NodeColorBalance *n= (NodeColorBalance *)node->storage;
+       bNode *node = this->getbNode();
+       NodeColorBalance *n = (NodeColorBalance *)node->storage;
        NodeOperation*operation;
        if (node->custom1 == 0) {
-               ColorBalanceLGGOperationoperationLGG = new ColorBalanceLGGOperation();
+               ColorBalanceLGGOperation *operationLGG = new ColorBalanceLGGOperation();
                {
                                int c;
        
index 6de431a764f4f81048aa2ea7e7dd5335be6c53e0..61a09d28c0172628a6641e98022d74a7527ff182 100644 (file)
@@ -32,8 +32,8 @@
 class ColorBalanceNode : public Node
 {
 public:
-       ColorBalanceNode(bNodeeditorNode);
-       void convertToOperations(ExecutionSystem* graph, CompositorContext * context);
+       ColorBalanceNode(bNode *editorNode);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
 
 #endif // COM_ColorBalanceNODE_H
index ac3e1285e7532289f1079887aad06611ec07a0ce..995d66fcf23b6ed1235a2f69fc2c087802ebb4b8 100644 (file)
 #include "COM_ColorCorrectionOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ColorCorrectionNode::ColorCorrectionNode(bNode *editorNode): Node(editorNode) {
+ColorCorrectionNode::ColorCorrectionNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void ColorCorrectionNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void ColorCorrectionNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        ColorCorrectionOperation *operation = new ColorCorrectionOperation();
-       bNodeeditorNode = getbNode();
+       bNode *editorNode = getbNode();
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0),true, 0, graph);
        this->getInputSocket(1)->relinkConnections(operation->getInputSocket(1),true, 1, graph);
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket(0));
index e5c35476931a7909a265e2d0c1ee983ec1f17868..46b7fe5e0bc2ae30c7e783c6d898b5a89849794d 100644 (file)
@@ -32,7 +32,7 @@
 class ColorCorrectionNode: public Node {
 public:
        ColorCorrectionNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 55837a35b59737f49a459a7024f6e4a526c0f546..a96fdf72b1133a0abc87cfe941d38fa9610dca9c 100644 (file)
 #include "COM_ColorCurveOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ColorCurveNode::ColorCurveNode(bNode *editorNode): Node(editorNode) {
+ColorCurveNode::ColorCurveNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void ColorCurveNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void ColorCurveNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        ColorCurveOperation *operation = new ColorCurveOperation();
 
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), true, 0, graph);
index aade20860c2b83b043f46134bdeea58e34150e29..264e269156610d675b225769131d7f60836c33ed 100644 (file)
@@ -32,7 +32,7 @@
 class ColorCurveNode: public Node {
 public:
        ColorCurveNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index fa00c95f50b477d5dd3f1d10a1b04630aa69da8e..e5231a48e050af716d86cf9846cac8a80cb35d45 100644 (file)
@@ -28,7 +28,8 @@
 ColorMatteNode::ColorMatteNode(bNode *editorNode): Node(editorNode)
 {}
 
-void ColorMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) {
+void ColorMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
+{
        InputSocket *inputSocketImage = this->getInputSocket(0);
        InputSocket *inputSocketKey = this->getInputSocket(1);
        OutputSocket *outputSocketImage = this->getOutputSocket(0);
@@ -38,7 +39,7 @@ void ColorMatteNode::convertToOperations(ExecutionSystem *graph, CompositorConte
        ConvertRGBToHSVOperation *operationRGBToHSV_Key = new ConvertRGBToHSVOperation();
 
        ColorMatteOperation *operation = new ColorMatteOperation();
-       bNodeeditorsnode = getbNode();
+       bNode *editorsnode = getbNode();
        operation->setSettings((NodeChroma*)editorsnode->storage);
 
        inputSocketImage->relinkConnections(operationRGBToHSV_Image->getInputSocket(0), true, 0, graph);
index 0eee305a7e6cf38d66524915d5edf42d8e91151d..f5fcb0177f7cea7559ff3c9a852f70e62f56fd28 100644 (file)
 #include "COM_SetColorOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ColorNode::ColorNode(bNode *editorNode): Node(editorNode) {
+ColorNode::ColorNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void ColorNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void ColorNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        SetColorOperation *operation = new SetColorOperation();
-       bNodeSocketsocket = this->getEditorOutputSocket(0);
+       bNodeSocket *socket = this->getEditorOutputSocket(0);
        bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA*)socket->default_value;
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket());
        operation->setChannels(dval->value);
index 6a9f30626761c35b6fe27a9d56f592fb8c889c42..937979dd961bf9f5c76c0fc4be823329079e8a84 100644 (file)
@@ -32,7 +32,7 @@
 class ColorNode: public Node {
 public:
        ColorNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index bd1b3b5a35e5c8038632a3d851055ce8ae47ad76..1873cad5d576d6c3aa47f8f5945e5d91d502b182 100644 (file)
 #include "COM_SeparateChannelOperation.h"
 #include "DNA_texture_types.h"
 
-ColorRampNode::ColorRampNode(bNodeeditorNode): Node(editorNode)
+ColorRampNode::ColorRampNode(bNode *editorNode): Node(editorNode)
 {}
 
-void ColorRampNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void ColorRampNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        InputSocket *inputSocket = this->getInputSocket(0);
        OutputSocket *outputSocket = this->getOutputSocket(0);
        OutputSocket *outputSocketAlpha = this->getOutputSocket(1);
-       bNodeeditorNode = this->getbNode();
+       bNode *editorNode = this->getbNode();
 
-       ColorRampOperation * operation = new ColorRampOperation();
+       ColorRampOperation *operation = new ColorRampOperation();
        outputSocket->relinkConnections(operation->getOutputSocket(0));
        if (outputSocketAlpha->isConnected()) {
                SeparateChannelOperation *operation2 = new SeparateChannelOperation();
index de0f2a5395e75a67253ba98b523ffc8d20ba69ce..53fff2b0d983593b7285df3201a55dfdc13cedf4 100644 (file)
@@ -32,8 +32,8 @@
 class ColorRampNode : public Node
 {
 public:
-       ColorRampNode(bNodeeditorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       ColorRampNode(bNode *editorNode);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif // COM_ColorRampNODE_H
index 5935167d88e68d06bc915745a71e60fbc1ea051a..88043653b4fca486594fac28c90434ba2e87823a 100644 (file)
 ColorSpillNode::ColorSpillNode(bNode *editorNode): Node(editorNode)
 {}
 
-void ColorSpillNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) {
+void ColorSpillNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
+{
        InputSocket *inputSocketImage = this->getInputSocket(0);
        InputSocket *inputSocketFac = this->getInputSocket(1);
        OutputSocket *outputSocketImage = this->getOutputSocket(0);
 
-       bNodeeditorsnode = getbNode();
+       bNode *editorsnode = getbNode();
 
        
        ColorSpillOperation *operation;
index a58c2e9fd1914d4833483d6dc36257644899052a..7ff7ee1c13eac175771a1a4c8595b0c54439e9ca 100644 (file)
 #include "COM_ConvertColorToBWOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ColourToBWNode::ColourToBWNode(bNode *editorNode): Node(editorNode) {
+ColourToBWNode::ColourToBWNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void ColourToBWNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void ColourToBWNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        InputSocket *colourSocket = this->getInputSocket(0);
        OutputSocket *valueSocket = this->getOutputSocket(0);
        
index bd43f207fc7e488810c14cef3946daf4a35e8c8c..a0f46ad6b6c5da07d6ec4d68499dc1e3503dfc08 100644 (file)
 #include "COM_SetValueOperation.h"
 #include "COM_ConvertHSVToRGBOperation.h"
 
-CombineHSVANode::CombineHSVANode(bNode *editorNode): CombineRGBANode(editorNode) {
+CombineHSVANode::CombineHSVANode(bNode *editorNode): CombineRGBANode(editorNode)
+{
 }
 
-void CombineHSVANode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void CombineHSVANode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        ConvertHSVToRGBOperation *operation = new ConvertHSVToRGBOperation();
        OutputSocket *outputSocket = this->getOutputSocket(0);
        if (outputSocket->isConnected()) {
index 6bef0441e5ec977a75bf68dad6056ca0f8a1a81e..d5fef1e756aaad0c899b94c7bf4afa7bdbfea71d 100644 (file)
 #include "DNA_material_types.h" // the ramp types
 
 
-CombineRGBANode::CombineRGBANode(bNode *editorNode): Node(editorNode) {
+CombineRGBANode::CombineRGBANode(bNode *editorNode): Node(editorNode)
+{
 }
 
 
-void CombineRGBANode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void CombineRGBANode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        InputSocket *inputRSocket = this->getInputSocket(0);
        InputSocket *inputGSocket = this->getInputSocket(1);
        InputSocket *inputBSocket = this->getInputSocket(2);
index bf31daf58521c114d79eca8edc31cbd10d85bfa9..ad6203ea85a121cd2a05edaa00e1bd87b7c87a63 100644 (file)
 #include "COM_CombineYCCANode.h"
 #include "COM_ConvertYCCToRGBOperation.h"
 
-CombineYCCANode::CombineYCCANode(bNode *editorNode): CombineRGBANode(editorNode) {
+CombineYCCANode::CombineYCCANode(bNode *editorNode): CombineRGBANode(editorNode)
+{
 }
 
-void CombineYCCANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) {
+void CombineYCCANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
+{
        ConvertYCCToRGBOperation *operation = new ConvertYCCToRGBOperation();
        OutputSocket *outputSocket = this->getOutputSocket(0);
 
index 3348eacc86f114edbbb956dc3afc813139af504e..ea92a40f803e31451bd0c738d4c19aa9e87fcb0d 100644 (file)
 #include "COM_CombineYUVANode.h"
 #include "COM_ConvertYUVToRGBOperation.h"
 
-CombineYUVANode::CombineYUVANode(bNode *editorNode): CombineRGBANode(editorNode) {
+CombineYUVANode::CombineYUVANode(bNode *editorNode): CombineRGBANode(editorNode)
+{
 }
 
-void CombineYUVANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) {
+void CombineYUVANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
+{
        ConvertYUVToRGBOperation *operation = new ConvertYUVToRGBOperation();
        OutputSocket *outputSocket = this->getOutputSocket(0);
        if (outputSocket->isConnected()) {
index 95db41b322c3444ab6764263c0449f0acb90e94d..57821e7fe27034bbfc8a6f7e125493e91452acf7 100644 (file)
 #include "COM_CompositorOperation.h"
 #include "COM_ExecutionSystem.h"
 
-CompositorNode::CompositorNode(bNode *editorNode): Node(editorNode) {
+CompositorNode::CompositorNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void CompositorNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void CompositorNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        InputSocket *imageSocket = this->getInputSocket(0);
        InputSocket *alphaSocket = this->getInputSocket(1);
        if (imageSocket->isConnected()) {
index 775fa1ad0fdf55f4e927236914da0c0e3e5c89b6..94139c132fb7a2b2b10e9587c938942f0faf53de 100644 (file)
 #include "COM_ConvertKeyToPremulOperation.h"
 #include "COM_ExecutionSystem.h"
 
-void ConvertAlphaNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
-       NodeOperation* operation = NULL;
-       bNode* node = this->getbNode();
+void ConvertAlphaNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
+       NodeOperation *operation = NULL;
+       bNode *node = this->getbNode();
 
        /* value hardcoded in rna_nodetree.c */
        if (node->custom1 == 1) {
index 04834a45c453c0ead657d7e35ae19962f7f25bf7..2e3fe743f4e4d4c30adff1c6f9693590ef21156b 100644 (file)
@@ -30,7 +30,7 @@
   */
 class ConvertAlphaNode: public Node {
 public:
-       ConvertAlphaNode(bNodeeditorNode) :Node(editorNode) {}
+       ConvertAlphaNode(bNode *editorNode) :Node(editorNode) {}
        void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
index 9d48922d0d659cd4a4a36a2d5083cc015b9ff87a..52329be30340c0165b8708df0532da72f93be0b5 100644 (file)
 #include "COM_CropOperation.h"
 
 
-CropNode::CropNode(bNode *editorNode) : Node(editorNode) {
+CropNode::CropNode(bNode *editorNode) : Node(editorNode)
+{
 }
 
-void CropNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
-       bNode* node = getbNode();
+void CropNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
+       bNode *node = getbNode();
        NodeTwoXYs *cropSettings = (NodeTwoXYs*)node->storage;
        bool relative = (bool)node->custom2;
        bool cropImage = (bool)node->custom1;
index a39bd47f22ac97d03cd79c2b4717f52c9ea45b3e..0bdfffc8fec7d631fe7fb4457a2e4a5552dfa7b5 100644 (file)
@@ -28,7 +28,7 @@
 class CropNode: public Node {
 public:
        CropNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 40adc3793b0dfb26026d027f7e0fd264c8ff7d6e..77f7baaef98408ed3101438681fe1cf544fd3328 100644 (file)
 #include "COM_SetValueOperation.h"
 #include "COM_GammaCorrectOperation.h"
 
-DefocusNode::DefocusNode(bNode *editorNode): Node(editorNode) {
+DefocusNode::DefocusNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        bNode *node = this->getbNode();
-       Scene *scene= (Scene*)node->id;
-       Objectcamob = (scene)? scene->camera: NULL;
+       Scene *scene = (Scene*)node->id;
+       Object *camob = (scene)? scene->camera: NULL;
        NodeDefocus *data = (NodeDefocus*)node->storage;
 
-       NodeOperationradiusOperation;
+       NodeOperation *radiusOperation;
        if (data->no_zbuf) {
                MathMultiplyOperation *multiply = new MathMultiplyOperation();
                SetValueOperation *multiplier = new SetValueOperation();
index 3d2ff7eb4de0722766855f96c78aefc02f6cf5d0..d52ee3da77b1c25529626c5047b3d7f1d4a04e65 100644 (file)
@@ -33,7 +33,7 @@
 class DefocusNode: public Node {
 public:
        DefocusNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 8327813cf05f1a30fcb88a8681fef7247a1674bb..ab6917f3a59d2823bf8e0fedd4a4fbfec23f638e 100644 (file)
 #include "COM_DifferenceMatteOperation.h"
 #include "COM_SetAlphaOperation.h"
 
-DifferenceMatteNode::DifferenceMatteNode(bNodeeditorNode): Node(editorNode)
+DifferenceMatteNode::DifferenceMatteNode(bNode *editorNode): Node(editorNode)
 {}
 
-void DifferenceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void DifferenceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        InputSocket *inputSocket = this->getInputSocket(0);
        InputSocket *inputSocket2 = this->getInputSocket(1);
        OutputSocket *outputSocketImage = this->getOutputSocket(0);
        OutputSocket *outputSocketMatte = this->getOutputSocket(1);
-       bNodeeditorNode = this->getbNode();
+       bNode *editorNode = this->getbNode();
 
        DifferenceMatteOperation * operationSet = new DifferenceMatteOperation();
        operationSet->setSettings((NodeChroma*)editorNode->storage);
index 2adce752f497e7f2322e9127d3a740cf6908390f..3b270ebc3b720a1bc3e6496e46f26c7ad699cfb8 100644 (file)
@@ -32,8 +32,8 @@
 class DifferenceMatteNode : public Node
 {
 public:
-       DifferenceMatteNode(bNodeeditorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       DifferenceMatteNode(bNode *editorNode);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif // COM_DifferenceMatteNODE_H
index 185eb6475bfb6834b17513a369108ea0d48c8738..2118f5b8e47b46759e5ce81fca9deabcb6ca2638 100644 (file)
 #include "COM_AntiAliasOperation.h"
 #include "BLI_math.h"
 
-DilateErodeNode::DilateErodeNode(bNode *editorNode): Node(editorNode) {
+DilateErodeNode::DilateErodeNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void DilateErodeNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
-       bNode* editorNode = this->getbNode();
+void DilateErodeNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
+       bNode *editorNode = this->getbNode();
        DilateErodeOperation *operation = new DilateErodeOperation();
        operation->setDistance(editorNode->custom2);
        operation->setInset(2.0f);
index 1ebf7e0b4c8162c54f2ea914f16aca9ba1c3b1fc..496bd0203dd47de617953dfeaf4d2e0766debfe8 100644 (file)
@@ -32,7 +32,7 @@
 class DilateErodeNode: public Node {
 public:
        DilateErodeNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index ef3e49180487d80c0c9f3058dd957d4ab3ffffa8..cefeffcfc07f0a97512e442099f1d8811dfbbab6 100644 (file)
 #include "COM_ExecutionSystem.h"
 #include "COM_DirectionalBlurOperation.h"
 
-DirectionalBlurNode::DirectionalBlurNode(bNode *editorNode): Node(editorNode) {
+DirectionalBlurNode::DirectionalBlurNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void DirectionalBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void DirectionalBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        NodeDBlurData *data = (NodeDBlurData*)this->getbNode()->storage;
        DirectionalBlurOperation *operation = new DirectionalBlurOperation();
        operation->setQuality(context->getQuality());
index 842e330d6d033e5901c09cea6ae5088e40147aeb..1cf36fdeae728341c41b577cb69fb944ff1208f1 100644 (file)
@@ -32,7 +32,7 @@
 class DirectionalBlurNode: public Node {
 public:
        DirectionalBlurNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index ff5dd413468c4f567fd1f362ff16b42b66d2ccc3..5fe9591bfd4b5f7e65e5a34627dfad7ae320e0d4 100644 (file)
@@ -24,7 +24,8 @@
 #include "COM_DisplaceSimpleOperation.h"
 #include "COM_ExecutionSystem.h"
 
-DisplaceNode::DisplaceNode(bNode *editorNode): Node(editorNode) {
+DisplaceNode::DisplaceNode(bNode *editorNode): Node(editorNode)
+{
 }
 
 void DisplaceNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
index c55ce803f97179afd30628a4efb4dd72bf452da7..3fc4a882eaf9fd75cf372582bb3b0186af434696 100644 (file)
 DistanceMatteNode::DistanceMatteNode(bNode *editorNode): Node(editorNode)
 {}
 
-void DistanceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) {
+void DistanceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
+{
        InputSocket *inputSocketImage = this->getInputSocket(0);
        InputSocket *inputSocketKey = this->getInputSocket(1);
        OutputSocket *outputSocketImage = this->getOutputSocket(0);
        OutputSocket *outputSocketMatte = this->getOutputSocket(1);
 
        DistanceMatteOperation *operation = new DistanceMatteOperation();
-       bNodeeditorsnode = getbNode();
+       bNode *editorsnode = getbNode();
        operation->setSettings((NodeChroma*)editorsnode->storage);
 
        inputSocketImage->relinkConnections(operation->getInputSocket(0), true, 0, graph);
index f1ec4ab9b23f808d3f1b1b6192dcd010d3914d89..1ac273a52cb8ef34d0e893505b454749252ef389 100644 (file)
 #include "DNA_scene_types.h"
 #include "COM_ExecutionSystem.h"
 
-DoubleEdgeMaskNode::DoubleEdgeMaskNode(bNode *editorNode): Node(editorNode) {
+DoubleEdgeMaskNode::DoubleEdgeMaskNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void DoubleEdgeMaskNode::convertToOperations(ExecutionSystem *system, CompositorContext * context) {
+void DoubleEdgeMaskNode::convertToOperations(ExecutionSystem *system, CompositorContext * context)
+{
        DoubleEdgeMaskOperation *operation;
-       bNodebnode = this->getbNode();
+       bNode *bnode = this->getbNode();
        
        operation = new DoubleEdgeMaskOperation();
        operation->setAdjecentOnly(bnode->custom1);
index 26d553a1422b4b1774f0d3f78af15bbc3ed8f6d9..2c52e98894667917d58786aba54ae00a88f47320 100644 (file)
@@ -32,7 +32,7 @@
 class DoubleEdgeMaskNode: public Node {
 public:
        DoubleEdgeMaskNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index 89996f0e590b916c6c171d282aaac8a52b1659e2..7e327a306b61d7e5d8362b7ab32e43b13cc07d0d 100644 (file)
 #include "COM_EllipseMaskOperation.h"
 #include "COM_ExecutionSystem.h"
 
-EllipseMaskNode::EllipseMaskNode(bNode *editorNode): Node(editorNode) {
+EllipseMaskNode::EllipseMaskNode(bNode *editorNode): Node(editorNode)
+{
 }
 
-void EllipseMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void EllipseMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        EllipseMaskOperation *operation;
        operation = new EllipseMaskOperation();
        operation->setData((NodeEllipseMask*)this->getbNode()->storage);
index 4fecf6946cc03e522b767269193862875cb297c6..be6956e30b5168962e01455336023f056b4e1b29 100644 (file)
@@ -32,7 +32,7 @@
 class EllipseMaskNode: public Node {
 public:
        EllipseMaskNode(bNode *editorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif
index f10d03913178783ee15990d9d0d3f0348905d08e..a1d405c0dffd42d735b8eef07d9084860ee08acc 100644 (file)
 #include "BKE_node.h"
 #include "COM_MixBlendOperation.h"
 
-FilterNode::FilterNode(bNodeeditorNode): Node(editorNode)
+FilterNode::FilterNode(bNode *editorNode): Node(editorNode)
 {
 }
 
-void FilterNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context) {
+void FilterNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
        InputSocket *inputSocket = this->getInputSocket(0);
        InputSocket *inputImageSocket = this->getInputSocket(1);
        OutputSocket *outputSocket = this->getOutputSocket(0);
index c77846ef2fe0203b0d2cf13a8d50e530072919ea..080682dcefe08cb1d7ab5dfb94cd5d265000cbb0 100644 (file)
@@ -32,8 +32,8 @@
 class FilterNode : public Node
 {
 public:
-       FilterNode(bNodeeditorNode);
-       void convertToOperations(ExecutionSystemgraph, CompositorContext * context);
+       FilterNode(bNode *editorNode);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext * context);
 };
 
 #endif // COM_FILTERNODE_H
index 7fbb21478ecf19073342b6c221126c27d85531f5..a4924aaae401163d16a01ccce5