tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

style cleanup: more nodes

This commit is contained in:
Campbell Barton 2012-06-15 17:57:39 +00:00
parent 687b6e5447
commit cde4d72848
110 changed files with 593 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
source/blender/compositor/intern/COM_NodeBase.cpp
View File

@ -31,6 +31,7 @@
NodeBase::NodeBase()
{
/* pass */
}

2
source/blender/compositor/intern/COM_NodeOperation.cpp
View 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)
{

1
source/blender/compositor/intern/COM_OutputSocket.cpp
View File

@ -27,6 +27,7 @@
OutputSocket::OutputSocket(DataType datatype) : Socket(datatype)
{
/* pass */
}
int OutputSocket::isOutputSocket() const { return true; }

6
source/blender/compositor/nodes/COM_AlphaOverNode.cpp
View 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;

1
source/blender/compositor/nodes/COM_BilateralBlurNode.cpp
View File

@ -28,6 +28,7 @@
BilateralBlurNode::BilateralBlurNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void BilateralBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)

1
source/blender/compositor/nodes/COM_BlurNode.cpp
View File

@ -31,6 +31,7 @@
BlurNode::BlurNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void BlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)

1
source/blender/compositor/nodes/COM_BokehBlurNode.cpp
View File

@ -32,6 +32,7 @@
BokehBlurNode::BokehBlurNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void BokehBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)

7
source/blender/compositor/nodes/COM_BokehImageNode.cpp
View File

@ -25,15 +25,16 @@
#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));
}

7
source/blender/compositor/nodes/COM_BoxMaskNode.cpp
View File

@ -25,15 +25,16 @@
#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));

5
source/blender/compositor/nodes/COM_BrightnessNode.cpp
View File

@ -25,11 +25,12 @@
#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);

38
source/blender/compositor/nodes/COM_ChannelMatteNode.cpp
View File

@ -27,8 +27,10 @@
#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();

8
source/blender/compositor/nodes/COM_ChromaMatteNode.cpp
View File

@ -25,8 +25,10 @@
#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);

18
source/blender/compositor/nodes/COM_ColorBalanceNode.cpp
View File

@ -27,10 +27,12 @@
#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);

13
source/blender/compositor/nodes/COM_ColorCorrectionNode.cpp
View File

@ -25,20 +25,21 @@
#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);
}

16
source/blender/compositor/nodes/COM_ColorCurveNode.cpp
View File

@ -25,11 +25,12 @@
#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);
}

8
source/blender/compositor/nodes/COM_ColorMatteNode.cpp
View File

@ -25,8 +25,10 @@
#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);

7
source/blender/compositor/nodes/COM_ColorNode.cpp
View File

@ -25,15 +25,16 @@
#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);

10
source/blender/compositor/nodes/COM_ColorRampNode.cpp
View File

@ -27,10 +27,12 @@
#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);
}

10
source/blender/compositor/nodes/COM_ColorSpillNode.cpp
View File

@ -24,8 +24,10 @@
#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);

5
source/blender/compositor/nodes/COM_ColorToBWNode.cpp
View File

@ -25,11 +25,12 @@
#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);

5
source/blender/compositor/nodes/COM_CombineHSVANode.cpp
View File

@ -28,11 +28,12 @@
#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);

6
source/blender/compositor/nodes/COM_CombineRGBANode.cpp
View File

@ -29,12 +29,12 @@
#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);

3
source/blender/compositor/nodes/COM_CombineYCCANode.cpp
View 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)

3
source/blender/compositor/nodes/COM_CombineYUVANode.cpp
View 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)

5
source/blender/compositor/nodes/COM_CompositorNode.cpp
View File

@ -24,11 +24,12 @@
#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);

2
source/blender/compositor/nodes/COM_ConvertAlphaNode.cpp
View 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();

5
source/blender/compositor/nodes/COM_CropNode.cpp
View File

@ -26,12 +26,13 @@
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;

19
source/blender/compositor/nodes/COM_DefocusNode.cpp
View File

@ -33,16 +33,17 @@
#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));

14
source/blender/compositor/nodes/COM_DifferenceMatteNode.cpp
View File

@ -25,10 +25,12 @@
#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());

1
source/blender/compositor/nodes/COM_DilateErodeNode.cpp
View File

@ -29,6 +29,7 @@
DilateErodeNode::DilateErodeNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void DilateErodeNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)

1
source/blender/compositor/nodes/COM_DirectionalBlurNode.cpp
View File

@ -28,6 +28,7 @@
DirectionalBlurNode::DirectionalBlurNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void DirectionalBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)

5
source/blender/compositor/nodes/COM_DisplaceNode.cpp
View File

@ -24,11 +24,12 @@
#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)

8
source/blender/compositor/nodes/COM_DistanceMatteNode.cpp
View File

@ -24,8 +24,10 @@
#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);

5
source/blender/compositor/nodes/COM_DoubleEdgeMaskNode.cpp
View File

@ -25,11 +25,12 @@
#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();

7
source/blender/compositor/nodes/COM_EllipseMaskNode.cpp
View File

@ -25,15 +25,16 @@
#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));

69
source/blender/compositor/nodes/COM_FilterNode.cpp
View File

@ -27,11 +27,12 @@
#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);

27
source/blender/compositor/nodes/COM_FlipNode.cpp
View File

@ -27,26 +27,27 @@
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);

5
source/blender/compositor/nodes/COM_GammaNode.cpp
View File

@ -25,11 +25,12 @@
#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();

45
source/blender/compositor/nodes/COM_GlareNode.cpp
View File

@ -31,36 +31,37 @@
#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);
}
}

26
source/blender/compositor/nodes/COM_GroupNode.cpp
View File

@ -24,44 +24,46 @@
#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);
}

13
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.cpp
View File

@ -33,23 +33,24 @@
#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));

13
source/blender/compositor/nodes/COM_HueSaturationValueNode.cpp
View File

@ -32,22 +32,23 @@
#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));

9
source/blender/compositor/nodes/COM_IDMaskNode.cpp
View File

@ -26,10 +26,11 @@
#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);

76
source/blender/compositor/nodes/COM_ImageNode.cpp
View File

@ -28,25 +28,27 @@
#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());

5
source/blender/compositor/nodes/COM_InvertNode.cpp
View File

@ -26,11 +26,12 @@
#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();

5
source/blender/compositor/nodes/COM_KeyingNode.cpp
View 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);

5
source/blender/compositor/nodes/COM_KeyingScreenNode.cpp
View 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);

7
source/blender/compositor/nodes/COM_LensDistortionNode.cpp
View File

@ -26,14 +26,15 @@
#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();

8
source/blender/compositor/nodes/COM_LuminanceMatteNode.cpp
View File

@ -25,8 +25,10 @@
#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));

5
source/blender/compositor/nodes/COM_MapUVNode.cpp
View File

@ -23,11 +23,12 @@
#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();

7
source/blender/compositor/nodes/COM_MapValueNode.cpp
View File

@ -25,15 +25,16 @@
#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);

7
source/blender/compositor/nodes/COM_MaskNode.cpp
View 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);
}

38
source/blender/compositor/nodes/COM_MathNode.cpp
View File

@ -24,61 +24,61 @@
#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;
}

118
source/blender/compositor/nodes/COM_MixNode.cpp
View File

@ -46,12 +46,12 @@
#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);

21
source/blender/compositor/nodes/COM_MovieClipNode.cpp
View 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);

7
source/blender/compositor/nodes/COM_MovieDistortionNode.cpp
View File

@ -28,16 +28,17 @@
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());

17
source/blender/compositor/nodes/COM_MuteNode.cpp
View File

@ -27,14 +27,15 @@
#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);
}

14
source/blender/compositor/nodes/COM_NormalNode.cpp
View File

@ -26,19 +26,21 @@
#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]);

5
source/blender/compositor/nodes/COM_NormalizeNode.cpp
View File

@ -23,11 +23,12 @@
#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();

19
source/blender/compositor/nodes/COM_OutputFileNode.cpp
View File

@ -27,13 +27,14 @@
#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) {

9
source/blender/compositor/nodes/COM_RenderLayersNode.cpp
View File

@ -47,14 +47,15 @@
#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());

21
source/blender/compositor/nodes/COM_RotateNode.cpp
View File

@ -28,9 +28,10 @@
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;
}

1
source/blender/compositor/nodes/COM_ScaleNode.cpp
View File

@ -29,6 +29,7 @@
ScaleNode::ScaleNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void ScaleNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)

5
source/blender/compositor/nodes/COM_SeparateHSVANode.cpp
View File

@ -27,11 +27,12 @@
#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);

5
source/blender/compositor/nodes/COM_SeparateRGBANode.cpp
View File

@ -28,12 +28,13 @@
#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);

3
source/blender/compositor/nodes/COM_SeparateYCCANode.cpp
View 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)

3
source/blender/compositor/nodes/COM_SeparateYUVANode.cpp
View 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)

2
source/blender/compositor/nodes/COM_SetAlphaNode.cpp
View 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();

62
source/blender/compositor/nodes/COM_SocketProxyNode.cpp
View 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;
}
}
}
}

1
source/blender/compositor/nodes/COM_SplitViewerNode.cpp
View File

@ -28,6 +28,7 @@
SplitViewerNode::SplitViewerNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void SplitViewerNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)

11
source/blender/compositor/nodes/COM_Stabilize2dNode.cpp
View 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();

7
source/blender/compositor/nodes/COM_SwitchNode.cpp
View File

@ -24,14 +24,15 @@
#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) {

7
source/blender/compositor/nodes/COM_TextureNode.cpp
View File

@ -24,14 +24,15 @@
#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);

9
source/blender/compositor/nodes/COM_TimeNode.cpp
View 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);
}

9
source/blender/compositor/nodes/COM_TonemapNode.cpp
View File

@ -25,14 +25,15 @@
#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);

29
source/blender/compositor/nodes/COM_TransformNode.cpp
View File

@ -28,11 +28,12 @@
#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);

3
source/blender/compositor/nodes/COM_TranslateNode.cpp
View File

@ -27,9 +27,10 @@
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);

7
source/blender/compositor/nodes/COM_ValueNode.cpp
View File

@ -25,15 +25,16 @@
#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);

1
source/blender/compositor/nodes/COM_VectorBlurNode.cpp
View File

@ -26,6 +26,7 @@
VectorBlurNode::VectorBlurNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void VectorBlurNode::convertToOperations(ExecutionSystem *system, CompositorContext *context)

7
source/blender/compositor/nodes/COM_VectorCurveNode.cpp
View File

@ -25,18 +25,19 @@
#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);
}

2
source/blender/compositor/nodes/COM_ViewLevelsNode.cpp
View File

@ -28,7 +28,9 @@
ViewLevelsNode::ViewLevelsNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void ViewLevelsNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)
{
InputSocket *input = this->getInputSocket(0);

1
source/blender/compositor/nodes/COM_ViewerNode.cpp
View File

@ -28,6 +28,7 @@
ViewerNode::ViewerNode(bNode *editorNode) : Node(editorNode)
{
/* pass */
}
void ViewerNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context)

8
source/blender/compositor/nodes/COM_ZCombineNode.cpp
View File

@ -30,10 +30,10 @@
#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());

1
source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
View File

@ -24,6 +24,7 @@
AlphaOverKeyOperation::AlphaOverKeyOperation(): MixBaseOperation()
{
/* pass */
}
void AlphaOverKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp
View File

@ -24,6 +24,7 @@
AlphaOverPremultiplyOperation::AlphaOverPremultiplyOperation(): MixBaseOperation()
{
/* pass */
}
void AlphaOverPremultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp
View File

@ -28,6 +28,7 @@
CalculateStandardDeviationOperation::CalculateStandardDeviationOperation(): CalculateMeanOperation()
{
/* pass */
}
void CalculateStandardDeviationOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void * data)

1
source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp
View File

@ -25,6 +25,7 @@
ConvolutionEdgeFilterOperation::ConvolutionEdgeFilterOperation() : ConvolutionFilterOperation()
{
/* pass */
}
void ConvolutionEdgeFilterOperation::executePixel(float *color,int x, int y, MemoryBuffer *inputBuffers[], void *data)

2
source/blender/compositor/operations/COM_CropOperation.cpp
View 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)

2
source/blender/compositor/operations/COM_DilateErodeOperation.cpp
View 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)

1
source/blender/compositor/operations/COM_MixAddOperation.cpp
View File

@ -24,6 +24,7 @@
MixAddOperation::MixAddOperation(): MixBaseOperation()
{
/* pass */
}
void MixAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixBlendOperation.cpp
View File

@ -24,6 +24,7 @@
MixBlendOperation::MixBlendOperation(): MixBaseOperation()
{
/* pass */
}
void MixBlendOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixBurnOperation.cpp
View File

@ -24,6 +24,7 @@
MixBurnOperation::MixBurnOperation(): MixBaseOperation()
{
/* pass */
}
void MixBurnOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixColorOperation.cpp
View File

@ -28,6 +28,7 @@ extern "C" {
MixColorOperation::MixColorOperation(): MixBaseOperation()
{
/* pass */
}
void MixColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixDarkenOperation.cpp
View File

@ -24,6 +24,7 @@
MixDarkenOperation::MixDarkenOperation(): MixBaseOperation()
{
/* pass */
}
void MixDarkenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
View File

@ -25,6 +25,7 @@
MixDifferenceOperation::MixDifferenceOperation(): MixBaseOperation()
{
/* pass */
}
void MixDifferenceOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixDivideOperation.cpp
View File

@ -24,6 +24,7 @@
MixDivideOperation::MixDivideOperation(): MixBaseOperation()
{
/* pass */
}
void MixDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixDodgeOperation.cpp
View File

@ -24,6 +24,7 @@
MixDodgeOperation::MixDodgeOperation(): MixBaseOperation()
{
/* pass */
}
void MixDodgeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixGlareOperation.cpp
View File

@ -24,6 +24,7 @@
MixGlareOperation::MixGlareOperation(): MixBaseOperation()
{
/* pass */
}
void MixGlareOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixHueOperation.cpp
View File

@ -28,6 +28,7 @@ extern "C" {
MixHueOperation::MixHueOperation(): MixBaseOperation()
{
/* pass */
}
void MixHueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

1
source/blender/compositor/operations/COM_MixLightenOperation.cpp
View File

@ -24,6 +24,7 @@
MixLightenOperation::MixLightenOperation(): MixBaseOperation()
{
/* pass */
}
void MixLightenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])

Some files were not shown because too many files have changed in this diff Show More