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 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 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 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 BokehBlurNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
bNode *b_node = this->getbNode();
NodeInput *inputSizeSocket = this->getInputSocket(2);
bool connectedSizeSocket = inputSizeSocket->isLinked();
const bool extend_bounds = (b_node->custom1 & CMP_NODEFLAG_BLUR_EXTEND_BOUNDS) != 0;
if ((b_node->custom1 & CMP_NODEFLAG_BLUR_VARIABLE_SIZE) && connectedSizeSocket) {
VariableSizeBokehBlurOperation *operation = new VariableSizeBokehBlurOperation();
operation->setQuality(context.getQuality());
operation->setThreshold(0.0f);
operation->setMaxBlur(b_node->custom4);
operation->setDoScaleSize(true);
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.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
}
else {
BokehBlurOperation *operation = new BokehBlurOperation();
operation->setQuality(context.getQuality());
operation->setExtendBounds(extend_bounds);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(1), operation->getInputSocket(1));
// NOTE: on the bokeh blur operation the sockets are switched.
// for this reason the next two lines are correct.
// Fix for T43771
converter.mapInputSocket(getInputSocket(2), operation->getInputSocket(3));
converter.mapInputSocket(getInputSocket(3), operation->getInputSocket(2));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
if (!connectedSizeSocket) {
operation->setSize(this->getInputSocket(2)->getEditorValueFloat());
}
}
}
void Stabilize2dNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
NodeInput *imageInput = this->getInputSocket(0);
MovieClip *clip = (MovieClip *)getbNode()->id;
ScaleOperation *scaleOperation = new ScaleOperation();
scaleOperation->setSampler((PixelSampler)this->getbNode()->custom1);
RotateOperation *rotateOperation = new RotateOperation();
rotateOperation->setDoDegree2RadConversion(false);
TranslateOperation *translateOperation = new TranslateOperation();
MovieClipAttributeOperation *scaleAttribute = new MovieClipAttributeOperation();
MovieClipAttributeOperation *angleAttribute = new MovieClipAttributeOperation();
MovieClipAttributeOperation *xAttribute = new MovieClipAttributeOperation();
MovieClipAttributeOperation *yAttribute = new MovieClipAttributeOperation();
SetSamplerOperation *psoperation = new SetSamplerOperation();
psoperation->setSampler((PixelSampler)this->getbNode()->custom1);
scaleAttribute->setAttribute(MCA_SCALE);
scaleAttribute->setFramenumber(context.getFramenumber());
scaleAttribute->setMovieClip(clip);
angleAttribute->setAttribute(MCA_ANGLE);
angleAttribute->setFramenumber(context.getFramenumber());
angleAttribute->setMovieClip(clip);
xAttribute->setAttribute(MCA_X);
xAttribute->setFramenumber(context.getFramenumber());
xAttribute->setMovieClip(clip);
yAttribute->setAttribute(MCA_Y);
yAttribute->setFramenumber(context.getFramenumber());
yAttribute->setMovieClip(clip);
converter.addOperation(scaleAttribute);
converter.addOperation(angleAttribute);
converter.addOperation(xAttribute);
converter.addOperation(yAttribute);
converter.addOperation(scaleOperation);
converter.addOperation(translateOperation);
converter.addOperation(rotateOperation);
converter.addOperation(psoperation);
converter.mapInputSocket(imageInput, scaleOperation->getInputSocket(0));
converter.addLink(scaleAttribute->getOutputSocket(), scaleOperation->getInputSocket(1));
converter.addLink(scaleAttribute->getOutputSocket(), scaleOperation->getInputSocket(2));
converter.addLink(scaleOperation->getOutputSocket(), rotateOperation->getInputSocket(0));
converter.addLink(angleAttribute->getOutputSocket(), rotateOperation->getInputSocket(1));
converter.addLink(rotateOperation->getOutputSocket(), translateOperation->getInputSocket(0));
converter.addLink(xAttribute->getOutputSocket(), translateOperation->getInputSocket(1));
converter.addLink(yAttribute->getOutputSocket(), translateOperation->getInputSocket(2));
converter.addLink(translateOperation->getOutputSocket(), psoperation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(), psoperation->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 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 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 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 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));
}
void TransformNode::convertToOperations(NodeConverter &converter,
const CompositorContext & /*context*/) const
{
NodeInput *imageInput = this->getInputSocket(0);
NodeInput *xInput = this->getInputSocket(1);
NodeInput *yInput = this->getInputSocket(2);
NodeInput *angleInput = this->getInputSocket(3);
NodeInput *scaleInput = this->getInputSocket(4);
ScaleOperation *scaleOperation = new ScaleOperation();
converter.addOperation(scaleOperation);
RotateOperation *rotateOperation = new RotateOperation();
rotateOperation->setDoDegree2RadConversion(false);
converter.addOperation(rotateOperation);
TranslateOperation *translateOperation = new TranslateOperation();
converter.addOperation(translateOperation);
SetSamplerOperation *sampler = new SetSamplerOperation();
sampler->setSampler((PixelSampler)this->getbNode()->custom1);
converter.addOperation(sampler);
converter.mapInputSocket(imageInput, sampler->getInputSocket(0));
converter.addLink(sampler->getOutputSocket(), scaleOperation->getInputSocket(0));
converter.mapInputSocket(scaleInput, scaleOperation->getInputSocket(1));
converter.mapInputSocket(scaleInput, scaleOperation->getInputSocket(2)); // xscale = yscale
converter.addLink(scaleOperation->getOutputSocket(), rotateOperation->getInputSocket(0));
converter.mapInputSocket(angleInput, rotateOperation->getInputSocket(1));
converter.addLink(rotateOperation->getOutputSocket(), translateOperation->getInputSocket(0));
converter.mapInputSocket(xInput, translateOperation->getInputSocket(1));
converter.mapInputSocket(yInput, translateOperation->getInputSocket(2));
converter.mapOutputSocket(getOutputSocket(), translateOperation->getOutputSocket());
}
void ZCombineNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
if ((context.getRenderData()->scemode & R_FULL_SAMPLE) || this->getbNode()->custom2) {
ZCombineOperation *operation = NULL;
if (this->getbNode()->custom1) {
operation = new ZCombineAlphaOperation();
}
else {
operation = new ZCombineOperation();
}
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());
MathMinimumOperation *zoperation = new MathMinimumOperation();
converter.addOperation(zoperation);
converter.mapInputSocket(getInputSocket(1), zoperation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(3), zoperation->getInputSocket(1));
converter.mapOutputSocket(getOutputSocket(1), zoperation->getOutputSocket());
}
else {
/* XXX custom1 is "use_alpha", what on earth is this supposed to do here?!? */
// not full anti alias, use masking for Z combine. be aware it uses anti aliasing.
// step 1 create mask
NodeOperation *maskoperation;
if (this->getbNode()->custom1) {
maskoperation = new MathGreaterThanOperation();
converter.addOperation(maskoperation);
converter.mapInputSocket(getInputSocket(1), maskoperation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(3), maskoperation->getInputSocket(1));
}
else {
maskoperation = new MathLessThanOperation();
converter.addOperation(maskoperation);
converter.mapInputSocket(getInputSocket(1), maskoperation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(3), maskoperation->getInputSocket(1));
}
// step 2 anti alias mask bit of an expensive operation, but does the trick
AntiAliasOperation *antialiasoperation = new AntiAliasOperation();
converter.addOperation(antialiasoperation);
converter.addLink(maskoperation->getOutputSocket(), antialiasoperation->getInputSocket(0));
// use mask to blend between the input colors.
ZCombineMaskOperation *zcombineoperation = this->getbNode()->custom1 ? new ZCombineMaskAlphaOperation() : new ZCombineMaskOperation();
converter.addOperation(zcombineoperation);
converter.addLink(antialiasoperation->getOutputSocket(), zcombineoperation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(0), zcombineoperation->getInputSocket(1));
converter.mapInputSocket(getInputSocket(2), zcombineoperation->getInputSocket(2));
converter.mapOutputSocket(getOutputSocket(0), zcombineoperation->getOutputSocket());
MathMinimumOperation *zoperation = new MathMinimumOperation();
converter.addOperation(zoperation);
converter.mapInputSocket(getInputSocket(1), zoperation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(3), zoperation->getInputSocket(1));
converter.mapOutputSocket(getOutputSocket(1), zoperation->getOutputSocket());
}
}
void BlurNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
bNode *editorNode = this->getbNode();
NodeBlurData *data = (NodeBlurData *)editorNode->storage;
NodeInput *inputSizeSocket = this->getInputSocket(1);
bool connectedSizeSocket = inputSizeSocket->isLinked();
const float size = this->getInputSocket(1)->getEditorValueFloat();
CompositorQuality quality = context.getQuality();
NodeOperation *input_operation = NULL, *output_operation = NULL;
if (data->filtertype == R_FILTER_FAST_GAUSS) {
FastGaussianBlurOperation *operationfgb = new FastGaussianBlurOperation();
operationfgb->setData(data);
converter.addOperation(operationfgb);
converter.mapInputSocket(getInputSocket(1), operationfgb->getInputSocket(1));
input_operation = operationfgb;
output_operation = operationfgb;
}
else if (editorNode->custom1 & CMP_NODEFLAG_BLUR_VARIABLE_SIZE) {
MathAddOperation *clamp = new MathAddOperation();
SetValueOperation *zero = new SetValueOperation();
zero->setValue(0.0f);
clamp->setUseClamp(true);
converter.addOperation(clamp);
converter.addOperation(zero);
converter.mapInputSocket(getInputSocket(1), clamp->getInputSocket(0));
converter.addLink(zero->getOutputSocket(), clamp->getInputSocket(1));
GaussianAlphaXBlurOperation *operationx = new GaussianAlphaXBlurOperation();
operationx->setData(data);
operationx->setQuality(quality);
operationx->setSize(1.0f);
operationx->setFalloff(PROP_SMOOTH);
operationx->setSubtract(false);
converter.addOperation(operationx);
converter.addLink(clamp->getOutputSocket(), operationx->getInputSocket(0));
GaussianAlphaYBlurOperation *operationy = new GaussianAlphaYBlurOperation();
operationy->setData(data);
operationy->setQuality(quality);
operationy->setSize(1.0f);
operationy->setFalloff(PROP_SMOOTH);
operationy->setSubtract(false);
converter.addOperation(operationy);
converter.addLink(operationx->getOutputSocket(), operationy->getInputSocket(0));
GaussianBlurReferenceOperation *operation = new GaussianBlurReferenceOperation();
operation->setData(data);
operation->setQuality(quality);
converter.addOperation(operation);
converter.addLink(operationy->getOutputSocket(), operation->getInputSocket(1));
output_operation = operation;
input_operation = operation;
}
else if (!data->bokeh) {
GaussianXBlurOperation *operationx = new GaussianXBlurOperation();
operationx->setData(data);
operationx->setQuality(quality);
converter.addOperation(operationx);
converter.mapInputSocket(getInputSocket(1), operationx->getInputSocket(1));
GaussianYBlurOperation *operationy = new GaussianYBlurOperation();
operationy->setData(data);
operationy->setQuality(quality);
converter.addOperation(operationy);
converter.mapInputSocket(getInputSocket(1), operationy->getInputSocket(1));
converter.addLink(operationx->getOutputSocket(), operationy->getInputSocket(0));
if (!connectedSizeSocket) {
operationx->setSize(size);
operationy->setSize(size);
}
input_operation = operationx;
output_operation = operationy;
}
else {
GaussianBokehBlurOperation *operation = new GaussianBokehBlurOperation();
operation->setData(data);
operation->setQuality(quality);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(1), operation->getInputSocket(1));
if (!connectedSizeSocket) {
operation->setSize(size);
}
input_operation = operation;
output_operation = operation;
}
if (data->gamma) {
GammaCorrectOperation *correct = new GammaCorrectOperation();
GammaUncorrectOperation *inverse = new GammaUncorrectOperation();
converter.addOperation(correct);
converter.addOperation(inverse);
converter.mapInputSocket(getInputSocket(0), correct->getInputSocket(0));
converter.addLink(correct->getOutputSocket(), input_operation->getInputSocket(0));
converter.addLink(output_operation->getOutputSocket(), inverse->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(), inverse->getOutputSocket());
converter.addPreview(inverse->getOutputSocket());
}
else {
converter.mapInputSocket(getInputSocket(0), input_operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(), output_operation->getOutputSocket());
converter.addPreview(output_operation->getOutputSocket());
}
}
void MathNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
MathBaseOperation *operation = NULL;
switch (this->getbNode()->custom1) {
case 0: /* Add */
operation = new MathAddOperation();
break;
case 1: /* Subtract */
operation = new MathSubtractOperation();
break;
case 2: /* Multiply */
operation = new MathMultiplyOperation();
break;
case 3: /* Divide */
operation = new MathDivideOperation();
break;
case 4: /* Sine */
operation = new MathSineOperation();
break;
case 5: /* Cosine */
operation = new MathCosineOperation();
break;
case 6: /* Tangent */
operation = new MathTangentOperation();
break;
case 7: /* Arc-Sine */
operation = new MathArcSineOperation();
break;
case 8: /* Arc-Cosine */
operation = new MathArcCosineOperation();
break;
case 9: /* Arc-Tangent */
operation = new MathArcTangentOperation();
break;
case 10: /* Power */
operation = new MathPowerOperation();
break;
case 11: /* Logarithm */
operation = new MathLogarithmOperation();
break;
case 12: /* Minimum */
operation = new MathMinimumOperation();
break;
case 13: /* Maximum */
operation = new MathMaximumOperation();
break;
case 14: /* Round */
operation = new MathRoundOperation();
break;
case 15: /* Less Than */
operation = new MathLessThanOperation();
break;
case 16: /* Greater Than */
operation = new MathGreaterThanOperation();
break;
case 17: /* Modulo */
operation = new MathModuloOperation();
break;
case 18: /* Absolute Value */
operation = new MathAbsoluteOperation();
break;
}
if (operation) {
bool useClamp = getbNode()->custom2;
operation->setUseClamp(useClamp);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapInputSocket(getInputSocket(1), operation->getInputSocket(1));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket());
}
}
void ImageNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
/// Image output
NodeOutput *outputImage = this->getOutputSocket(0);
bNode *editorNode = this->getbNode();
Image *image = (Image *)editorNode->id;
ImageUser *imageuser = (ImageUser *)editorNode->storage;
int framenumber = context.getFramenumber();
int numberOfOutputs = this->getNumberOfOutputSockets();
bool outputStraightAlpha = (editorNode->custom1 & CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT) != 0;
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) {
bool is_multilayer_ok = false;
ImBuf *ibuf = BKE_image_acquire_ibuf(image, imageuser, NULL);
if (image->rr) {
RenderLayer *rl = (RenderLayer *)BLI_findlink(&image->rr->layers, imageuser->layer);
if (rl) {
NodeOutput *socket;
int index;
is_multilayer_ok = true;
for (index = 0; index < numberOfOutputs; index++) {
NodeOperation *operation = NULL;
socket = this->getOutputSocket(index);
bNodeSocket *bnodeSocket = socket->getbNodeSocket();
/* Passes in the file can differ from passes stored in sockets (#36755).
* Look up the correct file pass using the socket identifier instead.
*/
#if 0
NodeImageLayer *storage = (NodeImageLayer *)bnodeSocket->storage;*/
int passindex = storage->pass_index;*/
RenderPass *rpass = (RenderPass *)BLI_findlink(&rl->passes, passindex);
#endif
int passindex;
RenderPass *rpass;
for (rpass = (RenderPass *)rl->passes.first, passindex = 0; rpass; rpass = rpass->next, ++passindex)
if (STREQ(rpass->name, bnodeSocket->identifier))
break;
if (rpass) {
imageuser->pass = passindex;
switch (rpass->channels) {
case 1:
operation = doMultilayerCheck(converter, 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(converter, rl, image, imageuser, framenumber, index, passindex, COM_DT_VECTOR);
break;
case 4:
operation = doMultilayerCheck(converter, rl, image, imageuser, framenumber, index, passindex, COM_DT_COLOR);
break;
default:
/* dummy operation is added below */
break;
}
if (index == 0 && operation) {
converter.addPreview(operation->getOutputSocket());
}
}
/* incase we can't load the layer */
if (operation == NULL)
converter.setInvalidOutput(getOutputSocket(index));
}
}
}
void DilateErodeNode::convertToOperations(NodeConverter &converter,
const CompositorContext &context) const
{
bNode *editorNode = this->getbNode();
if (editorNode->custom1 == CMP_NODE_DILATEERODE_DISTANCE_THRESH) {
DilateErodeThresholdOperation *operation = new DilateErodeThresholdOperation();
operation->setDistance(editorNode->custom2);
operation->setInset(editorNode->custom3);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
if (editorNode->custom3 < 2.0f) {
AntiAliasOperation *antiAlias = new AntiAliasOperation();
converter.addOperation(antiAlias);
converter.addLink(operation->getOutputSocket(), antiAlias->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), antiAlias->getOutputSocket(0));
}
else {
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
}
else if (editorNode->custom1 == CMP_NODE_DILATEERODE_DISTANCE) {
if (editorNode->custom2 > 0) {
DilateDistanceOperation *operation = new DilateDistanceOperation();
operation->setDistance(editorNode->custom2);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
else {
ErodeDistanceOperation *operation = new ErodeDistanceOperation();
operation->setDistance(-editorNode->custom2);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
}
else if (editorNode->custom1 == CMP_NODE_DILATEERODE_DISTANCE_FEATHER) {
/* this uses a modified gaussian blur function otherwise its far too slow */
CompositorQuality quality = context.getQuality();
GaussianAlphaXBlurOperation *operationx = new GaussianAlphaXBlurOperation();
operationx->setData(&m_alpha_blur);
operationx->setQuality(quality);
operationx->setFalloff(PROP_SMOOTH);
converter.addOperation(operationx);
converter.mapInputSocket(getInputSocket(0), operationx->getInputSocket(0));
// converter.mapInputSocket(getInputSocket(1), operationx->getInputSocket(1)); // no size input
// yet
GaussianAlphaYBlurOperation *operationy = new GaussianAlphaYBlurOperation();
operationy->setData(&m_alpha_blur);
operationy->setQuality(quality);
operationy->setFalloff(PROP_SMOOTH);
converter.addOperation(operationy);
converter.addLink(operationx->getOutputSocket(), operationy->getInputSocket(0));
// converter.mapInputSocket(getInputSocket(1), operationy->getInputSocket(1)); // no size input
// yet
converter.mapOutputSocket(getOutputSocket(0), operationy->getOutputSocket());
converter.addPreview(operationy->getOutputSocket());
/* TODO? */
/* see gaussian blue node for original usage */
#if 0
if (!connectedSizeSocket) {
operationx->setSize(size);
operationy->setSize(size);
}
#else
operationx->setSize(1.0f);
operationy->setSize(1.0f);
#endif
operationx->setSubtract(editorNode->custom2 < 0);
operationy->setSubtract(editorNode->custom2 < 0);
if (editorNode->storage) {
NodeDilateErode *data_storage = (NodeDilateErode *)editorNode->storage;
operationx->setFalloff(data_storage->falloff);
operationy->setFalloff(data_storage->falloff);
}
}
else {
if (editorNode->custom2 > 0) {
DilateStepOperation *operation = new DilateStepOperation();
operation->setIterations(editorNode->custom2);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
else {
ErodeStepOperation *operation = new ErodeStepOperation();
operation->setIterations(-editorNode->custom2);
converter.addOperation(operation);
converter.mapInputSocket(getInputSocket(0), operation->getInputSocket(0));
converter.mapOutputSocket(getOutputSocket(0), operation->getOutputSocket(0));
}
}
}
void SocketProxyNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
NodeOperationOutput *proxy_output = converter.addInputProxy(getInputSocket(0), m_use_conversion);
converter.mapOutputSocket(getOutputSocket(), proxy_output);
}
void ImageNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
/// Image output
NodeOutput *outputImage = this->getOutputSocket(0);
bNode *editorNode = this->getbNode();
Image *image = (Image *)editorNode->id;
ImageUser *imageuser = (ImageUser *)editorNode->storage;
int framenumber = context.getFramenumber();
int numberOfOutputs = this->getNumberOfOutputSockets();
bool outputStraightAlpha = (editorNode->custom1 & CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT) != 0;
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) {
bool is_multilayer_ok = false;
ImBuf *ibuf = BKE_image_acquire_ibuf(image, imageuser, NULL);
if (image->rr) {
RenderLayer *rl = (RenderLayer *)BLI_findlink(&image->rr->layers, imageuser->layer);
if (rl) {
NodeOutput *socket;
int index;
is_multilayer_ok = true;
for (index = 0; index < numberOfOutputs; index++) {
NodeOperation *operation = NULL;
socket = this->getOutputSocket(index);
bNodeSocket *bnodeSocket = socket->getbNodeSocket();
RenderPass *rpass = (RenderPass *)BLI_findstring(&rl->passes, bnodeSocket->identifier, offsetof(RenderPass, internal_name));
int view = 0;
/* Passes in the file can differ from passes stored in sockets (#36755).
* Look up the correct file pass using the socket identifier instead.
*/
#if 0
NodeImageLayer *storage = (NodeImageLayer *)bnodeSocket->storage;*/
int passindex = storage->pass_index;*/
RenderPass *rpass = (RenderPass *)BLI_findlink(&rl->passes, passindex);
#endif
/* returns the image view to use for the current active view */
if (BLI_listbase_count_ex(&image->rr->views, 2) > 1) {
const int view_image = imageuser->view;
const bool is_allview = (view_image == 0); /* if view selected == All (0) */
if (is_allview) {
/* heuristic to match image name with scene names
* check if the view name exists in the image */
view = BLI_findstringindex(&image->rr->views, context.getViewName(), offsetof(RenderView, name));
if (view == -1) view = 0;
}
else {
view = view_image - 1;
}
}
if (rpass) {
switch (rpass->channels) {
case 1:
operation = doMultilayerCheck(converter, rl, image, imageuser, framenumber, index,
rpass->passtype, view, 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(converter, rl, image, imageuser, framenumber, index,
rpass->passtype, view, COM_DT_VECTOR);
break;
case 4:
operation = doMultilayerCheck(converter, rl, image, imageuser, framenumber, index,
rpass->passtype, view, COM_DT_COLOR);
break;
default:
/* dummy operation is added below */
break;
}
if (index == 0 && operation) {
converter.addPreview(operation->getOutputSocket());
}
if (rpass->passtype == SCE_PASS_COMBINED) {
BLI_assert(operation != NULL);
BLI_assert(index < numberOfOutputs - 1);
NodeOutput *outputSocket = this->getOutputSocket(index + 1);
SeparateChannelOperation *separate_operation;
separate_operation = new SeparateChannelOperation();
separate_operation->setChannel(3);
converter.addOperation(separate_operation);
converter.addLink(operation->getOutputSocket(), separate_operation->getInputSocket(0));
converter.mapOutputSocket(outputSocket, separate_operation->getOutputSocket());
index++;
}
}
/* incase we can't load the layer */
if (operation == NULL)
converter.setInvalidOutput(getOutputSocket(index));
}
}
}
