void ColorSpillNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
bNode *editorsnode = getbNode();
NodeInput *inputSocketImage = this->getInputSocket(0);
NodeInput *inputSocketFac = this->getInputSocket(1);
NodeOutput *outputSocketImage = this->getOutputSocket(0);
ColorSpillOperation *operation;
if (editorsnode->custom2 == 0) {
// Simple color spill
operation = new ColorSpillOperation();
}
else {
// Average color spill
operation = new ColorSpillAverageOperation();
}
operation->setSettings((NodeColorspill *)editorsnode->storage);
operation->setSpillChannel(editorsnode->custom1 - 1); // Channel for spilling
converter.addOperation(operation);
converter.mapInputSocket(inputSocketImage, operation->getInputSocket(0));
converter.mapInputSocket(inputSocketFac, operation->getInputSocket(1));
converter.mapOutputSocket(outputSocketImage, operation->getOutputSocket());
}
void TimeNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
SetValueOperation *operation = new SetValueOperation();
bNode *node = this->getbNode();
/* stack order output: fac */
float fac = 0.0f;
const int framenumber = context.getFramenumber();
if (framenumber < node->custom1) {
fac = 0.0f;
}
else if (framenumber > node->custom2) {
fac = 1.0f;
}
else if (node->custom1 < node->custom2) {
fac = (context.getFramenumber() - node->custom1) / (float)(node->custom2 - node->custom1);
}
curvemapping_initialize((CurveMapping *)node->storage);
fac = curvemapping_evaluateF((CurveMapping *)node->storage, 0, fac);
operation->setValue(clamp_f(fac, 0.0f, 1.0f));
converter.addOperation(operation);
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
}
void RenderLayersNode::missingSocketLink(NodeConverter &converter,
NodeOutput *output) const
{
NodeOperation *operation;
switch (output->getDataType()) {
case COM_DT_COLOR:
{
const float color[4] = {0.0f, 0.0f, 0.0f, 0.0f};
SetColorOperation *color_operation = new SetColorOperation();
color_operation->setChannels(color);
operation = color_operation;
break;
}
case COM_DT_VECTOR:
{
const float vector[3] = {0.0f, 0.0f, 0.0f};
SetVectorOperation *vector_operation = new SetVectorOperation();
vector_operation->setVector(vector);
operation = vector_operation;
break;
}
case COM_DT_VALUE:
{
SetValueOperation *value_operation = new SetValueOperation();
value_operation->setValue(0.0f);
operation = value_operation;
break;
}
}
converter.mapOutputSocket(output, operation->getOutputSocket());
converter.addOperation(operation);
}
void GammaNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
GammaOperation *operation = new GammaOperation();
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(1), operation->getInputSocket(1));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
void VectorCurveNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
VectorCurveOperation *operation = new VectorCurveOperation();
operation->setCurveMapping((CurveMapping *)this->getbNode()->storage);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
}
void BokehImageNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
BokehImageOperation *operation = new BokehImageOperation();
operation->setData((NodeBokehImage *)this->getbNode()->storage);
converter.addOperation(operation);
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
converter.addPreview(operation->getOutputSocket(0));
}
void HueSaturationValueCorrectNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
NodeInput *valueSocket = this->getInputSocket(0);
NodeInput *colorSocket = this->getInputSocket(1);
NodeOutput *outputSocket = this->getOutputSocket(0);
bNode *editorsnode = getbNode();
CurveMapping *storage = (CurveMapping *)editorsnode->storage;
ConvertRGBToHSVOperation *rgbToHSV = new ConvertRGBToHSVOperation();
converter.addOperation(rgbToHSV);
ConvertHSVToRGBOperation *hsvToRGB = new ConvertHSVToRGBOperation();
converter.addOperation(hsvToRGB);
HueSaturationValueCorrectOperation *changeHSV = new HueSaturationValueCorrectOperation();
changeHSV->setCurveMapping(storage);
converter.addOperation(changeHSV);
MixBlendOperation *blend = new MixBlendOperation();
blend->setResolutionInputSocketIndex(1);
converter.addOperation(blend);
converter.mapInputSocket(colorSocket, rgbToHSV->getInputSocket(0));
converter.addLink(rgbToHSV->getOutputSocket(), changeHSV->getInputSocket(0));
converter.addLink(changeHSV->getOutputSocket(), hsvToRGB->getInputSocket(0));
converter.addLink(hsvToRGB->getOutputSocket(), blend->getInputSocket(2));
converter.mapInputSocket(colorSocket, blend->getInputSocket(1));
converter.mapInputSocket(valueSocket, blend->getInputSocket(0));
converter.mapOutputSocket(outputSocket, blend->getOutputSocket());
}
void DifferenceMatteNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
NodeInput *inputSocket = this->getInputSocket(0);
NodeInput *inputSocket2 = this->getInputSocket(1);
NodeOutput *outputSocketImage = this->getOutputSocket(0);
NodeOutput *outputSocketMatte = this->getOutputSocket(1);
bNode *editorNode = this->getbNode();
DifferenceMatteOperation *operationSet = new DifferenceMatteOperation();
operationSet->setSettings((NodeChroma *)editorNode->storage);
converter.addOperation(operationSet);
converter.mapInputSocket(inputSocket, operationSet->getInputSocket(0));
converter.mapInputSocket(inputSocket2, operationSet->getInputSocket(1));
converter.mapOutputSocket(outputSocketMatte, operationSet->getOutputSocket(0));
SetAlphaOperation *operation = new SetAlphaOperation();
converter.addOperation(operation);
converter.mapInputSocket(inputSocket, operation->getInputSocket(0));
converter.addLink(operationSet->getOutputSocket(), operation->getInputSocket(1));
converter.mapOutputSocket(outputSocketImage, operation->getOutputSocket());
converter.addPreview(operation->getOutputSocket());
}
void ColorNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
SetColorOperation *operation = new SetColorOperation();
NodeOutput *output = this->getOutputSocket(0);
float col[4];
output->getEditorValueColor(col);
operation->setChannels(col);
converter.addOperation(operation);
converter.mapOutputSocket(output, operation->getOutputSocket());
}
void TonemapNode::convertToOperations(NodeConverter &converter, const CompositorContext &/*context*/) const
{
NodeTonemap *data = (NodeTonemap *)this->getbNode()->storage;
TonemapOperation *operation = data->type == 1 ? new PhotoreceptorTonemapOperation() : new TonemapOperation();
operation->setData(data);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
void SwitchNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
bool condition = this->getbNode()->custom1;
NodeOperationOutput *result;
if (!condition)
result = converter.addInputProxy(getInputSocket(0));
else
result = converter.addInputProxy(getInputSocket(1));
converter.mapOutputSocket(getOutputSocket(0), result);
}
void BilateralBlurNode::convertToOperations(NodeConverter &converter,
const CompositorContext &context) const
{
NodeBilateralBlurData *data = (NodeBilateralBlurData *)this->getbNode()->storage;
BilateralBlurOperation *operation = new BilateralBlurOperation();
operation->setQuality(context.getQuality());
operation->setData(data);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(1), operation->getInputSocket(1));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
void SetAlphaNode::convertToOperations(NodeConverter &converter, const CompositorContext &/*context*/) const
{
SetAlphaOperation *operation = new SetAlphaOperation();
if (!this->getInputSocket(0)->isLinked() && this->getInputSocket(1)->isLinked()) {
operation->setResolutionInputSocketIndex(1);
}
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(1), operation->getInputSocket(1));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
}
void SocketBufferNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
NodeOutput *output = this->getOutputSocket(0);
NodeInput *input = this->getInputSocket(0);
DataType datatype = output->getDataType();
WriteBufferOperation *writeOperation = new WriteBufferOperation(datatype);
ReadBufferOperation *readOperation = new ReadBufferOperation(datatype);
readOperation->setMemoryProxy(writeOperation->getMemoryProxy());
converter.addOperation(writeOperation);
converter.addOperation(readOperation);
converter.mapInputSocket(input, writeOperation->getInputSocket(0));
converter.mapOutputSocket(output, readOperation->getOutputSocket());
}
void GlareNode::convertToOperations(NodeConverter &converter,
const CompositorContext & /*context*/) const
{
bNode *node = this->getbNode();
NodeGlare *glare = (NodeGlare *)node->storage;
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;
}
BLI_assert(glareoperation);
glareoperation->setGlareSettings(glare);
GlareThresholdOperation *thresholdOperation = new GlareThresholdOperation();
thresholdOperation->setGlareSettings(glare);
SetValueOperation *mixvalueoperation = new SetValueOperation();
mixvalueoperation->setValue(0.5f + glare->mix * 0.5f);
MixGlareOperation *mixoperation = new MixGlareOperation();
mixoperation->setResolutionInputSocketIndex(1);
mixoperation->getInputSocket(2)->setResizeMode(COM_SC_FIT);
converter.addOperation(glareoperation);
converter.addOperation(thresholdOperation);
converter.addOperation(mixvalueoperation);
converter.addOperation(mixoperation);
converter.mapInputSocket(getInputSocket(0), thresholdOperation->getInputSocket(0));
converter.addLink(thresholdOperation->getOutputSocket(), glareoperation->getInputSocket(0));
converter.addLink(mixvalueoperation->getOutputSocket(), mixoperation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(0), mixoperation->getInputSocket(1));
converter.addLink(glareoperation->getOutputSocket(), mixoperation->getInputSocket(2));
converter.mapOutputSocket(getOutputSocket(), mixoperation->getOutputSocket());
}
void InpaintNode::convertToOperations(NodeConverter &converter,
const CompositorContext & /*context*/) const
{
bNode *editorNode = this->getbNode();
/* if (editorNode->custom1 == CMP_NODE_INPAINT_SIMPLE) { */
if (true) {
InpaintSimpleOperation *operation = new InpaintSimpleOperation();
operation->setIterations(editorNode->custom2);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
}
void MovieDistortionNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
bNode *bnode = this->getbNode();
MovieClip *clip = (MovieClip *)bnode->id;
NodeInput *inputSocket = this->getInputSocket(0);
NodeOutput *outputSocket = this->getOutputSocket(0);
MovieDistortionOperation *operation = new MovieDistortionOperation(bnode->custom1 == 1);
operation->setMovieClip(clip);
operation->setFramenumber(context.getFramenumber());
converter.addOperation(operation);
converter.mapInputSocket(inputSocket, operation->getInputSocket(0));
converter.mapOutputSocket(outputSocket, operation->getOutputSocket(0));
}
void KeyingScreenNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
bNode *editorNode = this->getbNode();
MovieClip *clip = (MovieClip *) editorNode->id;
NodeKeyingScreenData *keyingscreen_data = (NodeKeyingScreenData *) editorNode->storage;
NodeOutput *outputScreen = this->getOutputSocket(0);
// always connect the output image
KeyingScreenOperation *operation = new KeyingScreenOperation();
operation->setMovieClip(clip);
operation->setTrackingObject(keyingscreen_data->tracking_object);
operation->setFramenumber(context.getFramenumber());
converter.addOperation(operation);
converter.mapOutputSocket(outputScreen, operation->getOutputSocket());
}
void CornerPinNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
NodeInput *input_image = this->getInputSocket(0);
/* note: socket order differs between UI node and operations:
* bNode uses intuitive order following top-down layout:
* upper-left, upper-right, lower-left, lower-right
* Operations use same order as the tracking blenkernel functions expect:
* lower-left, lower-right, upper-right, upper-left
*/
const int node_corner_index[4] = { 3, 4, 2, 1 };
NodeOutput *output_warped_image = this->getOutputSocket(0);
NodeOutput *output_plane = this->getOutputSocket(1);
PlaneCornerPinWarpImageOperation *warp_image_operation = new PlaneCornerPinWarpImageOperation();
converter.addOperation(warp_image_operation);
PlaneCornerPinMaskOperation *plane_mask_operation = new PlaneCornerPinMaskOperation();
converter.addOperation(plane_mask_operation);
converter.mapInputSocket(input_image, warp_image_operation->getInputSocket(0));
for (int i = 0; i < 4; ++i) {
NodeInput *corner_input = getInputSocket(node_corner_index[i]);
converter.mapInputSocket(corner_input, warp_image_operation->getInputSocket(i + 1));
converter.mapInputSocket(corner_input, plane_mask_operation->getInputSocket(i));
}
converter.mapOutputSocket(output_warped_image, warp_image_operation->getOutputSocket());
converter.mapOutputSocket(output_plane, plane_mask_operation->getOutputSocket());
}
void ColorCurveNode::convertToOperations(NodeConverter &converter, const CompositorContext &/*context*/) const
{
if (this->getInputSocket(2)->isLinked() || this->getInputSocket(3)->isLinked()) {
ColorCurveOperation *operation = new ColorCurveOperation();
operation->setCurveMapping((CurveMapping *)this->getbNode()->storage);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(1), operation->getInputSocket(1));
converter.mapInputSocket(getInputSocket(2), operation->getInputSocket(2));
converter.mapInputSocket(getInputSocket(3), operation->getInputSocket(3));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
}
else {
ConstantLevelColorCurveOperation *operation = new ConstantLevelColorCurveOperation();
float col[4];
this->getInputSocket(2)->getEditorValueColor(col);
operation->setBlackLevel(col);
this->getInputSocket(3)->getEditorValueColor(col);
operation->setWhiteLevel(col);
operation->setCurveMapping((CurveMapping *)this->getbNode()->storage);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(1), operation->getInputSocket(1));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
}
}
void ViewLevelsNode::convertToOperations(NodeConverter &converter, const CompositorContext &/*context*/) const
{
NodeInput *input = this->getInputSocket(0);
if (input->isLinked()) {
// add preview to inputSocket;
/* calculate mean operation */
{
CalculateMeanOperation *operation = new CalculateMeanOperation();
operation->setSetting(this->getbNode()->custom1);
converter.addOperation(operation);
converter.mapInputSocket(input, operation->getInputSocket(0));
converter.mapOutputSocket(this->getOutputSocket(0), operation->getOutputSocket());
}
/* calculate standard deviation operation */
{
CalculateStandardDeviationOperation *operation = new CalculateStandardDeviationOperation();
operation->setSetting(this->getbNode()->custom1);
converter.addOperation(operation);
converter.mapInputSocket(input, operation->getInputSocket(0));
converter.mapOutputSocket(this->getOutputSocket(1), operation->getOutputSocket());
}
}
else {
converter.addOutputValue(getOutputSocket(0), 0.0f);
converter.addOutputValue(getOutputSocket(1), 0.0f);
}
}
void ConvertAlphaNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
NodeOperation *operation = NULL;
bNode *node = this->getbNode();
/* value hardcoded in rna_nodetree.c */
if (node->custom1 == 1) {
operation = new ConvertPremulToStraightOperation();
}
else {
operation = new ConvertStraightToPremulOperation();
}
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
}
void DespeckleNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
bNode *editorNode = this->getbNode();
NodeInput *inputSocket = this->getInputSocket(0);
NodeInput *inputImageSocket = this->getInputSocket(1);
NodeOutput *outputSocket = this->getOutputSocket(0);
DespeckleOperation *operation = new DespeckleOperation();
operation->setThreshold(editorNode->custom3);
operation->setThresholdNeighbor(editorNode->custom4);
converter.addOperation(operation);
converter.mapInputSocket(inputImageSocket, operation->getInputSocket(0));
converter.mapInputSocket(inputSocket, operation->getInputSocket(1));
converter.mapOutputSocket(outputSocket, operation->getOutputSocket());
converter.addPreview(operation->getOutputSocket(0));
}
void RenderLayersNode::testSocketLink(NodeConverter &converter,
const CompositorContext &context,
NodeOutput *output,
RenderLayersProg *operation,
Scene *scene,
int layerId,
bool is_preview) const
{
operation->setScene(scene);
operation->setLayerId(layerId);
operation->setRenderData(context.getRenderData());
operation->setViewName(context.getViewName());
converter.mapOutputSocket(output, operation->getOutputSocket());
converter.addOperation(operation);
if (is_preview) /* only for image socket */
converter.addPreview(operation->getOutputSocket());
}
void ColorBalanceNode::convertToOperations(NodeConverter &converter, const CompositorContext &/*context*/) const
{
bNode *node = this->getbNode();
NodeColorBalance *n = (NodeColorBalance *)node->storage;
NodeInput *inputSocket = this->getInputSocket(0);
NodeInput *inputImageSocket = this->getInputSocket(1);
NodeOutput *outputSocket = this->getOutputSocket(0);
NodeOperation *operation;
if (node->custom1 == 0) {
ColorBalanceLGGOperation *operationLGG = new ColorBalanceLGGOperation();
float lift_lgg[3], gamma_inv[3];
for (int c = 0; c < 3; c++) {
lift_lgg[c] = 2.0f - n->lift[c];
gamma_inv[c] = (n->gamma[c] != 0.0f) ? 1.0f / n->gamma[c] : 1000000.0f;
}
operationLGG->setGain(n->gain);
operationLGG->setLift(lift_lgg);
operationLGG->setGammaInv(gamma_inv);
operation = operationLGG;
}
else {
ColorBalanceASCCDLOperation *operationCDL = new ColorBalanceASCCDLOperation();
float offset[3];
copy_v3_fl(offset, n->offset_basis);
add_v3_v3(offset, n->offset);
operationCDL->setOffset(offset);
operationCDL->setPower(n->power);
operationCDL->setSlope(n->slope);
operation = operationCDL;
}
converter.addOperation(operation);
converter.mapInputSocket(inputSocket, operation->getInputSocket(0));
converter.mapInputSocket(inputImageSocket, operation->getInputSocket(1));
converter.mapOutputSocket(outputSocket, operation->getOutputSocket(0));
}
void ColorSpillNode::convertToOperations(NodeConverter &converter,
const CompositorContext & /*context*/) const
{
bNode *editorsnode = getbNode();
NodeInput *inputSocketImage = this->getInputSocket(0);
NodeInput *inputSocketFac = this->getInputSocket(1);
NodeOutput *outputSocketImage = this->getOutputSocket(0);
ColorSpillOperation *operation;
operation = new ColorSpillOperation();
operation->setSettings((NodeColorspill *)editorsnode->storage);
operation->setSpillChannel(editorsnode->custom1 - 1); // Channel for spilling
operation->setSpillMethod(editorsnode->custom2); // Channel method
converter.addOperation(operation);
converter.mapInputSocket(inputSocketImage, operation->getInputSocket(0));
converter.mapInputSocket(inputSocketFac, operation->getInputSocket(1));
converter.mapOutputSocket(outputSocketImage, operation->getOutputSocket());
}
void MapRangeNode::convertToOperations(NodeConverter &converter, const CompositorContext &/*context*/) const
{
NodeInput *valueSocket = this->getInputSocket(0);
NodeInput *sourceMinSocket = this->getInputSocket(1);
NodeInput *sourceMaxSocket = this->getInputSocket(2);
NodeInput *destMinSocket = this->getInputSocket(3);
NodeInput *destMaxSocket = this->getInputSocket(4);
NodeOutput *outputSocket = this->getOutputSocket(0);
MapRangeOperation *operation = new MapRangeOperation();
operation->setUseClamp(this->getbNode()->custom1);
converter.addOperation(operation);
converter.mapInputSocket(valueSocket, operation->getInputSocket(0));
converter.mapInputSocket(sourceMinSocket, operation->getInputSocket(1));
converter.mapInputSocket(sourceMaxSocket, operation->getInputSocket(2));
converter.mapInputSocket(destMinSocket, operation->getInputSocket(3));
converter.mapInputSocket(destMaxSocket, operation->getInputSocket(4));
converter.mapOutputSocket(outputSocket, operation->getOutputSocket(0));
}
void TrackPositionNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
bNode *editorNode = this->getbNode();
MovieClip *clip = (MovieClip *) editorNode->id;
NodeTrackPosData *trackpos_data = (NodeTrackPosData *) editorNode->storage;
NodeOutput *outputX = this->getOutputSocket(0);
NodeOutput *outputY = this->getOutputSocket(1);
int frame_number;
if (editorNode->custom1 == CMP_TRACKPOS_ABSOLUTE_FRAME) {
frame_number = editorNode->custom2;
}
else {
frame_number = context.getFramenumber();
}
TrackPositionOperation *operationX = new TrackPositionOperation();
operationX->setMovieClip(clip);
operationX->setTrackingObject(trackpos_data->tracking_object);
operationX->setTrackName(trackpos_data->track_name);
operationX->setFramenumber(frame_number);
operationX->setAxis(0);
operationX->setPosition(editorNode->custom1);
operationX->setRelativeFrame(editorNode->custom2);
converter.addOperation(operationX);
TrackPositionOperation *operationY = new TrackPositionOperation();
operationY->setMovieClip(clip);
operationY->setTrackingObject(trackpos_data->tracking_object);
operationY->setTrackName(trackpos_data->track_name);
operationY->setFramenumber(frame_number);
operationY->setAxis(1);
operationY->setPosition(editorNode->custom1);
operationY->setRelativeFrame(editorNode->custom2);
converter.addOperation(operationY);
converter.mapOutputSocket(outputX, operationX->getOutputSocket());
converter.mapOutputSocket(outputY, operationY->getOutputSocket());
}
void CompositorNode::convertToOperations(NodeConverter &converter,
const CompositorContext &context) const
{
bNode *editorNode = this->getbNode();
bool is_active = (editorNode->flag & NODE_DO_OUTPUT_RECALC) || context.isRendering();
bool ignore_alpha = (editorNode->custom2 & CMP_NODE_OUTPUT_IGNORE_ALPHA) != 0;
NodeInput *imageSocket = this->getInputSocket(0);
NodeInput *alphaSocket = this->getInputSocket(1);
NodeInput *depthSocket = this->getInputSocket(2);
CompositorOperation *compositorOperation = new CompositorOperation();
compositorOperation->setScene(context.getScene());
compositorOperation->setSceneName(context.getScene()->id.name);
compositorOperation->setRenderData(context.getRenderData());
compositorOperation->setViewName(context.getViewName());
compositorOperation->setbNodeTree(context.getbNodeTree());
/* alpha socket gives either 1 or a custom alpha value if "use alpha" is enabled */
compositorOperation->setUseAlphaInput(ignore_alpha || alphaSocket->isLinked());
compositorOperation->setActive(is_active);
converter.addOperation(compositorOperation);
converter.mapInputSocket(imageSocket, compositorOperation->getInputSocket(0));
/* only use alpha link if "use alpha" is enabled */
if (ignore_alpha) {
converter.addInputValue(compositorOperation->getInputSocket(1), 1.0f);
}
else {
converter.mapInputSocket(alphaSocket, compositorOperation->getInputSocket(1));
}
converter.mapInputSocket(depthSocket, compositorOperation->getInputSocket(2));
converter.addNodeInputPreview(imageSocket);
}
void AlphaOverNode::convertToOperations(NodeConverter &converter, const CompositorContext &/*context*/) const
{
NodeInput *color1Socket = this->getInputSocket(1);
NodeInput *color2Socket = this->getInputSocket(2);
bNode *editorNode = this->getbNode();
MixBaseOperation *convertProg;
NodeTwoFloats *ntf = (NodeTwoFloats *)editorNode->storage;
if (ntf->x != 0.0f) {
AlphaOverMixedOperation *mixOperation = new AlphaOverMixedOperation();
mixOperation->setX(ntf->x);
convertProg = mixOperation;
}
else if (editorNode->custom1) {
convertProg = new AlphaOverKeyOperation();
}
else {
convertProg = new AlphaOverPremultiplyOperation();
}
convertProg->setUseValueAlphaMultiply(false);
if (color1Socket->isLinked()) {
convertProg->setResolutionInputSocketIndex(1);
}
else if (color2Socket->isLinked()) {
convertProg->setResolutionInputSocketIndex(2);
}
else {
convertProg->setResolutionInputSocketIndex(0);
}
converter.addOperation(convertProg);
converter.mapInputSocket(getInputSocket(0), convertProg->getInputSocket(0));
converter.mapInputSocket(getInputSocket(1), convertProg->getInputSocket(1));
converter.mapInputSocket(getInputSocket(2), convertProg->getInputSocket(2));
converter.mapOutputSocket(getOutputSocket(0), convertProg->getOutputSocket(0));
}
