style cleanup: more nodes
authorCampbell Barton <ideasman42@gmail.com>
Fri, 15 Jun 2012 17:57:39 +0000 (17:57 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Fri, 15 Jun 2012 17:57:39 +0000 (17:57 +0000)
110 files changed:
source/blender/compositor/intern/COM_NodeBase.cpp
source/blender/compositor/intern/COM_NodeOperation.cpp
source/blender/compositor/intern/COM_OutputSocket.cpp
source/blender/compositor/nodes/COM_AlphaOverNode.cpp
source/blender/compositor/nodes/COM_BilateralBlurNode.cpp
source/blender/compositor/nodes/COM_BlurNode.cpp
source/blender/compositor/nodes/COM_BokehBlurNode.cpp
source/blender/compositor/nodes/COM_BokehImageNode.cpp
source/blender/compositor/nodes/COM_BoxMaskNode.cpp
source/blender/compositor/nodes/COM_BrightnessNode.cpp
source/blender/compositor/nodes/COM_ChannelMatteNode.cpp
source/blender/compositor/nodes/COM_ChromaMatteNode.cpp
source/blender/compositor/nodes/COM_ColorBalanceNode.cpp
source/blender/compositor/nodes/COM_ColorCorrectionNode.cpp
source/blender/compositor/nodes/COM_ColorCurveNode.cpp
source/blender/compositor/nodes/COM_ColorMatteNode.cpp
source/blender/compositor/nodes/COM_ColorNode.cpp
source/blender/compositor/nodes/COM_ColorRampNode.cpp
source/blender/compositor/nodes/COM_ColorSpillNode.cpp
source/blender/compositor/nodes/COM_ColorToBWNode.cpp
source/blender/compositor/nodes/COM_CombineHSVANode.cpp
source/blender/compositor/nodes/COM_CombineRGBANode.cpp
source/blender/compositor/nodes/COM_CombineYCCANode.cpp
source/blender/compositor/nodes/COM_CombineYUVANode.cpp
source/blender/compositor/nodes/COM_CompositorNode.cpp
source/blender/compositor/nodes/COM_ConvertAlphaNode.cpp
source/blender/compositor/nodes/COM_CropNode.cpp
source/blender/compositor/nodes/COM_DefocusNode.cpp
source/blender/compositor/nodes/COM_DifferenceMatteNode.cpp
source/blender/compositor/nodes/COM_DilateErodeNode.cpp
source/blender/compositor/nodes/COM_DirectionalBlurNode.cpp
source/blender/compositor/nodes/COM_DisplaceNode.cpp
source/blender/compositor/nodes/COM_DistanceMatteNode.cpp
source/blender/compositor/nodes/COM_DoubleEdgeMaskNode.cpp
source/blender/compositor/nodes/COM_EllipseMaskNode.cpp
source/blender/compositor/nodes/COM_FilterNode.cpp
source/blender/compositor/nodes/COM_FlipNode.cpp
source/blender/compositor/nodes/COM_GammaNode.cpp
source/blender/compositor/nodes/COM_GlareNode.cpp
source/blender/compositor/nodes/COM_GroupNode.cpp
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.cpp
source/blender/compositor/nodes/COM_HueSaturationValueNode.cpp
source/blender/compositor/nodes/COM_IDMaskNode.cpp
source/blender/compositor/nodes/COM_ImageNode.cpp
source/blender/compositor/nodes/COM_InvertNode.cpp
source/blender/compositor/nodes/COM_KeyingNode.cpp
source/blender/compositor/nodes/COM_KeyingScreenNode.cpp
source/blender/compositor/nodes/COM_LensDistortionNode.cpp
source/blender/compositor/nodes/COM_LuminanceMatteNode.cpp
source/blender/compositor/nodes/COM_MapUVNode.cpp
source/blender/compositor/nodes/COM_MapValueNode.cpp
source/blender/compositor/nodes/COM_MaskNode.cpp
source/blender/compositor/nodes/COM_MathNode.cpp
source/blender/compositor/nodes/COM_MixNode.cpp
source/blender/compositor/nodes/COM_MovieClipNode.cpp
source/blender/compositor/nodes/COM_MovieDistortionNode.cpp
source/blender/compositor/nodes/COM_MuteNode.cpp
source/blender/compositor/nodes/COM_NormalNode.cpp
source/blender/compositor/nodes/COM_NormalizeNode.cpp
source/blender/compositor/nodes/COM_OutputFileNode.cpp
source/blender/compositor/nodes/COM_RenderLayersNode.cpp
source/blender/compositor/nodes/COM_RotateNode.cpp
source/blender/compositor/nodes/COM_ScaleNode.cpp
source/blender/compositor/nodes/COM_SeparateHSVANode.cpp
source/blender/compositor/nodes/COM_SeparateRGBANode.cpp
source/blender/compositor/nodes/COM_SeparateYCCANode.cpp
source/blender/compositor/nodes/COM_SeparateYUVANode.cpp
source/blender/compositor/nodes/COM_SetAlphaNode.cpp
source/blender/compositor/nodes/COM_SocketProxyNode.cpp
source/blender/compositor/nodes/COM_SplitViewerNode.cpp
source/blender/compositor/nodes/COM_Stabilize2dNode.cpp
source/blender/compositor/nodes/COM_SwitchNode.cpp
source/blender/compositor/nodes/COM_TextureNode.cpp
source/blender/compositor/nodes/COM_TimeNode.cpp
source/blender/compositor/nodes/COM_TonemapNode.cpp
source/blender/compositor/nodes/COM_TransformNode.cpp
source/blender/compositor/nodes/COM_TranslateNode.cpp
source/blender/compositor/nodes/COM_ValueNode.cpp
source/blender/compositor/nodes/COM_VectorBlurNode.cpp
source/blender/compositor/nodes/COM_VectorCurveNode.cpp
source/blender/compositor/nodes/COM_ViewLevelsNode.cpp
source/blender/compositor/nodes/COM_ViewerNode.cpp
source/blender/compositor/nodes/COM_ZCombineNode.cpp
source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp
source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp
source/blender/compositor/operations/COM_CropOperation.cpp
source/blender/compositor/operations/COM_DilateErodeOperation.cpp
source/blender/compositor/operations/COM_MixAddOperation.cpp
source/blender/compositor/operations/COM_MixBlendOperation.cpp
source/blender/compositor/operations/COM_MixBurnOperation.cpp
source/blender/compositor/operations/COM_MixColorOperation.cpp
source/blender/compositor/operations/COM_MixDarkenOperation.cpp
source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
source/blender/compositor/operations/COM_MixDivideOperation.cpp
source/blender/compositor/operations/COM_MixDodgeOperation.cpp
source/blender/compositor/operations/COM_MixGlareOperation.cpp
source/blender/compositor/operations/COM_MixHueOperation.cpp
source/blender/compositor/operations/COM_MixLightenOperation.cpp
source/blender/compositor/operations/COM_MixLinearLightOperation.cpp
source/blender/compositor/operations/COM_MixMultiplyOperation.cpp
source/blender/compositor/operations/COM_MixOverlayOperation.cpp
source/blender/compositor/operations/COM_MixSaturationOperation.cpp
source/blender/compositor/operations/COM_MixScreenOperation.cpp
source/blender/compositor/operations/COM_MixSoftLightOperation.cpp
source/blender/compositor/operations/COM_MixSubtractOperation.cpp
source/blender/compositor/operations/COM_MixValueOperation.cpp
source/blender/compositor/operations/COM_NormalizeOperation.cpp
source/blender/compositor/operations/COM_TonemapOperation.cpp

index 5ffe9bdd26a5e57ad90755fe03053d1cce1b27f6..42946d7315e543fa6e6c544586d10fbb92525206 100644 (file)
@@ -31,6 +31,7 @@
 
 NodeBase::NodeBase()
 {
+       /* pass */
 }
 
 
index 1c05c2a3ae819e8888527936ebe6ae676577608b..114d9f44cef2c107e392880a4829aee643c930eb 100644 (file)
@@ -69,6 +69,7 @@ void NodeOperation::setResolutionInputSocketIndex(unsigned int index)
 }
 void NodeOperation::initExecution()
 {
+       /* pass */
 }
 
 void NodeOperation::initMutex()
@@ -93,6 +94,7 @@ void NodeOperation::deinitMutex()
 
 void NodeOperation::deinitExecution()
 {
+       /* pass */
 }
 SocketReader *NodeOperation::getInputSocketReader(unsigned int inputSocketIndex)
 {
index da08b5120035fc5f0023e50b6e6d8e2812fc780e..484254fe6de571cd8eb34a72a77c603c621afee4 100644 (file)
@@ -27,6 +27,7 @@
 
 OutputSocket::OutputSocket(DataType datatype) : Socket(datatype)
 {
+       /* pass */
 }
 
 int OutputSocket::isOutputSocket() const { return true; }
index eb3cd82117262d7d7263e7bf422e4949b559e7a4..4f3ed36aadb49af89ad85cd45857c79606c77e6a 100644 (file)
@@ -31,7 +31,7 @@
 #include "COM_SetValueOperation.h"
 #include "DNA_material_types.h" // the ramp types
 
-void AlphaOverNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void AlphaOverNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *valueSocket = this->getInputSocket(0);
        InputSocket *color1Socket = this->getInputSocket(1);
@@ -40,8 +40,8 @@ void AlphaOverNode::convertToOperations(ExecutionSystem *graph, CompositorContex
        bNode *editorNode = this->getbNode();
        
        MixBaseOperation *convertProg;
-       NodeTwoFloats *ntf = (NodeTwoFloats*)editorNode->storage;
-       if (ntf->x!= 0.0f) {
+       NodeTwoFloats *ntf = (NodeTwoFloats *)editorNode->storage;
+       if (ntf->x != 0.0f) {
                AlphaOverMixedOperation *mixOperation  = new AlphaOverMixedOperation();
                mixOperation->setX(ntf->x);
                convertProg = mixOperation;
index 6baa04ff7c2a252a5968b662c4f232124bd0946b..f96a92068f40c16567be9529b5bb5d4ec568bf4f 100644 (file)
@@ -28,6 +28,7 @@
 
 BilateralBlurNode::BilateralBlurNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void BilateralBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index fe93768161c67ff7d958d8be96ff7bf26591c0d7..1b541d81c33e238fc835d590865f818bf2c71ce4 100644 (file)
@@ -31,6 +31,7 @@
 
 BlurNode::BlurNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void BlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index ee0119230f4bfe7d3b538ab50d2930b7564d183d..296056b6c48f01b393493ac9f6b980133b7aa7d7 100644 (file)
@@ -32,6 +32,7 @@
 
 BokehBlurNode::BokehBlurNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void BokehBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index f498fa11e30052545f868c9704be78f09aca5411..75f5e07d552595f0a4f519e9209ea2434b473ce3 100644 (file)
 #include "COM_BokehImageOperation.h"
 #include "COM_ExecutionSystem.h"
 
-BokehImageNode::BokehImageNode(bNode *editorNode): Node(editorNode)
+BokehImageNode::BokehImageNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void BokehImageNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void BokehImageNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        BokehImageOperation *operation = new BokehImageOperation();
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket(0));
        graph->addOperation(operation);
-       operation->setData((NodeBokehImage*)this->getbNode()->storage);
+       operation->setData((NodeBokehImage *)this->getbNode()->storage);
        addPreviewOperation(graph, operation->getOutputSocket(0));
 }
index e99252663d0660e73ad5272d6116208bc04fc1f0..789ff265a5c81e6cee7ba49a7fa4f50d6ca74c5c 100644 (file)
 #include "COM_BoxMaskOperation.h"
 #include "COM_ExecutionSystem.h"
 
-BoxMaskNode::BoxMaskNode(bNode *editorNode): Node(editorNode)
+BoxMaskNode::BoxMaskNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void BoxMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void BoxMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        BoxMaskOperation *operation;
        operation = new BoxMaskOperation();
-       operation->setData((NodeBoxMask*)this->getbNode()->storage);
+       operation->setData((NodeBoxMask *)this->getbNode()->storage);
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph);
        this->getInputSocket(1)->relinkConnections(operation->getInputSocket(1), 1, graph);
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket(0));
index 9ccb58a45dec0b655de7715cc3a04c5fda4561ed..1e1fbdbc301b61f8e1666e2fb661840c2a359709 100644 (file)
 #include "COM_BrightnessOperation.h"
 #include "COM_ExecutionSystem.h"
 
-BrightnessNode::BrightnessNode(bNode *editorNode): Node(editorNode)
+BrightnessNode::BrightnessNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void BrightnessNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void BrightnessNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        BrightnessOperation *operation = new BrightnessOperation();
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph);
index f1d5b8d39cc195acbfe005d89a449e912ce24772..69f396396602f97aedad83874594da669d353e06 100644 (file)
 #include "COM_ConvertRGBToYUVOperation.h"
 #include "COM_SetAlphaOperation.h"
 
-ChannelMatteNode::ChannelMatteNode(bNode *editorNode): Node(editorNode)
-{}
+ChannelMatteNode::ChannelMatteNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
 void ChannelMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
@@ -36,30 +38,30 @@ void ChannelMatteNode::convertToOperations(ExecutionSystem *graph, CompositorCon
        OutputSocket *outputSocketImage = this->getOutputSocket(0);
        OutputSocket *outputSocketMatte = this->getOutputSocket(1);
 
-       NodeOperation *convert=NULL;
+       NodeOperation *convert = NULL;
        bNode *node = this->getbNode();
 
        /* colorspace */
        switch (node->custom1) {
-       case CMP_NODE_CHANNEL_MATTE_CS_RGB:
-               break;
-       case CMP_NODE_CHANNEL_MATTE_CS_HSV: /*HSV*/
-               convert = new ConvertRGBToHSVOperation();
-               break;
-       case CMP_NODE_CHANNEL_MATTE_CS_YUV: /*YUV*/
-               convert = new ConvertRGBToYUVOperation();
-               break;
-       case CMP_NODE_CHANNEL_MATTE_CS_YCC: /*YCC*/
-               convert = new ConvertRGBToYCCOperation();
-               ((ConvertRGBToYCCOperation *)convert)->setMode(0); /* BLI_YCC_ITU_BT601 */
-               break;
-       default:
-               break;
+               case CMP_NODE_CHANNEL_MATTE_CS_RGB:
+                       break;
+               case CMP_NODE_CHANNEL_MATTE_CS_HSV: /*HSV*/
+                       convert = new ConvertRGBToHSVOperation();
+                       break;
+               case CMP_NODE_CHANNEL_MATTE_CS_YUV: /*YUV*/
+                       convert = new ConvertRGBToYUVOperation();
+                       break;
+               case CMP_NODE_CHANNEL_MATTE_CS_YCC: /*YCC*/
+                       convert = new ConvertRGBToYCCOperation();
+                       ((ConvertRGBToYCCOperation *)convert)->setMode(0); /* BLI_YCC_ITU_BT601 */
+                       break;
+               default:
+                       break;
        }
 
        ChannelMatteOperation *operation = new ChannelMatteOperation();
        /* pass the ui properties to the operation */
-       operation->setSettings((NodeChroma*)node->storage, node->custom2);
+       operation->setSettings((NodeChroma *)node->storage, node->custom2);
 
        SetAlphaOperation *operationAlpha = new SetAlphaOperation();
 
index 82059ed84935968b69b9cc84e4d85500b8d0b4e0..0fb09157351eab43522dccc706dba15cb46e8137 100644 (file)
 #include "COM_ConvertRGBToYCCOperation.h"
 #include "COM_SetAlphaOperation.h"
 
-ChromaMatteNode::ChromaMatteNode(bNode *editorNode): Node(editorNode)
-{}
+ChromaMatteNode::ChromaMatteNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
 void ChromaMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
@@ -42,7 +44,7 @@ void ChromaMatteNode::convertToOperations(ExecutionSystem *graph, CompositorCont
 
        ChromaMatteOperation *operation = new ChromaMatteOperation();
        bNode *editorsnode = getbNode();
-       operation->setSettings((NodeChroma*)editorsnode->storage);
+       operation->setSettings((NodeChroma *)editorsnode->storage);
 
        inputSocketImage->relinkConnections(operationRGBToYCC_Image->getInputSocket(0), 0, graph);
        inputSocketKey->relinkConnections(operationRGBToYCC_Key->getInputSocket(0), 0, graph);
index 7b852678191bcc36fa540c5d14f7250a946b52aa..d85b1ec1de1a789f1d93d03d423384d0cd78ac49 100644 (file)
 #include "BKE_node.h"
 #include "COM_MixBlendOperation.h"
 
-ColorBalanceNode::ColorBalanceNode(bNode *editorNode): Node(editorNode)
+ColorBalanceNode::ColorBalanceNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
-void ColorBalanceNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+
+void ColorBalanceNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        InputSocket *inputImageSocket = this->getInputSocket(1);
@@ -38,16 +40,16 @@ void ColorBalanceNode::convertToOperations(ExecutionSystem *graph, CompositorCon
        
        bNode *node = this->getbNode();
        NodeColorBalance *n = (NodeColorBalance *)node->storage;
-       NodeOperation*operation;
+       NodeOperation *operation;
        if (node->custom1 == 0) {
                ColorBalanceLGGOperation *operationLGG = new ColorBalanceLGGOperation();
                {
-                               int c;
+                       int c;
        
-                               for (c = 0; c < 3; c++) {
-                                               n->lift_lgg[c] = 2.0f - n->lift[c];
-                                               n->gamma_inv[c] = (n->gamma[c] != 0.0f) ? 1.0f/n->gamma[c] : 1000000.0f;
-                               }
+                       for (c = 0; c < 3; c++) {
+                               n->lift_lgg[c] = 2.0f - n->lift[c];
+                               n->gamma_inv[c] = (n->gamma[c] != 0.0f) ? 1.0f / n->gamma[c] : 1000000.0f;
+                       }
                }
        
                operationLGG->setGain(n->gain);
index 4909f1b9895d9288923233cee39a0be2e6bd549e..41b3bebbd7bea25064452ebad4b31f4410873db0 100644 (file)
 #include "COM_ColorCorrectionOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ColorCorrectionNode::ColorCorrectionNode(bNode *editorNode): Node(editorNode)
+ColorCorrectionNode::ColorCorrectionNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void ColorCorrectionNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void ColorCorrectionNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        ColorCorrectionOperation *operation = new ColorCorrectionOperation();
        bNode *editorNode = getbNode();
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph);
        this->getInputSocket(1)->relinkConnections(operation->getInputSocket(1), 1, graph);
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket(0));
-       operation->setData((NodeColorCorrection*)editorNode->storage);
-       operation->setRedChannelEnabled((editorNode->custom1&1)>0);
-       operation->setGreenChannelEnabled((editorNode->custom1&2)>0);
-       operation->setBlueChannelEnabled((editorNode->custom1&4)>0);
+       operation->setData((NodeColorCorrection *)editorNode->storage);
+       operation->setRedChannelEnabled((editorNode->custom1 & 1) > 0);
+       operation->setGreenChannelEnabled((editorNode->custom1 & 2) > 0);
+       operation->setBlueChannelEnabled((editorNode->custom1 & 4) > 0);
        graph->addOperation(operation);
 }
index 0d331ed9b057837bcf9d9db8923759c4186d43cf..9ae11c22b6a8c46e7c92d1c204c9983df6078e86 100644 (file)
 #include "COM_ColorCurveOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ColorCurveNode::ColorCurveNode(bNode *editorNode): Node(editorNode)
+ColorCurveNode::ColorCurveNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void ColorCurveNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void ColorCurveNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        if (this->getInputSocket(2)->isConnected() || this->getInputSocket(3)->isConnected()) {
                ColorCurveOperation *operation = new ColorCurveOperation();
@@ -41,21 +42,22 @@ void ColorCurveNode::convertToOperations(ExecutionSystem *graph, CompositorConte
        
                this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket());
        
-               operation->setCurveMapping((CurveMapping*)this->getbNode()->storage);
+               operation->setCurveMapping((CurveMapping *)this->getbNode()->storage);
        
                graph->addOperation(operation);
-       } else {
+       }
+       else {
                ConstantLevelColorCurveOperation *operation = new ConstantLevelColorCurveOperation();
        
                this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph);
                this->getInputSocket(1)->relinkConnections(operation->getInputSocket(1), 1, graph);
-               bNodeSocketValueRGBA *val = (bNodeSocketValueRGBA*)this->getInputSocket(2)->getbNodeSocket()->default_value;
+               bNodeSocketValueRGBA *val = (bNodeSocketValueRGBA *)this->getInputSocket(2)->getbNodeSocket()->default_value;
                operation->setBlackLevel(val->value);
-               val = (bNodeSocketValueRGBA*)this->getInputSocket(3)->getbNodeSocket()->default_value;
+               val = (bNodeSocketValueRGBA *)this->getInputSocket(3)->getbNodeSocket()->default_value;
                operation->setWhiteLevel(val->value);
                this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket());
        
-               operation->setCurveMapping((CurveMapping*)this->getbNode()->storage);
+               operation->setCurveMapping((CurveMapping *)this->getbNode()->storage);
        
                graph->addOperation(operation);
        }
index ad117e1ca2c1717284437021661bd43d1b172987..38ab6ba8da2af61a67c12e60e2ac9914569e6734 100644 (file)
 #include "COM_ConvertRGBToHSVOperation.h"
 #include "COM_SetAlphaOperation.h"
 
-ColorMatteNode::ColorMatteNode(bNode *editorNode): Node(editorNode)
-{}
+ColorMatteNode::ColorMatteNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
 void ColorMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
@@ -40,7 +42,7 @@ void ColorMatteNode::convertToOperations(ExecutionSystem *graph, CompositorConte
 
        ColorMatteOperation *operation = new ColorMatteOperation();
        bNode *editorsnode = getbNode();
-       operation->setSettings((NodeChroma*)editorsnode->storage);
+       operation->setSettings((NodeChroma *)editorsnode->storage);
 
        inputSocketImage->relinkConnections(operationRGBToHSV_Image->getInputSocket(0), 0, graph);
        inputSocketKey->relinkConnections(operationRGBToHSV_Key->getInputSocket(0), 1, graph);
index f5fcb0177f7cea7559ff3c9a852f70e62f56fd28..65480c7aeb245eacbda3ae3f0153df1845ba6de8 100644 (file)
 #include "COM_SetColorOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ColorNode::ColorNode(bNode *editorNode): Node(editorNode)
+ColorNode::ColorNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void ColorNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void ColorNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        SetColorOperation *operation = new SetColorOperation();
        bNodeSocket *socket = this->getEditorOutputSocket(0);
-       bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA*)socket->default_value;
+       bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA *)socket->default_value;
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket());
        operation->setChannels(dval->value);
        graph->addOperation(operation);
index c6090120467dfc4fdf825a66a116cb0de0af40ac..a79c7885ae467c5014f5369e862b472c78e02de3 100644 (file)
 #include "COM_SeparateChannelOperation.h"
 #include "DNA_texture_types.h"
 
-ColorRampNode::ColorRampNode(bNode *editorNode): Node(editorNode)
-{}
+ColorRampNode::ColorRampNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
-void ColorRampNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void ColorRampNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        OutputSocket *outputSocket = this->getOutputSocket(0);
@@ -46,7 +48,7 @@ void ColorRampNode::convertToOperations(ExecutionSystem *graph, CompositorContex
                operation2->setChannel(3);
                graph->addOperation(operation2);
        }
-       operation->setColorBand((ColorBand*)editorNode->storage);
+       operation->setColorBand((ColorBand *)editorNode->storage);
        inputSocket->relinkConnections(operation->getInputSocket(0), 0, graph);
        graph->addOperation(operation);
 }
index 503ca3c8bd3fa460982d1de179ede4d3aa8710eb..0e586955ff8b6d31d544937832e533a5a893e6f1 100644 (file)
 #include "BKE_node.h"
 #include "COM_ColorSpillOperation.h"
 
-ColorSpillNode::ColorSpillNode(bNode *editorNode): Node(editorNode)
-{}
+ColorSpillNode::ColorSpillNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
 void ColorSpillNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
@@ -45,8 +47,8 @@ void ColorSpillNode::convertToOperations(ExecutionSystem *graph, CompositorConte
                // Average color spill
                operation = new ColorSpillAverageOperation();
        }
-       operation->setSettings((NodeColorspill*)editorsnode->storage);
-       operation->setSpillChannel(editorsnode->custom1-1); // Channel for spilling
+       operation->setSettings((NodeColorspill *)editorsnode->storage);
+       operation->setSpillChannel(editorsnode->custom1 - 1); // Channel for spilling
        
 
        inputSocketImage->relinkConnections(operation->getInputSocket(0), 0, graph);
index ed2869d35f2882191960ae82917fe136f8379f93..430f317eae27212d566eeb7a1593f0061d4aa9f4 100644 (file)
 #include "COM_ConvertColorToBWOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ColourToBWNode::ColourToBWNode(bNode *editorNode): Node(editorNode)
+ColourToBWNode::ColourToBWNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void ColourToBWNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void ColourToBWNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *colourSocket = this->getInputSocket(0);
        OutputSocket *valueSocket = this->getOutputSocket(0);
index a0f46ad6b6c5da07d6ec4d68499dc1e3503dfc08..beba41fade92d459fdbf9474f2f83bab545c6411 100644 (file)
 #include "COM_SetValueOperation.h"
 #include "COM_ConvertHSVToRGBOperation.h"
 
-CombineHSVANode::CombineHSVANode(bNode *editorNode): CombineRGBANode(editorNode)
+CombineHSVANode::CombineHSVANode(bNode *editorNode) : CombineRGBANode(editorNode)
 {
+       /* pass */
 }
 
-void CombineHSVANode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void CombineHSVANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        ConvertHSVToRGBOperation *operation = new ConvertHSVToRGBOperation();
        OutputSocket *outputSocket = this->getOutputSocket(0);
index e6fcc48ac5bff0deadeb402138215ba9a5f4d17d..a8cdd8c2950022d73f814622d5f8af6ecc2471fc 100644 (file)
 #include "DNA_material_types.h" // the ramp types
 
 
-CombineRGBANode::CombineRGBANode(bNode *editorNode): Node(editorNode)
+CombineRGBANode::CombineRGBANode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-
-void CombineRGBANode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void CombineRGBANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *inputRSocket = this->getInputSocket(0);
        InputSocket *inputGSocket = this->getInputSocket(1);
index ad6203ea85a121cd2a05edaa00e1bd87b7c87a63..5319eb84184a90aa3ae30754eed86cbf7984acf6 100644 (file)
@@ -22,8 +22,9 @@
 #include "COM_CombineYCCANode.h"
 #include "COM_ConvertYCCToRGBOperation.h"
 
-CombineYCCANode::CombineYCCANode(bNode *editorNode): CombineRGBANode(editorNode)
+CombineYCCANode::CombineYCCANode(bNode *editorNode) : CombineRGBANode(editorNode)
 {
+       /* pass */
 }
 
 void CombineYCCANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index ea92a40f803e31451bd0c738d4c19aa9e87fcb0d..48c2c6ca649e2c352a2765f2ea3cf4515f6f0bb5 100644 (file)
@@ -22,8 +22,9 @@
 #include "COM_CombineYUVANode.h"
 #include "COM_ConvertYUVToRGBOperation.h"
 
-CombineYUVANode::CombineYUVANode(bNode *editorNode): CombineRGBANode(editorNode)
+CombineYUVANode::CombineYUVANode(bNode *editorNode) : CombineRGBANode(editorNode)
 {
+       /* pass */
 }
 
 void CombineYUVANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index e2cc34bb6ce30d96e853295434e15a84437de55d..fccb92ddd8b979dc1c64d1c5a306d190eab50ffd 100644 (file)
 #include "COM_CompositorOperation.h"
 #include "COM_ExecutionSystem.h"
 
-CompositorNode::CompositorNode(bNode *editorNode): Node(editorNode)
+CompositorNode::CompositorNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void CompositorNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void CompositorNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *imageSocket = this->getInputSocket(0);
        InputSocket *alphaSocket = this->getInputSocket(1);
index 0b4326a17ca024c827e2587f7facd94c26dc3393..70aeee8fc276b42c49160f3beda5ab87b415382c 100644 (file)
@@ -24,7 +24,7 @@
 #include "COM_ConvertKeyToPremulOperation.h"
 #include "COM_ExecutionSystem.h"
 
-void ConvertAlphaNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void ConvertAlphaNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        NodeOperation *operation = NULL;
        bNode *node = this->getbNode();
index c58fcc874cb61d634dad81d95bc0032160ac7884..b80a3e088f2af3fa5688d96b19bc7ddf4909f3b4 100644 (file)
 
 CropNode::CropNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void CropNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void CropNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        bNode *node = getbNode();
-       NodeTwoXYs *cropSettings = (NodeTwoXYs*)node->storage;
+       NodeTwoXYs *cropSettings = (NodeTwoXYs *)node->storage;
        bool relative = (bool)node->custom2;
        bool cropImage = (bool)node->custom1;
        CropBaseOperation *operation;
index e4e19fdbe27d5879d452fbeabd4b7ae2afa501ee..d1f90b490adf6f577f27d9a03da8ab1db4607c38 100644 (file)
 #include "COM_SetValueOperation.h"
 #include "COM_GammaCorrectOperation.h"
 
-DefocusNode::DefocusNode(bNode *editorNode): Node(editorNode)
+DefocusNode::DefocusNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        bNode *node = this->getbNode();
-       Scene *scene = (Scene*)node->id;
-       Object *camob = (scene)? scene->camera: NULL;
-       NodeDefocus *data = (NodeDefocus*)node->storage;
+       Scene *scene = (Scene *)node->id;
+       Object *camob = (scene) ? scene->camera : NULL;
+       NodeDefocus *data = (NodeDefocus *)node->storage;
 
        NodeOperation *radiusOperation;
        if (data->no_zbuf) {
@@ -74,11 +75,11 @@ void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext
        }
        
        BokehImageOperation *bokeh = new BokehImageOperation();
-       NodeBokehImage * bokehdata = new NodeBokehImage();
+       NodeBokehImage *bokehdata = new NodeBokehImage();
        bokehdata->angle = data->rotation;
        bokehdata->rounding = 0.0f;
        bokehdata->flaps = data->bktype;
-       if (data->bktype<3) {
+       if (data->bktype < 3) {
                bokehdata->flaps = 5;
                bokehdata->rounding = 1.0f;
        }
@@ -96,8 +97,8 @@ void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext
        addLink(graph, bokeh->getOutputSocket(), operation->getInputSocket(1));
        addLink(graph, radiusOperation->getOutputSocket(), operation->getInputSocket(2));
        if (data->gamco) {
-               GammaCorrectOperation * correct = new GammaCorrectOperation();
-               GammaUncorrectOperation * inverse = new GammaUncorrectOperation();
+               GammaCorrectOperation *correct = new GammaCorrectOperation();
+               GammaUncorrectOperation *inverse = new GammaUncorrectOperation();
                this->getInputSocket(0)->relinkConnections(correct->getInputSocket(0), 0, graph);
                addLink(graph, correct->getOutputSocket(), operation->getInputSocket(0));
                addLink(graph, operation->getOutputSocket(), inverse->getInputSocket(0));
index 596fefff77c8ac7a160ba06b3d41b22ea32a0741..6dca049a6ae8b50b92efda02b0872b6cab3b7179 100644 (file)
 #include "COM_DifferenceMatteOperation.h"
 #include "COM_SetAlphaOperation.h"
 
-DifferenceMatteNode::DifferenceMatteNode(bNode *editorNode): Node(editorNode)
-{}
+DifferenceMatteNode::DifferenceMatteNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
-void DifferenceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void DifferenceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        InputSocket *inputSocket2 = this->getInputSocket(1);
@@ -36,15 +38,15 @@ void DifferenceMatteNode::convertToOperations(ExecutionSystem *graph, Compositor
        OutputSocket *outputSocketMatte = this->getOutputSocket(1);
        bNode *editorNode = this->getbNode();
 
-       DifferenceMatteOperation * operationSet = new DifferenceMatteOperation();
-       operationSet->setSettings((NodeChroma*)editorNode->storage);
+       DifferenceMatteOperation *operationSet = new DifferenceMatteOperation();
+       operationSet->setSettings((NodeChroma *)editorNode->storage);
        inputSocket->relinkConnections(operationSet->getInputSocket(0), 0, graph);
        inputSocket2->relinkConnections(operationSet->getInputSocket(1), 1, graph);
 
        outputSocketMatte->relinkConnections(operationSet->getOutputSocket(0));
        graph->addOperation(operationSet);
 
-       SetAlphaOperation * operation = new SetAlphaOperation();
+       SetAlphaOperation *operation = new SetAlphaOperation();
        addLink(graph, operationSet->getInputSocket(0)->getConnection()->getFromSocket(), operation->getInputSocket(0));
        addLink(graph, operationSet->getOutputSocket(), operation->getInputSocket(1));
        outputSocketImage->relinkConnections(operation->getOutputSocket());
index fe9e97a3e4b1bb45660a7d375cb2806801766d5e..6ee5b2a2b0d72689c0650e4953d56b39468c3e8f 100644 (file)
@@ -29,6 +29,7 @@
 
 DilateErodeNode::DilateErodeNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void DilateErodeNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index d096ef977f81f8365a85d0b96aea1eb662344614..dee0e6a88dab4559248990863ec5d3d386f2ff2a 100644 (file)
@@ -28,6 +28,7 @@
 
 DirectionalBlurNode::DirectionalBlurNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void DirectionalBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index 9604db378bcf1e1b7fd7112247cb2b472fc41e59..41fbfd61981b2a1606648b57980da4fdba35f405 100644 (file)
 #include "COM_DisplaceSimpleOperation.h"
 #include "COM_ExecutionSystem.h"
 
-DisplaceNode::DisplaceNode(bNode *editorNode): Node(editorNode)
+DisplaceNode::DisplaceNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void DisplaceNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void DisplaceNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        NodeOperation *operation;
        if (context->getQuality() == COM_QUALITY_LOW)
index 20a55ae195ca0d5a618ba977e6b91bdc1292d066..d6730ef6a007fed49b9509a73515b7d573346023 100644 (file)
 #include "COM_DistanceMatteOperation.h"
 #include "COM_SetAlphaOperation.h"
 
-DistanceMatteNode::DistanceMatteNode(bNode *editorNode): Node(editorNode)
-{}
+DistanceMatteNode::DistanceMatteNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
 void DistanceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
@@ -36,7 +38,7 @@ void DistanceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorCo
 
        DistanceMatteOperation *operation = new DistanceMatteOperation();
        bNode *editorsnode = getbNode();
-       operation->setSettings((NodeChroma*)editorsnode->storage);
+       operation->setSettings((NodeChroma *)editorsnode->storage);
 
        inputSocketImage->relinkConnections(operation->getInputSocket(0), 0, graph);
        inputSocketKey->relinkConnections(operation->getInputSocket(1), 1, graph);
index ab9e101dad81a31b4ed5b47f804472f1462453c1..57c319e763028e3cc0e00a70d8e1fb2c557b26aa 100644 (file)
 #include "DNA_scene_types.h"
 #include "COM_ExecutionSystem.h"
 
-DoubleEdgeMaskNode::DoubleEdgeMaskNode(bNode *editorNode): Node(editorNode)
+DoubleEdgeMaskNode::DoubleEdgeMaskNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void DoubleEdgeMaskNode::convertToOperations(ExecutionSystem *system, CompositorContext * context)
+void DoubleEdgeMaskNode::convertToOperations(ExecutionSystem *system, CompositorContext *context)
 {
        DoubleEdgeMaskOperation *operation;
        bNode *bnode = this->getbNode();
index f5003c4be945cd33a01672c5161c3279d4423aa1..23410c6a115eb1959ceabfd78a16f3a478c350af 100644 (file)
 #include "COM_EllipseMaskOperation.h"
 #include "COM_ExecutionSystem.h"
 
-EllipseMaskNode::EllipseMaskNode(bNode *editorNode): Node(editorNode)
+EllipseMaskNode::EllipseMaskNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void EllipseMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void EllipseMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        EllipseMaskOperation *operation;
        operation = new EllipseMaskOperation();
-       operation->setData((NodeEllipseMask*)this->getbNode()->storage);
+       operation->setData((NodeEllipseMask *)this->getbNode()->storage);
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph);
        this->getInputSocket(1)->relinkConnections(operation->getInputSocket(1), 1, graph);
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket(0));
index 7700bceb4abbf50b68a8067042c4e28e3c7c5bc8..23f87805821c8ac4a9bfc6974347dfe1e57fea6f 100644 (file)
 #include "BKE_node.h"
 #include "COM_MixBlendOperation.h"
 
-FilterNode::FilterNode(bNode *editorNode): Node(editorNode)
+FilterNode::FilterNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void FilterNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void FilterNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        InputSocket *inputImageSocket = this->getInputSocket(1);
@@ -39,38 +40,38 @@ void FilterNode::convertToOperations(ExecutionSystem *graph, CompositorContext *
        ConvolutionFilterOperation *operation = NULL;
        
        switch (this->getbNode()->custom1) {
-       case CMP_FILT_SOFT:
-               operation = new ConvolutionFilterOperation();
-               operation->set3x3Filter(1/16.0f, 2/16.0f, 1/16.0f, 2/16.0f, 4/16.0f, 2/16.0f, 1/16.0f, 2/16.0f, 1/16.0f);
-               break;
-       case CMP_FILT_SHARP:
-               operation = new ConvolutionFilterOperation();
-               operation->set3x3Filter(-1,-1,-1,-1,9,-1,-1,-1,-1);
-               break;
-       case CMP_FILT_LAPLACE:
-               operation = new ConvolutionFilterOperation();
-               operation->set3x3Filter(-1/8.0f, -1/8.0f, -1/8.0f, -1/8.0f, 1.0f, -1/8.0f, -1/8.0f, -1/8.0f, -1/8.0f);
-               break;
-       case CMP_FILT_SOBEL:
-               operation = new ConvolutionEdgeFilterOperation();
-               operation->set3x3Filter(1,2,1,0,0,0,-1,-2,-1);
-               break;
-       case CMP_FILT_PREWITT:
-               operation = new ConvolutionEdgeFilterOperation();
-               operation->set3x3Filter(1,1,1,0,0,0,-1,-1,-1);
-               break;
-       case CMP_FILT_KIRSCH:
-               operation = new ConvolutionEdgeFilterOperation();
-               operation->set3x3Filter(5,5,5,-3,-3,-3,-2,-2,-2);
-               break;
-       case CMP_FILT_SHADOW:
-               operation = new ConvolutionFilterOperation();
-               operation->set3x3Filter(1,2,1,0,1,0,-1,-2,-1);
-               break;
-       default:
-               operation = new ConvolutionFilterOperation();
-               operation->set3x3Filter(0,0,0,0,1,0,0,0,0);
-               break;
+               case CMP_FILT_SOFT:
+                       operation = new ConvolutionFilterOperation();
+                       operation->set3x3Filter(1 / 16.0f, 2 / 16.0f, 1 / 16.0f, 2 / 16.0f, 4 / 16.0f, 2 / 16.0f, 1 / 16.0f, 2 / 16.0f, 1 / 16.0f);
+                       break;
+               case CMP_FILT_SHARP:
+                       operation = new ConvolutionFilterOperation();
+                       operation->set3x3Filter(-1, -1, -1, -1, 9, -1, -1, -1, -1);
+                       break;
+               case CMP_FILT_LAPLACE:
+                       operation = new ConvolutionFilterOperation();
+                       operation->set3x3Filter(-1 / 8.0f, -1 / 8.0f, -1 / 8.0f, -1 / 8.0f, 1.0f, -1 / 8.0f, -1 / 8.0f, -1 / 8.0f, -1 / 8.0f);
+                       break;
+               case CMP_FILT_SOBEL:
+                       operation = new ConvolutionEdgeFilterOperation();
+                       operation->set3x3Filter(1, 2, 1, 0, 0, 0, -1, -2, -1);
+                       break;
+               case CMP_FILT_PREWITT:
+                       operation = new ConvolutionEdgeFilterOperation();
+                       operation->set3x3Filter(1, 1, 1, 0, 0, 0, -1, -1, -1);
+                       break;
+               case CMP_FILT_KIRSCH:
+                       operation = new ConvolutionEdgeFilterOperation();
+                       operation->set3x3Filter(5, 5, 5, -3, -3, -3, -2, -2, -2);
+                       break;
+               case CMP_FILT_SHADOW:
+                       operation = new ConvolutionFilterOperation();
+                       operation->set3x3Filter(1, 2, 1, 0, 1, 0, -1, -2, -1);
+                       break;
+               default:
+                       operation = new ConvolutionFilterOperation();
+                       operation->set3x3Filter(0, 0, 0, 0, 1, 0, 0, 0, 0);
+                       break;
        }
        
        inputImageSocket->relinkConnections(operation->getInputSocket(0), 1, graph);
index 0830c7578331bf64b3271246f6dae8a6a1f6d2fc..a50297aae1a44c78b94a3ceec1fc9f81b03a1baa 100644 (file)
 
 FlipNode::FlipNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void FlipNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void FlipNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        OutputSocket *outputSocket = this->getOutputSocket(0);
        FlipOperation *operation = new FlipOperation();
        switch (this->getbNode()->custom1) {
-       case 0: /// @TODO: I didn't find any constants in the old implementation, should I introduce them.
-               operation->setFlipX(true);
-               operation->setFlipY(false);
-               break;
-       case 1:
-               operation->setFlipX(false);
-               operation->setFlipY(true);
-               break;
-       case 2:
-               operation->setFlipX(true);
-               operation->setFlipY(true);
-               break;
+               case 0: /// @TODO: I didn't find any constants in the old implementation, should I introduce them.
+                       operation->setFlipX(true);
+                       operation->setFlipY(false);
+                       break;
+               case 1:
+                       operation->setFlipX(false);
+                       operation->setFlipY(true);
+                       break;
+               case 2:
+                       operation->setFlipX(true);
+                       operation->setFlipY(true);
+                       break;
        }
        
        inputSocket->relinkConnections(operation->getInputSocket(0), 0, graph);
index 58b0560761819d8a9e35d053d6de48db4ca7ea6c..52699c83bf9b8a26826205396f9c0b97a44ff0f2 100644 (file)
 #include "COM_GammaOperation.h"
 #include "COM_ExecutionSystem.h"
 
-GammaNode::GammaNode(bNode *editorNode): Node(editorNode)
+GammaNode::GammaNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void GammaNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void GammaNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        GammaOperation *operation = new GammaOperation();
        
index dcb8f3a3a4cf086e5e7aa13c50f520afe2ec5268..7b34fa4d286a50428d121cf70a6e9d33607bab7d 100644 (file)
 #include "COM_GlareGhostOperation.h"
 #include "COM_GlareFogGlowOperation.h"
 
-GlareNode::GlareNode(bNode *editorNode): Node(editorNode)
+GlareNode::GlareNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void GlareNode::convertToOperations(ExecutionSystem *system, CompositorContext * context)\
-{
+void GlareNode::convertToOperations(ExecutionSystem *system, CompositorContext *context) \
+       {
        bNode *node = this->getbNode();
-       NodeGlare *glare = (NodeGlare*)node->storage;
+       NodeGlare *glare = (NodeGlare *)node->storage;
        
-       GlareBaseOperation * glareoperation = NULL;
+       GlareBaseOperation *glareoperation = NULL;
        
        switch (glare->type) {
        
-       default:
-       case 3:
-               glareoperation = new GlareGhostOperation();
-               break;
-       case 2: // streaks
-               glareoperation = new GlareStreaksOperation();
-               break;
-       case 1: // fog glow
-               glareoperation = new GlareFogGlowOperation();
-               break;
-       case 0: // simple star
-               glareoperation = new GlareSimpleStarOperation();
-               break;
+               default:
+               case 3:
+                       glareoperation = new GlareGhostOperation();
+                       break;
+               case 2: // streaks
+                       glareoperation = new GlareStreaksOperation();
+                       break;
+               case 1: // fog glow
+                       glareoperation = new GlareFogGlowOperation();
+                       break;
+               case 0: // simple star
+                       glareoperation = new GlareSimpleStarOperation();
+                       break;
        }
        GlareThresholdOperation *thresholdOperation = new GlareThresholdOperation();
-       SetValueOperation * mixvalueoperation = new SetValueOperation();
-       MixGlareOperation * mixoperation = new MixGlareOperation();
+       SetValueOperation *mixvalueoperation = new SetValueOperation();
+       MixGlareOperation *mixoperation = new MixGlareOperation();
        mixoperation->getInputSocket(2)->setResizeMode(COM_SC_FIT);
 
        this->getInputSocket(0)->relinkConnections(thresholdOperation->getInputSocket(0), 0, system);
@@ -72,7 +73,7 @@ void GlareNode::convertToOperations(ExecutionSystem *system, CompositorContext *
 
        thresholdOperation->setGlareSettings(glare);
        glareoperation->setGlareSettings(glare);
-       mixvalueoperation->setValue(0.5f+glare->mix*0.5f);
+       mixvalueoperation->setValue(0.5f + glare->mix * 0.5f);
        mixoperation->setResolutionInputSocketIndex(1);
 
        system->addOperation(glareoperation);
@@ -80,4 +81,4 @@ void GlareNode::convertToOperations(ExecutionSystem *system, CompositorContext *
        system->addOperation(mixvalueoperation);
        system->addOperation(mixoperation);
        
-}
+       }
index 8a8c1db86b4ab41612e70326e1e008a0310ebdc6..e5255b6bb873902d9f8c9ef1f9ae7d8169580e4f 100644 (file)
 #include "COM_SocketProxyNode.h"
 #include "COM_ExecutionSystemHelper.h"
 
-GroupNode::GroupNode(bNode *editorNode): Node(editorNode)
+GroupNode::GroupNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void GroupNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void GroupNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
+       /* pass */
 }
 
 void GroupNode::ungroup(ExecutionSystem &system)
 {
-       bNode * bnode = this->getbNode();
-       vector<InputSocket*> &inputsockets = this->getInputSockets();
-       vector<OutputSocket*> &outputsockets = this->getOutputSockets();
+       bNode *bnode = this->getbNode();
+       vector<InputSocket *> &inputsockets = this->getInputSockets();
+       vector<OutputSocket *> &outputsockets = this->getOutputSockets();
        unsigned int index;
 
        /* get the node list size _before_ adding proxy nodes, so they are available for linking */
        int nodes_start = system.getNodes().size();
 
-       for (index = 0 ; index < inputsockets.size();index ++) {
-               InputSocket * inputSocket = inputsockets[index];
+       for (index = 0; index < inputsockets.size(); index++) {
+               InputSocket *inputSocket = inputsockets[index];
                bNodeSocket *editorInput = inputSocket->getbNodeSocket();
                if (editorInput->groupsock) {
-                       SocketProxyNode * proxy = new SocketProxyNode(bnode, editorInput, editorInput->groupsock);
+                       SocketProxyNode *proxy = new SocketProxyNode(bnode, editorInput, editorInput->groupsock);
                        inputSocket->relinkConnections(proxy->getInputSocket(0), index, &system);
                        ExecutionSystemHelper::addNode(system.getNodes(), proxy);
                }
        }
 
-       for (index = 0 ; index < outputsockets.size();index ++) {
-               OutputSocket * outputSocket = outputsockets[index];
+       for (index = 0; index < outputsockets.size(); index++) {
+               OutputSocket *outputSocket = outputsockets[index];
                bNodeSocket *editorOutput = outputSocket->getbNodeSocket();
                if (editorOutput->groupsock) {
-                       SocketProxyNode * proxy = new SocketProxyNode(bnode, editorOutput->groupsock, editorOutput);
+                       SocketProxyNode *proxy = new SocketProxyNode(bnode, editorOutput->groupsock, editorOutput);
                        outputSocket->relinkConnections(proxy->getOutputSocket(0));
                        ExecutionSystemHelper::addNode(system.getNodes(), proxy);
                }
        }
 
-       bNodeTree *subtree = (bNodeTree*)bnode->id;
+       bNodeTree *subtree = (bNodeTree *)bnode->id;
        ExecutionSystemHelper::addbNodeTree(system, nodes_start, subtree, bnode);
 }
index ae96a8c9fb826c1304387bbe65dff68859ea2f52..6057a7f0e6c2018b7926726dc9989bed985fc5b2 100644 (file)
 #include "DNA_node_types.h"
 #include "COM_HueSaturationValueCorrectOperation.h"
 
-HueSaturationValueCorrectNode::HueSaturationValueCorrectNode(bNode *editorNode): Node(editorNode)
+HueSaturationValueCorrectNode::HueSaturationValueCorrectNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void HueSaturationValueCorrectNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void HueSaturationValueCorrectNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *valueSocket = this->getInputSocket(0);
        InputSocket *colourSocket = this->getInputSocket(1);
        OutputSocket *outputSocket = this->getOutputSocket(0);
        bNode *editorsnode = getbNode();
-       CurveMapping *storage = (CurveMapping*)editorsnode->storage;
+       CurveMapping *storage = (CurveMapping *)editorsnode->storage;
        
        if (colourSocket->isConnected() && outputSocket->isConnected()) {
-               ConvertRGBToHSVOperation * rgbToHSV = new ConvertRGBToHSVOperation();
-               ConvertHSVToRGBOperation * hsvToRGB = new ConvertHSVToRGBOperation();
+               ConvertRGBToHSVOperation *rgbToHSV = new ConvertRGBToHSVOperation();
+               ConvertHSVToRGBOperation *hsvToRGB = new ConvertHSVToRGBOperation();
                HueSaturationValueCorrectOperation *changeHSV = new HueSaturationValueCorrectOperation();
-               MixBlendOperation * blend = new MixBlendOperation();
+               MixBlendOperation *blend = new MixBlendOperation();
        
                colourSocket->relinkConnections(rgbToHSV->getInputSocket(0), 1, graph);
                addLink(graph, rgbToHSV->getOutputSocket(), changeHSV->getInputSocket(0));
index 32c7d4719a42d9d97130e59f2dba4fe3aa599a73..ef501317e489899f9ad3b80d84a940fa7556fc80 100644 (file)
 #include "COM_ChangeHSVOperation.h"
 #include "DNA_node_types.h"
 
-HueSaturationValueNode::HueSaturationValueNode(bNode *editorNode): Node(editorNode)
+HueSaturationValueNode::HueSaturationValueNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void HueSaturationValueNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void HueSaturationValueNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *valueSocket = this->getInputSocket(0);
        InputSocket *colourSocket = this->getInputSocket(1);
        OutputSocket *outputSocket = this->getOutputSocket(0);
        bNode *editorsnode = getbNode();
-       NodeHueSat *storage = (NodeHueSat*)editorsnode->storage;
+       NodeHueSat *storage = (NodeHueSat *)editorsnode->storage;
 
-       ConvertRGBToHSVOperation * rgbToHSV = new ConvertRGBToHSVOperation();
-       ConvertHSVToRGBOperation * hsvToRGB = new ConvertHSVToRGBOperation();
+       ConvertRGBToHSVOperation *rgbToHSV = new ConvertRGBToHSVOperation();
+       ConvertHSVToRGBOperation *hsvToRGB = new ConvertHSVToRGBOperation();
        ChangeHSVOperation *changeHSV = new ChangeHSVOperation();
-       MixBlendOperation * blend = new MixBlendOperation();
+       MixBlendOperation *blend = new MixBlendOperation();
 
        colourSocket->relinkConnections(rgbToHSV->getInputSocket(0), 0, graph);
        addLink(graph, rgbToHSV->getOutputSocket(), changeHSV->getInputSocket(0));
index 82d3ae8ca29f82fe78a0bf0452eb45eb898f14fb..4005e5d2900c9f02bf2c019c4cc8edf13f0294da 100644 (file)
 #include "COM_ExecutionSystem.h"
 #include "COM_AntiAliasOperation.h"
 
-IDMaskNode::IDMaskNode(bNode *editorNode): Node(editorNode)
+IDMaskNode::IDMaskNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
-void IDMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void IDMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        bNode *bnode = this->getbNode();
        IDMaskOperation *operation;
@@ -37,11 +38,11 @@ void IDMaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext *
        operation->setObjectIndex(bnode->custom1);
        
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph);
-       if (bnode->custom2==0 || context->getScene()->r.scemode & R_FULL_SAMPLE) {
+       if (bnode->custom2 == 0 || context->getScene()->r.scemode & R_FULL_SAMPLE) {
                this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket(0));
        }
        else {
-               AntiAliasOperation * antiAliasOperation = new AntiAliasOperation();
+               AntiAliasOperation *antiAliasOperation = new AntiAliasOperation();
                addLink(graph, operation->getOutputSocket(), antiAliasOperation->getInputSocket(0));
                this->getOutputSocket(0)->relinkConnections(antiAliasOperation->getOutputSocket(0));
                graph->addOperation(antiAliasOperation);
index cfd530173a98409fbe0258b37a285d2315eafcaa..addde140b9f7d3bb935f427402b7f7f4f0aaf15c 100644 (file)
 #include "BKE_node.h"
 #include "BLI_utildefines.h"
 
-ImageNode::ImageNode(bNode *editorNode): Node(editorNode)
+ImageNode::ImageNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
+
 }
 NodeOperation *ImageNode::doMultilayerCheck(ExecutionSystem *system, RenderLayer *rl, Image *image, ImageUser *user, int framenumber, int outputsocketIndex, int pass, DataType datatype)
 {
        OutputSocket *outputSocket = this->getOutputSocket(outputsocketIndex);
-       MultilayerBaseOperation * operation = NULL;
+       MultilayerBaseOperation *operation = NULL;
        switch (datatype) {
-       case COM_DT_VALUE:
-               operation = new MultilayerValueOperation(pass);
-               break;
-       case COM_DT_VECTOR:
-               operation = new MultilayerVectorOperation(pass);
-               break;
-       case COM_DT_COLOR:
-               operation = new MultilayerColorOperation(pass);
-               break;
-       default:
-               break;
+               case COM_DT_VALUE:
+                       operation = new MultilayerValueOperation(pass);
+                       break;
+               case COM_DT_VECTOR:
+                       operation = new MultilayerVectorOperation(pass);
+                       break;
+               case COM_DT_COLOR:
+                       operation = new MultilayerColorOperation(pass);
+                       break;
+               default:
+                       break;
        }
        operation->setImage(image);
        operation->setRenderLayer(rl);
@@ -57,52 +59,52 @@ NodeOperation *ImageNode::doMultilayerCheck(ExecutionSystem *system, RenderLayer
        return operation;
 }
 
-void ImageNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void ImageNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        /// Image output
        OutputSocket *outputImage = this->getOutputSocket(0);
        bNode *editorNode = this->getbNode();
-       Image *image = (Image*)editorNode->id;
-       ImageUser *imageuser = (ImageUser*)editorNode->storage;
+       Image *image = (Image *)editorNode->id;
+       ImageUser *imageuser = (ImageUser *)editorNode->storage;
        int framenumber = context->getFramenumber();
        int numberOfOutputs = this->getNumberOfOutputSockets();
        BKE_image_user_frame_calc(imageuser, context->getFramenumber(), 0);
 
        /* force a load, we assume iuser index will be set OK anyway */
-       if (image && image->type==IMA_TYPE_MULTILAYER) {
+       if (image && image->type == IMA_TYPE_MULTILAYER) {
                BKE_image_get_ibuf(image, imageuser);
                if (image->rr) {
-                       RenderLayer *rl = (RenderLayer*)BLI_findlink(&image->rr->layers, imageuser->layer);
+                       RenderLayer *rl = (RenderLayer *)BLI_findlink(&image->rr->layers, imageuser->layer);
                        if (rl) {
-                               OutputSocket * socket;
+                               OutputSocket *socket;
                                int index;
-                               for (index = 0 ; index < numberOfOutputs ; index ++) {
+                               for (index = 0; index < numberOfOutputs; index++) {
                                        socket = this->getOutputSocket(index);
                                        if (socket->isConnected() || index == 0) {
                                                bNodeSocket *bnodeSocket = socket->getbNodeSocket();
-                                               NodeImageLayer *storage = (NodeImageLayer*)bnodeSocket->storage;
+                                               NodeImageLayer *storage = (NodeImageLayer *)bnodeSocket->storage;
                                                int passindex = storage->pass_index;
                                                
                                                RenderPass *rpass = (RenderPass *)BLI_findlink(&rl->passes, passindex);
                                                if (rpass) {
-                                                       NodeOperation * operation = NULL;
+                                                       NodeOperation *operation = NULL;
                                                        imageuser->pass = passindex;
                                                        switch (rpass->channels) {
-                                                       case 1:
-                                                               operation = doMultilayerCheck(graph, rl, image, imageuser, framenumber, index, passindex, COM_DT_VALUE);
-                                                               break;
-                                                       /* using image operations for both 3 and 4 channels (RGB and RGBA respectively) */
-                                                       /* XXX any way to detect actual vector images? */
-                                                       case 3:
-                                                               operation = doMultilayerCheck(graph, rl, image, imageuser, framenumber, index, passindex, COM_DT_VECTOR);
-                                                               break;
-                                                       case 4:
-                                                               operation = doMultilayerCheck(graph, rl, image, imageuser, framenumber, index, passindex, COM_DT_COLOR);
-                                                               break;
-                                                       
-                                                       default:
-                                                       /* XXX add a dummy operation? */
-                                                       break;
+                                                               case 1:
+                                                                       operation = doMultilayerCheck(graph, rl, image, imageuser, framenumber, index, passindex, COM_DT_VALUE);
+                                                                       break;
+                                                               /* using image operations for both 3 and 4 channels (RGB and RGBA respectively) */
+                                                               /* XXX any way to detect actual vector images? */
+                                                               case 3:
+                                                                       operation = doMultilayerCheck(graph, rl, image, imageuser, framenumber, index, passindex, COM_DT_VECTOR);
+                                                                       break;
+                                                               case 4:
+                                                                       operation = doMultilayerCheck(graph, rl, image, imageuser, framenumber, index, passindex, COM_DT_COLOR);
+                                                                       break;
+
+                                                               default:
+                                                                       /* XXX add a dummy operation? */
+                                                                       break;
                                                        }
                                                        if (index == 0 && operation) {
                                                                addPreviewOperation(graph, operation->getOutputSocket());
index 5d039239fbe41b7620b9e5d5ebc42c645474c5aa..c468bda1b67e3cf65f3caceb950b2b00ce60b5d4 100644 (file)
 #include "COM_ExecutionSystem.h"
 #include "BKE_node.h"
 
-InvertNode::InvertNode(bNode *editorNode): Node(editorNode)
+InvertNode::InvertNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void InvertNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void InvertNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InvertOperation *operation = new InvertOperation();
        bNode *node = this->getbNode();
index 75a2fe966461f2d8969032fbea67626bbf75fdd4..50c1903982ee5ac3d2c5f947c5505a34638f34a9 100644 (file)
@@ -41,8 +41,9 @@
 
 #include "COM_SetAlphaOperation.h"
 
-KeyingNode::KeyingNode(bNode *editorNode): Node(editorNode)
+KeyingNode::KeyingNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 OutputSocket *KeyingNode::setupPreBlur(ExecutionSystem *graph, InputSocket *inputImage, int size, OutputSocket **originalImage)
@@ -189,7 +190,7 @@ void KeyingNode::convertToOperations(ExecutionSystem *graph, CompositorContext *
 
        postprocessedMatte = keyingOperation->getOutputSocket();
 
-       if (keying_data->clip_black > 0.0f || keying_data->clip_white< 1.0f) {
+       if (keying_data->clip_black > 0.0f || keying_data->clip_white < 1.0f) {
                postprocessedMatte = setupClip(graph, postprocessedMatte,
                                               keying_data->edge_kernel_radius, keying_data->edge_kernel_tolerance,
                                               keying_data->clip_black, keying_data->clip_white, false);
index ad58adae48bfe24f1c1d69bc32c5fef069527e69..0fb8d45d066061d35ce3ea6eb4359da458bade53 100644 (file)
@@ -29,11 +29,12 @@ extern "C" {
        #include "DNA_movieclip_types.h"
 }
 
-KeyingScreenNode::KeyingScreenNode(bNode *editorNode): Node(editorNode)
+KeyingScreenNode::KeyingScreenNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void KeyingScreenNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void KeyingScreenNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        OutputSocket *outputScreen = this->getOutputSocket(0);
 
index e55dd5e64d8cb635c592e3672eccdf1533f8e2c8..03034e34eb70374ce24884b6154888874110930a 100644 (file)
 #include "COM_ProjectorLensDistortionOperation.h"
 #include "COM_ScreenLensDistortionOperation.h"
 
-LensDistortionNode::LensDistortionNode(bNode *editorNode): Node(editorNode)
+LensDistortionNode::LensDistortionNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void LensDistortionNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void LensDistortionNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        bNode *editorNode = this->getbNode();
-       NodeLensDist * data = (NodeLensDist*)editorNode->storage;
+       NodeLensDist *data = (NodeLensDist *)editorNode->storage;
        if (data->proj) {
                ProjectorLensDistortionOperation *operation = new ProjectorLensDistortionOperation();
 
index 3797621610676a55aac362a5f9327904712d204c..be949e2cacb7c8b915194ba3496d5b79f6700d1c 100644 (file)
 #include "COM_ConvertRGBToYUVOperation.h"
 #include "COM_SetAlphaOperation.h"
 
-LuminanceMatteNode::LuminanceMatteNode(bNode *editorNode): Node(editorNode)
-{}
+LuminanceMatteNode::LuminanceMatteNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
 void LuminanceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
@@ -37,7 +39,7 @@ void LuminanceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorC
        ConvertRGBToYUVOperation *rgbToYUV = new ConvertRGBToYUVOperation();
        LuminanceMatteOperation *operationSet = new LuminanceMatteOperation();
        bNode *editorsnode = getbNode();
-       operationSet->setSettings((NodeChroma*)editorsnode->storage);
+       operationSet->setSettings((NodeChroma *)editorsnode->storage);
 
        inputSocket->relinkConnections(rgbToYUV->getInputSocket(0), 0, graph);
        addLink(graph, rgbToYUV->getOutputSocket(), operationSet->getInputSocket(0));
index e0e7e2594edd9d1464199734df290e2c136df7f4..447b8239a93c44fbbf49ab3f6bf3f24039e726de 100644 (file)
 #include "COM_MapUVOperation.h"
 #include "COM_ExecutionSystem.h"
 
-MapUVNode::MapUVNode(bNode *editorNode): Node(editorNode)
+MapUVNode::MapUVNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void MapUVNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void MapUVNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        MapUVOperation *operation = new MapUVOperation();
 
index f56662b1d64cb76119e2349fa5be34bfbf265328..ba2fc804f425f590b38d9504af5652e230cd192f 100644 (file)
 #include "COM_MapValueOperation.h"
 #include "COM_ExecutionSystem.h"
 
-MapValueNode::MapValueNode(bNode *editorNode): Node(editorNode)
+MapValueNode::MapValueNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void MapValueNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void MapValueNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *colourSocket = this->getInputSocket(0);
        OutputSocket *valueSocket = this->getOutputSocket(0);
-       TexMapping *storage =  (TexMapping*)this->getbNode()->storage;
+       TexMapping *storage =  (TexMapping *)this->getbNode()->storage;
        MapValueOperation *convertProg = new MapValueOperation();
        convertProg->setSettings(storage);
        colourSocket->relinkConnections(convertProg->getInputSocket(0), 0, graph);
index 4371a848a3dd5c894595cda4992c98b6d1a9958b..ed07e41a6497a3fc9f227a98d64c19ca0b8ba0ad 100644 (file)
@@ -29,11 +29,12 @@ extern "C" {
        #include "DNA_mask_types.h"
 }
 
-MaskNode::MaskNode(bNode *editorNode): Node(editorNode)
+MaskNode::MaskNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void MaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void MaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        const RenderData *data = &context->getScene()->r;
 
@@ -54,7 +55,7 @@ void MaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * c
 
        operation->setMask(mask);
        operation->setFramenumber(context->getFramenumber());
-    operation->setSmooth((bool)editorNode->custom1);
+       operation->setSmooth((bool)editorNode->custom1);
 
        graph->addOperation(operation);
 }
index eabd0481e3859a98cae3dce2938bb1401b671d8a..6e9b49253e7dc330c94380c68d56078eed2d9d49 100644 (file)
 #include "COM_MathBaseOperation.h"
 #include "COM_ExecutionSystem.h"
 
-void MathNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void MathNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
-       MathBaseOperation *operation=NULL;
+       MathBaseOperation *operation = NULL;
        
        switch (this->getbNode()->custom1)
        {
-       case 0: /* Add */
+               case 0: /* Add */
                        operation = new MathAddOperation();
                        break;
-       case 1: /* Subtract */
+               case 1: /* Subtract */
                        operation = new MathSubtractOperation();
                        break;
-       case 2: /* Multiply */
+               case 2: /* Multiply */
                        operation = new MathMultiplyOperation();
                        break;
-       case 3: /* Divide */
+               case 3: /* Divide */
                        operation = new MathDivideOperation();
                        break;
-       case 4: /* Sine */
+               case 4: /* Sine */
                        operation = new MathSineOperation();
                        break;
-       case 5: /* Cosine */
+               case 5: /* Cosine */
                        operation = new MathCosineOperation();
                        break;
-       case 6: /* Tangent */
+               case 6: /* Tangent */
                        operation = new MathTangentOperation();
                        break;
-       case 7: /* Arc-Sine */
+               case 7: /* Arc-Sine */
                        operation = new MathArcSineOperation();
                        break;
-       case 8: /* Arc-Cosine */
+               case 8: /* Arc-Cosine */
                        operation = new MathArcCosineOperation();
                        break;
-       case 9: /* Arc-Tangent */
+               case 9: /* Arc-Tangent */
                        operation = new MathArcTangentOperation();
                        break;
-       case 10: /* Power */
+               case 10: /* Power */
                        operation = new MathPowerOperation();
                        break;
-       case 11: /* Logarithm */
+               case 11: /* Logarithm */
                        operation = new MathLogarithmOperation();
                        break;
-       case 12: /* Minimum */
+               case 12: /* Minimum */
                        operation = new MathMinimumOperation();
                        break;
-       case 13: /* Maximum */
+               case 13: /* Maximum */
                        operation = new MathMaximumOperation();
                        break;
-       case 14: /* Round */
+               case 14: /* Round */
                        operation = new MathRoundOperation();
                        break;
-       case 15: /* Less Than */
+               case 15: /* Less Than */
                        operation = new MathLessThanOperation();
                        break;
-       case 16: /* Greater Than */
+               case 16: /* Greater Than */
                        operation = new MathGreaterThanOperation();
                        break;
        }
index 42e32a4e55ed764ca1ed017673dac8f43cff8122..eb62ebd263590505b134f7b7e00711ca6259883d 100644 (file)
 #include "DNA_material_types.h" // the ramp types
 
 
-MixNode::MixNode(bNode *editorNode): Node(editorNode)
+MixNode::MixNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-
-void MixNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void MixNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *valueSocket = this->getInputSocket(0);
        InputSocket *color1Socket = this->getInputSocket(1);
@@ -62,62 +62,62 @@ void MixNode::convertToOperations(ExecutionSystem *graph, CompositorContext * co
        MixBaseOperation *convertProg;
        
        switch (editorNode->custom1) {
-       case MA_RAMP_ADD:
-               convertProg = new MixAddOperation();
-               break;
-       case MA_RAMP_MULT:
-               convertProg = new MixMultiplyOperation();
-               break;
-       case MA_RAMP_LIGHT:
-               convertProg = new MixLightenOperation();
-               break;
-       case MA_RAMP_BURN:
-               convertProg = new MixBurnOperation();
-               break;
-       case MA_RAMP_HUE:
-               convertProg = new MixHueOperation();
-               break;
-       case MA_RAMP_COLOR:
-               convertProg = new MixColorOperation();
-               break;
-       case MA_RAMP_SOFT:
-               convertProg = new MixSoftLightOperation();
-               break;
-       case MA_RAMP_SCREEN:
-               convertProg = new MixScreenOperation();
-               break;
-       case MA_RAMP_LINEAR:
-               convertProg = new MixLinearLightOperation();
-               break;
-       case MA_RAMP_DIFF:
-               convertProg = new MixDifferenceOperation();
-               break;
-       case MA_RAMP_SAT:
-               convertProg = new MixSaturationOperation();
-               break;
-       case MA_RAMP_DIV:
-               convertProg = new MixDivideOperation();
-               break;
-       case MA_RAMP_SUB:
-               convertProg = new MixSubtractOperation();
-               break;
-       case MA_RAMP_DARK:
-               convertProg = new MixDarkenOperation();
-               break;
-       case MA_RAMP_OVERLAY:
-               convertProg = new MixOverlayOperation();
-               break;
-       case MA_RAMP_VAL:
-               convertProg = new MixValueOperation();
-               break;
-       case MA_RAMP_DODGE:
-               convertProg = new MixDodgeOperation();
-               break;
-       
-       case MA_RAMP_BLEND:
-       default:
-               convertProg = new MixBlendOperation();
-               break;
+               case MA_RAMP_ADD:
+                       convertProg = new MixAddOperation();
+                       break;
+               case MA_RAMP_MULT:
+                       convertProg = new MixMultiplyOperation();
+                       break;
+               case MA_RAMP_LIGHT:
+                       convertProg = new MixLightenOperation();
+                       break;
+               case MA_RAMP_BURN:
+                       convertProg = new MixBurnOperation();
+                       break;
+               case MA_RAMP_HUE:
+                       convertProg = new MixHueOperation();
+                       break;
+               case MA_RAMP_COLOR:
+                       convertProg = new MixColorOperation();
+                       break;
+               case MA_RAMP_SOFT:
+                       convertProg = new MixSoftLightOperation();
+                       break;
+               case MA_RAMP_SCREEN:
+                       convertProg = new MixScreenOperation();
+                       break;
+               case MA_RAMP_LINEAR:
+                       convertProg = new MixLinearLightOperation();
+                       break;
+               case MA_RAMP_DIFF:
+                       convertProg = new MixDifferenceOperation();
+                       break;
+               case MA_RAMP_SAT:
+                       convertProg = new MixSaturationOperation();
+                       break;
+               case MA_RAMP_DIV:
+                       convertProg = new MixDivideOperation();
+                       break;
+               case MA_RAMP_SUB:
+                       convertProg = new MixSubtractOperation();
+                       break;
+               case MA_RAMP_DARK:
+                       convertProg = new MixDarkenOperation();
+                       break;
+               case MA_RAMP_OVERLAY:
+                       convertProg = new MixOverlayOperation();
+                       break;
+               case MA_RAMP_VAL:
+                       convertProg = new MixValueOperation();
+                       break;
+               case MA_RAMP_DODGE:
+                       convertProg = new MixDodgeOperation();
+                       break;
+
+               case MA_RAMP_BLEND:
+               default:
+                       convertProg = new MixBlendOperation();
+                       break;
        }
        convertProg->setUseValueAlphaMultiply(this->getbNode()->custom2);
 
index 083d1bf42b9ac590fcbec9c01bbb8eed56c4d3d3..89bd0e8549e6ffee192e63743b6f48f5529f936d 100644 (file)
@@ -33,11 +33,12 @@ extern "C" {
        #include "IMB_imbuf.h"
 }
 
-MovieClipNode::MovieClipNode(bNode *editorNode): Node(editorNode)
+MovieClipNode::MovieClipNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void MovieClipNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void MovieClipNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        OutputSocket *outputMovieClip = this->getOutputSocket(0);
        OutputSocket *offsetXMovieClip = this->getOutputSocket(1);
@@ -46,10 +47,10 @@ void MovieClipNode::convertToOperations(ExecutionSystem *graph, CompositorContex
        OutputSocket *angleMovieClip = this->getOutputSocket(4);
        
        bNode *editorNode = this->getbNode();
-       MovieClip *movieClip = (MovieClip*)editorNode->id;
-       MovieClipUser *movieClipUser = (MovieClipUser*)editorNode->storage;
+       MovieClip *movieClip = (MovieClip *)editorNode->id;
+       MovieClipUser *movieClipUser = (MovieClipUser *)editorNode->storage;
        
-       ImBuf * ibuf = NULL;
+       ImBuf *ibuf = NULL;
        if (movieClip) {
                ibuf = BKE_movieclip_get_ibuf(movieClip, movieClipUser);
        }
@@ -90,7 +91,7 @@ void MovieClipNode::convertToOperations(ExecutionSystem *graph, CompositorContex
        angle = 0.0f;
 
        if (ibuf) {
-               if (stab->flag&TRACKING_2D_STABILIZATION) {
+               if (stab->flag & TRACKING_2D_STABILIZATION) {
                        int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip, context->getFramenumber());
 
                        BKE_tracking_stabilization_data_get(&movieClip->tracking, clip_framenr, ibuf->x, ibuf->y, loc, &scale, &angle);
@@ -98,25 +99,25 @@ void MovieClipNode::convertToOperations(ExecutionSystem *graph, CompositorContex
        }
        
        if (offsetXMovieClip->isConnected()) {
-               SetValueOperation * operationSetValue = new SetValueOperation();
+               SetValueOperation *operationSetValue = new SetValueOperation();
                operationSetValue->setValue(loc[0]);
                offsetXMovieClip->relinkConnections(operationSetValue->getOutputSocket());
                graph->addOperation(operationSetValue);
        }
        if (offsetYMovieClip->isConnected()) {
-               SetValueOperation * operationSetValue = new SetValueOperation();
+               SetValueOperation *operationSetValue = new SetValueOperation();
                operationSetValue->setValue(loc[1]);
                offsetYMovieClip->relinkConnections(operationSetValue->getOutputSocket());
                graph->addOperation(operationSetValue);
        }
        if (scaleMovieClip->isConnected()) {
-               SetValueOperation * operationSetValue = new SetValueOperation();
+               SetValueOperation *operationSetValue = new SetValueOperation();
                operationSetValue->setValue(scale);
                scaleMovieClip->relinkConnections(operationSetValue->getOutputSocket());
                graph->addOperation(operationSetValue);
        }
        if (angleMovieClip->isConnected()) {
-               SetValueOperation * operationSetValue = new SetValueOperation();
+               SetValueOperation *operationSetValue = new SetValueOperation();
                operationSetValue->setValue(angle);
                angleMovieClip->relinkConnections(operationSetValue->getOutputSocket());
                graph->addOperation(operationSetValue);
index bdf4c53fa729e39a6385083dc6036be30ecf1e8e..c29bc27cd800bf7d7d95ece6e15e3252b18aaa61 100644 (file)
 
 MovieDistortionNode::MovieDistortionNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void MovieDistortionNode::convertToOperations(ExecutionSystem *system, CompositorContext * context)
+void MovieDistortionNode::convertToOperations(ExecutionSystem *system, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        OutputSocket *outputSocket = this->getOutputSocket(0);
        bNode *bnode = this->getbNode();
-       MovieClip * clip = (MovieClip*)bnode->id;
+       MovieClip *clip = (MovieClip *)bnode->id;
        
-       MovieDistortionOperation * operation = new MovieDistortionOperation(bnode->custom1 == 1);
+       MovieDistortionOperation *operation = new MovieDistortionOperation(bnode->custom1 == 1);
        operation->setMovieClip(clip);
        operation->setFramenumber(context->getFramenumber());
 
index 57b7871318bcd92b56cf58ab13caa404375f97b5..ccf7721b989876e8e215f20a2d5d5a8aeed92e7f 100644 (file)
 #include "COM_SetVectorOperation.h"
 #include "COM_SetColorOperation.h"
 
-MuteNode::MuteNode(bNode *editorNode): Node(editorNode)
+MuteNode::MuteNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void MuteNode::reconnect(ExecutionSystem * graph, OutputSocket * output)
+void MuteNode::reconnect(ExecutionSystem *graph, OutputSocket *output)
 {
-       vector<InputSocket*> &inputsockets = this->getInputSockets();
-       for (unsigned int index = 0; index < inputsockets.size() ; index ++) {
+       vector<InputSocket *> &inputsockets = this->getInputSockets();
+       for (unsigned int index = 0; index < inputsockets.size(); index++) {
                InputSocket *input = inputsockets[index];
                if (input->getDataType() == output->getDataType()) {
                        if (input->isConnected()) {
@@ -82,12 +83,12 @@ void MuteNode::reconnect(ExecutionSystem * graph, OutputSocket * output)
        output->clearConnections();
 }
 
-void MuteNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void MuteNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
-       vector<OutputSocket*> &outputsockets = this->getOutputSockets();
+       vector<OutputSocket *> &outputsockets = this->getOutputSockets();
 
-       for (unsigned int index = 0 ; index < outputsockets.size() ; index ++) {
-               OutputSocket * output = outputsockets[index];
+       for (unsigned int index = 0; index < outputsockets.size(); index++) {
+               OutputSocket *output = outputsockets[index];
                if (output->isConnected()) {
                        reconnect(graph, output);
                }
index 0b1faafe3025afd53cdc3f9180b8d9a9c4db26f3..e00e71e50e956c791cfba3d1c453cac960d736cf 100644 (file)
 #include "COM_DotproductOperation.h"
 #include "COM_SetVectorOperation.h"
 
-NormalNode::NormalNode(bNode *editorNode): Node(editorNode)
-{}
+NormalNode::NormalNode(bNode *editorNode) : Node(editorNode)
+{
+       /* pass */
+}
 
-void NormalNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void NormalNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        OutputSocket *outputSocket = this->getOutputSocket(0);
        OutputSocket *outputSocketDotproduct = this->getOutputSocket(1);
        bNode *editorNode = this->getbNode();
        
-       SetVectorOperation * operationSet = new SetVectorOperation();
-       bNodeSocket * insock = (bNodeSocket*)editorNode->outputs.first;
-       bNodeSocketValueVector *dval = (bNodeSocketValueVector*)insock->default_value;
+       SetVectorOperation *operationSet = new SetVectorOperation();
+       bNodeSocket *insock = (bNodeSocket *)editorNode->outputs.first;
+       bNodeSocketValueVector *dval = (bNodeSocketValueVector *)insock->default_value;
        operationSet->setX(dval->value[0]);
        operationSet->setY(dval->value[1]);
        operationSet->setZ(dval->value[2]);
index 11173b3a73fd3911c7006dd313cb85182fcc22e4..7c1c695f8b634dc71293ffdc1c989db60bceddd9 100644 (file)
 #include "COM_NormalizeOperation.h"
 #include "COM_ExecutionSystem.h"
 
-NormalizeNode::NormalizeNode(bNode *editorNode): Node(editorNode)
+NormalizeNode::NormalizeNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void NormalizeNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void NormalizeNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        NormalizeOperation *operation = new NormalizeOperation();
 
index e5deb595d7856f0d5e3feb907f595b690b18c80b..402529b91868ecde42a542df962f877131c2ea74 100644 (file)
 #include "BLI_path_util.h"
 #include "BKE_utildefines.h"
 
-OutputFileNode::OutputFileNode(bNode *editorNode): Node(editorNode)
+OutputFileNode::OutputFileNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void OutputFileNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void OutputFileNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
-       NodeImageMultiFile *storage = (NodeImageMultiFile*)this->getbNode()->storage;
+       NodeImageMultiFile *storage = (NodeImageMultiFile *)this->getbNode()->storage;
        
        if (!context->isRendering()) {
                /* XXX TODO as in previous implementation?
@@ -41,14 +42,14 @@ void OutputFileNode::convertToOperations(ExecutionSystem *graph, CompositorConte
                 */
        }
        
-       if (storage->format.imtype==R_IMF_IMTYPE_MULTILAYER) {
+       if (storage->format.imtype == R_IMF_IMTYPE_MULTILAYER) {
                /* single output operation for the multilayer file */
                OutputOpenExrMultiLayerOperation *outputOperation = new OutputOpenExrMultiLayerOperation(
-                               context->getScene(), context->getbNodeTree(), storage->base_path, storage->format.exr_codec);
+                       context->getScene(), context->getbNodeTree(), storage->base_path, storage->format.exr_codec);
                
                int num_inputs = getNumberOfInputSockets();
                bool hasConnections = false;
-               for (int i=0; i < num_inputs; ++i) {
+               for (int i = 0; i < num_inputs; ++i) {
                        InputSocket *input = getInputSocket(i);
                        if (input->isConnected()) {
                                hasConnections = true;
@@ -63,10 +64,10 @@ void OutputFileNode::convertToOperations(ExecutionSystem *graph, CompositorConte
                
                graph->addOperation(outputOperation);
        }
-       else {  /* single layer format */
+       else {  /* single layer format */
                int num_inputs = getNumberOfInputSockets();
                bool previewAdded = false;
-               for (int i=0; i < num_inputs; ++i) {
+               for (int i = 0; i < num_inputs; ++i) {
                        InputSocket *input = getInputSocket(i);
                        if (input->isConnected()) {
                                NodeImageMultiFileSocket *sockdata = (NodeImageMultiFileSocket *)input->getbNodeSocket()->storage;
@@ -77,7 +78,7 @@ void OutputFileNode::convertToOperations(ExecutionSystem *graph, CompositorConte
                                BLI_join_dirfile(path, FILE_MAX, storage->base_path, sockdata->path);
                                
                                OutputSingleLayerOperation *outputOperation = new OutputSingleLayerOperation(
-                                               context->getScene(), context->getbNodeTree(), input->getDataType(), format, path);
+                                       context->getScene(), context->getbNodeTree(), input->getDataType(), format, path);
                                input->relinkConnections(outputOperation->getInputSocket(0));
                                graph->addOperation(outputOperation);
                                if (!previewAdded) {
index 8216205b9252e976d36e19aea089b19a2a0d10a5..95e759fde24c0f4cee42a22d9e88f5bd9b85a619 100644 (file)
 #include "COM_ScaleOperation.h"
 #include "COM_SetValueOperation.h"
 
-RenderLayersNode::RenderLayersNode(bNode *editorNode): Node(editorNode)
+RenderLayersNode::RenderLayersNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void RenderLayersNode::testSocketConnection(ExecutionSystem *system, int outputSocketNumber, RenderLayersBaseProg * operation)
+void RenderLayersNode::testSocketConnection(ExecutionSystem *system, int outputSocketNumber, RenderLayersBaseProg *operation)
 {
        OutputSocket *outputSocket = this->getOutputSocket(outputSocketNumber);
-       Scene *scene = (Scene*)this->getbNode()->id;
+       Scene *scene = (Scene *)this->getbNode()->id;
        short layerId = this->getbNode()->custom1;
 
        if (outputSocket->isConnected()) {
@@ -79,7 +80,7 @@ void RenderLayersNode::testSocketConnection(ExecutionSystem *system, int outputS
        }
 }
 
-void RenderLayersNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void RenderLayersNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        testSocketConnection(graph, 0, new RenderLayersColourProg());
        testSocketConnection(graph, 1, new RenderLayersAlphaProg());
index 48acc567739b8da34300a8f99d6ebd78b83eafde..bb058d18b8072d4e6c30ce801aba72366a34a18b 100644 (file)
 
 RotateNode::RotateNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void RotateNode::convertToOperations(ExecutionSystem *system, CompositorContext * context)
+void RotateNode::convertToOperations(ExecutionSystem *system, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        InputSocket *inputDegreeSocket = this->getInputSocket(1);
@@ -39,15 +40,15 @@ void RotateNode::convertToOperations(ExecutionSystem *system, CompositorContext
        SetSamplerOperation *sampler = new SetSamplerOperation();
 
        switch (this->getbNode()->custom1) {
-       case 0:
-               sampler->setSampler(COM_PS_NEAREST);
-               break ;
-       case 1:
-               sampler->setSampler(COM_PS_BILINEAR);
-               break;
-       case 2:
-               sampler->setSampler(COM_PS_BICUBIC);
-               break;
+               case 0:
+                       sampler->setSampler(COM_PS_NEAREST);
+                       break;
+               case 1:
+                       sampler->setSampler(COM_PS_BILINEAR);
+                       break;
+               case 2:
+                       sampler->setSampler(COM_PS_BICUBIC);
+                       break;
        
        }
 
index 870ed8f2484eb5129076575a81f26ae57ee440a6..17b521c589d60e9e582d39bac79851292d263dfa 100644 (file)
@@ -29,6 +29,7 @@
 
 ScaleNode::ScaleNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void ScaleNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index cfce56a080a0a04e99b4e2f952e6fb7ae907dfd8..4f93b226fa1f2311b5b158d3a51f888d4066bf29 100644 (file)
 #include "COM_SetValueOperation.h"
 #include "COM_ConvertRGBToHSVOperation.h"
 
-SeparateHSVANode::SeparateHSVANode(bNode *editorNode): SeparateRGBANode(editorNode)
+SeparateHSVANode::SeparateHSVANode(bNode *editorNode) : SeparateRGBANode(editorNode)
 {
+       /* pass */
 }
 
-void SeparateHSVANode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void SeparateHSVANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        ConvertRGBToHSVOperation *operation = new ConvertRGBToHSVOperation();
        InputSocket *inputSocket = this->getInputSocket(0);
index dd154fe604d3228a25a85281bccfd7df71d2cd33..67ac6ffc388e157472abed343d20ca0d3e3628fe 100644 (file)
 #include "DNA_material_types.h" // the ramp types
 
 
-SeparateRGBANode::SeparateRGBANode(bNode *editorNode): Node(editorNode)
+SeparateRGBANode::SeparateRGBANode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 
-void SeparateRGBANode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void SeparateRGBANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *imageSocket = this->getInputSocket(0);
        OutputSocket *outputRSocket = this->getOutputSocket(0);
index 68d20235de7992ba296eea3d1db9ea4fd007068a..154e2bcd5509096d76374a57ebdc2e7df469d8b0 100644 (file)
@@ -25,8 +25,9 @@
 #include "COM_SetValueOperation.h"
 #include "COM_ConvertRGBToYCCOperation.h"
 
-SeparateYCCANode::SeparateYCCANode(bNode *editorNode): SeparateRGBANode(editorNode)
+SeparateYCCANode::SeparateYCCANode(bNode *editorNode) : SeparateRGBANode(editorNode)
 {
+       /* pass */
 }
 
 void SeparateYCCANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index 650e5d1340bb5ab34b3bd261abb5a807a130d4f5..8a647b7f84921dd5ffae98fd9d3e5294dd7de1d4 100644 (file)
@@ -25,8 +25,9 @@
 #include "COM_SetValueOperation.h"
 #include "COM_ConvertRGBToYUVOperation.h"
 
-SeparateYUVANode::SeparateYUVANode(bNode *editorNode): SeparateRGBANode(editorNode)
+SeparateYUVANode::SeparateYUVANode(bNode *editorNode) : SeparateRGBANode(editorNode)
 {
+       /* pass */
 }
 
 void SeparateYUVANode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index 1d09b81c4d284ee5d72fa4050708a24a4e36d68e..709dc75b502cd04c3f3e3b50822bdc86bbc4f2ef 100644 (file)
@@ -24,7 +24,7 @@
 #include "COM_SetAlphaOperation.h"
 #include "COM_ExecutionSystem.h"
 
-void SetAlphaNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void SetAlphaNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        SetAlphaOperation *operation = new SetAlphaOperation();
        
index cdb844cad54d2fa45239631ad24d650a59689087..bfb32a96156efd8bad2665fc7600539fc2555783 100644 (file)
@@ -28,7 +28,7 @@
 #include "COM_SetVectorOperation.h"
 #include "COM_SetColorOperation.h"
 
-SocketProxyNode::SocketProxyNode(bNode *editorNode, bNodeSocket *editorInput, bNodeSocket *editorOutput): Node(editorNode, false)
+SocketProxyNode::SocketProxyNode(bNode *editorNode, bNodeSocket *editorInput, bNodeSocket *editorOutput) : Node(editorNode, false)
 {
        DataType dt;
        
@@ -43,10 +43,10 @@ SocketProxyNode::SocketProxyNode(bNode *editorNode, bNodeSocket *editorInput, bN
        this->addOutputSocket(dt, editorOutput);
 }
 
-void SocketProxyNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void SocketProxyNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
-       OutputSocket * outputsocket = this->getOutputSocket(0);
-       InputSocket * inputsocket = this->getInputSocket(0);
+       OutputSocket *outputsocket = this->getOutputSocket(0);
+       InputSocket *inputsocket = this->getInputSocket(0);
        if (outputsocket->isConnected()) {
                if (inputsocket->isConnected()) {
                        SocketProxyOperation *operation = new SocketProxyOperation(this->getOutputSocket()->getDataType());
@@ -57,33 +57,33 @@ void SocketProxyNode::convertToOperations(ExecutionSystem *graph, CompositorCont
                else {
                        /* If input is not connected, add a constant value operation instead */
                        switch (outputsocket->getDataType()) {
-                       case COM_DT_VALUE:
-                       {
-                               SetValueOperation *operation = new SetValueOperation();
-                               bNodeSocketValueFloat *dval = (bNodeSocketValueFloat*)inputsocket->getbNodeSocket()->default_value;
-                               operation->setValue(dval->value);
-                               outputsocket->relinkConnections(operation->getOutputSocket(0));
-                               graph->addOperation(operation);
-                               break;
-                       }
-                       case COM_DT_COLOR:
-                       {
-                               SetColorOperation *operation = new SetColorOperation();
-                               bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA*)inputsocket->getbNodeSocket()->default_value;
-                               operation->setChannels(dval->value);
-                               outputsocket->relinkConnections(operation->getOutputSocket(0));
-                               graph->addOperation(operation);
-                               break;
-                       }
-                       case COM_DT_VECTOR:
-                       {
-                               SetVectorOperation *operation = new SetVectorOperation();
-                               bNodeSocketValueVector *dval = (bNodeSocketValueVector*)inputsocket->getbNodeSocket()->default_value;
-                               operation->setVector(dval->value);
-                               outputsocket->relinkConnections(operation->getOutputSocket(0));
-                               graph->addOperation(operation);
-                               break;
-                       }
+                               case COM_DT_VALUE:
+                               {
+                                       SetValueOperation *operation = new SetValueOperation();
+                                       bNodeSocketValueFloat *dval = (bNodeSocketValueFloat *)inputsocket->getbNodeSocket()->default_value;
+                                       operation->setValue(dval->value);
+                                       outputsocket->relinkConnections(operation->getOutputSocket(0));
+                                       graph->addOperation(operation);
+                                       break;
+                               }
+                               case COM_DT_COLOR:
+                               {
+                                       SetColorOperation *operation = new SetColorOperation();
+                                       bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA *)inputsocket->getbNodeSocket()->default_value;
+                                       operation->setChannels(dval->value);
+                                       outputsocket->relinkConnections(operation->getOutputSocket(0));
+                                       graph->addOperation(operation);
+                                       break;
+                               }
+                               case COM_DT_VECTOR:
+                               {
+                                       SetVectorOperation *operation = new SetVectorOperation();
+                                       bNodeSocketValueVector *dval = (bNodeSocketValueVector *)inputsocket->getbNodeSocket()->default_value;
+                                       operation->setVector(dval->value);
+                                       outputsocket->relinkConnections(operation->getOutputSocket(0));
+                                       graph->addOperation(operation);
+                                       break;
+                               }
                        }
                }
        }
index 7e8a218cbc13e7ff1a137d15b78d89267927699d..22a004103840c6b50b53c9bcb4e77198f6fb43d4 100644 (file)
@@ -28,6 +28,7 @@
 
 SplitViewerNode::SplitViewerNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void SplitViewerNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index 7234e71a43c961c0cc8dc2ce8da514036130b73e..85b8695263f5523b958cf6576445025d1de3ad73 100644 (file)
@@ -32,18 +32,19 @@ extern "C" {
        #include "BKE_tracking.h"
 }
 
-Stabilize2dNode::Stabilize2dNode(bNode *editorNode): Node(editorNode)
+Stabilize2dNode::Stabilize2dNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void Stabilize2dNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void Stabilize2dNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *imageInput = this->getInputSocket(0);
        MovieClip *clip = (MovieClip *)getbNode()->id;
        
-       ScaleOperation * scaleOperation = new ScaleOperation();
-       RotateOperation * rotateOperation = new RotateOperation();
-       TranslateOperation * translateOperation = new TranslateOperation();
+       ScaleOperation *scaleOperation = new ScaleOperation();
+       RotateOperation *rotateOperation = new RotateOperation();
+       TranslateOperation *translateOperation = new TranslateOperation();
        MovieClipAttributeOperation *scaleAttribute = new MovieClipAttributeOperation();
        MovieClipAttributeOperation *angleAttribute = new MovieClipAttributeOperation();
        MovieClipAttributeOperation *xAttribute = new MovieClipAttributeOperation();
index bb1a9c119f8c2035bc01d4b9064fb4a72a9ce012..2a4616fcd3e6c21a1b4c04ff6c425807e9db8944 100644 (file)
 #include "COM_ExecutionSystem.h"
 #include "COM_SocketProxyOperation.h"
 
-SwitchNode::SwitchNode(bNode *editorNode): Node(editorNode)
+SwitchNode::SwitchNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 
-void SwitchNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void SwitchNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
-       SocketProxyOperation * operation = new SocketProxyOperation(COM_DT_COLOR);
+       SocketProxyOperation *operation = new SocketProxyOperation(COM_DT_COLOR);
        int switchFrame = this->getbNode()->custom1;
 
        if (!switchFrame) {
index fe8a8e2250ef75312d4ab14efcaf5950121df4cd..a3526e3c1a132a257a5fafe56738530f8d9af8b0 100644 (file)
 #include "COM_ExecutionSystem.h"
 #include "COM_TextureOperation.h"
 
-TextureNode::TextureNode(bNode *editorNode): Node(editorNode)
+TextureNode::TextureNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void TextureNode::convertToOperations(ExecutionSystem *system, CompositorContext * context)
+void TextureNode::convertToOperations(ExecutionSystem *system, CompositorContext *context)
 {
        bNode *editorNode = this->getbNode();
-       Tex *texture = (Tex*)editorNode->id;
+       Tex *texture = (Tex *)editorNode->id;
        TextureOperation *operation = new TextureOperation();
        this->getOutputSocket(1)->relinkConnections(operation->getOutputSocket());
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, system);
index b3ce27a382912be6849efcc5426e2b92d0bda258..8e155e375e1c049e66f23e4341f63af34b8f8354 100644 (file)
@@ -29,11 +29,12 @@ extern "C" {
 }
 #include "BLI_utildefines.h"
 
-TimeNode::TimeNode(bNode *editorNode): Node(editorNode)
+TimeNode::TimeNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void TimeNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void TimeNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        SetValueOperation *operation = new SetValueOperation();
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket());
@@ -50,10 +51,10 @@ void TimeNode::convertToOperations(ExecutionSystem *graph, CompositorContext * c
                fac = 1.0f;
        }
        else if (node->custom1 < node->custom2) {
-               fac = (context->getFramenumber() - node->custom1)/(float)(node->custom2-node->custom1);
+               fac = (context->getFramenumber() - node->custom1) / (float)(node->custom2 - node->custom1);
        }
 
-       fac = curvemapping_evaluateF((CurveMapping*)node->storage, 0, fac);
+       fac = curvemapping_evaluateF((CurveMapping *)node->storage, 0, fac);
        operation->setValue(CLAMPIS(fac, 0.0f, 1.0f));
        graph->addOperation(operation);
 }
index 80f02f3edbbbec651ca74cb63be566c9285310bf..a1f33ed464bb9dce4c0a6107a9d2b7b728a5acfc 100644 (file)
 #include "COM_TonemapOperation.h"
 #include "COM_ExecutionSystem.h"
 
-TonemapNode::TonemapNode(bNode *editorNode): Node(editorNode)
+TonemapNode::TonemapNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void TonemapNode::convertToOperations(ExecutionSystem *system, CompositorContext * context)
+void TonemapNode::convertToOperations(ExecutionSystem *system, CompositorContext *context)
 {
-       NodeTonemap *data = (NodeTonemap*)this->getbNode()->storage;
-       TonemapOperation *operation = data->type==1?new PhotoreceptorTonemapOperation():new TonemapOperation();
+       NodeTonemap *data = (NodeTonemap *)this->getbNode()->storage;
+       TonemapOperation *operation = data->type == 1 ? new PhotoreceptorTonemapOperation() : new TonemapOperation();
 
        operation->setData(data);
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, system);
index da3e85036a568ec20a022c827d23979c6759436d..ff6e276d1acd536c53d974ba0c4f71ff9f79fa93 100644 (file)
 #include "COM_SetValueOperation.h"
 #include "COM_SetSamplerOperation.h"
 
-TransformNode::TransformNode(bNode *editorNode): Node(editorNode)
+TransformNode::TransformNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void TransformNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void TransformNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *imageInput = this->getInputSocket(0);
        InputSocket *xInput = this->getInputSocket(1);
@@ -40,21 +41,21 @@ void TransformNode::convertToOperations(ExecutionSystem *graph, CompositorContex
        InputSocket *angleInput = this->getInputSocket(3);
        InputSocket *scaleInput = this->getInputSocket(4);
        
-       ScaleOperation * scaleOperation = new ScaleOperation();
-       RotateOperation * rotateOperation = new RotateOperation();
-       TranslateOperation * translateOperation = new TranslateOperation();
+       ScaleOperation *scaleOperation = new ScaleOperation();
+       RotateOperation *rotateOperation = new RotateOperation();
+       TranslateOperation *translateOperation = new TranslateOperation();
        SetSamplerOperation *sampler = new SetSamplerOperation();
 
        switch (this->getbNode()->custom1) {
-       case 0:
-               sampler->setSampler(COM_PS_NEAREST);
-               break ;
-       case 1:
-               sampler->setSampler(COM_PS_BILINEAR);
-               break;
-       case 2:
-               sampler->setSampler(COM_PS_BICUBIC);
-               break;
+               case 0:
+                       sampler->setSampler(COM_PS_NEAREST);
+                       break;
+               case 1:
+                       sampler->setSampler(COM_PS_BILINEAR);
+                       break;
+               case 2:
+                       sampler->setSampler(COM_PS_BICUBIC);
+                       break;
        }
        
        imageInput->relinkConnections(sampler->getInputSocket(0), 0, graph);
index 407c6da4e4d3a0267892f576e4072f36bdd52891..c805f8f8baacd03813f64afd64d06b76742eb27c 100644 (file)
 
 TranslateNode::TranslateNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void TranslateNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void TranslateNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *inputSocket = this->getInputSocket(0);
        InputSocket *inputXSocket = this->getInputSocket(1);
index 39245e75a2febd2d912c95170c3871e243e30094..89b0602f8b0dcc4c1f30d5fa9f813b8841956718 100644 (file)
 #include "COM_SetValueOperation.h"
 #include "COM_ExecutionSystem.h"
 
-ValueNode::ValueNode(bNode *editorNode): Node(editorNode)
+ValueNode::ValueNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void ValueNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void ValueNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        SetValueOperation *operation = new SetValueOperation();
        bNodeSocket *socket = this->getEditorOutputSocket(0);
-       bNodeSocketValueFloat *dval = (bNodeSocketValueFloat*)socket->default_value;
+       bNodeSocketValueFloat *dval = (bNodeSocketValueFloat *)socket->default_value;
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket());
        operation->setValue(dval->value);
        graph->addOperation(operation);
index 78b9065b4daae8e163eaaa3f61f81835e1116e9f..5ef384a9984785652c754db5ea5ccf9dbd5036fb 100644 (file)
@@ -26,6 +26,7 @@
 
 VectorBlurNode::VectorBlurNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void VectorBlurNode::convertToOperations(ExecutionSystem *system, CompositorContext *context)
index 908e1a19f1655fef8e93402ecd462a4ca1e57117..ee32c3b77a3e89fd6aefbaa1fc69edf059d568c0 100644 (file)
 #include "COM_VectorCurveOperation.h"
 #include "COM_ExecutionSystem.h"
 
-VectorCurveNode::VectorCurveNode(bNode *editorNode): Node(editorNode)
+VectorCurveNode::VectorCurveNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
-void VectorCurveNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+void VectorCurveNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        VectorCurveOperation *operation = new VectorCurveOperation();
 
        this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph);
        this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket());
 
-       operation->setCurveMapping((CurveMapping*)this->getbNode()->storage);
+       operation->setCurveMapping((CurveMapping *)this->getbNode()->storage);
 
        graph->addOperation(operation);
 }
index a7974efe9543c084e1d96baee531a7d1fc714853..309568c3aec8eb3d6c0c957af3cea33e6cf4dd54 100644 (file)
@@ -28,7 +28,9 @@
 
 ViewLevelsNode::ViewLevelsNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
+
 void ViewLevelsNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
 {
        InputSocket *input = this->getInputSocket(0);
index 79c76f2e89e58c743ee4b18083212f6b1d6bf3bd..9228fdbef8542193f628439c4c5d3d9cc7a36359 100644 (file)
@@ -28,6 +28,7 @@
 
 ViewerNode::ViewerNode(bNode *editorNode) : Node(editorNode)
 {
+       /* pass */
 }
 
 void ViewerNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
index 2495d1a5ab23d1191818ef4e3dd793f0279388f3..f48fca72c05c5683d4b0bdb0f72cdee042b47373 100644 (file)
 
 #include "DNA_material_types.h" // the ramp types
 
-void ZCombineNode::convertToOperations(ExecutionSystem *system, CompositorContext * context)
+void ZCombineNode::convertToOperations(ExecutionSystem *system, CompositorContext *context)
 {
        if (this->getOutputSocket(0)->isConnected()) {
-               ZCombineOperation * operation = NULL;
+               ZCombineOperation *operation = NULL;
                if (this->getbNode()->custom1) {
                        operation = new ZCombineAlphaOperation();
                }
@@ -48,7 +48,7 @@ void ZCombineNode::convertToOperations(ExecutionSystem *system, CompositorContex
                this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket());
                system->addOperation(operation);
                if (this->getOutputSocket(1)->isConnected()) {
-                       MathMinimumOperation * zoperation = new MathMinimumOperation();
+                       MathMinimumOperation *zoperation = new MathMinimumOperation();
                        addLink(system, operation->getInputSocket(1)->getConnection()->getFromSocket(), zoperation->getInputSocket(0));
                        addLink(system, operation->getInputSocket(3)->getConnection()->getFromSocket(), zoperation->getInputSocket(1));
                        this->getOutputSocket(1)->relinkConnections(zoperation->getOutputSocket());
@@ -57,7 +57,7 @@ void ZCombineNode::convertToOperations(ExecutionSystem *system, CompositorContex
        }
        else {
                if (this->getOutputSocket(1)->isConnected()) {
-                       MathMinimumOperation * zoperation = new MathMinimumOperation();
+                       MathMinimumOperation *zoperation = new MathMinimumOperation();
                        this->getInputSocket(1)->relinkConnections(zoperation->getInputSocket(0), 1, system);
                        this->getInputSocket(3)->relinkConnections(zoperation->getInputSocket(1), 3, system);
                        this->getOutputSocket(1)->relinkConnections(zoperation->getOutputSocket());
index 0c9f9b970312ccc4946f14deb473d821db1f0e61..4a0c8b7ab7fc648c330526a630f267524e963f7f 100644 (file)
@@ -24,6 +24,7 @@
 
 AlphaOverKeyOperation::AlphaOverKeyOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void AlphaOverKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index db67f2e040688e62a1707405f626ed92fbd0f454..5b36f83af4134da5576c684bfa9c3087215bd937 100644 (file)
@@ -24,6 +24,7 @@
 
 AlphaOverPremultiplyOperation::AlphaOverPremultiplyOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void AlphaOverPremultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index dfe1b6aa329c214b417872c188f7b8038d34f76a..884c22021df935cdba55cb4af72dacd33ef7e2fd 100644 (file)
@@ -28,6 +28,7 @@
 
 CalculateStandardDeviationOperation::CalculateStandardDeviationOperation(): CalculateMeanOperation()
 {
+       /* pass */
 }
 
 void CalculateStandardDeviationOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void * data)
index 6edb046a070f4c95b015b671215c38dff210eb4e..18a12a21f26a12d2ad60e66eebbacdf4e3ca5655 100644 (file)
@@ -25,6 +25,7 @@
 
 ConvolutionEdgeFilterOperation::ConvolutionEdgeFilterOperation() : ConvolutionFilterOperation()
 {
+       /* pass */
 }
 
 void ConvolutionEdgeFilterOperation::executePixel(float *color,int x, int y, MemoryBuffer *inputBuffers[], void *data)
index 192ad8d0bda4f10d27a63b5ba8c514d652514f72..9b105bb276089436bd19a0d6d8e1242faae31d7d 100644 (file)
@@ -70,6 +70,7 @@ void CropBaseOperation::deinitExecution()
 
 CropOperation::CropOperation() :CropBaseOperation()
 {
+       /* pass */
 }
 
 void CropOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
@@ -87,6 +88,7 @@ void CropOperation::executePixel(float *color, float x, float y, PixelSampler sa
 
 CropImageOperation::CropImageOperation() :CropBaseOperation()
 {
+       /* pass */
 }
 
 bool CropImageOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
index f6d794fe564396c06d5b023c11471bcc4ab7c6af..306a2d96985eeb0a0faa109e1cbe9a2f7c6e1abe 100644 (file)
@@ -257,6 +257,7 @@ void DilateDistanceOperation::executeOpenCL(cl_context context, cl_program progr
 // Erode Distance
 ErodeDistanceOperation::ErodeDistanceOperation() : DilateDistanceOperation() 
 {
+       /* pass */
 }
 
 void ErodeDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
@@ -411,6 +412,7 @@ bool DilateStepOperation::determineDependingAreaOfInterest(rcti *input, ReadBuff
 // Erode step
 ErodeStepOperation::ErodeStepOperation() : DilateStepOperation()
 {
+       /* pass */
 }
 
 void *ErodeStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
index a4f601ae9e64a16939a59ff137f2b86dc442c857..2c25635e3bc06e7a43a7c361537bb31836826803 100644 (file)
@@ -24,6 +24,7 @@
 
 MixAddOperation::MixAddOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 579f15bcc27398aeb6bd3a082f7c91ed9d647fa5..fadac8bbf21a722a1c06cd3159edf37504be34cd 100644 (file)
@@ -24,6 +24,7 @@
 
 MixBlendOperation::MixBlendOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixBlendOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 7cad107c5e97cded4ede92fb6e943be04ea89694..8231a5d60af3e2311e8b3a7af99d2e32e1b77afb 100644 (file)
@@ -24,6 +24,7 @@
 
 MixBurnOperation::MixBurnOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixBurnOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index e14b10b305e568d4d2b2aa6e8a0117682f82f6df..035e764d780a2b2028b0fd08ef496021aab68ce7 100644 (file)
@@ -28,6 +28,7 @@ extern "C" {
 
 MixColorOperation::MixColorOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 666db9d8f32a9e26dde3d8c032024fe94be64eb7..a1da5dce9c8339ef19d4693c721c6d0bfd0626c0 100644 (file)
@@ -24,6 +24,7 @@
 
 MixDarkenOperation::MixDarkenOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixDarkenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 497bb9c2bb5ecf24ff52035d6860e7a8a39342ee..883837f09176890189812d970588a0b62b8250bb 100644 (file)
@@ -25,6 +25,7 @@
 
 MixDifferenceOperation::MixDifferenceOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixDifferenceOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index c522fcf225a42b836231a6e96cc648fb6479e499..706308dccc568f4f061131cffc1e22025c41482f 100644 (file)
@@ -24,6 +24,7 @@
 
 MixDivideOperation::MixDivideOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 10c04ba376bee55198d1499be9c79c8d60307142..619819e6298b2e9f4834f8d57abc661c26aa456f 100644 (file)
@@ -24,6 +24,7 @@
 
 MixDodgeOperation::MixDodgeOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixDodgeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 229fc1e5313f4190d0e653e0cd4ecf34d4869a97..71b676622c55dce19f2a42e7e65df382afcea86b 100644 (file)
@@ -24,6 +24,7 @@
 
 MixGlareOperation::MixGlareOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixGlareOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index de376f3500c43466c4127b79a86d9b8f7f80d6f9..d97109c244cfa45cfd61f6ae6e4a842fae6c56b9 100644 (file)
@@ -28,6 +28,7 @@ extern "C" {
 
 MixHueOperation::MixHueOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixHueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index bc3e5090bd81897aded0053ed78f6726c4c557a5..09d81afcec79a67552a3375952ad438e1e0520e2 100644 (file)
@@ -24,6 +24,7 @@
 
 MixLightenOperation::MixLightenOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixLightenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index b68064f0e47f039da09b599e9acbfdd416c33cca..2e3907c15d42dfe842ea2d53fa7c45eda5537d63 100644 (file)
@@ -24,6 +24,7 @@
 
 MixLinearLightOperation::MixLinearLightOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixLinearLightOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index fdf8c1ca51bcc03f38af38cf12159de38fa5f870..223aa476f18a14fd05e037267ad215320e0228ea 100644 (file)
@@ -24,6 +24,7 @@
 
 MixMultiplyOperation::MixMultiplyOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixMultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 0025daeb3f58429422471b13501c2f9cb9669a69..dfea8440b674b3ab751116fd4b2bb1782b080344 100644 (file)
@@ -24,6 +24,7 @@
 
 MixOverlayOperation::MixOverlayOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixOverlayOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index f6f6ec73c6ed6cceffc8f849c23ba84ac62fe69c..25342abec8a132937be8ce69b95fb5d3e82bad8f 100644 (file)
@@ -28,6 +28,7 @@ extern "C" {
 
 MixSaturationOperation::MixSaturationOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixSaturationOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index a1a98bd82a2b21f15009902a53afa60be8dc64cb..8b9916165e2b0636ef9fe95a11df11c10d1145f1 100644 (file)
@@ -24,6 +24,7 @@
 
 MixScreenOperation::MixScreenOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixScreenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index ea6a3ddd498ea79055a0b66801feae33ad0916f4..a4882b7b83b79e16c9266196010c6178975adf24 100644 (file)
@@ -24,6 +24,7 @@
 
 MixSoftLightOperation::MixSoftLightOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixSoftLightOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])\
index 57320dcd6111649065a80d5e2ffbc2961e8b3e64..d7c7da688a3da770f756f416b1cda7984fd0e63f 100644 (file)
@@ -24,6 +24,7 @@
 
 MixSubtractOperation::MixSubtractOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixSubtractOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 8c43bb6af8c9c26576da7afe008ebca8db915ba5..f680692f5296e4e246607cffa6b4b0d21e75b6ba 100644 (file)
@@ -28,6 +28,7 @@ extern "C" {
 
 MixValueOperation::MixValueOperation(): MixBaseOperation()
 {
+       /* pass */
 }
 
 void MixValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
index 4dd94943f4eecc242f1d8904f3be7b6b84f3e374..df382547f132f8852e3c4f21862a7869c966db8b 100644 (file)
@@ -110,4 +110,5 @@ void *NormalizeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBu
 
 void NormalizeOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
 {
+       /* pass */
 }
index b281fb938fda76d73c4ca70b2d2b028e8fab9815..412cdbdf661a3d031c30832e4074f8f604b876e5 100644 (file)
@@ -156,4 +156,5 @@ void *TonemapOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuff
 
 void TonemapOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
 {
+       /* pass */
 }