Cleanup: comment block tabs
authorCampbell Barton <ideasman42@gmail.com>
Wed, 14 Nov 2018 01:53:15 +0000 (12:53 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 14 Nov 2018 06:10:56 +0000 (17:10 +1100)
584 files changed:
intern/elbeem/extern/LBM_fluidsim.h
intern/ghost/intern/GHOST_DropTargetWin32.h
intern/ghost/intern/GHOST_EventTrackpad.h
intern/ghost/intern/GHOST_SystemCocoa.h
intern/ghost/intern/GHOST_SystemX11.h
intern/ghost/intern/GHOST_Window.h
intern/ghost/intern/GHOST_WindowWin32.h
intern/smoke/intern/FLUID_3D.cpp
source/blender/blenkernel/BKE_action.h
source/blender/blenkernel/BKE_animsys.h
source/blender/blenkernel/BKE_fcurve.h
source/blender/blenkernel/BKE_shrinkwrap.h
source/blender/blenkernel/intern/action.c
source/blender/blenkernel/intern/anim.c
source/blender/blenkernel/intern/anim_sys.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/armature_update.c
source/blender/blenkernel/intern/boids.c
source/blender/blenkernel/intern/cloth.c
source/blender/blenkernel/intern/collision.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/fcurve.c
source/blender/blenkernel/intern/fmodifier.c
source/blender/blenkernel/intern/gpencil.c
source/blender/blenkernel/intern/ipo.c
source/blender/blenkernel/intern/lamp.c
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/mball_tessellate.c
source/blender/blenkernel/intern/nla.c
source/blender/blenkernel/intern/object_dupli.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenkernel/intern/rigidbody.c
source/blender/blenkernel/intern/scene.c
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenkernel/intern/shrinkwrap.c
source/blender/blenkernel/intern/smoke.c
source/blender/blenkernel/intern/softbody.c
source/blender/blenkernel/intern/text.c
source/blender/blenkernel/intern/texture.c
source/blender/blenkernel/intern/world.c
source/blender/blenlib/BLI_dlrbTree.h
source/blender/blenlib/BLI_math.h
source/blender/blenlib/intern/BLI_kdopbvh.c
source/blender/blenlib/intern/DLRB_tree.c
source/blender/blenlib/intern/math_matrix.c
source/blender/blenlib/intern/math_rotation.c
source/blender/blenloader/intern/readfile.c
source/blender/bmesh/intern/bmesh_mesh.c
source/blender/bmesh/intern/bmesh_query.c
source/blender/bmesh/intern/bmesh_structure.c
source/blender/bmesh/intern/bmesh_walkers.c
source/blender/collada/AnimationExporter.cpp
source/blender/compositor/COM_compositor.h
source/blender/compositor/COM_defines.h
source/blender/compositor/intern/COM_CPUDevice.cpp
source/blender/compositor/intern/COM_CPUDevice.h
source/blender/compositor/intern/COM_ChunkOrder.cpp
source/blender/compositor/intern/COM_ChunkOrder.h
source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp
source/blender/compositor/intern/COM_ChunkOrderHotspot.h
source/blender/compositor/intern/COM_CompositorContext.cpp
source/blender/compositor/intern/COM_CompositorContext.h
source/blender/compositor/intern/COM_Converter.cpp
source/blender/compositor/intern/COM_Converter.h
source/blender/compositor/intern/COM_Debug.cpp
source/blender/compositor/intern/COM_Debug.h
source/blender/compositor/intern/COM_Device.cpp
source/blender/compositor/intern/COM_Device.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_MemoryBuffer.cpp
source/blender/compositor/intern/COM_MemoryBuffer.h
source/blender/compositor/intern/COM_MemoryProxy.cpp
source/blender/compositor/intern/COM_MemoryProxy.h
source/blender/compositor/intern/COM_Node.cpp
source/blender/compositor/intern/COM_Node.h
source/blender/compositor/intern/COM_NodeConverter.cpp
source/blender/compositor/intern/COM_NodeConverter.h
source/blender/compositor/intern/COM_NodeGraph.cpp
source/blender/compositor/intern/COM_NodeGraph.h
source/blender/compositor/intern/COM_NodeOperation.cpp
source/blender/compositor/intern/COM_NodeOperation.h
source/blender/compositor/intern/COM_NodeOperationBuilder.cpp
source/blender/compositor/intern/COM_NodeOperationBuilder.h
source/blender/compositor/intern/COM_OpenCLDevice.cpp
source/blender/compositor/intern/COM_OpenCLDevice.h
source/blender/compositor/intern/COM_SingleThreadedOperation.cpp
source/blender/compositor/intern/COM_SingleThreadedOperation.h
source/blender/compositor/intern/COM_SocketReader.cpp
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_ChannelMatteNode.h
source/blender/compositor/nodes/COM_ChromaMatteNode.cpp
source/blender/compositor/nodes/COM_ChromaMatteNode.h
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_ColorMatteNode.h
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_ColorSpillNode.h
source/blender/compositor/nodes/COM_ColorToBWNode.cpp
source/blender/compositor/nodes/COM_ColorToBWNode.h
source/blender/compositor/nodes/COM_CombineColorNode.cpp
source/blender/compositor/nodes/COM_CombineColorNode.h
source/blender/compositor/nodes/COM_CompositorNode.cpp
source/blender/compositor/nodes/COM_CompositorNode.h
source/blender/compositor/nodes/COM_ConvertAlphaNode.cpp
source/blender/compositor/nodes/COM_ConvertAlphaNode.h
source/blender/compositor/nodes/COM_CornerPinNode.cpp
source/blender/compositor/nodes/COM_CornerPinNode.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_DisplaceNode.h
source/blender/compositor/nodes/COM_DistanceMatteNode.cpp
source/blender/compositor/nodes/COM_DistanceMatteNode.h
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_HueSaturationValueCorrectNode.cpp
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
source/blender/compositor/nodes/COM_HueSaturationValueNode.cpp
source/blender/compositor/nodes/COM_HueSaturationValueNode.h
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_InpaintNode.cpp
source/blender/compositor/nodes/COM_InpaintNode.h
source/blender/compositor/nodes/COM_InvertNode.cpp
source/blender/compositor/nodes/COM_InvertNode.h
source/blender/compositor/nodes/COM_KeyingNode.cpp
source/blender/compositor/nodes/COM_KeyingNode.h
source/blender/compositor/nodes/COM_KeyingScreenNode.cpp
source/blender/compositor/nodes/COM_KeyingScreenNode.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_LuminanceMatteNode.h
source/blender/compositor/nodes/COM_MapRangeNode.cpp
source/blender/compositor/nodes/COM_MapRangeNode.h
source/blender/compositor/nodes/COM_MapUVNode.cpp
source/blender/compositor/nodes/COM_MapUVNode.h
source/blender/compositor/nodes/COM_MapValueNode.cpp
source/blender/compositor/nodes/COM_MapValueNode.h
source/blender/compositor/nodes/COM_MaskNode.cpp
source/blender/compositor/nodes/COM_MaskNode.h
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_MixNode.h
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_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_OutputFileNode.h
source/blender/compositor/nodes/COM_PixelateNode.cpp
source/blender/compositor/nodes/COM_PixelateNode.h
source/blender/compositor/nodes/COM_PlaneTrackDeformNode.cpp
source/blender/compositor/nodes/COM_PlaneTrackDeformNode.h
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_SeparateColorNode.cpp
source/blender/compositor/nodes/COM_SeparateColorNode.h
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_SplitViewerNode.h
source/blender/compositor/nodes/COM_Stabilize2dNode.cpp
source/blender/compositor/nodes/COM_Stabilize2dNode.h
source/blender/compositor/nodes/COM_SunBeamsNode.cpp
source/blender/compositor/nodes/COM_SunBeamsNode.h
source/blender/compositor/nodes/COM_SwitchNode.cpp
source/blender/compositor/nodes/COM_SwitchNode.h
source/blender/compositor/nodes/COM_SwitchViewNode.cpp
source/blender/compositor/nodes/COM_SwitchViewNode.h
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_TrackPositionNode.cpp
source/blender/compositor/nodes/COM_TrackPositionNode.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_ViewerNode.h
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.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_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_ConvertDepthToRadiusOperation.cpp
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h
source/blender/compositor/operations/COM_ConvertOperation.cpp
source/blender/compositor/operations/COM_ConvertOperation.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_DistanceRGBMatteOperation.cpp
source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h
source/blender/compositor/operations/COM_DistanceYCCMatteOperation.cpp
source/blender/compositor/operations/COM_DistanceYCCMatteOperation.h
source/blender/compositor/operations/COM_DotproductOperation.cpp
source/blender/compositor/operations/COM_DotproductOperation.h
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h
source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
source/blender/compositor/operations/COM_EllipseMaskOperation.h
source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
source/blender/compositor/operations/COM_FlipOperation.cpp
source/blender/compositor/operations/COM_FlipOperation.h
source/blender/compositor/operations/COM_GammaCorrectOperation.cpp
source/blender/compositor/operations/COM_GammaCorrectOperation.h
source/blender/compositor/operations/COM_GammaOperation.cpp
source/blender/compositor/operations/COM_GammaOperation.h
source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h
source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h
source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianXBlurOperation.h
source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianYBlurOperation.h
source/blender/compositor/operations/COM_GlareBaseOperation.cpp
source/blender/compositor/operations/COM_GlareBaseOperation.h
source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp
source/blender/compositor/operations/COM_GlareFogGlowOperation.h
source/blender/compositor/operations/COM_GlareGhostOperation.cpp
source/blender/compositor/operations/COM_GlareGhostOperation.h
source/blender/compositor/operations/COM_GlareSimpleStarOperation.cpp
source/blender/compositor/operations/COM_GlareSimpleStarOperation.h
source/blender/compositor/operations/COM_GlareStreaksOperation.cpp
source/blender/compositor/operations/COM_GlareStreaksOperation.h
source/blender/compositor/operations/COM_GlareThresholdOperation.cpp
source/blender/compositor/operations/COM_GlareThresholdOperation.h
source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h
source/blender/compositor/operations/COM_IDMaskOperation.cpp
source/blender/compositor/operations/COM_IDMaskOperation.h
source/blender/compositor/operations/COM_ImageOperation.cpp
source/blender/compositor/operations/COM_ImageOperation.h
source/blender/compositor/operations/COM_InpaintOperation.cpp
source/blender/compositor/operations/COM_InpaintOperation.h
source/blender/compositor/operations/COM_InvertOperation.cpp
source/blender/compositor/operations/COM_InvertOperation.h
source/blender/compositor/operations/COM_KeyingBlurOperation.cpp
source/blender/compositor/operations/COM_KeyingBlurOperation.h
source/blender/compositor/operations/COM_KeyingClipOperation.cpp
source/blender/compositor/operations/COM_KeyingClipOperation.h
source/blender/compositor/operations/COM_KeyingDespillOperation.cpp
source/blender/compositor/operations/COM_KeyingDespillOperation.h
source/blender/compositor/operations/COM_KeyingOperation.cpp
source/blender/compositor/operations/COM_KeyingOperation.h
source/blender/compositor/operations/COM_KeyingScreenOperation.cpp
source/blender/compositor/operations/COM_KeyingScreenOperation.h
source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp
source/blender/compositor/operations/COM_LuminanceMatteOperation.h
source/blender/compositor/operations/COM_MapRangeOperation.cpp
source/blender/compositor/operations/COM_MapRangeOperation.h
source/blender/compositor/operations/COM_MapUVOperation.cpp
source/blender/compositor/operations/COM_MapUVOperation.h
source/blender/compositor/operations/COM_MapValueOperation.cpp
source/blender/compositor/operations/COM_MapValueOperation.h
source/blender/compositor/operations/COM_MaskOperation.cpp
source/blender/compositor/operations/COM_MaskOperation.h
source/blender/compositor/operations/COM_MathBaseOperation.cpp
source/blender/compositor/operations/COM_MathBaseOperation.h
source/blender/compositor/operations/COM_MixOperation.cpp
source/blender/compositor/operations/COM_MixOperation.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
source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cpp
source/blender/compositor/operations/COM_OutputFileMultiViewOperation.h
source/blender/compositor/operations/COM_OutputFileOperation.cpp
source/blender/compositor/operations/COM_OutputFileOperation.h
source/blender/compositor/operations/COM_PixelateOperation.cpp
source/blender/compositor/operations/COM_PixelateOperation.h
source/blender/compositor/operations/COM_PlaneCornerPinOperation.cpp
source/blender/compositor/operations/COM_PlaneCornerPinOperation.h
source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cpp
source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h
source/blender/compositor/operations/COM_PlaneTrackOperation.cpp
source/blender/compositor/operations/COM_PlaneTrackOperation.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_RenderLayersProg.cpp
source/blender/compositor/operations/COM_RenderLayersProg.h
source/blender/compositor/operations/COM_RotateOperation.cpp
source/blender/compositor/operations/COM_RotateOperation.h
source/blender/compositor/operations/COM_ScaleOperation.cpp
source/blender/compositor/operations/COM_ScaleOperation.h
source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp
source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h
source/blender/compositor/operations/COM_SetAlphaOperation.cpp
source/blender/compositor/operations/COM_SetAlphaOperation.h
source/blender/compositor/operations/COM_SetColorOperation.cpp
source/blender/compositor/operations/COM_SetColorOperation.h
source/blender/compositor/operations/COM_SetSamplerOperation.cpp
source/blender/compositor/operations/COM_SetSamplerOperation.h
source/blender/compositor/operations/COM_SetValueOperation.cpp
source/blender/compositor/operations/COM_SetValueOperation.h
source/blender/compositor/operations/COM_SetVectorOperation.cpp
source/blender/compositor/operations/COM_SetVectorOperation.h
source/blender/compositor/operations/COM_SocketProxyOperation.cpp
source/blender/compositor/operations/COM_SocketProxyOperation.h
source/blender/compositor/operations/COM_SplitOperation.cpp
source/blender/compositor/operations/COM_SplitOperation.h
source/blender/compositor/operations/COM_SunBeamsOperation.cpp
source/blender/compositor/operations/COM_SunBeamsOperation.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_TrackPositionOperation.cpp
source/blender/compositor/operations/COM_TrackPositionOperation.h
source/blender/compositor/operations/COM_TranslateOperation.cpp
source/blender/compositor/operations/COM_TranslateOperation.h
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h
source/blender/compositor/operations/COM_VectorBlurOperation.cpp
source/blender/compositor/operations/COM_VectorBlurOperation.h
source/blender/compositor/operations/COM_VectorCurveOperation.cpp
source/blender/compositor/operations/COM_VectorCurveOperation.h
source/blender/compositor/operations/COM_ViewerOperation.cpp
source/blender/compositor/operations/COM_ViewerOperation.h
source/blender/compositor/operations/COM_WrapOperation.cpp
source/blender/compositor/operations/COM_WrapOperation.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/animation/anim_channels_defines.c
source/blender/editors/animation/anim_channels_edit.c
source/blender/editors/animation/anim_deps.c
source/blender/editors/animation/anim_draw.c
source/blender/editors/animation/anim_filter.c
source/blender/editors/animation/anim_intern.h
source/blender/editors/animation/anim_ipo_utils.c
source/blender/editors/animation/anim_ops.c
source/blender/editors/animation/drivers.c
source/blender/editors/animation/fmodifier_ui.c
source/blender/editors/animation/keyframes_draw.c
source/blender/editors/animation/keyframes_edit.c
source/blender/editors/animation/keyframes_general.c
source/blender/editors/animation/keyframing.c
source/blender/editors/animation/keyingsets.c
source/blender/editors/armature/armature_add.c
source/blender/editors/armature/armature_edit.c
source/blender/editors/armature/armature_relations.c
source/blender/editors/armature/pose_group.c
source/blender/editors/armature/pose_lib.c
source/blender/editors/armature/pose_select.c
source/blender/editors/armature/pose_slide.c
source/blender/editors/armature/pose_transform.c
source/blender/editors/armature/pose_utils.c
source/blender/editors/gpencil/drawgpencil.c
source/blender/editors/gpencil/editaction_gpencil.c
source/blender/editors/gpencil/gpencil_brush.c
source/blender/editors/gpencil/gpencil_convert.c
source/blender/editors/gpencil/gpencil_edit.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/gpencil/gpencil_select.c
source/blender/editors/gpencil/gpencil_undo.c
source/blender/editors/gpencil/gpencil_utils.c
source/blender/editors/include/ED_anim_api.h
source/blender/editors/include/ED_armature.h
source/blender/editors/include/ED_keyframes_edit.h
source/blender/editors/include/ED_keyframing.h
source/blender/editors/include/UI_view2d.h
source/blender/editors/interface/interface_ops.c
source/blender/editors/interface/interface_panel.c
source/blender/editors/interface/interface_templates.c
source/blender/editors/interface/view2d.c
source/blender/editors/interface/view2d_ops.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/object/object_constraint.c
source/blender/editors/space_action/action_draw.c
source/blender/editors/space_action/action_edit.c
source/blender/editors/space_action/action_select.c
source/blender/editors/space_graph/graph_buttons.c
source/blender/editors/space_graph/graph_draw.c
source/blender/editors/space_graph/graph_edit.c
source/blender/editors/space_graph/graph_ops.c
source/blender/editors/space_graph/graph_select.c
source/blender/editors/space_graph/graph_utils.c
source/blender/editors/space_graph/space_graph.c
source/blender/editors/space_nla/nla_buttons.c
source/blender/editors/space_nla/nla_channels.c
source/blender/editors/space_nla/nla_draw.c
source/blender/editors/space_nla/nla_edit.c
source/blender/editors/space_nla/nla_ops.c
source/blender/editors/space_nla/nla_select.c
source/blender/editors/space_outliner/outliner_draw.c
source/blender/editors/space_outliner/outliner_edit.c
source/blender/editors/space_outliner/outliner_tree.c
source/blender/editors/space_sequencer/sequencer_add.c
source/blender/editors/space_time/space_time.c
source/blender/editors/space_view3d/drawanimviz.c
source/blender/editors/space_view3d/drawarmature.c
source/blender/editors/space_view3d/drawmesh.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_generics.c
source/blender/gpu/GPU_texture.h
source/blender/gpu/intern/gpu_codegen.h
source/blender/imbuf/intern/filter.c
source/blender/imbuf/intern/iris.c
source/blender/imbuf/intern/jpeg.c
source/blender/imbuf/intern/scaling.c
source/blender/makesdna/DNA_action_types.h
source/blender/makesdna/DNA_anim_types.h
source/blender/makesdna/DNA_constraint_types.h
source/blender/makesdna/DNA_gpencil_types.h
source/blender/makesdna/intern/makesdna.c
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_color.c
source/blender/makesrna/intern/rna_dynamicpaint.c
source/blender/makesrna/intern/rna_fcurve.c
source/blender/makesrna/intern/rna_key.c
source/blender/makesrna/intern/rna_nla.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_space.c
source/blender/modifiers/intern/MOD_mask.c
source/blender/render/intern/raytrace/rayobject_internal.h
source/blender/render/intern/raytrace/rayobject_rtbuild.h
source/blender/render/intern/raytrace/reorganize.h
source/blender/render/intern/source/render_texture.c
source/gameengine/Expressions/EXP_BoolValue.h
source/gameengine/Expressions/EXP_Value.h
source/gameengine/GameLogic/SCA_KeyboardSensor.cpp
source/gameengine/Ketsji/KX_Dome.cpp
source/gameengine/Ketsji/KX_KetsjiEngine.cpp
source/gameengine/Ketsji/KX_MouseFocusSensor.cpp
source/gameengine/Ketsji/KX_RadarSensor.cpp
source/gameengine/Network/NG_NetworkScene.h
source/gameengine/SceneGraph/SG_Spatial.h

index 374e11d..05ac143 100644 (file)
@@ -1,7 +1,4 @@
 /*
- * BKE_fluidsim.h 
- *     
- *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -44,5 +41,3 @@ int performElbeemSimulation(char *cfgfilename);
 
 
 #endif
-
-
index 3d7be45..5dcefca 100644 (file)
@@ -60,7 +60,7 @@ public:
         *  - Determining the effect of the drop on the target application.
         *  - Incorporating any valid dropped data when the drop occurs.
         *  - Communicating target feedback to the source so the source application
-        *        can provide appropriate visual feedback such as setting the cursor.
+        *    can provide appropriate visual feedback such as setting the cursor.
         *  - Implementing drag scrolling.
         *  - Registering and revoking its application windows as drop targets.
         *
index faf0f16..2598809 100644 (file)
@@ -20,8 +20,8 @@
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s):  James Deery                11/2009
- *                                     Damien Plisson  12/2009
+ * Contributor(s): James Deery     11/2009
+ *                 Damien Plisson  12/2009
  *
  * ***** END GPL LICENSE BLOCK *****
  */
index d31df79..146fa84 100644 (file)
@@ -20,8 +20,8 @@
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s):     Maarten Gribnau 05/2001
- *                                     Damien Plisson 09/2009
+ * Contributor(s): Maarten Gribnau 05/2001
+ *                 Damien Plisson 09/2009
  *
  * ***** END GPL LICENSE BLOCK *****
  */
index 3a65ff2..e9312ce 100644 (file)
@@ -149,16 +149,16 @@ public:
         * Create a new window.
         * The new window is added to the list of windows managed.
         * Never explicitly delete the window, use disposeWindow() instead.
-        * \param       title   The name of the window (displayed in the title bar of the window if the OS supports it).
-        * \param       left            The coordinate of the left edge of the window.
-        * \param       top             The coordinate of the top edge of the window.
-        * \param       width           The width the window.
-        * \param       height          The height the window.
-        * \param       state           The state of the window when opened.
-        * \param       type            The type of drawing context installed in this window.
-        * \param       stereoVisual    Create a stereo visual for quad buffered stereo.
-        * \param       exclusive       Use to show the window ontop and ignore others
-        *                                              (used fullscreen).
+        * \param   title   The name of the window (displayed in the title bar of the window if the OS supports it).
+        * \param   left        The coordinate of the left edge of the window.
+        * \param   top     The coordinate of the top edge of the window.
+        * \param   width       The width the window.
+        * \param   height      The height the window.
+        * \param   state       The state of the window when opened.
+        * \param   type        The type of drawing context installed in this window.
+        * \param   stereoVisual    Create a stereo visual for quad buffered stereo.
+        * \param   exclusive   Use to show the window ontop and ignore others
+        *                      (used fullscreen).
         * \param       parentWindow    Parent (embedder) window
         * \return      The new window (or 0 if creation failed).
         */
index 59d3123..2fa3004 100644 (file)
@@ -55,14 +55,14 @@ public:
         * Constructor.
         * Creates a new window and opens it.
         * To check if the window was created properly, use the getValid() method.
-        * \param width                         The width the window.
-        * \param heigh                         The height the window.
-        * \param state                         The state the window is initially opened with.
-        * \param type                          The type of drawing context installed in this window.
-        * \param stereoVisual          Stereo visual for quad buffered stereo.
-        * \param exclusive                     Use to show the window ontop and ignore others
-        *                                                      (used fullscreen).
-        * \param numOfAASamples        Number of samples used for AA (zero if no AA)
+        * \param width             The width the window.
+        * \param heigh             The height the window.
+        * \param state             The state the window is initially opened with.
+        * \param type              The type of drawing context installed in this window.
+        * \param stereoVisual      Stereo visual for quad buffered stereo.
+        * \param exclusive         Use to show the window ontop and ignore others
+        *                          (used fullscreen).
+        * \param numOfAASamples    Number of samples used for AA (zero if no AA)
         */
        GHOST_Window(
            GHOST_TUns32 width,
index 9907385..8b0ba2f 100644 (file)
@@ -225,10 +225,10 @@ public:
         * capturing).
         *
         * \param press
-        *              0 - mouse pressed
-        *              1 - mouse released
-        *              2 - operator grab
-        *              3 - operator ungrab
+        *      0 - mouse pressed
+        *      1 - mouse released
+        *      2 - operator grab
+        *      3 - operator ungrab
         */
        void registerMouseClickEvent(int press);
 
index 8a27818..fd0a7e2 100644 (file)
@@ -38,7 +38,7 @@
 
 #if PARALLEL==1
 #include <omp.h>
-#endif // PARALLEL 
+#endif // PARALLEL
 
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
@@ -51,13 +51,13 @@ FLUID_3D::FLUID_3D(int *res, float dx, float dtdef, int init_heat, int init_fire
        _dt = dtdef;    // just in case. set in step from a RNA factor
 
        _iterations = 100;
-       _tempAmb = 0; 
+       _tempAmb = 0;
        _heatDiffusion = 1e-3;
        _totalTime = 0.0f;
        _totalSteps = 0;
        _res = Vec3Int(_xRes,_yRes,_zRes);
        _maxRes = MAX3(_xRes, _yRes, _zRes);
-       
+
        // initialize wavelet turbulence
        /*
        if(amplify)
@@ -65,7 +65,7 @@ FLUID_3D::FLUID_3D(int *res, float dx, float dtdef, int init_heat, int init_fire
        else
                _wTurbulence = NULL;
        */
-       
+
        // scale the constants according to the refinement of the grid
        if (!dx)
                _dx = 1.0f / (float)_maxRes;
@@ -218,7 +218,7 @@ void FLUID_3D::initColors(float init_r, float init_g, float init_b)
 
 void FLUID_3D::setBorderObstacles()
 {
-       
+
        // set side obstacles
        unsigned int index;
        for (int y = 0; y < _yRes; y++)
@@ -331,7 +331,7 @@ void FLUID_3D::step(float dt, float gravity[3])
        // If border rules have been changed
        if (_colloPrev != *_borderColli) {
                printf("Border collisions changed\n");
-               
+
                // DG TODO: Need to check that no animated obstacle flags are overwritten
                setBorderCollisions();
        }
@@ -490,7 +490,7 @@ void FLUID_3D::step(float dt, float gravity[3])
        for (int i=1; i<stepParts; i++)
        {
                int zPos=(int)((float)i*partSize + 0.5f);
-               
+
                artificialDampingExactSL(zPos);
 
        }
@@ -620,7 +620,7 @@ void FLUID_3D::artificialDampingSL(int zBegin, int zEnd) {
 void FLUID_3D::artificialDampingExactSL(int pos) {
        const float w = 0.9;
        int index, x,y,z;
-       
+
 
        size_t posslab;
 
@@ -650,7 +650,7 @@ void FLUID_3D::artificialDampingExactSL(int pos) {
                                                        _zVelocityTemp[index+1] + _zVelocityTemp[index-1] +
                                                        _zVelocityTemp[index+_res[0]] + _zVelocityTemp[index-_res[0]] +
                                                        _zVelocityTemp[index+_slabSize] + _zVelocityTemp[index-_slabSize] );
-                                       
+
                                }
        }
 
@@ -677,7 +677,7 @@ void FLUID_3D::artificialDampingExactSL(int pos) {
                                                        _zVelocityTemp[index+1] + _zVelocityTemp[index-1] +
                                                        _zVelocityTemp[index+_res[0]] + _zVelocityTemp[index-_res[0]] +
                                                        _zVelocityTemp[index+_slabSize] + _zVelocityTemp[index-_slabSize] );
-                                       
+
                                }
 
        }
@@ -759,7 +759,7 @@ void FLUID_3D::wipeBoundaries(int zBegin, int zEnd)
 
 void FLUID_3D::wipeBoundariesSL(int zBegin, int zEnd)
 {
-       
+
        /////////////////////////////////////
        // setZeroBorder to all:
        /////////////////////////////////////
@@ -933,16 +933,16 @@ void FLUID_3D::project()
 
        memset(_pressure, 0, sizeof(float)*_totalCells);
        memset(_divergence, 0, sizeof(float)*_totalCells);
-       
+
        // set velocity and pressure inside of obstacles to zero
        setObstacleBoundaries(_pressure, 0, _zRes);
-       
+
        // copy out the boundaries
        if(!_domainBcLeft)  setNeumannX(_xVelocity, _res, 0, _zRes);
-       else setZeroX(_xVelocity, _res, 0, _zRes); 
+       else setZeroX(_xVelocity, _res, 0, _zRes);
 
        if(!_domainBcFront)   setNeumannY(_yVelocity, _res, 0, _zRes);
-       else setZeroY(_yVelocity, _res, 0, _zRes); 
+       else setZeroY(_yVelocity, _res, 0, _zRes);
 
        if(!_domainBcTop) setNeumannZ(_zVelocity, _res, 0, _zRes);
        else setZeroZ(_zVelocity, _res, 0, _zRes);
@@ -953,13 +953,13 @@ void FLUID_3D::project()
                for (y = 1; y < _yRes - 1; y++, index += 2)
                        for (x = 1; x < _xRes - 1; x++, index++)
                        {
-                               
+
                                if(_obstacles[index])
                                {
                                        _divergence[index] = 0.0f;
                                        continue;
                                }
-                               
+
 
                                float xright = _xVelocity[index + 1];
                                float xleft  = _xVelocity[index - 1];
@@ -1058,7 +1058,7 @@ void FLUID_3D::project()
 //////////////////////////////////////////////////////////////////////
 void FLUID_3D::setObstacleVelocity(int zBegin, int zEnd)
 {
-       
+
        // completely TODO <-- who wrote this and what is here TODO? DG
 
        const size_t index_ = _slabSize + _xRes + 1;
@@ -1082,7 +1082,7 @@ void FLUID_3D::setObstacleVelocity(int zBegin, int zEnd)
                {
                        if (!_obstacles[index])
                        {
-                               // if(_obstacles[index+1]) xright = - _xVelocityOb[index]; 
+                               // if(_obstacles[index+1]) xright = - _xVelocityOb[index];
                                if((_obstacles[index - 1] & 8) && abs(_xVelocityOb[index - 1]) > FLT_EPSILON )
                                {
                                        // printf("velocity x!\n");
@@ -1221,7 +1221,7 @@ void FLUID_3D::setObstaclePressure(float *_pressure, int zBegin, int zEnd)
                                        _pressure[index] += _pressure[index + _slabSize];
                                        pcnt += 1.0f;
                                }
-                               
+
                                if(pcnt > 0.000001f)
                                        _pressure[index] /= pcnt;
 
@@ -1254,7 +1254,7 @@ void FLUID_3D::setObstacleBoundaries(float *_pressure, int zBegin, int zEnd)
        for (int z = zBegin + bb; z < zEnd - bt; z++)
        {
                size_t index = index_ +(z-1)*_slabSize;
-               
+
                for (int y = 1; y < _yRes - 1; y++, index += 2)
                {
                        for (int x = 1; x < _xRes - 1; x++, index++)
@@ -1563,7 +1563,7 @@ void FLUID_3D::addVorticity(int zBegin, int zEnd)
 
        // calculate normalized vorticity vectors
        float eps = _vorticityEps;
-       
+
        //index = _slabSize + _xRes + 1;
        vIndex=_slabSize + _xRes + 1;
 
@@ -1618,7 +1618,7 @@ void FLUID_3D::addVorticity(int zBegin, int zEnd)
                                }               // y loop
                        //vIndex+=2*_xRes;
                }                               // z loop
-                               
+
        if (_xVorticity) delete[] _xVorticity;
        if (_yVorticity) delete[] _yVorticity;
        if (_zVorticity) delete[] _zVorticity;
@@ -1704,10 +1704,10 @@ void FLUID_3D::advectMacCormackEnd2(int zBegin, int zEnd)
 
        /* set boundary conditions for velocity */
        if(!_domainBcLeft) copyBorderX(_xVelocityTemp, res, zBegin, zEnd);
-       else setZeroX(_xVelocityTemp, res, zBegin, zEnd);                               
+       else setZeroX(_xVelocityTemp, res, zBegin, zEnd);
 
        if(!_domainBcFront) copyBorderY(_yVelocityTemp, res, zBegin, zEnd);
-       else setZeroY(_yVelocityTemp, res, zBegin, zEnd); 
+       else setZeroY(_yVelocityTemp, res, zBegin, zEnd);
 
        if(!_domainBcTop) copyBorderZ(_zVelocityTemp, res, zBegin, zEnd);
        else setZeroZ(_zVelocityTemp, res, zBegin, zEnd);
@@ -1778,9 +1778,9 @@ void FLUID_3D::updateFlame(float *react, float *flame, int total_cells)
        for (int index = 0; index < total_cells; index++)
        {
                /* model flame temperature curve from the reaction coordinate (fuel)
-                *      TODO: Would probably be best to get rid of whole "flame" data field.
-                *               Currently it's just sqrt mirror of reaction coordinate, and therefore
-                *               basically just waste of memory and disk space...
+                *  TODO: Would probably be best to get rid of whole "flame" data field.
+                *        Currently it's just sqrt mirror of reaction coordinate, and therefore
+                *        basically just waste of memory and disk space...
                 */
                if (react[index]>0.0f) {
                        /* do a smooth falloff for rest of the values */
index b627e3f..f1858fc 100644 (file)
@@ -19,7 +19,7 @@
  * All rights reserved.
  *
  * Contributor(s): Full recode, Ton Roosendaal, Crete 2005
- *                              Full recode, Joshua Leung, 2009
+ *                 Full recode, Joshua Leung, 2009
  *
  * ***** END GPL LICENSE BLOCK *****
  */
@@ -70,7 +70,7 @@ void BKE_action_make_local(struct Main *bmain, struct bAction *act, const bool l
 /* Action API ----------------- */
 
 /* types of transforms applied to the given item
- *  - these are the return flags for action_get_item_transforms()
+ * - these are the return flags for action_get_item_transforms()
  */
 typedef enum eAction_TransformFlags {
        /* location */
@@ -94,8 +94,8 @@ typedef enum eAction_TransformFlags {
 } eAction_TransformFlags;
 
 /* Return flags indicating which transforms the given object/posechannel has
- *     - if 'curves' is provided, a list of links to these curves are also returned
- *       whose nodes WILL NEED FREEING
+ * - if 'curves' is provided, a list of links to these curves are also returned
+ *   whose nodes WILL NEED FREEING
  */
 short action_get_item_transforms(struct bAction *act, struct Object *ob, struct bPoseChannel *pchan, ListBase *curves);
 
index 5cce1e0..40b4bf8 100644 (file)
@@ -190,7 +190,7 @@ bool BKE_animsys_execute_fcurve(struct PointerRNA *ptr, struct AnimMapper *remap
  * for standard animation evaluation UNDER ANY CIRCUMSTANCES!
  *
  * i.e. Pose Library (PoseLib) uses some of these for selectively applying poses, but
- *         Particles/Sequencer performing funky time manipulation is not ok.
+ *      Particles/Sequencer performing funky time manipulation is not ok.
  */
 
 /* Evaluate Action (F-Curve Bag) */
index 1dfcfd5..055a3d4 100644 (file)
@@ -122,8 +122,8 @@ typedef struct GHash FModifierStackStorage;
  *  as some constraints don't define some of these.
  *
  *  Warning: it is not too advisable to reorder order of members of this struct,
- *                     as you'll have to edit quite a few ($FMODIFIER_NUM_TYPES) of these
- *                     structs.
+ *           as you'll have to edit quite a few ($FMODIFIER_NUM_TYPES) of these
+ *           structs.
  */
 typedef struct FModifierTypeInfo {
        /* admin/ident */
@@ -230,7 +230,7 @@ struct FCurve *iter_step_fcurve(struct FCurve *fcu_iter, const char rna_path[]);
 struct FCurve *id_data_find_fcurve(ID *id, void *data, struct StructRNA *type, const char *prop_name, int index, bool *r_driven);
 
 /* Get list of LinkData's containing pointers to the F-Curves which control the types of data indicated
- *     e.g.  numMatches = list_find_data_fcurves(matches, &act->curves, "pose.bones[", "MyFancyBone");
+ * e.g.  numMatches = list_find_data_fcurves(matches, &act->curves, "pose.bones[", "MyFancyBone");
  */
 int list_find_data_fcurves(ListBase *dst, ListBase *src, const char *dataPrefix, const char *dataName);
 
@@ -291,8 +291,8 @@ float calculate_fcurve(struct PathResolvedRNA *anim_rna, struct FCurve *fcu, flo
 /* -------- Defines --------  */
 
 /* Basic signature for F-Curve sample-creation function
- *     - fcu: the F-Curve being operated on
- *     - data: pointer to some specific data that may be used by one of the callbacks
+ * - fcu: the F-Curve being operated on
+ * - data: pointer to some specific data that may be used by one of the callbacks
  */
 typedef float (*FcuSampleFunc)(struct FCurve *fcu, void *data, float evaltime);
 
index 31b4b5c..2dd42a9 100644 (file)
@@ -38,9 +38,9 @@
  * Shrinkwrap is composed by a set of functions and options that define the type of shrink.
  *
  * 3 modes are available:
- *    - Nearest vertex
- *       - Nearest surface
- *    - Normal projection
+ * - Nearest vertex
+ * - Nearest surface
+ * - Normal projection
  *
  * ShrinkwrapCalcData encapsulates all needed data for shrinkwrap functions.
  * (So that you don't have to pass an enormous amount of arguments to functions)
index 00e5d17..7612e9a 100644 (file)
@@ -19,7 +19,7 @@
  * All rights reserved.
  *
  * Contributor(s): Full recode, Ton Roosendaal, Crete 2005
- *                              Full recode, Joshua Leung, 2009
+ *                 Full recode, Joshua Leung, 2009
  *
  * ***** END GPL LICENSE BLOCK *****
  */
@@ -263,8 +263,8 @@ bActionGroup *action_groups_add_new(bAction *act, const char name[])
 }
 
 /* Add given channel into (active) group
- *     - assumes that channel is not linked to anything anymore
- *     - always adds at the end of the group
+ * - assumes that channel is not linked to anything anymore
+ * - always adds at the end of the group
  */
 void action_groups_add_channel(bAction *act, bActionGroup *agrp, FCurve *fcurve)
 {
@@ -309,8 +309,8 @@ void action_groups_add_channel(bAction *act, bActionGroup *agrp, FCurve *fcurve)
                for (grp = agrp->prev; grp; grp = grp->prev) {
                        /* if this group has F-Curves, we want weave the given one in right after the last channel there,
                         * but via the Action's list not this group's list
-                        *      - this is so that the F-Curve is in the right place in the Action,
-                        *        but won't be included in the previous group
+                        * - this is so that the F-Curve is in the right place in the Action,
+                        *   but won't be included in the previous group
                         */
                        if (grp->channels.last) {
                                /* once we've added, break here since we don't need to search any further... */
@@ -1063,8 +1063,8 @@ void BKE_pose_remove_group(bPose *pose, bActionGroup *grp, const int index)
        BLI_assert(idx > 0);
 
        /* adjust group references (the trouble of using indices!):
-        *  - firstly, make sure nothing references it
-        *  - also, make sure that those after this item get corrected
+        * - firstly, make sure nothing references it
+        * - also, make sure that those after this item get corrected
         */
        for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
                if (pchan->agrp_index == idx)
@@ -1147,7 +1147,7 @@ void calc_action_range(const bAction *act, float *start, float *end, short incl_
                        }
 
                        /* if incl_modifiers is enabled, need to consider modifiers too
-                        *      - only really care about the last modifier
+                        * - only really care about the last modifier
                         */
                        if ((incl_modifiers) && (fcu->modifiers.last)) {
                                FModifier *fcm = fcu->modifiers.last;
@@ -1203,7 +1203,7 @@ void calc_action_range(const bAction *act, float *start, float *end, short incl_
 }
 
 /* Return flags indicating which transforms the given object/posechannel has
- *     - if 'curves' is provided, a list of links to these curves are also returned
+ * - if 'curves' is provided, a list of links to these curves are also returned
  */
 short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan, ListBase *curves)
 {
@@ -1226,7 +1226,7 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
                return 0;
 
        /* search F-Curves for the given properties
-        *      - we cannot use the groups, since they may not be grouped in that way...
+        * - we cannot use the groups, since they may not be grouped in that way...
         */
        for (fcu = act->curves.first; fcu; fcu = fcu->next) {
                const char *bPtr = NULL, *pPtr = NULL;
@@ -1249,11 +1249,11 @@ short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan,
                        bPtr += strlen(basePath);
 
                        /* step 2: check for some property with transforms
-                        *      - to speed things up, only check for the ones not yet found
-                        *    unless we're getting the curves too
-                        *      - if we're getting the curves, the BLI_genericNodeN() creates a LinkData
-                        *        node wrapping the F-Curve, which then gets added to the list
-                        *      - once a match has been found, the curve cannot possibly be any other one
+                        * - to speed things up, only check for the ones not yet found
+                        *   unless we're getting the curves too
+                        * - if we're getting the curves, the BLI_genericNodeN() creates a LinkData
+                        *   node wrapping the F-Curve, which then gets added to the list
+                        * - once a match has been found, the curve cannot possibly be any other one
                         */
                        if ((curves) || (flags & ACT_TRANS_LOC) == 0) {
                                pPtr = strstr(bPtr, "location");
index e35af19..d5f269b 100644 (file)
@@ -235,7 +235,7 @@ typedef struct MPathTarget {
 /* ........ */
 
 /* get list of motion paths to be baked for the given object
- *  - assumes the given list is ready to be used
+ * - assumes the given list is ready to be used
  */
 /* TODO: it would be nice in future to be able to update objects dependent on these bones too? */
 void animviz_get_object_motionpaths(Object *ob, ListBase *targets)
@@ -349,9 +349,9 @@ static void motionpaths_calc_update_scene(Main *bmain, Scene *scene)
        }
 #else // original, 'always correct' version
        /* do all updates
-        *  - if this is too slow, resort to using a more efficient way
-        *    that doesn't force complete update, but for now, this is the
-        *    most accurate way!
+        * - if this is too slow, resort to using a more efficient way
+        *   that doesn't force complete update, but for now, this is the
+        *   most accurate way!
         */
        BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, scene->lay); /* XXX this is the best way we can get anything moving */
 #endif
@@ -370,7 +370,7 @@ static void motionpaths_calc_bake_targets(Scene *scene, ListBase *targets)
                bMotionPathVert *mpv;
 
                /* current frame must be within the range the cache works for
-                *      - is inclusive of the first frame, but not the last otherwise we get buffer overruns
+                * - is inclusive of the first frame, but not the last otherwise we get buffer overruns
                 */
                if ((CFRA < mpath->start_frame) || (CFRA >= mpath->end_frame))
                        continue;
@@ -399,9 +399,9 @@ static void motionpaths_calc_bake_targets(Scene *scene, ListBase *targets)
 }
 
 /* Perform baking of the given object's and/or its bones' transforms to motion paths
- *     - scene: current scene
- *     - ob: object whose flagged motionpaths should get calculated
- *     - recalc: whether we need to
+ * - scene: current scene
+ * - ob: object whose flagged motionpaths should get calculated
+ * - recalc: whether we need to
  */
 /* TODO: include reports pointer? */
 void animviz_calc_motionpaths(Main *bmain, Scene *scene, ListBase *targets)
@@ -474,7 +474,7 @@ void free_path(Path *path)
 }
 
 /* calculate a curve-deform path for a curve
- *  - only called from displist.c -> do_makeDispListCurveTypes
+ * - only called from displist.c -> do_makeDispListCurveTypes
  */
 void calc_curvepath(Object *ob, ListBase *nurbs)
 {
index 05cb10a..b17bc70 100644 (file)
@@ -422,8 +422,8 @@ static bool animpath_matches_basepath(const char path[], const char basepath[])
 /* Move F-Curves in src action to dst action, setting up all the necessary groups
  * for this to happen, but only if the F-Curves being moved have the appropriate
  * "base path".
- *     - This is used when data moves from one datablock to another, causing the
- *       F-Curves to need to be moved over too
+ * - This is used when data moves from one datablock to another, causing the
+ *   F-Curves to need to be moved over too
  */
 void action_move_fcurves_by_basepath(bAction *srcAct, bAction *dstAct, const char basepath[])
 {
@@ -449,7 +449,7 @@ void action_move_fcurves_by_basepath(bAction *srcAct, bAction *dstAct, const cha
                fcn = fcu->next;
 
                /* should F-Curve be moved over?
-                *      - we only need the start of the path to match basepath
+                * - we only need the start of the path to match basepath
                 */
                if (animpath_matches_basepath(fcu->rna_path, basepath)) {
                        bActionGroup *agrp = NULL;
@@ -1188,8 +1188,8 @@ void BKE_animdata_fix_paths_rename_all(ID *ref_id, const char *prefix, const cha
        ID *id;
 
        /* macro for less typing
-        *      - whether animdata exists is checked for by the main renaming callback, though taking
-        *        this outside of the function may make things slightly faster?
+        * - whether animdata exists is checked for by the main renaming callback, though taking
+        *   this outside of the function may make things slightly faster?
         */
 #define RENAMEFIX_ANIM_IDS(first) \
        for (id = first; id; id = id->next) { \
@@ -1465,7 +1465,7 @@ void BKE_keyingsets_free(ListBase *list)
                return;
 
        /* loop over KeyingSets freeing them
-        *  - BKE_keyingset_free() doesn't free the set itself, but it frees its sub-data
+        * - BKE_keyingset_free() doesn't free the set itself, but it frees its sub-data
         */
        for (ks = list->first; ks; ks = ksn) {
                ksn = ks->next;
@@ -1481,9 +1481,9 @@ void BKE_keyingsets_free(ListBase *list)
  * It returns whether the string needs to be freed (i.e. if it was a temp remapped one)
  * // FIXME: maybe it would be faster if we didn't have to alloc/free strings like this all the time, but for now it's safer
  *
- *     - remap: remapping table to use
- *     - path: original path string (as stored in F-Curve data)
- *     - dst: destination string to write data to
+ * - remap: remapping table to use
+ * - path: original path string (as stored in F-Curve data)
+ * - dst: destination string to write data to
  */
 static bool animsys_remap_path(AnimMapper *UNUSED(remap), char *path, char **dst)
 {
@@ -1781,8 +1781,8 @@ static void action_idcode_patch_check(ID *id, bAction *act)
        /* the actual checks... hopefully not too much of a performance hit in the long run... */
        if (act->idroot == 0) {
                /* use the current root if not set already (i.e. newly created actions and actions from 2.50-2.57 builds)
-                *  - this has problems if there are 2 users, and the first one encountered is the invalid one
-                *        in which case, the user will need to manually fix this (?)
+                * - this has problems if there are 2 users, and the first one encountered is the invalid one
+                *   in which case, the user will need to manually fix this (?)
                 */
                act->idroot = idcode;
        }
@@ -1878,8 +1878,8 @@ static void nlastrip_evaluate_controls(NlaStrip *strip, float ctime)
        }
 
        /* analytically generate values for influence and time (if applicable)
-        *  - we do this after the F-Curves have been evaluated to override the effects of those
-        *    in case the override has been turned off.
+        * - we do this after the F-Curves have been evaluated to override the effects of those
+        *   in case the override has been turned off.
         */
        if ((strip->flag & NLASTRIP_FLAG_USR_TIME) == 0)
                strip->strip_time = nlastrip_get_frame(strip, ctime, NLATIME_CONVERT_EVAL);
@@ -1925,8 +1925,8 @@ NlaEvalStrip *nlastrips_ctime_get_strip(ListBase *list, ListBase *strips, short
                        else {
                                /* before next strip - previous strip has ended, but next hasn't begun,
                                 * so blending mode depends on whether strip is being held or not...
-                                *  - only occurs when no transition strip added, otherwise the transition would have
-                                *    been picked up above...
+                                * - only occurs when no transition strip added, otherwise the transition would have
+                                *   been picked up above...
                                 */
                                strip = strip->prev;
 
@@ -1953,7 +1953,7 @@ NlaEvalStrip *nlastrips_ctime_get_strip(ListBase *list, ListBase *strips, short
        }
 
        /* check if a valid strip was found
-        *      - must not be muted (i.e. will have contribution
+        * - must not be muted (i.e. will have contribution
         */
        if ((estrip == NULL) || (estrip->flag & NLASTRIP_FLAG_MUTED))
                return NULL;
@@ -1969,8 +1969,8 @@ NlaEvalStrip *nlastrips_ctime_get_strip(ListBase *list, ListBase *strips, short
        }
 
        /* evaluate strip's evaluation controls
-        *  - skip if no influence (i.e. same effect as muting the strip)
-        *      - negative influence is not supported yet... how would that be defined?
+        * - skip if no influence (i.e. same effect as muting the strip)
+        * - negative influence is not supported yet... how would that be defined?
         */
        /* TODO: this sounds a bit hacky having a few isolated F-Curves stuck on some data it operates on... */
        nlastrip_evaluate_controls(estrip, ctime);
@@ -2014,7 +2014,7 @@ NlaEvalStrip *nlastrips_ctime_get_strip(ListBase *list, ListBase *strips, short
 /* ---------------------- */
 
 /* find an NlaEvalChannel that matches the given criteria
- *     - ptr and prop are the RNA data to find a match for
+ * - ptr and prop are the RNA data to find a match for
  */
 static NlaEvalChannel *nlaevalchan_find_match(ListBase *channels, PointerRNA *ptr, PropertyRNA *prop, int array_index)
 {
@@ -2029,7 +2029,7 @@ static NlaEvalChannel *nlaevalchan_find_match(ListBase *channels, PointerRNA *pt
                /* - comparing the PointerRNA's is done by comparing the pointers
                 *   to the actual struct the property resides in, since that all the
                 *   other data stored in PointerRNA cannot allow us to definitively
-                *      identify the data
+                *   identify the data
                 */
                if ((nec->ptr.data == ptr->data) && (nec->prop == prop) && (nec->index == array_index))
                        return nec;
@@ -2176,8 +2176,8 @@ static void nlaevalchan_accumulate(NlaEvalChannel *nec, NlaEvalStrip *nes, float
                case NLASTRIP_MODE_REPLACE:
                default: /* TODO: do we really want to blend by default? it seems more uses might prefer add... */
                        /* do linear interpolation
-                        *      - the influence of the accumulated data (elsewhere, that is called dstweight)
-                        *        is 1 - influence, since the strip's influence is srcweight
+                        * - the influence of the accumulated data (elsewhere, that is called dstweight)
+                        *   is 1 - influence, since the strip's influence is srcweight
                         */
                        nec->value = nec->value * (1.0f - inf)   +   (value * inf);
                        break;
@@ -2238,7 +2238,7 @@ static void nlaeval_fmodifiers_join_stacks(ListBase *result, ListBase *list1, Li
        }
        else {
                /* list1 should be added first, and list2 second, with the endpoints of these being the endpoints for result
-                *  - the original lists must be left unchanged though, as we need that fact for restoring
+                * - the original lists must be left unchanged though, as we need that fact for restoring
                 */
                result->first = list1->first;
                result->last = list2->last;
@@ -2350,11 +2350,11 @@ static void nlastrip_evaluate_transition(PointerRNA *ptr, ListBase *channels, Li
        nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &nes->strip->modifiers, modifiers);
 
        /* get the two strips to operate on
-        *      - we use the endpoints of the strips directly flanking our strip
-        *        using these as the endpoints of the transition (destination and source)
-        *      - these should have already been determined to be valid...
-        *      - if this strip is being played in reverse, we need to swap these endpoints
-        *        otherwise they will be interpolated wrong
+        * - we use the endpoints of the strips directly flanking our strip
+        *   using these as the endpoints of the transition (destination and source)
+        * - these should have already been determined to be valid...
+        * - if this strip is being played in reverse, we need to swap these endpoints
+        *   otherwise they will be interpolated wrong
         */
        if (nes->strip->flag & NLASTRIP_FLAG_REVERSE) {
                s1 = nes->strip->next;
@@ -2366,11 +2366,11 @@ static void nlastrip_evaluate_transition(PointerRNA *ptr, ListBase *channels, Li
        }
 
        /* prepare template for 'evaluation strip'
-        *      - based on the transition strip's evaluation strip data
-        *      - strip_mode is NES_TIME_TRANSITION_* based on which endpoint
-        *      - strip_time is the 'normalized' (i.e. in-strip) time for evaluation,
-        *        which doubles up as an additional weighting factor for the strip influences
-        *        which allows us to appear to be 'interpolating' between the two extremes
+        * - based on the transition strip's evaluation strip data
+        * - strip_mode is NES_TIME_TRANSITION_* based on which endpoint
+        * - strip_time is the 'normalized' (i.e. in-strip) time for evaluation,
+        *   which doubles up as an additional weighting factor for the strip influences
+        *   which allows us to appear to be 'interpolating' between the two extremes
         */
        tmp_nes = *nes;
 
@@ -2551,7 +2551,7 @@ static void animsys_evaluate_nla(ListBase *echannels, PointerRNA *ptr, AnimData
                }
 
                /* if this track has strips (but maybe they won't be suitable), set has_strips
-                *      - used for mainly for still allowing normal action evaluation...
+                * - used for mainly for still allowing normal action evaluation...
                 */
                if (nlt->strips.first)
                        has_strips = true;
@@ -2562,9 +2562,9 @@ static void animsys_evaluate_nla(ListBase *echannels, PointerRNA *ptr, AnimData
        }
 
        /* add 'active' Action (may be tweaking track) as last strip to evaluate in NLA stack
-        *      - only do this if we're not exclusively evaluating the 'solo' NLA-track
-        *      - however, if the 'solo' track houses the current 'tweaking' strip,
-        *        then we should allow this to play, otherwise nothing happens
+        * - only do this if we're not exclusively evaluating the 'solo' NLA-track
+        * - however, if the 'solo' track houses the current 'tweaking' strip,
+        *   then we should allow this to play, otherwise nothing happens
         */
        if ((adt->action) && ((adt->flag & ADT_NLA_SOLO_TRACK) == 0 || (adt->flag & ADT_NLA_EDIT_ON))) {
                /* if there are strips, evaluate action as per NLA rules */
@@ -2636,8 +2636,8 @@ static void animsys_evaluate_nla(ListBase *echannels, PointerRNA *ptr, AnimData
 }
 
 /* NLA Evaluation function (mostly for use through do_animdata)
- *     - All channels that will be affected are not cleared anymore. Instead, we just evaluate into
- *             some temp channels, where values can be accumulated in one go.
+ * - All channels that will be affected are not cleared anymore. Instead, we just evaluate into
+ *   some temp channels, where values can be accumulated in one go.
  */
 static void animsys_calculate_nla(PointerRNA *ptr, AnimData *adt, float ctime)
 {
@@ -2690,34 +2690,34 @@ static void animsys_evaluate_overrides(PointerRNA *ptr, AnimData *adt)
 /* Evaluation System - Public API */
 
 /* Overview of how this system works:
- *     1) Depsgraph sorts data as necessary, so that data is in an order that means
- *             that all dependencies are resolved before dependents.
- *     2) All normal animation is evaluated, so that drivers have some basis values to
- *             work with
- *             a.      NLA stacks are done first, as the Active Actions act as 'tweaking' tracks
- *                     which modify the effects of the NLA-stacks
- *             b.      Active Action is evaluated as per normal, on top of the results of the NLA tracks
+ * 1) Depsgraph sorts data as necessary, so that data is in an order that means
+ *     that all dependencies are resolved before dependents.
+ * 2) All normal animation is evaluated, so that drivers have some basis values to
+ *    work with
+ *    a.  NLA stacks are done first, as the Active Actions act as 'tweaking' tracks
+ *        which modify the effects of the NLA-stacks
+ *    b.  Active Action is evaluated as per normal, on top of the results of the NLA tracks
  *
  * --------------< often in a separate phase... >------------------
  *
- *     3) Drivers/expressions are evaluated on top of this, in an order where dependencies are
- *             resolved nicely.
- *        Note: it may be necessary to have some tools to handle the cases where some higher-level
- *             drivers are added and cause some problematic dependencies that didn't exist in the local levels...
+ * 3) Drivers/expressions are evaluated on top of this, in an order where dependencies are
+ *    resolved nicely.
+ *    Note: it may be necessary to have some tools to handle the cases where some higher-level
+ *          drivers are added and cause some problematic dependencies that didn't exist in the local levels...
  *
  * --------------< always executed >------------------
  *
  * Maintenance of editability of settings (XXX):
- *     In order to ensure that settings that are animated can still be manipulated in the UI without requiring
- *     that keyframes are added to prevent these values from being overwritten, we use 'overrides'.
+ *  In order to ensure that settings that are animated can still be manipulated in the UI without requiring
+ *  that keyframes are added to prevent these values from being overwritten, we use 'overrides'.
  *
  * Unresolved things:
- *     - Handling of multi-user settings (i.e. time-offset, group-instancing) -> big cache grids or nodal system? but stored where?
- *     - Multiple-block dependencies (i.e. drivers for settings are in both local and higher levels) -> split into separate lists?
+ * - Handling of multi-user settings (i.e. time-offset, group-instancing) -> big cache grids or nodal system? but stored where?
+ * - Multiple-block dependencies (i.e. drivers for settings are in both local and higher levels) -> split into separate lists?
  *
  * Current Status:
- *     - Currently (as of September 2009), overrides we haven't needed to (fully) implement overrides.
- *    However, the code for this is relatively harmless, so is left in the code for now.
+ * - Currently (as of September 2009), overrides we haven't needed to (fully) implement overrides.
+ *   However, the code for this is relatively harmless, so is left in the code for now.
  */
 
 /* Evaluation loop for evaluation animation data
@@ -2738,15 +2738,15 @@ void BKE_animsys_evaluate_animdata(Scene *scene, ID *id, AnimData *adt, float ct
        RNA_id_pointer_create(id, &id_ptr);
 
        /* recalculate keyframe data:
-        *      - NLA before Active Action, as Active Action behaves as 'tweaking track'
-        *        that overrides 'rough' work in NLA
+        * - NLA before Active Action, as Active Action behaves as 'tweaking track'
+        *   that overrides 'rough' work in NLA
         */
        /* TODO: need to double check that this all works correctly */
        if ((recalc & ADT_RECALC_ANIM) || (adt->recalc & ADT_RECALC_ANIM)) {
                /* evaluate NLA data */
                if ((adt->nla_tracks.first) && !(adt->flag & ADT_NLA_EVAL_OFF)) {
                        /* evaluate NLA-stack
-                        *      - active action is evaluated as part of the NLA stack as the last item
+                        * - active action is evaluated as part of the NLA stack as the last item
                         */
                        animsys_calculate_nla(&id_ptr, adt, ctime);
                }
@@ -2759,9 +2759,9 @@ void BKE_animsys_evaluate_animdata(Scene *scene, ID *id, AnimData *adt, float ct
        }
 
        /* recalculate drivers
-        *      - Drivers need to be evaluated afterwards, as they can either override
-        *        or be layered on top of existing animation data.
-        *      - Drivers should be in the appropriate order to be evaluated without problems...
+        * - Drivers need to be evaluated afterwards, as they can either override
+        *   or be layered on top of existing animation data.
+        * - Drivers should be in the appropriate order to be evaluated without problems...
         */
        if ((recalc & ADT_RECALC_DRIVERS)
            /* XXX for now, don't check yet, as depsgraph hasn't been updated */
@@ -2771,10 +2771,10 @@ void BKE_animsys_evaluate_animdata(Scene *scene, ID *id, AnimData *adt, float ct
        }
 
        /* always execute 'overrides'
-        *      - Overrides allow editing, by overwriting the value(s) set from animation-data, with the
-        *        value last set by the user (and not keyframed yet).
-        *      - Overrides are cleared upon frame change and/or keyframing
-        *      - It is best that we execute this every time, so that no errors are likely to occur.
+        * - Overrides allow editing, by overwriting the value(s) set from animation-data, with the
+        *   value last set by the user (and not keyframed yet).
+        * - Overrides are cleared upon frame change and/or keyframing
+        * - It is best that we execute this every time, so that no errors are likely to occur.
         */
        animsys_evaluate_overrides(&id_ptr, adt);
 
@@ -2804,9 +2804,9 @@ void BKE_animsys_evaluate_all_animation(Main *main, Scene *scene, float ctime)
                printf("Evaluate all animation - %f\n", ctime);
 
        /* macros for less typing
-        *      - only evaluate animation data for id if it has users (and not just fake ones)
-        *      - whether animdata exists is checked for by the evaluation function, though taking
-        *        this outside of the function may make things slightly faster?
+        * - only evaluate animation data for id if it has users (and not just fake ones)
+        * - whether animdata exists is checked for by the evaluation function, though taking
+        *   this outside of the function may make things slightly faster?
         */
 #define EVAL_ANIM_IDS(first, aflag) \
        for (id = first; id; id = id->next) { \
@@ -2817,10 +2817,10 @@ void BKE_animsys_evaluate_all_animation(Main *main, Scene *scene, float ctime)
        } (void)0
 
        /* another macro for the "embedded" nodetree cases
-        *      - this is like EVAL_ANIM_IDS, but this handles the case "embedded nodetrees"
-        *        (i.e. scene/material/texture->nodetree) which we need a special exception
-        *    for, otherwise they'd get skipped
-        *      - ntp = "node tree parent" = datablock where node tree stuff resides
+        * - this is like EVAL_ANIM_IDS, but this handles the case "embedded nodetrees"
+        *   (i.e. scene/material/texture->nodetree) which we need a special exception
+        *   for, otherwise they'd get skipped
+        * - ntp = "node tree parent" = datablock where node tree stuff resides
         */
 #define EVAL_ANIM_NODETREE_IDS(first, NtId_Type, aflag) \
        for (id = first; id; id = id->next) { \
index 2eded2e..4ad9e9c 100644 (file)
@@ -295,12 +295,12 @@ int bone_autoside_name(char name[MAXBONENAME], int UNUSED(strip_number), short a
        BLI_strncpy(basename, name, sizeof(basename));
 
        /* Figure out extension to append:
-        *      - The extension to append is based upon the axis that we are working on.
-        *      - If head happens to be on 0, then we must consider the tail position as well to decide
-        *        which side the bone is on
-        *              -> If tail is 0, then it's bone is considered to be on axis, so no extension should be added
-        *              -> Otherwise, extension is added from perspective of object based on which side tail goes to
-        *      - If head is non-zero, extension is added from perspective of object based on side head is on
+        * - The extension to append is based upon the axis that we are working on.
+        * - If head happens to be on 0, then we must consider the tail position as well to decide
+        *   which side the bone is on
+        *   -> If tail is 0, then it's bone is considered to be on axis, so no extension should be added
+        *   -> Otherwise, extension is added from perspective of object based on which side tail goes to
+        * - If head is non-zero, extension is added from perspective of object based on side head is on
         */
        if (axis == 2) {
                /* z-axis - vertical (top/bottom) */
@@ -350,8 +350,8 @@ int bone_autoside_name(char name[MAXBONENAME], int UNUSED(strip_number), short a
        }
 
        /* Simple name truncation
-        *      - truncate if there is an extension and it wouldn't be able to fit
-        *      - otherwise, just append to end
+        * - truncate if there is an extension and it wouldn't be able to fit
+        * - otherwise, just append to end
         */
        if (extension[0]) {
                bool changed = true;
@@ -2314,8 +2314,8 @@ void BKE_pose_where_is(Scene *scene, Object *ob)
                BIK_initialize_tree(scene, ob, ctime);
 
                /* 2b. construct the Spline IK trees
-                *  - this is not integrated as an IK plugin, since it should be able
-                *        to function in conjunction with standard IK
+                * - this is not integrated as an IK plugin, since it should be able
+                *   to function in conjunction with standard IK
                 */
                BKE_pose_splineik_init_tree(scene, ob, ctime);
 
index cb4237f..241a842 100644 (file)
@@ -160,7 +160,7 @@ static void splineik_init_tree_from_pchan(Scene *scene, Object *UNUSED(ob), bPos
                 */
                for (i = 0; i < segcount; i++) {
                        /* 'head' joints, traveling towards the root of the chain
-                        *  - 2 methods; the one chosen depends on whether we've got usable lengths
+                        * - 2 methods; the one chosen depends on whether we've got usable lengths
                         */
                        if ((ikData->flag & CONSTRAINT_SPLINEIK_EVENSPLITS) || (totLength == 0.0f)) {
                                /* 1) equi-spaced joints */
@@ -363,7 +363,7 @@ static void splineik_evaluate_bone(tSplineIK_Tree *tree, Scene *scene, Object *o
                rangle *= tree->con->enforce;
 
                /* construct rotation matrix from the axis-angle rotation found above
-                *      - this call takes care to make sure that the axis provided is a unit vector first
+                * - this call takes care to make sure that the axis provided is a unit vector first
                 */
                axis_angle_to_mat3(dmat, raxis, rangle);
 
@@ -486,8 +486,8 @@ static void splineik_evaluate_bone(tSplineIK_Tree *tree, Scene *scene, Object *o
        }
        else if (tree->con->enforce < 1.0f) {
                /* when the influence is too low
-                *      - blend the positions for the 'root' bone
-                *      - stick to the parent for any other
+                * - blend the positions for the 'root' bone
+                * - stick to the parent for any other
                 */
                if (pchan->parent) {
                        copy_v3_v3(poseHead, pchan->pose_head);
@@ -604,8 +604,8 @@ void BKE_pose_eval_init_ik(EvaluationContext *UNUSED(eval_ctx),
        /* construct the IK tree (standard IK) */
        BIK_initialize_tree(scene, ob, ctime);
        /* construct the Spline IK trees
-        *  - this is not integrated as an IK plugin, since it should be able
-        *    to function in conjunction with standard IK
+        * - this is not integrated as an IK plugin, since it should be able
+        *   to function in conjunction with standard IK
         */
        BKE_pose_splineik_init_tree(scene, ob, ctime);
 }
index 10f7a3b..810056f 100644 (file)
@@ -1282,8 +1282,8 @@ void boid_body(BoidBrainData *bbd, ParticleData *pa)
 
        /* integrate new location & velocity */
 
-       /* by regarding the acceleration as a force at this stage we*/
-       /* can get better control although it's a bit unphysical        */
+       /* by regarding the acceleration as a force at this stage we
+        * can get better control although it's a bit unphysical */
        mul_v3_fl(acc, 1.0f/pa_mass);
 
        copy_v3_v3(dvec, acc);
index 22fdcb9..88d4766 100644 (file)
@@ -1439,13 +1439,13 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
                        }
                }
                else {
-                       /* bending springs for hair strands */
-                       /* The current algorithm only goes through the edges in order of the mesh edges list    */
-                       /* and makes springs between the outer vert of edges sharing a vertice. This works just */
-                       /* fine for hair, but not for user generated string meshes. This could/should be later  */
-                       /* extended to work with non-ordered edges so that it can be used for general "rope             */
-                       /* dynamics" without the need for the vertices or edges to be ordered through the length*/
-                       /* of the strands. -jahka */
+                       /* bending springs for hair strands
+                        * The current algorithm only goes through the edges in order of the mesh edges list
+                        * and makes springs between the outer vert of edges sharing a vertice. This works just
+                        * fine for hair, but not for user generated string meshes. This could/should be later
+                        * extended to work with non-ordered edges so that it can be used for general "rope
+                        * dynamics" without the need for the vertices or edges to be ordered through the length
+                        * of the strands. -jahka */
                        search = cloth->springs;
                        search2 = search->next;
                        while (search && search2) {
index 1df749e..84490ba 100644 (file)
@@ -1062,9 +1062,11 @@ BLI_INLINE bool cloth_point_face_collision_params(const float p1[3], const float
 
        *r_lambda = f * dot_v3v3(edge2, q);
        /* don't care about 0..1 lambda range here */
-       /*if ((*r_lambda < 0.0f) || (*r_lambda > 1.0f))
-        *      return 0;
-        */
+#if 0
+       if ((*r_lambda < 0.0f) || (*r_lambda > 1.0f)) {
+               return 0;
+       }
+#endif
 
        r_w[0] = 1.0f - u - v;
        r_w[1] = u;
index 2f3a18c..66147c4 100644 (file)
@@ -452,10 +452,10 @@ static void contarget_get_mesh_mat(Object *ob, const char *substring, float mat[
 
 
                        /* derive the rotation from the average normal:
-                        *              - code taken from transform_manipulator.c,
-                        *                      calc_manipulator_stats, V3D_MANIP_NORMAL case
+                        * - code taken from transform_manipulator.c,
+                        *   calc_manipulator_stats, V3D_MANIP_NORMAL case
                         */
-                       /*      we need the transpose of the inverse for a normal... */
+                       /* we need the transpose of the inverse for a normal... */
                        copy_m3_m4(imat, ob->obmat);
 
                        invert_m3_m3(tmat, imat);
@@ -543,7 +543,7 @@ static void contarget_get_lattice_mat(Object *ob, const char *substring, float m
 /* The cases where the target can be object data have not been implemented */
 static void constraint_target_to_mat4(Object *ob, const char *substring, float mat[4][4], short from, short to, short flag, float headtail)
 {
-       /*      Case OBJECT */
+       /* Case OBJECT */
        if (substring[0] == '\0') {
                copy_m4_m4(mat, ob->obmat);
                BKE_constraint_mat_convertspace(ob, NULL, mat, from, to, false);
@@ -555,7 +555,7 @@ static void constraint_target_to_mat4(Object *ob, const char *substring, float m
         * 'average' vertex normal, and deriving the rotation from that.
         *
         * NOTE: EditMode is not currently supported, and will most likely remain that
-        *              way as constraints can only really affect things on object/bone level.
+        *       way as constraints can only really affect things on object/bone level.
         */
        else if (ob->type == OB_MESH) {
                contarget_get_mesh_mat(ob, substring, mat);
@@ -565,7 +565,7 @@ static void constraint_target_to_mat4(Object *ob, const char *substring, float m
                contarget_get_lattice_mat(ob, substring, mat);
                BKE_constraint_mat_convertspace(ob, NULL, mat, from, to, false);
        }
-       /*      Case BONE */
+       /* Case BONE */
        else {
                bPoseChannel *pchan;
 
@@ -659,15 +659,15 @@ static void constraint_target_to_mat4(Object *ob, const char *substring, float m
  */
 
 /* Template for type-info data:
- *  - make a copy of this when creating new constraints, and just change the functions
- *    pointed to as necessary
- *  - although the naming of functions doesn't matter, it would help for code
- *    readability, to follow the same naming convention as is presented here
- *  - any functions that a constraint doesn't need to define, don't define
- *    for such cases, just use NULL
- *  - these should be defined after all the functions have been defined, so that
- *    forward-definitions/prototypes don't need to be used!
- *     - keep this copy #if-def'd so that future constraints can get based off this
+ * - make a copy of this when creating new constraints, and just change the functions
+ *   pointed to as necessary
+ * - although the naming of functions doesn't matter, it would help for code
+ *   readability, to follow the same naming convention as is presented here
+ * - any functions that a constraint doesn't need to define, don't define
+ *   for such cases, just use NULL
+ * - these should be defined after all the functions have been defined, so that
+ *   forward-definitions/prototypes don't need to be used!
+ * - keep this copy #if-def'd so that future constraints can get based off this
  */
 #if 0
 static bConstraintTypeInfo CTI_CONSTRNAME = {
@@ -1257,7 +1257,7 @@ static void followpath_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstra
                unit_m4(ct->matrix);
 
                /* note: when creating constraints that follow path, the curve gets the CU_PATH set now,
-                *              currently for paths to work it needs to go through the bevlist/displist system (ton)
+                * currently for paths to work it needs to go through the bevlist/displist system (ton)
                 */
 
 #ifdef CYCLIC_DEPENDENCY_WORKAROUND
@@ -2163,9 +2163,9 @@ static void actcon_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstraintT
 
                /* determine where in transform range target is */
                /* data->type is mapped as follows for backwards compatibility:
-                *      00,01,02        - rotation (it used to be like this)
-                *  10,11,12    - scaling
-                *      20,21,22        - location
+                * 00,01,02 - rotation (it used to be like this)
+                * 10,11,12 - scaling
+                * 20,21,22 - location
                 */
                if (data->type < 10) {
                        /* extract rotation (is in whatever space target should be in) */
@@ -2209,7 +2209,7 @@ static void actcon_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstraintT
                        bPoseChannel *pchan, *tchan;
 
                        /* make a copy of the bone of interest in the temp pose before evaluating action, so that it can get set
-                        *      - we need to manually copy over a few settings, including rotation order, otherwise this fails
+                        * - we need to manually copy over a few settings, including rotation order, otherwise this fails
                         */
                        pchan = cob->pchan;
 
@@ -2764,12 +2764,14 @@ static void stretchto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
                normalize_v3_v3(zz, cob->matrix[2]);
 
                /* XXX That makes the constraint buggy with asymmetrically scaled objects, see #29940. */
-/*             sub_v3_v3v3(vec, cob->matrix[3], ct->matrix[3]);*/
-/*             vec[0] /= size[0];*/
-/*             vec[1] /= size[1];*/
-/*             vec[2] /= size[2];*/
+#if 0
+               sub_v3_v3v3(vec, cob->matrix[3], ct->matrix[3]);
+               vec[0] /= size[0];
+               vec[1] /= size[1];
+               vec[2] /= size[2];
 
-/*             dist = normalize_v3(vec);*/
+               dist = normalize_v3(vec);
+#endif
 
                dist = len_v3v3(cob->matrix[3], ct->matrix[3]);
                /* Only Y constrained object axis scale should be used, to keep same length when scaling it. */
@@ -3678,9 +3680,9 @@ static void damptrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
                float rmat[3][3], tmat[4][4];
 
                /* find the (unit) direction that the axis we're interested in currently points
-                *      - mul_mat3_m4_v3() only takes the 3x3 (rotation+scaling) components of the 4x4 matrix
-                *      - the normalization step at the end should take care of any unwanted scaling
-                *        left over in the 3x3 matrix we used
+                * - mul_mat3_m4_v3() only takes the 3x3 (rotation+scaling) components of the 4x4 matrix
+                * - the normalization step at the end should take care of any unwanted scaling
+                *   left over in the 3x3 matrix we used
                 */
                copy_v3_v3(obvec, track_dir_vecs[data->trackflag]);
                mul_mat3_m4_v3(cob->matrix, obvec);
@@ -3703,11 +3705,11 @@ static void damptrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
 
                /* determine the axis-angle rotation, which represents the smallest possible rotation
                 * between the two rotation vectors (i.e. the 'damping' referred to in the name)
-                *      - we take this to be the rotation around the normal axis/vector to the plane defined
-                *        by the current and destination vectors, which will 'map' the current axis to the
-                *        destination vector
-                *      - the min/max wrappers around (obvec . tarvec) result (stored temporarily in rangle)
-                *        are used to ensure that the smallest angle is chosen
+                * - we take this to be the rotation around the normal axis/vector to the plane defined
+                *   by the current and destination vectors, which will 'map' the current axis to the
+                *   destination vector
+                * - the min/max wrappers around (obvec . tarvec) result (stored temporarily in rangle)
+                *   are used to ensure that the smallest angle is chosen
                 */
                cross_v3_v3v3_hi_prec(raxis, obvec, tarvec);
 
@@ -3715,15 +3717,15 @@ static void damptrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
                rangle = acosf(max_ff(-1.0f, min_ff(1.0f, rangle)));
 
                /* construct rotation matrix from the axis-angle rotation found above
-                *      - this call takes care to make sure that the axis provided is a unit vector first
+                * - this call takes care to make sure that the axis provided is a unit vector first
                 */
                float norm = normalize_v3(raxis);
 
                if (norm < FLT_EPSILON) {
                        /* if dot product is nonzero, while cross is zero, we have two opposite vectors!
-                        *  - this is an ambiguity in the math that needs to be resolved arbitrarily,
-                        *    or there will be a case where damped track strangely does nothing
-                        *  - to do that, rotate around a different local axis
+                        * - this is an ambiguity in the math that needs to be resolved arbitrarily,
+                        *   or there will be a case where damped track strangely does nothing
+                        * - to do that, rotate around a different local axis
                         */
                        float tmpvec[3];
 
@@ -4970,13 +4972,13 @@ void BKE_constraint_targets_for_solving_get(bConstraint *con, bConstraintOb *cob
                bConstraintTarget *ct;
 
                /* get targets
-                *  - constraints should use ct->matrix, not directly accessing values
-                *      - ct->matrix members have not yet been calculated here!
+                * - constraints should use ct->matrix, not directly accessing values
+                * - ct->matrix members have not yet been calculated here!
                 */
                cti->get_constraint_targets(con, targets);
 
                /* set matrices
-                *  - calculate if possible, otherwise just initialize as identity matrix
+                * - calculate if possible, otherwise just initialize as identity matrix
                 */
                if (cti->get_target_matrix) {
                        for (ct = targets->first; ct; ct = ct->next)
@@ -5021,7 +5023,7 @@ void BKE_constraints_solve(ListBase *conlist, bConstraintOb *cob, float ctime)
                if (con->enforce == 0.0f) continue;
 
                /* influence of constraint
-                *  - value should have been set from animation data already
+                * - value should have been set from animation data already
                 */
                enf = con->enforce;
 
@@ -5038,8 +5040,8 @@ void BKE_constraints_solve(ListBase *conlist, bConstraintOb *cob, float ctime)
                cti->evaluate_constraint(con, cob, &targets);
 
                /* clear targets after use
-                *      - this should free temp targets but no data should be copied back
-                *        as constraints may have done some nasty things to it...
+                * - this should free temp targets but no data should be copied back
+                *   as constraints may have done some nasty things to it...
                 */
                if (cti->flush_constraint_targets) {
                        cti->flush_constraint_targets(con, &targets, 1);
@@ -5050,9 +5052,9 @@ void BKE_constraints_solve(ListBase *conlist, bConstraintOb *cob, float ctime)
                        BKE_constraint_mat_convertspace(cob->ob, cob->pchan, cob->matrix, con->ownspace, CONSTRAINT_SPACE_WORLD, false);
 
                /* Interpolate the enforcement, to blend result of constraint into final owner transform
-                *  - all this happens in worldspace to prevent any weirdness creeping in ([#26014] and [#25725]),
-                *    since some constraints may not convert the solution back to the input space before blending
-                *    but all are guaranteed to end up in good "worldspace" result
+                * - all this happens in worldspace to prevent any weirdness creeping in ([#26014] and [#25725]),
+                *   since some constraints may not convert the solution back to the input space before blending
+                *   but all are guaranteed to end up in good "worldspace" result
                 */
                /* Note: all kind of stuff here before (caused trouble), much easier to just interpolate,
                 * or did I miss something? -jahka (r.32105) */
index 661c802..e129251 100644 (file)
 #include "BKE_pointcache.h"
 #include "BKE_scene.h"
 
-/* for image output    */
+/* for image output */
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
-/* to read material/texture color      */
+/* to read material/texture color */
 #include "RE_render_ext.h"
 #include "RE_shader_ext.h"
 
@@ -90,7 +90,7 @@
 //#  pragma GCC diagnostic ignored "-Wdouble-promotion"
 #endif
 
-/* precalculated gaussian factors for 5x super sampling        */
+/* precalculated gaussian factors for 5x super sampling */
 static const float gaussianFactors[5] = {
     0.996849f,
     0.596145f,
@@ -169,7 +169,7 @@ typedef struct BakeAdjPoint {
        float dist;     /* distance to */
 } BakeAdjPoint;
 
-/* Surface data used while processing a frame  */
+/* Surface data used while processing a frame */
 typedef struct PaintBakeNormal {
        float invNorm[3];  /* current pixel world-space inverted normal */
        float normal_scale;  /* normal directional scale for displace mapping */
@@ -201,7 +201,7 @@ typedef struct PaintBakeData {
        int clear;              /* flag to check if surface was cleared/reset -> have to redo velocity etc. */
 } PaintBakeData;
 
-/* UV Image sequence format point      */
+/* UV Image sequence format point */
 typedef struct PaintUVPoint {
        /* Pixel / mesh data */
        unsigned int tri_index, pixel_index;    /* tri index on domain derived mesh */
@@ -1132,7 +1132,7 @@ bool dynamicPaint_createType(struct DynamicPaintModifierData *pmd, int type, str
                                if (!brush->paint_ramp)
                                        return false;
                                ramp = brush->paint_ramp->data;
-                               /* Add default smooth-falloff ramp.     */
+                               /* Add default smooth-falloff ramp. */
                                ramp[0].r = ramp[0].g = ramp[0].b = ramp[0].a = 1.0f;
                                ramp[0].pos = 0.0f;
                                ramp[1].r = ramp[1].g = ramp[1].b = ramp[1].pos = 1.0f;
@@ -1163,14 +1163,14 @@ bool dynamicPaint_createType(struct DynamicPaintModifierData *pmd, int type, str
 
 void dynamicPaint_Modifier_copy(const struct DynamicPaintModifierData *pmd, struct DynamicPaintModifierData *tpmd)
 {
-       /* Init modifier        */
+       /* Init modifier */
        tpmd->type = pmd->type;
        if (pmd->canvas)
                dynamicPaint_createType(tpmd, MOD_DYNAMICPAINT_TYPE_CANVAS, NULL);
        if (pmd->brush)
                dynamicPaint_createType(tpmd, MOD_DYNAMICPAINT_TYPE_BRUSH, NULL);
 
-       /* Copy data    */
+       /* Copy data */
        if (tpmd->canvas) {
                DynamicPaintSurface *surface;
                tpmd->canvas->pmd = tpmd;
@@ -1880,7 +1880,7 @@ static void dynamic_paint_apply_surface_wave_cb(
 }
 
 /*
- *     Apply canvas data to the object derived mesh
+ * Apply canvas data to the object derived mesh
  */
 static DerivedMesh *dynamicPaint_Modifier_apply(
         DynamicPaintModifierData *pmd, Object *ob, DerivedMesh *dm)
@@ -2070,7 +2070,7 @@ static void canvas_copyDerivedMesh(DynamicPaintCanvasSettings *canvas, DerivedMe
 }
 
 /*
- *     Updates derived mesh copy and processes dynamic paint step / caches.
+ * Updates derived mesh copy and processes dynamic paint step / caches.
  */
 static void dynamicPaint_frameUpdate(
         Main *bmain, EvaluationContext *eval_ctx, DynamicPaintModifierData *pmd, Scene *scene, Object *ob, DerivedMesh *dm)
@@ -2182,7 +2182,7 @@ DerivedMesh *dynamicPaint_Modifier_do(Main *bmain,
 /***************************** Image Sequence / UV Image Surface Calls ******************************/
 
 /*
- *     Create a surface for uv image sequence format
+ * Create a surface for uv image sequence format
  */
 #define JITTER_SAMPLES { \
        0.0f, 0.0f, \
@@ -2240,7 +2240,7 @@ static void dynamic_paint_create_uv_surface_direct_cb(
                tPoint->neighbour_pixel = -1;
                tPoint->pixel_index = index;
 
-               /* Actual pixel center, used when collision is found    */
+               /* Actual pixel center, used when collision is found */
                point[0][0] = ((float)tx + 0.5f) / w;
                point[0][1] = ((float)ty + 0.5f) / h;
 
@@ -2261,12 +2261,12 @@ static void dynamic_paint_create_uv_surface_direct_cb(
                point[4][1] = ((float)ty + 1) / h;
 
 
-               /* Loop through samples, starting from middle point     */
+               /* Loop through samples, starting from middle point */
                for (int sample = 0; sample < 5; sample++) {
-                       /* Loop through every face in the mesh  */
+                       /* Loop through every face in the mesh */
                        /* XXX TODO This is *horrible* with big meshes, should use a 2D BVHTree over UV tris here! */
                        for (int i = 0; i < tottri; i++) {
-                               /* Check uv bb  */
+                               /* Check uv bb */
                                if ((faceBB[i].min[0] > point[sample][0]) ||
                                    (faceBB[i].min[1] > point[sample][1]) ||
                                    (faceBB[i].max[0] < point[sample][0]) ||
@@ -2283,7 +2283,7 @@ static void dynamic_paint_create_uv_surface_direct_cb(
                                if (isect_point_tri_v2(point[sample], uv1, uv2, uv3) != 0) {
                                        float uv[2];
 
-                                       /* Add b-weights per anti-aliasing sample       */
+                                       /* Add b-weights per anti-aliasing sample */
                                        for (int j = 0; j < aa_samples; j++) {
                                                uv[0] = point[0][0] + jitter5sample[j * 2] / w;
                                                uv[1] = point[0][1] + jitter5sample[j * 2 + 1] / h;
@@ -2291,10 +2291,10 @@ static void dynamic_paint_create_uv_surface_direct_cb(
                                                barycentric_weights_v2(uv1, uv2, uv3, uv, tempWeights[index * aa_samples + j].v);
                                        }
 
-                                       /* Set surface point face values        */
+                                       /* Set surface point face values */
                                        tPoint->tri_index = i;
 
-                                       /* save vertex indexes  */
+                                       /* save vertex indexes */
                                        tPoint->v1 = mloop[mlooptri[i].tri[0]].v;
                                        tPoint->v2 = mloop[mlooptri[i].tri[1]].v;
                                        tPoint->v3 = mloop[mlooptri[i].tri[2]].v;
@@ -2333,11 +2333,11 @@ static void dynamic_paint_create_uv_surface_neighbor_cb(
                const int index = tx + w * ty;
                PaintUVPoint *tPoint = &tempPoints[index];
 
-               /* If point isn't on canvas mesh        */
+               /* If point isn't on canvas mesh */
                if (tPoint->tri_index == -1) {
                        float point[2];
 
-                       /* get loop area        */
+                       /* get loop area */
                        const int u_min = (tx > 0) ? -1 : 0;
                        const int u_max = (tx < (w - 1)) ? 1 : 0;
                        const int v_min = (ty > 0) ? -1 : 0;
@@ -2352,7 +2352,7 @@ static void dynamic_paint_create_uv_surface_neighbor_cb(
                                int v = neighStraightY[ni];
 
                                if (u >= u_min && u <= u_max && v >= v_min && v <= v_max) {
-                                       /* if not this pixel itself     */
+                                       /* if not this pixel itself */
                                        if (u != 0 || v != 0) {
                                                const int ind = (tx + u) + w * (ty + v);
 
@@ -2377,14 +2377,14 @@ static void dynamic_paint_create_uv_surface_neighbor_cb(
                                                        tPoint->tri_index = i;
 
                                                        /* Now calculate pixel data for this pixel as it was on polygon surface */
-                                                       /* Add b-weights per anti-aliasing sample       */
+                                                       /* Add b-weights per anti-aliasing sample */
                                                        for (int j = 0; j < aa_samples; j++) {
                                                                uv[0] = point[0] + jitter5sample[j * 2] / w;
                                                                uv[1] = point[1] + jitter5sample[j * 2 + 1] / h;
                                                                barycentric_weights_v2(uv1, uv2, uv3, uv, tempWeights[index * aa_samples + j].v);
                                                        }
 
-                                                       /* save vertex indexes  */
+                                                       /* save vertex indexes */
                                                        tPoint->v1 = mloop[mlooptri[i].tri[0]].v;
                                                        tPoint->v2 = mloop[mlooptri[i].tri[1]].v;
                                                        tPoint->v3 = mloop[mlooptri[i].tri[2]].v;
@@ -2609,8 +2609,8 @@ static void dynamic_paint_find_island_border(
                        continue;
 
                /*
-                *      Find a point that is relatively at same edge position
-                *      on this other face UV
+                * Find a point that is relatively at same edge position
+                * on this other face UV
                 */
                float closest_point[2], dir_vec[2], tgt_pixel[2];
 
@@ -2624,7 +2624,7 @@ static void dynamic_paint_find_island_border(
 
                int final_pixel[2] = { (int)floorf(tgt_pixel[0] * w), (int)floorf(tgt_pixel[1] * h) };
 
-               /* If current pixel uv is outside of texture    */
+               /* If current pixel uv is outside of texture */
                if (final_pixel[0] < 0 || final_pixel[0] >= w || final_pixel[1] < 0 || final_pixel[1] >= h) {
                        if (bdata->best_index == NOT_FOUND)
                                bdata->best_index = OUT_OF_TEXTURE;
@@ -2635,7 +2635,7 @@ static void dynamic_paint_find_island_border(
                const PaintUVPoint *tempPoints = data->tempPoints;
                int final_index = final_pixel[0] + w * final_pixel[1];
 
-               /* If we ended up to our origin point ( mesh has smaller than pixel sized faces)        */
+               /* If we ended up to our origin point ( mesh has smaller than pixel sized faces) */
                if (final_index == (px + w * py))
                        continue;
 
@@ -2648,7 +2648,7 @@ static void dynamic_paint_find_island_border(
                                continue;
                }
 
-               /* If found pixel still lies on wrong face ( mesh has smaller than pixel sized faces)   */
+               /* If found pixel still lies on wrong face ( mesh has smaller than pixel sized faces) */
                if (tempPoints[final_index].tri_index != target_tri) {
                        /* Check if it's close enough to likely touch the intended triangle. Any triangle
                         * becomes thinner than a pixel at its vertices, so robustness requires some margin. */
@@ -2768,7 +2768,7 @@ static bool dynamicPaint_symmetrizeAdjData(PaintAdjData *ed, int active_points)
 
 int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, float *progress, short *do_update)
 {
-       /* Antialias jitter point relative coords       */
+       /* Antialias jitter point relative coords */
        const int aa_samples = (surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
        char uvname[MAX_CUSTOMDATA_LAYER_NAME];
        uint32_t active_points = 0;
@@ -2805,7 +2805,7 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
                mloopuv = CustomData_get_layer_named(&dm->loopData, CD_MLOOPUV, uvname);
        }
 
-       /* Check for validity   */
+       /* Check for validity */
        if (!mloopuv)
                return setError(canvas, N_("No UV data on canvas"));
        if (surface->image_resolution < 16 || surface->image_resolution > 8192)
@@ -2815,7 +2815,7 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
        const int h = w;
 
        /*
-        *      Start generating the surface
+        * Start generating the surface
         */
        printf("DynamicPaint: Preparing UV surface of %ix%i pixels and %i tris.\n", w, h, tottri);
 
@@ -2839,8 +2839,8 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
                error = true;
 
        /*
-        *      Generate a temporary bounding box array for UV faces to optimize
-        *      the pixel-inside-a-face search.
+        * Generate a temporary bounding box array for UV faces to optimize
+        * the pixel-inside-a-face search.
         */
        if (!error) {
                faceBB = MEM_mallocN(tottri * sizeof(*faceBB), "MPCanvasFaceBB");
@@ -2884,10 +2884,10 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
                *do_update = true;
 
                /*
-                *      Now loop through every pixel that was left without index
-                *      and find if they have neighboring pixels that have an index.
-                *      If so use that polygon as pixel surface.
-                *      (To avoid seams on uv island edges)
+                * Now loop through every pixel that was left without index
+                * and find if they have neighboring pixels that have an index.
+                * If so use that polygon as pixel surface.
+                * (To avoid seams on uv island edges)
                 */
                data.active_points = &active_points;
                {
@@ -2903,7 +2903,7 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
                *progress = 0.06f;
                *do_update = true;
 
-               /*      Generate surface adjacency data. */
+               /* Generate surface adjacency data. */
                {
                        int cursor = 0;
 
@@ -2987,9 +2987,9 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
                                }
 
 #if 0
-                               /*  -----------------------------------------------------------------
-                                *      For debug, write a dump of adjacency data to a file.
-                                *      -----------------------------------------------------------------*/
+                               /* -----------------------------------------------------------------
+                                * For debug, write a dump of adjacency data to a file.
+                                * -----------------------------------------------------------------*/
                                FILE *dump_file = fopen("dynpaint-adj-data.txt", "w");
                                int *tmp = MEM_callocN(sizeof(int) * active_points, "tmp");
                                for (int ty = 0; ty < h; ty++) {
@@ -3080,20 +3080,20 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
                dynamicPaint_allocateSurfaceType(surface);
 
 #if 0
-               /*  -----------------------------------------------------------------
-                *      For debug, output pixel statuses to the color map
-                *      -----------------------------------------------------------------*/
+               /* -----------------------------------------------------------------
+                * For debug, output pixel statuses to the color map
+                * -----------------------------------------------------------------*/
                for (index = 0; index < sData->total_points; index++) {
                        ImgSeqFormatData *f_data = (ImgSeqFormatData *)sData->format_data;
                        PaintUVPoint *uvPoint = &((PaintUVPoint *)f_data->uv_p)[index];
                        PaintPoint *pPoint = &((PaintPoint *)sData->type_data)[index];
                        pPoint->alpha = 1.0f;
 
-                       /* Every pixel that is assigned as "edge pixel" gets blue color */
+                       /* Every pixel that is assigned as "edge pixel" gets blue color */
                        if (uvPoint->neighbour_pixel != -1)
                                pPoint->color[2] = 1.0f;
-                       /* and every pixel that finally got an polygon gets red color   */
-                       /* green color shows pixel face index hash      */
+                       /* and every pixel that finally got an polygon gets red color */
+                       /* green color shows pixel face index hash */
                        if (uvPoint->tri_index != -1) {
                                pPoint->color[0] = 1.0f;
                                pPoint->color[1] = (float)(uvPoint->tri_index % 255) / 256.0f;
@@ -3111,7 +3111,7 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
 }
 
 /*
- *     Outputs an image file from uv surface data.
+ * Outputs an image file from uv surface data.
  */
 typedef struct DynamicPaintOutputSurfaceImageData {
        const DynamicPaintSurface *surface;
@@ -3135,7 +3135,7 @@ static void dynamic_paint_output_surface_image_paint_cb(
        /* blend wet and dry layers */
        blendColors(point->color, point->color[3], point->e_color, point->e_color[3], &ibuf->rect_float[pos]);
 
-       /* Multiply color by alpha if enabled   */
+       /* Multiply color by alpha if enabled */
        if (surface->flags & MOD_DPAINT_MULALPHA) {
                mul_v3_fl(&ibuf->rect_float[pos], ibuf->rect_float[pos + 3]);
        }
@@ -3215,7 +3215,7 @@ void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char *filenam
 {
        ImBuf *ibuf = NULL;
        PaintSurfaceData *sData = surface->data;
-       /* OpenEXR or PNG       */
+       /* OpenEXR or PNG */
        int format = (surface->image_fileformat & MOD_DPAINT_IMGFORMAT_OPENEXR) ? R_IMF_IMTYPE_OPENEXR : R_IMF_IMTYPE_PNG;
        char output_file[FILE_MAX];
 
@@ -3231,11 +3231,11 @@ void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char *filenam
        BLI_strncpy(output_file, filename, sizeof(output_file));
        BKE_image_path_ensure_ext_from_imtype(output_file, format);
 
-       /* Validate output file path    */
+       /* Validate output file path */
        BLI_path_abs(output_file, BKE_main_blendfile_path_from_global());
        BLI_make_existing_file(output_file);
 
-       /* Init image buffer    */
+       /* Init image buffer */
        ibuf = IMB_allocImBuf(surface->image_resolution, surface->image_resolution, 32, IB_rectfloat);
        if (ibuf == NULL) {
                setError(surface->canvas, N_("Image save failed: not enough free memory"));
@@ -3396,7 +3396,7 @@ static void dynamicPaint_freeBrushMaterials(BrushMaterials *bMats)
 }
 
 /*
- *     Get material diffuse color and alpha (including linked textures) in given coordinates
+ * Get material diffuse color and alpha (including linked textures) in given coordinates
  */
 static void dynamicPaint_doMaterialTex(
         const BrushMaterials *bMats, float color[3], float *alpha, Object *brushOb,
@@ -3432,7 +3432,7 @@ static void dynamicPaint_doMaterialTex(
 /*  A modified callback to bvh tree raycast. The tree must have been built using bvhtree_from_mesh_looptri.
  *   userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
  *
- *     To optimize brush detection speed this doesn't calculate hit coordinates or normal.
+ * To optimize brush detection speed this doesn't calculate hit coordinates or normal.
  */
 static void mesh_tris_spherecast_dp(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit)
 {
@@ -3505,7 +3505,7 @@ static void dynamicPaint_mixPaintColors(
 {
        PaintPoint *pPoint = &((PaintPoint *)surface->data->type_data)[index];
 
-       /* Add paint    */
+       /* Add paint */
        if (!(paintFlags & MOD_DPAINT_ERASE)) {
                float mix[4];
                float temp_alpha = paintAlpha * ((paintFlags & MOD_DPAINT_ABS_ALPHA) ? 1.0f : timescale);
@@ -3531,15 +3531,15 @@ static void dynamicPaint_mixPaintColors(
 
                pPoint->state = DPAINT_PAINT_NEW;
        }
-       /* Erase paint  */
+       /* Erase paint */
        else {
                float a_ratio, a_highest;
                float wetness;
                float invFact = 1.0f - paintAlpha;
 
                /*
-                *      Make highest alpha to match erased value
-                *      but maintain alpha ratio
+                * Make highest alpha to match erased value
+                * but maintain alpha ratio
                 */
                if (paintFlags & MOD_DPAINT_ABS_ALPHA) {
                        a_highest = max_ff(pPoint->color[3], pPoint->e_color[3]);
@@ -3607,7 +3607,7 @@ static void dynamicPaint_mixWaveHeight(
 }
 
 /*
- *     add brush results to the surface data depending on surface type
+ * add brush results to the surface data depending on surface type
  */
 static void dynamicPaint_updatePointData(
         const DynamicPaintSurface *surface, const int index, const DynamicPaintBrushSettings *brush,
@@ -3874,7 +3874,7 @@ typedef struct DynamicPaintPaintData {
 } DynamicPaintPaintData;
 
 /*
- *     Paint a brush object mesh to the surface
+ * Paint a brush object mesh to the surface
  */
 static void dynamic_paint_paint_mesh_cell_point_cb_ex(
         void *__restrict userdata,
@@ -3921,7 +3921,7 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
        if (samples > 1 && surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ)
                total_sample = gaussianTotal;
 
-       /* Supersampling        */
+       /* Supersampling */
        for (ss = 0; ss < samples; ss++) {
                float ray_start[3], ray_dir[3];
                float sample_factor = 0.0f;
@@ -3938,17 +3938,17 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                const bool inner_proximity = (brush->flags & MOD_DPAINT_INVERSE_PROX &&
                                              brush->collision == MOD_DPAINT_COL_VOLDIST);
 
-               /* hit data     */
+               /* hit data */
                float hitCoord[3];
                int hitTri = -1;
 
-               /* Supersampling factor */
+               /* Supersampling factor */
                if (samples > 1 && surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ)
                        sample_factor = gaussianFactors[ss];
                else
                        sample_factor = 1.0f;
 
-               /* Get current sample position in world coordinates     */
+               /* Get current sample position in world coordinates */
                copy_v3_v3(ray_start, bData->realCoord[bData->s_pos[index] + ss].v);
                copy_v3_v3(ray_dir, bData->bNormal[index].invNorm);
 
@@ -3960,13 +3960,13 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                nearest.index = -1;
                nearest.dist_sq = brush_radius * brush_radius; /* find_nearest uses squared distance */
 
-               /* Check volume collision       */
+               /* Check volume collision */
                if (ELEM(brush->collision, MOD_DPAINT_COL_VOLUME, MOD_DPAINT_COL_VOLDIST)) {
                        BLI_bvhtree_ray_cast(treeData->tree, ray_start, ray_dir, 0.0f, &hit, mesh_tris_spherecast_dp, treeData);
                        if (hit.index != -1) {
-                               /* We hit a triangle, now check if collision point normal is facing the point   */
+                               /* We hit a triangle, now check if collision point normal is facing the point */
 
-                               /*      For optimization sake, hit point normal isn't calculated in ray cast loop       */
+                               /* For optimization sake, hit point normal isn't calculated in ray cast loop */
                                const int vtri[3] = {
                                    mloop[mlooptri[hit.index].tri[0]].v,
                                    mloop[mlooptri[hit.index].tri[1]].v,
@@ -3977,8 +3977,8 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                                normal_tri_v3(hit.no, mvert[vtri[0]].co, mvert[vtri[1]].co, mvert[vtri[2]].co);
                                dot = dot_v3v3(ray_dir, hit.no);
 
-                               /*  If ray and hit face normal are facing same direction
-                                *      hit point is inside a closed mesh. */
+                               /* If ray and hit face normal are facing same direction
+                                * hit point is inside a closed mesh. */
                                if (dot >= 0.0f) {
                                        const float dist = hit.dist;
                                        const int f_index = hit.index;
@@ -3993,7 +3993,7 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                                                    treeData->tree, ray_start, ray_dir, 0.0f, &hit, mesh_tris_spherecast_dp, treeData);
 
                                        if (hit.index != -1) {
-                                               /* Add factor on supersample filter     */
+                                               /* Add factor on supersample filter */
                                                volume_factor = 1.0f;
                                                hit_found = HIT_VOLUME;
 
@@ -4006,7 +4006,7 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                        }
                }
 
-               /* Check proximity collision    */
+               /* Check proximity collision */
                if (ELEM(brush->collision, MOD_DPAINT_COL_DIST, MOD_DPAINT_COL_VOLDIST) &&
                    (!hit_found || (brush->flags & MOD_DPAINT_INVERSE_PROX)))
                {
@@ -4043,7 +4043,7 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                                hit.index = -1;
                                hit.dist = brush_radius;
 
-                               /* Do a face normal directional raycast, and use that distance  */
+                               /* Do a face normal directional raycast, and use that distance */
                                BLI_bvhtree_ray_cast(
                                            treeData->tree, ray_start, proj_ray, 0.0f, &hit, mesh_tris_spherecast_dp, treeData);
                                if (hit.index != -1) {
@@ -4053,7 +4053,7 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                                }
                        }
 
-                       /* If a hit was found, calculate required values        */
+                       /* If a hit was found, calculate required values */
                        if (proxDist >= 0.0f && proxDist <= brush_radius) {
                                proximity_factor = proxDist / brush_radius;
                                CLAMP(proximity_factor, 0.0f, 1.0f);
@@ -4146,7 +4146,7 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                }
 
                /*
-                *      Process hit color and alpha
+                * Process hit color and alpha
                 */
                if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
                        float sampleColor[3];
@@ -4156,14 +4156,14 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                        sampleColor[1] = brush->g;
                        sampleColor[2] = brush->b;
 
-                       /* Get material+textures color on hit point if required */
+                       /* Get material+textures color on hit point if required */
                        if (brush_usesMaterial(brush, scene)) {
                                dynamicPaint_doMaterialTex(bMats, sampleColor, &alpha_factor, brushOb,
                                                           bData->realCoord[bData->s_pos[index] + ss].v,
                                                           hitCoord, hitTri, dm);
                        }
 
-                       /* Sample proximity colorband if required       */
+                       /* Sample proximity colorband if required */
                        if ((hit_found == HIT_PROXIMITY) &&
                            (brush->proximity_falloff == MOD_DPAINT_PRFALL_RAMP))
                        {
@@ -4187,16 +4187,16 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
        } // end supersampling
 
 
-       /* if any sample was inside paint range */
+       /* if any sample was inside paint range */
        if (brushStrength > 0.0f || depth > 0.0f) {
-               /* apply supersampling results  */
+               /* apply supersampling results */
                if (samples > 1) {
                        brushStrength /= total_sample;
                }
                CLAMP(brushStrength, 0.0f, 1.0f);
 
                if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
-                       /* Get final pixel color and alpha      */
+                       /* Get final pixel color and alpha */
                        paintColor[0] /= numOfHits;
                        paintColor[1] /= numOfHits;
                        paintColor[2] /= numOfHits;
@@ -4248,9 +4248,9 @@ static int dynamicPaint_paintMesh(Main *bmain,
                mloop = dm->getLoopArray(dm);
                numOfVerts = dm->getNumVerts(dm);
 
-               /*      Transform collider vertices to global space
-                *      (Faster than transforming per surface point
-                *      coordinates and normals to object space) */
+               /* Transform collider vertices to global space
+                * (Faster than transforming per surface point
+                * coordinates and normals to object space) */
                for (ii = 0; ii < numOfVerts; ii++) {
                        mul_m4_v3(brushOb->obmat, mvert[ii].co);
                        boundInsert(&mesh_bb, mvert[ii].co);
@@ -4276,7 +4276,7 @@ static int dynamicPaint_paintMesh(Main *bmain,
 
                /* check bounding box collision */
                if (grid && meshBrush_boundsIntersect(&grid->grid_bounds, &mesh_bb, brush, brush_radius)) {
-                       /* Build a bvh tree from transformed vertices   */
+                       /* Build a bvh tree from transformed vertices */
                        if (bvhtree_from_mesh_get(&treeData, dm, BVHTREE_FROM_LOOPTRI, 4)) {
                                int c_index;
                                int total_cells = grid->dim[0] * grid->dim[1] * grid->dim[2];
@@ -4323,7 +4323,7 @@ static int dynamicPaint_paintMesh(Main *bmain,
 }
 
 /*
- *     Paint a particle system to the surface
+ * Paint a particle system to the surface
  */
 static void dynamic_paint_paint_particle_cell_point_cb_ex(
         void *__restrict userdata,
@@ -4358,14 +4358,14 @@ static void dynamic_paint_paint_particle_cell_point_cb_ex(
        int part_index = -1;
 
        /*
-        *      With predefined radius, there is no variation between particles.
-        *      It's enough to just find the nearest one.
+        * With predefined radius, there is no variation between particles.
+        * It's enough to just find the nearest one.
         */
        {
                KDTreeNearest nearest;
                float smooth_range, part_solidradius;
 
-               /* Find nearest particle and get distance to it */
+               /* Find nearest particle and get distance to it */
                BLI_kdtree_find_nearest(tree, bData->realCoord[bData->s_pos[index]].v, &nearest);
                /* if outside maximum range, no other particle can influence either */
                if (nearest.dist > range)
@@ -4381,9 +4381,9 @@ static void dynamic_paint_paint_particle_cell_point_cb_ex(
                }
                radius = part_solidradius + smooth;
                if (nearest.dist < radius) {
-                       /* distances inside solid radius has maximum influence -> dist = 0      */
+                       /* distances inside solid radius has maximum influence -> dist = 0 */
                        smooth_range = max_ff(0.0f, (nearest.dist - part_solidradius));
-                       /* do smoothness if enabled     */
+                       /* do smoothness if enabled */
                        if (smooth)
                                smooth_range /= smooth;
 
@@ -4392,11 +4392,11 @@ static void dynamic_paint_paint_particle_cell_point_cb_ex(
                        part_index = nearest.index;
                }
        }
-       /* If using random per particle radius and closest particle didn't give max influence   */
+       /* If using random per particle radius and closest particle didn't give max influence */
        if (brush->flags & MOD_DPAINT_PART_RAD && strength < 1.0f && psys->part->randsize > 0.0f) {
                /*
-                *      If we use per particle radius, we have to sample all particles
-                *      within max radius range
+                * If we use per particle radius, we have to sample all particles
+                * within max radius range
                 */
                KDTreeNearest *nearest;
 
@@ -4444,13 +4444,13 @@ static void dynamic_paint_paint_particle_cell_point_cb_ex(
                        radius = rad;
                }
 
-               /* do smoothness if enabled     */
+               /* do smoothness if enabled */
                CLAMP_MIN(smooth_range, 0.0f);
                if (smooth)
                        smooth_range /= smooth;
 
                const float str = 1.0f - smooth_range;
-               /* if influence is greater, use this one        */
+               /* if influence is greater, use this one */
                if (str > strength)
                        strength = str;
        }
@@ -4485,7 +4485,7 @@ static void dynamic_paint_paint_particle_cell_point_cb_ex(
                        copy_v3_v3(paintColor, &brush->r);
                }
                else if (ELEM(surface->type, MOD_DPAINT_SURFACE_T_DISPLACE, MOD_DPAINT_SURFACE_T_WAVE)) {
-                       /* get displace depth   */
+                       /* get displace depth */
                        disp_intersect = (1.0f - sqrtf(disp_intersect / radius)) * radius;
                        depth = max_ff(0.0f, (radius - disp_intersect) / bData->bNormal[index].normal_scale);
                }
@@ -4521,14 +4521,14 @@ static int dynamicPaint_paintParticles(DynamicPaintSurface *surface,
                return 1;
 
        /*
-        *      Build a kd-tree to optimize distance search
+        * Build a kd-tree to optimize distance search
         */
        tree = BLI_kdtree_new(psys->totpart);
 
        /* loop through particles and insert valid ones to the tree */
        p = 0;
        for (ParticleData *pa = psys->particles; p < psys->totpart; p++, pa++) {
-               /* Proceed only if particle is active   */
+               /* Proceed only if particle is active */
                if ((pa->alive == PARS_UNBORN && (part->flag & PART_UNBORN) == 0) ||
                    (pa->alive == PARS_DEAD && (part->flag & PART_DIED) == 0) ||
                    (pa->flag & PARS_UNEXIST))
@@ -4536,8 +4536,8 @@ static int dynamicPaint_paintParticles(DynamicPaintSurface *surface,
                        continue;
                }
 
-               /*      for debug purposes check if any NAN particle proceeds
-                *      For some reason they get past activity check, this should rule most of them out */
+               /* for debug purposes check if any NAN particle proceeds
+                * For some reason they get past activity check, this should rule most of them out */
                if (isnan(pa->state.co[0]) || isnan(pa->state.co[1]) || isnan(pa->state.co[2])) {
                        invalidParticles++;
                        continue;
@@ -4557,7 +4557,7 @@ static int dynamicPaint_paintParticles(DynamicPaintSurface *surface,
        if (invalidParticles)
                printf("Warning: Invalid particle(s) found!\n");
 
-       /* If no suitable particles were found, exit    */
+       /* If no suitable particles were found, exit */
        if (particlesAdded < 1) {
                BLI_kdtree_free(tree);
                return 1;
@@ -4571,7 +4571,7 @@ static int dynamicPaint_paintParticles(DynamicPaintSurface *surface,
                int c_index;
                int total_cells = grid->dim[0] * grid->dim[1] * grid->dim[2];
 
-               /* balance tree */
+               /* balance tree */
                BLI_kdtree_balance(tree);
 
                /* loop through space partitioning grid */
@@ -4637,7 +4637,7 @@ static void dynamic_paint_paint_single_point_cb_ex(
        if (distance > brush_radius)
                return;
 
-       /* Smooth range or color ramp   */
+       /* Smooth range or color ramp */
        if (brush->proximity_falloff == MOD_DPAINT_PRFALL_SMOOTH ||
            brush->proximity_falloff == MOD_DPAINT_PRFALL_RAMP)
        {
@@ -4709,7 +4709,7 @@ static void dynamic_paint_paint_single_point_cb_ex(
                        }
                }
                else if (ELEM(surface->type, MOD_DPAINT_SURFACE_T_DISPLACE, MOD_DPAINT_SURFACE_T_WAVE)) {
-                       /* get displace depth   */
+                       /* get displace depth */
                        const float disp_intersect = (1.0f - sqrtf((brush_radius - distance) / brush_radius)) * brush_radius;
                        depth = max_ff(0.0f, (brush_radius - disp_intersect) / bData->bNormal[index].normal_scale);
                }
@@ -4731,7 +4731,7 @@ static int dynamicPaint_paintSinglePoint(
        const MVert *mvert = brush->dm->getVertArray(brush->dm);
 
        /*
-        *      Loop through every surface point
+        * Loop through every surface point
         */
        DynamicPaintPaintData data = {
            .surface = surface,
@@ -4756,7 +4756,7 @@ static int dynamicPaint_paintSinglePoint(
 /***************************** Dynamic Paint Step / Baking ******************************/
 
 /*
- *     Calculate current frame distances and directions for adjacency data
+ * Calculate current frame distances and directions for adjacency data
  */
 
 static void dynamic_paint_prepare_adjacency_cb(
@@ -4991,8 +4991,8 @@ typedef struct DynamicPaintEffectData {
 } DynamicPaintEffectData;
 
 /*
- *     Prepare data required by effects for current frame.
- *     Returns number of steps required
+ * Prepare data required by effects for current frame.
+ * Returns number of steps required
  */
 static void dynamic_paint_prepare_effect_cb(
         void *__restrict userdata,
@@ -5105,7 +5105,7 @@ static int dynamicPaint_prepareEffectStep(
 }
 
 /**
- *     Processes active effect step.
+ * Processes active effect step.
  */
 static void dynamic_paint_effect_spread_cb(
         void *__restrict userdata,
@@ -5129,7 +5129,7 @@ static void dynamic_paint_effect_spread_cb(
        const int *n_index = sData->adj_data->n_index;
        const int *n_target = sData->adj_data->n_target;
 
-       /*      Loop through neighboring points */
+       /* Loop through neighboring points */
        for (int i = 0; i < numOfNeighs; i++) {
                const int n_idx = n_index[index] + i;
                float w_factor;
@@ -5178,7 +5178,7 @@ static void dynamic_paint_effect_shrink_cb(
        const int *n_index = sData->adj_data->n_index;
        const int *n_target = sData->adj_data->n_target;
 
-       /*      Loop through neighboring points */
+       /* Loop through neighboring points */
        for (int i = 0; i < numOfNeighs; i++) {
                const int n_idx = n_index[index] + i;
                const float speed_scale = (bNeighs[n_idx].dist < eff_scale) ? 1.0f : eff_scale / bNeighs[n_idx].dist;
@@ -5333,12 +5333,12 @@ static void dynamicPaint_doEffectStep(
                return;
 
        /*
-        *      Spread Effect
+        * Spread Effect
         */
        if (surface->effect & MOD_DPAINT_EFFECT_DO_SPREAD) {
                const float eff_scale = distance_scale * EFF_MOVEMENT_PER_FRAME * surface->spread_speed * timescale;
 
-               /* Copy current surface to the previous points array to read unmodified values  */
+               /* Copy current surface to the previous points array to read unmodified values */
                memcpy(prevPoint, sData->type_data, sData->total_points * sizeof(struct PaintPoint));
 
                DynamicPaintEffectData data = {
@@ -5354,12 +5354,12 @@ static void dynamicPaint_doEffectStep(
        }
 
        /*
-        *      Shrink Effect
+        * Shrink Effect
         */
        if (surface->effect & MOD_DPAINT_EFFECT_DO_SHRINK) {
                const float eff_scale = distance_scale * EFF_MOVEMENT_PER_FRAME * surface->shrink_speed * timescale;
 
-               /* Copy current surface to the previous points array to read unmodified values  */
+               /* Copy current surface to the previous points array to read unmodified values */
                memcpy(prevPoint, sData->type_data, sData->total_points * sizeof(struct PaintPoint));
 
                DynamicPaintEffectData data = {
@@ -5375,7 +5375,7 @@ static void dynamicPaint_doEffectStep(
        }
 
        /*
-        *      Drip Effect
+        * Drip Effect
         */
        if (surface->effect & MOD_DPAINT_EFFECT_DO_DRIP && force) {
                const float eff_scale = distance_scale * EFF_MOVEMENT_PER_FRAME * timescale / 2.0f;
@@ -5384,7 +5384,7 @@ static void dynamicPaint_doEffectStep(
                const size_t point_locks_size = (sData->total_points / 8) + 1;
                uint8_t *point_locks = MEM_callocN(sizeof(*point_locks) * point_locks_size, __func__);
 
-               /* Copy current surface to the previous points array to read unmodified values  */
+               /* Copy current surface to the previous points array to read unmodified values */
                memcpy(prevPoint, sData->type_data, sData->total_points * sizeof(struct PaintPoint));
 
                DynamicPaintEffectData data = {
@@ -5685,7 +5685,7 @@ static void dynamic_paint_surface_pre_step_cb(
                                        dry_ratio = pPoint->wetness / p_wetness;
 
                                        /*
-                                        *      Slowly "shift" paint from wet layer to dry layer as it drys:
+                                        * Slowly "shift" paint from wet layer to dry layer as it drys:
                                         */
                                        /* make sure alpha values are within proper range */
                                        CLAMP(pPoint->color[3], 0.0f, 1.0f);
@@ -5810,7 +5810,7 @@ static void dynamic_paint_generate_bake_data_cb(
        }
 
        /*
-        *      Calculate current 3D-position and normal of each surface point
+        * Calculate current 3D-position and normal of each surface point
         */
        if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
                float n1[3], n2[3], n3[3];
@@ -5829,7 +5829,7 @@ static void dynamic_paint_generate_bake_data_cb(
                                         f_data->barycentricWeights[index * bData->s_num[index] + ss].v);
                }
 
-               /* Calculate current pixel surface normal       */
+               /* Calculate current pixel surface normal */
                normal_short_to_float_v3(n1, mvert[tPoint->v1].no);
                normal_short_to_float_v3(n2, mvert[tPoint->v2].no);
                normal_short_to_float_v3(n3, mvert[tPoint->v3].no);
@@ -5972,7 +5972,7 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, const Sce
        }
 
        /*
-        *      Make a transformed copy of canvas derived mesh vertices to avoid recalculation.
+        * Make a transformed copy of canvas derived mesh vertices to avoid recalculation.
         */
        bData->mesh_bounds.valid = false;
        for (index = 0; index < canvasNumOfVerts; index++) {
@@ -5982,7 +5982,7 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, const Sce
        }
 
        /*
-        *      Prepare each surface point for a new step
+        * Prepare each surface point for a new step
         */
        DynamicPaintGenerateBakeData data = {
            .surface = surface, .ob = ob,
@@ -6079,11 +6079,11 @@ static int dynamicPaint_doStep(
                                continue;
                        }
 
-                       /* check if target has an active dp modifier    */
+                       /* check if target has an active dp modifier */
                        md = modifiers_findByType(brushObj, eModifierType_DynamicPaint);
                        if (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render)) {
                                DynamicPaintModifierData *pmd2 = (DynamicPaintModifierData *)md;
-                               /* make sure we're dealing with a brush */
+                               /* make sure we're dealing with a brush */
                                if (pmd2->brush) {
                                        DynamicPaintBrushSettings *brush = pmd2->brush;
                                        BrushMaterials bMats = {NULL};
@@ -6104,7 +6104,7 @@ static int dynamicPaint_doStep(
                                                BKE_object_modifier_update_subframe(bmain, eval_ctx, scene, brushObj, true, SUBFRAME_RECURSION,
                                                                                    BKE_scene_frame_get(scene), eModifierType_DynamicPaint);
                                        }
-                                       /* Prepare materials if required        */
+                                       /* Prepare materials if required */
                                        if (brush_usesMaterial(brush, scene))
                                                dynamicPaint_updateBrushMaterials(brushObj, brush->mat, scene, &bMats);
 
@@ -6167,7 +6167,7 @@ static int dynamicPaint_doStep(
                        PaintPoint *prevPoint;
                        float *force = NULL;
 
-                       /* Allocate memory for surface previous points to read unchanged values from    */
+                       /* Allocate memory for surface previous points to read unchanged values from */
                        prevPoint = MEM_mallocN(sData->total_points * sizeof(struct PaintPoint), "PaintSurfaceDataCopy");
                        if (!prevPoint)
                                return setError(canvas, N_("Not enough free memory"));
@@ -6178,7 +6178,7 @@ static int dynamicPaint_doStep(
                                dynamicPaint_doEffectStep(surface, force, prevPoint, timescale, (float)steps);
                        }
 
-                       /* Free temporary effect data   */
+                       /* Free temporary effect data */
                        if (prevPoint)
                                MEM_freeN(prevPoint);
                        if (force)
index 6ee6d87..d4e69ad 100644 (file)
@@ -270,12 +270,12 @@ FCurve *iter_step_fcurve(FCurve *fcu_iter, const char rna_path[])
 
 /* Get list of LinkData's containing pointers to the F-Curves which control the types of data indicated
  * Lists...
- *     - dst: list of LinkData's matching the criteria returned.
- *       List must be freed after use, and is assumed to be empty when passed.
- *     - src: list of F-Curves to search through
+ * - dst: list of LinkData's matching the criteria returned.
+ *   List must be freed after use, and is assumed to be empty when passed.
+ * - src: list of F-Curves to search through
  * Filters...
- *  - dataPrefix: i.e. 'pose.bones[' or 'nodes['
- *  - dataName: name of entity within "" immediately following the prefix
+ * - dataPrefix: i.e. 'pose.bones[' or 'nodes['
+ * - dataName: name of entity within "" immediately following the prefix
  */
 int list_find_data_fcurves(ListBase *dst, ListBase *src, const char *dataPrefix, const char *dataName)
 {
@@ -428,8 +428,8 @@ static int binarysearch_bezt_index_ex(BezTriple array[], float frame, int arrayl
        *r_replace = false;
 
        /* sneaky optimizations (don't go through searching process if...):
-        *      - keyframe to be added is to be added out of current bounds
-        *      - keyframe to be added would replace one of the existing ones on bounds
+        * - keyframe to be added is to be added out of current bounds
+        * - keyframe to be added would replace one of the existing ones on bounds
         */
        if ((arraylen <= 0) || (array == NULL)) {
                printf("Warning: binarysearch_bezt_index() encountered invalid array\n");
@@ -829,7 +829,7 @@ void bezt_add_to_cfra_elem(ListBase *lb, BezTriple *bezt)
 
 
 /* Basic sampling callback which acts as a wrapper for evaluate_fcurve()
- *     'data' arg here is unneeded here...
+ * 'data' arg here is unneeded here...
  */
 float fcurve_samplingcb_evalcurve(FCurve *fcu, void *UNUSED(data), float evaltime)
 {
@@ -931,9 +931,9 @@ void calchandles_fcurve(FCurve *fcu)
        int a = fcu->totvert;
 
        /* Error checking:
-        *      - need at least two points
-        *      - need bezier keys
-        *      - only bezier-interpolation has handles (for now)
+        * - need at least two points
+        * - need bezier keys
+        * - only bezier-interpolation has handles (for now)
         */
        if (ELEM(NULL, fcu, fcu->bezt) || (a < 2) /*|| ELEM(fcu->ipo, BEZT_IPO_CONST, BEZT_IPO_LIN)*/)
                return;
@@ -1527,10 +1527,10 @@ static float dvar_eval_transChan(ChannelDriver *driver, DriverVar *dvar)
        pchan = BKE_pose_channel_find_name(ob->pose, dtar->pchan_name);
 
        /* check if object or bone, and get transform matrix accordingly
-        *      - "useEulers" code is used to prevent the problems associated with non-uniqueness
-        *        of euler decomposition from matrices [#20870]
-        *      - localspace is for [#21384], where parent results are not wanted
-        *        but local-consts is for all the common "corrective-shapes-for-limbs" situations
+        * - "useEulers" code is used to prevent the problems associated with non-uniqueness
+        *   of euler decomposition from matrices [#20870]
+        * - localspace is for [#21384], where parent results are not wanted
+        *   but local-consts is for all the common "corrective-shapes-for-limbs" situations
         */
        if (pchan) {
                /* bone */
@@ -1596,12 +1596,12 @@ static float dvar_eval_transChan(ChannelDriver *driver, DriverVar *dvar)
        }
        else if (dtar->transChan >= DTAR_TRANSCHAN_ROTX) {
                /* extract rotation as eulers (if needed)
-                *      - definitely if rotation order isn't eulers already
-                *      - if eulers, then we have 2 options:
-                *              a) decompose transform matrix as required, then try to make eulers from
-                *                 there compatible with original values
-                *              b) [NOT USED] directly use the original values (no decomposition)
-                *                      - only an option for "transform space", if quality is really bad with a)
+                * - definitely if rotation order isn't eulers already
+                * - if eulers, then we have 2 options:
+                *     a) decompose transform matrix as required, then try to make eulers from
+                *        there compatible with original values
+                *     b) [NOT USED] directly use the original values (no decomposition)
+                *         - only an option for "transform space", if quality is really bad with a)
                 */
                float eul[3];
 
@@ -1672,9 +1672,9 @@ void driver_free_variable(ListBase *variables, DriverVar *dvar)
                return;
 
        /* free target vars
-        *      - need to go over all of them, not just up to the ones that are used
-        *        currently, since there may be some lingering RNA paths from
-        *    previous users needing freeing
+        * - need to go over all of them, not just up to the ones that are used
+        *   currently, since there may be some lingering RNA paths from
+        *   previous users needing freeing
         */
        DRIVER_TARGETS_LOOPER(dvar)
        {
@@ -1920,8 +1920,8 @@ float driver_get_variable_value(ChannelDriver *driver, DriverVar *dvar)
 }
 
 /* Evaluate an Channel-Driver to get a 'time' value to use instead of "evaltime"
- *     - "evaltime" is the frame at which F-Curve is being evaluated
- *  - has to return a float value
+ * - "evaltime" is the frame at which F-Curve is being evaluated
+ * - has to return a float value
  */
 float evaluate_driver(PathResolvedRNA *anim_rna, ChannelDriver *driver, const float evaltime)
 {
@@ -2005,7 +2005,7 @@ float evaluate_driver(PathResolvedRNA *anim_rna, ChannelDriver *driver, const fl
                        }
                        else {
                                /* this evaluates the expression using Python, and returns its result:
-                                *  - on errors it reports, then returns 0.0f
+                                * - on errors it reports, then returns 0.0f
                                 */
                                BLI_mutex_lock(&python_driver_lock);
 
@@ -2050,9 +2050,9 @@ void correct_bezpart(float v1[2], float v2[2], float v3[2], float v4[2])
        h2[1] = v4[1] - v3[1];
 
        /* calculate distances:
-        *  - len       = span of time between keyframes
-        *      - len1  = length of handle of start key
-        *      - len2  = length of handle of end key
+        * - len  = span of time between keyframes
+        * - len1 = length of handle of start key
+        * - len2 = length of handle of end key
         */
        len = v4[0] - v1[0];
        len1 = fabsf(h1[0]);
@@ -2675,8 +2675,8 @@ static float evaluate_fcurve_ex(FCurve *fcu, float evaltime, float cvalue)
        devaltime = evaluate_time_fmodifiers(storage, &fcu->modifiers, fcu, cvalue, evaltime);
 
        /* evaluate curve-data
-        *      - 'devaltime' instead of 'evaltime', as this is the time that the last time-modifying
-        *        F-Curve modifier on the stack requested the curve to be evaluated at
+        * - 'devaltime' instead of 'evaltime', as this is the time that the last time-modifying
+        *   F-Curve modifier on the stack requested the curve to be evaluated at
         */
        if (fcu->bezt)
                cvalue = fcurve_eval_keyframes(fcu, fcu->bezt, devaltime);
index e288242..f5915e1 100644 (file)
@@ -69,15 +69,15 @@ void *fmodifiers_storage_get(FModifierStackStorage *storage, FModifier *fcm);
  */
 
 /* Template for type-info data:
- *  - make a copy of this when creating new modifiers, and just change the functions
- *    pointed to as necessary
- *  - although the naming of functions doesn't matter, it would help for code
- *    readability, to follow the same naming convention as is presented here
- *  - any functions that a constraint doesn't need to define, don't define
- *    for such cases, just use NULL
- *  - these should be defined after all the functions have been defined, so that
- *    forward-definitions/prototypes don't need to be used!
- *     - keep this copy #if-def'd so that future constraints can get based off this
+ * - make a copy of this when creating new modifiers, and just change the functions
+ *   pointed to as necessary
+ * - although the naming of functions doesn't matter, it would help for code
+ *   readability, to follow the same naming convention as is presented here
+ * - any functions that a constraint doesn't need to define, don't define
+ *   for such cases, just use NULL
+ * - these should be defined after all the functions have been defined, so that
+ *   forward-definitions/prototypes don't need to be used!
+ * - keep this copy #if-def'd so that future constraints can get based off this
  */
 #if 0
 static FModifierTypeInfo FMI_MODNAME = {
@@ -260,7 +260,7 @@ static FModifierTypeInfo FMI_GENERATOR = {
  * x is the evaluation 'time', and 'y' is the resultant value
  *
  * Functions available are
- *     sin, cos, tan, sinc (normalized sin), natural log, square root
+ * sin, cos, tan, sinc (normalized sin), natural log, square root
  */
 
 static void fcm_fn_generator_new_data(void *mdata)
@@ -460,8 +460,8 @@ static void fcm_envelope_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cv
        }
 
        /* adjust *cvalue
-        *      - fac is the ratio of how the current y-value corresponds to the reference range
-        *      - thus, the new value is found by mapping the old range to the new!
+        * - fac is the ratio of how the current y-value corresponds to the reference range
+        * - thus, the new value is found by mapping the old range to the new!
         */
        fac = (*cvalue - (env->midval + env->min)) / (env->max - env->min);
        *cvalue = min + fac * (max - min);
@@ -638,8 +638,8 @@ static float fcm_cycles_time(FModifierStackStorage *storage, FCurve *fcu, FModif
                return evaltime;
 
        /* check if modifier will do anything
-        *      1) if in data range, definitely don't do anything
-        *      2) if before first frame or after last frame, make sure some cycling is in use
+        * 1) if in data range, definitely don't do anything
+        * 2) if before first frame or after last frame, make sure some cycling is in use
         */
        if (evaltime < prevkey[0]) {
                if (data->before_mode) {
@@ -711,8 +711,8 @@ static float fcm_cycles_time(FModifierStackStorage *storage, FCurve *fcu, FModif
                /* calculate where in the cycle we are (overwrite evaltime to reflect this) */
                else if ((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)(cycle + 1) % 2)) {
                        /* when 'mirror' option is used and cycle number is odd, this cycle is played in reverse
-                        *      - for 'before' extrapolation, we need to flip in a different way, otherwise values past
-                        *        then end of the curve get referenced (result of fmod will be negative, and with different phase)
+                        * - for 'before' extrapolation, we need to flip in a different way, otherwise values past
+                        *   then end of the curve get referenced (result of fmod will be negative, and with different phase)
                         */
                        if (side < 0)
                                evaltime = prevkey[0] - cyct;
@@ -795,8 +795,8 @@ static void fcm_noise_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalu
        float noise;
 
        /* generate noise using good ol' Blender Noise
-        *      - 0.1 is passed as the 'z' value, otherwise evaluation fails for size = phase = 1
-        *        with evaltime being an integer (which happens when evaluating on frame by frame basis)
+        * - 0.1 is passed as the 'z' value, otherwise evaluation fails for size = phase = 1
+        *   with evaltime being an integer (which happens when evaluating on frame by frame basis)
         */
        noise = BLI_turbulence(data->size, evaltime - data->offset, data->phase, 0.1f, data->depth);
 
@@ -891,7 +891,7 @@ static void fcm_python_evaluate(FCurve *UNUSED(fcu), FModifier *UNUSED(fcm), flo
        //FMod_Python *data = (FMod_Python *)fcm->data;
 
        /* FIXME... need to implement this modifier...
-        *      It will need it execute a script using the custom properties
+        * It will need it execute a script using the custom properties
         */
 #endif /* WITH_PYTHON */
 }
@@ -986,7 +986,7 @@ static float fcm_stepped_time(FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(
 
        /* we snap to the start of the previous closest block of 'step_size' frames
         * after the start offset has been discarded
-        *      - i.e. round down
+        * - i.e. round down
         */
        snapblock = (int)((evaltime - data->offset) / data->step_size);
 
@@ -1264,8 +1264,8 @@ void set_active_fmodifier(ListBase *modifiers, FModifier *fcm)
 }
 
 /* Do we have any modifiers which match certain criteria
- *     - mtype - type of modifier (if 0, doesn't matter)
- *     - acttype - type of action to perform (if -1, doesn't matter)
+ * - mtype - type of modifier (if 0, doesn't matter)
+ * - acttype - type of action to perform (if -1, doesn't matter)
  */
 bool list_has_suitable_fmodifier(ListBase *modifiers, int mtype, short acttype)
 {
@@ -1397,13 +1397,13 @@ static float eval_fmodifier_influence(FModifier *fcm, float evaltime)
 }
 
 /* evaluate time modifications imposed by some F-Curve Modifiers
- *     - this step acts as an optimization to prevent the F-Curve stack being evaluated
- *       several times by modifiers requesting the time be modified, as the final result
- *       would have required using the modified time
- *     - modifiers only ever receive the unmodified time, as subsequent modifiers should be
- *       working on the 'global' result of the modified curve, not some localised segment,
- *       so nevaltime gets set to whatever the last time-modifying modifier likes...
- *     - we start from the end of the stack, as only the last one matters for now
+ * - this step acts as an optimization to prevent the F-Curve stack being evaluated
+ *   several times by modifiers requesting the time be modified, as the final result
+ *   would have required using the modified time
+ * - modifiers only ever receive the unmodified time, as subsequent modifiers should be
+ *   working on the 'global' result of the modified curve, not some localised segment,
+ *   so nevaltime gets set to whatever the last time-modifying modifier likes...
+ * - we start from the end of the stack, as only the last one matters for now
  *
  * Note: *fcu might be NULL
  */
index e89508f..a0d7591 100644 (file)
@@ -907,8 +907,8 @@ bGPDframe *BKE_gpencil_layer_find_frame(bGPDlayer *gpl, int cframe)
 }
 
 /* get the appropriate gp-frame from a given layer
- *     - this sets the layer's actframe var (if allowed to)
- *     - extension beyond range (if first gp-frame is after all frame in interest and cannot add)
+ * - this sets the layer's actframe var (if allowed to)
+ * - extension beyond range (if first gp-frame is after all frame in interest and cannot add)
  */
 bGPDframe *BKE_gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
 {
index 7cb9ffc..c11f236 100644 (file)
@@ -811,13 +811,13 @@ static const char *particle_adrcodes_to_paths(int adrcode, int *array_index)
 /* ------- */
 
 /* Allocate memory for RNA-path for some property given a blocktype, adrcode, and 'root' parts of path
- *     Input:
- *             - id                                    - the datablock that the curve's IPO block is attached to and/or which the new paths will start from
- *             - blocktype, adrcode    - determines setting to get
- *             - actname, constname,seq - used to build path
- *     Output:
- *             - array_index                   - index in property's array (if applicable) to use
- *             - return                                - the allocated path...
+ * Input:
+ *     - id                    - the datablock that the curve's IPO block is attached to and/or which the new paths will start from
+ *     - blocktype, adrcode    - determines setting to get
+ *     - actname, constname,seq - used to build path
+ * Output:
+ *     - array_index           - index in property's array (if applicable) to use
+ *     - return                - the allocated path...
  */
 static char *get_rna_access(ID *id, int blocktype, int adrcode, char actname[], char constname[], Sequence *seq, int *array_index)
 {
@@ -913,7 +913,7 @@ static char *get_rna_access(ID *id, int blocktype, int adrcode, char actname[],
        }
 
        /* check if any property found
-        *      - blocktype < 0 is special case for a specific type of driver, where we don't need a property name...
+        * - blocktype < 0 is special case for a specific type of driver, where we don't need a property name...
         */
        if ((propname == NULL) && (blocktype > 0)) {
                /* nothing was found, so exit */
@@ -1095,7 +1095,7 @@ static ChannelDriver *idriver_to_cdriver(IpoDriver *idriver)
 }
 
 /* Add F-Curve to the correct list
- *     - grpname is needed to be used as group name where relevant, and is usually derived from actname
+ * - grpname is needed to be used as group name where relevant, and is usually derived from actname
  */
 static void fcurve_add_to_list(ListBase *groups, ListBase *list, FCurve *fcu, char *grpname, int muteipo)
 {
@@ -1153,8 +1153,8 @@ static void fcurve_add_to_list(ListBase *groups, ListBase *list, FCurve *fcu, ch
 
 /* Convert IPO-Curve to F-Curve (including Driver data), and free any of the old data that
  * is not relevant, BUT do not free the IPO-Curve itself...
- *     actname: name of Action-Channel (if applicable) that IPO-Curve's IPO-block belonged to
- *     constname: name of Constraint-Channel (if applicable) that IPO-Curve's IPO-block belonged to
+ *  actname: name of Action-Channel (if applicable) that IPO-Curve's IPO-block belonged to
+ *  constname: name of Constraint-Channel (if applicable) that IPO-Curve's IPO-block belonged to
  *      seq: sequencer-strip (if applicable) that IPO-Curve's IPO-block belonged to
  */
 static void icu_to_fcurves(ID *id, ListBase *groups, ListBase *list, IpoCurve *icu, char *actname, char *constname, Sequence *seq, int muteipo)
@@ -1237,8 +1237,8 @@ static void icu_to_fcurves(ID *id, ListBase *groups, ListBase *list, IpoCurve *i
                        fcurve->array_index = abp->array_index;
 
                        /* convert keyframes
-                        *      - beztriples and bpoints are mutually exclusive, so we won't have both at the same time
-                        *      - beztriples are more likely to be encountered as they are keyframes (the other type wasn't used yet)
+                        * - beztriples and bpoints are mutually exclusive, so we won't have both at the same time
+                        * - beztriples are more likely to be encountered as they are keyframes (the other type wasn't used yet)
                         */
                        fcurve->totvert = icu->totvert;
 
@@ -1286,15 +1286,15 @@ static void icu_to_fcurves(ID *id, ListBase *groups, ListBase *list, IpoCurve *i
                unsigned int i = 0;
 
                /* get rna-path
-                *      - we will need to set the 'disabled' flag if no path is able to be made (for now)
+                * - we will need to set the 'disabled' flag if no path is able to be made (for now)
                 */
                fcu->rna_path = get_rna_access(id, icu->blocktype, icu->adrcode, actname, constname, seq, &fcu->array_index);
                if (fcu->rna_path == NULL)
                        fcu->flag |= FCURVE_DISABLED;
 
                /* convert keyframes
-                *      - beztriples and bpoints are mutually exclusive, so we won't have both at the same time
-                *      - beztriples are more likely to be encountered as they are keyframes (the other type wasn't used yet)
+                * - beztriples and bpoints are mutually exclusive, so we won't have both at the same time
+                * - beztriples are more likely to be encountered as they are keyframes (the other type wasn't used yet)
                 */
                fcu->totvert = icu->totvert;
 
@@ -1323,8 +1323,8 @@ static void icu_to_fcurves(ID *id, ListBase *groups, ListBase *list, IpoCurve *i
                                }
 
                                /* correct values for euler rotation curves
-                                *      - they were degrees/10
-                                *      - we need radians for RNA to do the right thing
+                                * - they were degrees/10
+                                * - we need radians for RNA to do the right thing
                                 */
                                if ( ((icu->blocktype == ID_OB) && ELEM(icu->adrcode, OB_ROT_X, OB_ROT_Y, OB_ROT_Z)) ||
                                     ((icu->blocktype == ID_PO) && ELEM(icu->adrcode, AC_EUL_X, AC_EUL_Y, AC_EUL_Z)) )
@@ -1337,8 +1337,8 @@ static void icu_to_fcurves(ID *id, ListBase *groups, ListBase *list, IpoCurve *i
                                }
 
                                /* correct values for path speed curves
-                                *      - their values were 0-1
-                                *      - we now need as 'frames'
+                                * - their values were 0-1
+                                * - we now need as 'frames'
                                 */
                                if ( (id) && (icu->blocktype == GS(id->name)) &&
                                     (fcu->rna_path && STREQ(fcu->rna_path, "eval_time")) )
@@ -1351,9 +1351,9 @@ static void icu_to_fcurves(ID *id, ListBase *groups, ListBase *list, IpoCurve *i
                                }
 
                                /* correct times for rotation drivers
-                                *      - need to go from degrees to radians...
-                                *  - there's only really 1 target to worry about
-                                *  - were also degrees/10
+                                * - need to go from degrees to radians...
+                                * - there's only really 1 target to worry about
+                                * - were also degrees/10
                                 */
                                if (fcu->driver && fcu->driver->variables.first) {
                                        DriverVar *dvar = fcu->driver->variables.first;
@@ -1412,10 +1412,10 @@ static void ipo_to_animato(ID *id, Ipo *ipo, char actname[], char constname[], S
        if (G.debug & G_DEBUG) printf("ipo_to_animato\n");
 
        /* validate actname and constname
-        *      - clear actname if it was one of the generic <builtin> ones (i.e. 'Object', or 'Shapes')
-        *      - actname can then be used to assign F-Curves in Action to Action Groups
-        *        (i.e. thus keeping the benefits that used to be provided by Action Channels for grouping
-        *              F-Curves for bones). This may be added later... for now let's just dump without them...
+        * - clear actname if it was one of the generic <builtin> ones (i.e. 'Object', or 'Shapes')
+        * - actname can then be used to assign F-Curves in Action to Action Groups
+        *   (i.e. thus keeping the benefits that used to be provided by Action Channels for grouping
+        *   F-Curves for bones). This may be added later... for now let's just dump without them...
         */
        if (actname) {
                if ((ipo->blocktype == ID_OB) && STREQ(actname, "Object"))
@@ -1623,8 +1623,8 @@ static void nlastrips_to_animdata(ID *id, ListBase *strips)
                        /* create a new-style NLA-strip which references this Action, then copy over relevant settings */
                        {
                                /* init a new strip, and assign the action to it
-                                *      - no need to muck around with the user-counts, since this is just
-                                *        passing over the ref to the new owner, not creating an additional ref
+                                * - no need to muck around with the user-counts, since this is just
+                                *   passing over the ref to the new owner, not creating an additional ref
                                 */
                                strip = MEM_callocN(sizeof(NlaStrip), "NlaStrip");
                                strip->act = as->act;