Merge some operations into a single file

This merges all mix operations into a COM_MixBaseOperation
(naming could be better, but this way it corresponds to what's
going on with math operations.

Same was done with RenderLayers operations.

Overall this gives 20% of bf_compositor library compilation
time decrease. And it was rather annoying to have tens of
files with just a single-line constructors anyway.

TODO:
- All Convert operations could also be merged into a single file,
  but that would require adding some ConvertBaseOperation to
  reduce code duplication (ideally). Leaving it unchanged for now.

- Some operations' headers seems to be wrongly including MixOperation
  header, they need to include NodeOperation instead it seems.

  This is rather harmless, but would be nice to doublecheck on this
  eventually.

1 files changed, 848 insertions, 0 deletions

diff --git a/source/blender/compositor/operations/COM_MixOperation.cpp b/source/blender/compositor/operations/COM_MixOperation.cpp
new file mode 100644
index 00000000000..f094e93f147
--- /dev/null
+++ b/source/blender/compositor/operations/COM_MixOperation.cpp
@@ -0,0 +1,848 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor: 
+ *		Jeroen Bakker 
+ *		Monique Dewanchand
+ */
+
+#include "COM_MixOperation.h"
+
+extern "C" {
+	#include "BLI_math.h"
+}
+
+/* ******** Mix Base Operation ******** */
+
+MixBaseOperation::MixBaseOperation() : NodeOperation()
+{
+	this->addInputSocket(COM_DT_VALUE);
+	this->addInputSocket(COM_DT_COLOR);
+	this->addInputSocket(COM_DT_COLOR);
+	this->addOutputSocket(COM_DT_COLOR);
+	this->m_inputValueOperation = NULL;
+	this->m_inputColor1Operation = NULL;
+	this->m_inputColor2Operation = NULL;
+	this->setUseValueAlphaMultiply(false);
+	this->setUseClamp(false);
+}
+
+void MixBaseOperation::initExecution()
+{
+	this->m_inputValueOperation = this->getInputSocketReader(0);
+	this->m_inputColor1Operation = this->getInputSocketReader(1);
+	this->m_inputColor2Operation = this->getInputSocketReader(2);
+}
+
+void MixBaseOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+	
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+	
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+	output[0] = valuem * (inputColor1[0]) + value * (inputColor2[0]);
+	output[1] = valuem * (inputColor1[1]) + value * (inputColor2[1]);
+	output[2] = valuem * (inputColor1[2]) + value * (inputColor2[2]);
+	output[3] = inputColor1[3];
+}
+
+void MixBaseOperation::determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2])
+{
+	InputSocket *socket;
+	unsigned int tempPreferredResolution[2] = {0, 0};
+	unsigned int tempResolution[2];
+
+	socket = this->getInputSocket(1);
+	socket->determineResolution(tempResolution, tempPreferredResolution);
+	if ((tempResolution[0] != 0) && (tempResolution[1] != 0)) {
+		this->setResolutionInputSocketIndex(1);
+	}
+	else {
+		socket = this->getInputSocket(2);
+		socket->determineResolution(tempResolution, tempPreferredResolution);
+		if ((tempResolution[0] != 0) && (tempResolution[1] != 0)) {
+			this->setResolutionInputSocketIndex(2);
+		}
+		else {
+			this->setResolutionInputSocketIndex(0);
+		}
+	}
+	NodeOperation::determineResolution(resolution, preferredResolution);
+}
+
+void MixBaseOperation::deinitExecution()
+{
+	this->m_inputValueOperation = NULL;
+	this->m_inputColor1Operation = NULL;
+	this->m_inputColor2Operation = NULL;
+}
+
+/* ******** Mix Add Operation ******** */
+
+MixAddOperation::MixAddOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixAddOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	output[0] = inputColor1[0] + value * inputColor2[0];
+	output[1] = inputColor1[1] + value * inputColor2[1];
+	output[2] = inputColor1[2] + value * inputColor2[2];
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Blend Operation ******** */
+
+MixBlendOperation::MixBlendOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixBlendOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+	float value;
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+	value = inputValue[0];
+	
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+	output[0] = valuem * (inputColor1[0]) + value * (inputColor2[0]);
+	output[1] = valuem * (inputColor1[1]) + value * (inputColor2[1]);
+	output[2] = valuem * (inputColor1[2]) + value * (inputColor2[2]);
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Burn Operation ******** */
+
+MixBurnOperation::MixBurnOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixBurnOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+	float tmp;
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+
+	tmp = valuem + value * inputColor2[0];
+	if (tmp <= 0.0f)
+		output[0] = 0.0f;
+	else {
+		tmp = 1.0f - (1.0f - inputColor1[0]) / tmp;
+		if (tmp < 0.0f)
+			output[0] = 0.0f;
+		else if (tmp > 1.0f)
+			output[0] = 1.0f;
+		else
+			output[0] = tmp;
+	}
+
+	tmp = valuem + value * inputColor2[1];
+	if (tmp <= 0.0f)
+		output[1] = 0.0f;
+	else {
+		tmp = 1.0f - (1.0f - inputColor1[1]) / tmp;
+		if (tmp < 0.0f)
+			output[1] = 0.0f;
+		else if (tmp > 1.0f)
+			output[1] = 1.0f;
+		else
+			output[1] = tmp;
+	}
+
+	tmp = valuem + value * inputColor2[2];
+	if (tmp <= 0.0f)
+		output[2] = 0.0f;
+	else {
+		tmp = 1.0f - (1.0f - inputColor1[2]) / tmp;
+		if (tmp < 0.0f)
+			output[2] = 0.0f;
+		else if (tmp > 1.0f)
+			output[2] = 1.0f;
+		else
+			output[2] = tmp;
+	}
+
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Color Operation ******** */
+
+MixColorOperation::MixColorOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixColorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+
+	float colH, colS, colV;
+	rgb_to_hsv(inputColor2[0], inputColor2[1], inputColor2[2], &colH, &colS, &colV);
+	if (colS != 0.0f) {
+		float rH, rS, rV;
+		float tmpr, tmpg, tmpb;
+		rgb_to_hsv(inputColor1[0], inputColor1[1], inputColor1[2], &rH, &rS, &rV);
+		hsv_to_rgb(colH, colS, rV, &tmpr, &tmpg, &tmpb);
+		output[0] = (valuem * inputColor1[0]) + (value * tmpr);
+		output[1] = (valuem * inputColor1[1]) + (value * tmpg);
+		output[2] = (valuem * inputColor1[2]) + (value * tmpb);
+	}
+	else {
+		copy_v3_v3(output, inputColor1);
+	}
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Darken Operation ******** */
+
+MixDarkenOperation::MixDarkenOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixDarkenOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+	float tmp;
+	tmp = inputColor2[0] + ((1.0f - inputColor2[0]) * valuem);
+	if (tmp < inputColor1[0]) output[0] = tmp;
+	else output[0] = inputColor1[0];
+	tmp = inputColor2[1] + ((1.0f - inputColor2[1]) * valuem);
+	if (tmp < inputColor1[1]) output[1] = tmp;
+	else output[1] = inputColor1[1];
+	tmp = inputColor2[2] + ((1.0f - inputColor2[2]) * valuem);
+	if (tmp < inputColor1[2]) output[2] = tmp;
+	else output[2] = inputColor1[2];
+
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Difference Operation ******** */
+
+MixDifferenceOperation::MixDifferenceOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixDifferenceOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+	output[0] = valuem * inputColor1[0] + value *fabsf(inputColor1[0] - inputColor2[0]);
+	output[1] = valuem * inputColor1[1] + value *fabsf(inputColor1[1] - inputColor2[1]);
+	output[2] = valuem * inputColor1[2] + value *fabsf(inputColor1[2] - inputColor2[2]);
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Difference Operation ******** */
+
+MixDivideOperation::MixDivideOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixDivideOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+
+	if (inputColor2[0] != 0.0f)
+		output[0] = valuem * (inputColor1[0]) + value * (inputColor1[0]) / inputColor2[0];
+	else
+		output[0] = 0.0f;
+	if (inputColor2[1] != 0.0f)
+		output[1] = valuem * (inputColor1[1]) + value * (inputColor1[1]) / inputColor2[1];
+	else
+		output[1] = 0.0f;
+	if (inputColor2[2] != 0.0f)
+		output[2] = valuem * (inputColor1[2]) + value * (inputColor1[2]) / inputColor2[2];
+	else
+		output[2] = 0.0f;
+
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Dodge Operation ******** */
+
+MixDodgeOperation::MixDodgeOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixDodgeOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+	float tmp;
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+
+	if (inputColor1[0] != 0.0f) {
+		tmp = 1.0f - value * inputColor2[0];
+		if (tmp <= 0.0f)
+			output[0] = 1.0f;
+		else {
+			tmp = inputColor1[0] / tmp;
+			if (tmp > 1.0f)
+				output[0] = 1.0f;
+			else
+				output[0] = tmp;
+		}
+	}
+	else
+		output[0] = 0.0f;
+
+	if (inputColor1[1] != 0.0f) {
+		tmp = 1.0f - value * inputColor2[1];
+		if (tmp <= 0.0f)
+			output[1] = 1.0f;
+		else {
+			tmp = inputColor1[1] / tmp;
+			if (tmp > 1.0f)
+				output[1] = 1.0f;
+			else
+				output[1] = tmp;
+		}
+	}
+	else
+		output[1] = 0.0f;
+
+	if (inputColor1[2] != 0.0f) {
+		tmp = 1.0f - value * inputColor2[2];
+		if (tmp <= 0.0f)
+			output[2] = 1.0f;
+		else {
+			tmp = inputColor1[2] / tmp;
+			if (tmp > 1.0f)
+				output[2] = 1.0f;
+			else
+				output[2] = tmp;
+		}
+	}
+	else
+		output[2] = 0.0f;
+
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Glare Operation ******** */
+
+MixGlareOperation::MixGlareOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixGlareOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+	float value;
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+	value = inputValue[0];
+	float mf = 2.f - 2.f * fabsf(value - 0.5f);
+
+	if (inputColor1[0] < 0.0f) inputColor1[0] = 0.0f;
+	if (inputColor1[1] < 0.0f) inputColor1[1] = 0.0f;
+	if (inputColor1[2] < 0.0f) inputColor1[2] = 0.0f;
+
+	output[0] = mf * max(inputColor1[0] + value * (inputColor2[0] - inputColor1[0]), 0.0f);
+	output[1] = mf * max(inputColor1[1] + value * (inputColor2[1] - inputColor1[1]), 0.0f);
+	output[2] = mf * max(inputColor1[2] + value * (inputColor2[2] - inputColor1[2]), 0.0f);
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Hue Operation ******** */
+
+MixHueOperation::MixHueOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixHueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+
+	float colH, colS, colV;
+	rgb_to_hsv(inputColor2[0], inputColor2[1], inputColor2[2], &colH, &colS, &colV);
+	if (colS != 0.0f) {
+		float rH, rS, rV;
+		float tmpr, tmpg, tmpb;
+		rgb_to_hsv(inputColor1[0], inputColor1[1], inputColor1[2], &rH, &rS, &rV);
+		hsv_to_rgb(colH, rS, rV, &tmpr, &tmpg, &tmpb);
+		output[0] = valuem * (inputColor1[0]) + value * tmpr;
+		output[1] = valuem * (inputColor1[1]) + value * tmpg;
+		output[2] = valuem * (inputColor1[2]) + value * tmpb;
+	}
+	else {
+		copy_v3_v3(output, inputColor1);
+	}
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Lighten Operation ******** */
+
+MixLightenOperation::MixLightenOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixLightenOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float tmp;
+	tmp = value * inputColor2[0];
+	if (tmp > inputColor1[0]) output[0] = tmp;
+	else output[0] = inputColor1[0];
+	tmp = value * inputColor2[1];
+	if (tmp > inputColor1[1]) output[1] = tmp;
+	else output[1] = inputColor1[1];
+	tmp = value * inputColor2[2];
+	if (tmp > inputColor1[2]) output[2] = tmp;
+	else output[2] = inputColor1[2];
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Linear Light Operation ******** */
+
+MixLinearLightOperation::MixLinearLightOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixLinearLightOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	if (inputColor2[0] > 0.5f)
+		output[0] = inputColor1[0] + value * (2.0f * (inputColor2[0] - 0.5f));
+	else
+		output[0] = inputColor1[0] + value * (2.0f * (inputColor2[0]) - 1.0f);
+	if (inputColor2[1] > 0.5f)
+		output[1] = inputColor1[1] + value * (2.0f * (inputColor2[1] - 0.5f));
+	else
+		output[1] = inputColor1[1] + value * (2.0f * (inputColor2[1]) - 1.0f);
+	if (inputColor2[2] > 0.5f)
+		output[2] = inputColor1[2] + value * (2.0f * (inputColor2[2] - 0.5f));
+	else
+		output[2] = inputColor1[2] + value * (2.0f * (inputColor2[2]) - 1.0f);
+
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Multiply Operation ******** */
+
+MixMultiplyOperation::MixMultiplyOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixMultiplyOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+	output[0] = inputColor1[0] * (valuem + value * inputColor2[0]);
+	output[1] = inputColor1[1] * (valuem + value * inputColor2[1]);
+	output[2] = inputColor1[2] * (valuem + value * inputColor2[2]);
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Ovelray Operation ******** */
+
+MixOverlayOperation::MixOverlayOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixOverlayOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+
+	float valuem = 1.0f - value;
+
+	if (inputColor1[0] < 0.5f) {
+		output[0] = inputColor1[0] * (valuem + 2.0f * value * inputColor2[0]);
+	}
+	else {
+		output[0] = 1.0f - (valuem + 2.0f * value * (1.0f - inputColor2[0])) * (1.0f - inputColor1[0]);
+	}
+	if (inputColor1[1] < 0.5f) {
+		output[1] = inputColor1[1] * (valuem + 2.0f * value * inputColor2[1]);
+	}
+	else {
+		output[1] = 1.0f - (valuem + 2.0f * value * (1.0f - inputColor2[1])) * (1.0f - inputColor1[1]);
+	}
+	if (inputColor1[2] < 0.5f) {
+		output[2] = inputColor1[2] * (valuem + 2.0f * value * inputColor2[2]);
+	}
+	else {
+		output[2] = 1.0f - (valuem + 2.0f * value * (1.0f - inputColor2[2])) * (1.0f - inputColor1[2]);
+	}
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Saturation Operation ******** */
+
+MixSaturationOperation::MixSaturationOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixSaturationOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+
+	float rH, rS, rV;
+	rgb_to_hsv(inputColor1[0], inputColor1[1], inputColor1[2], &rH, &rS, &rV);
+	if (rS != 0.0f) {
+		float colH, colS, colV;
+		rgb_to_hsv(inputColor2[0], inputColor2[1], inputColor2[2], &colH, &colS, &colV);
+		hsv_to_rgb(rH, (valuem * rS + value * colS), rV, &output[0], &output[1], &output[2]);
+	}
+	else {
+		copy_v3_v3(output, inputColor1);
+	}
+
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Screen Operation ******** */
+
+MixScreenOperation::MixScreenOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixScreenOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+
+	output[0] = 1.0f - (valuem + value * (1.0f - inputColor2[0])) * (1.0f - inputColor1[0]);
+	output[1] = 1.0f - (valuem + value * (1.0f - inputColor2[1])) * (1.0f - inputColor1[1]);
+	output[2] = 1.0f - (valuem + value * (1.0f - inputColor2[2])) * (1.0f - inputColor1[2]);
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Soft Light Operation ******** */
+
+MixSoftLightOperation::MixSoftLightOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixSoftLightOperation::executePixel(float output[4], float x, float y, PixelSampler sampler) \
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+	float scr, scg, scb;
+
+	/* first calculate non-fac based Screen mix */
+	scr = 1.0f - (1.0f - inputColor2[0]) * (1.0f - inputColor1[0]);
+	scg = 1.0f - (1.0f - inputColor2[1]) * (1.0f - inputColor1[1]);
+	scb = 1.0f - (1.0f - inputColor2[2]) * (1.0f - inputColor1[2]);
+
+	output[0] = valuem * (inputColor1[0]) + value * (((1.0f - inputColor1[0]) * inputColor2[0] * (inputColor1[0])) + (inputColor1[0] * scr));
+	output[1] = valuem * (inputColor1[1]) + value * (((1.0f - inputColor1[1]) * inputColor2[1] * (inputColor1[1])) + (inputColor1[1] * scg));
+	output[2] = valuem * (inputColor1[2]) + value * (((1.0f - inputColor1[2]) * inputColor2[2] * (inputColor1[2])) + (inputColor1[2] * scb));
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Subtract Operation ******** */
+
+MixSubtractOperation::MixSubtractOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixSubtractOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue,   x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1,   x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2,   x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	output[0] = inputColor1[0] - value * (inputColor2[0]);
+	output[1] = inputColor1[1] - value * (inputColor2[1]);
+	output[2] = inputColor1[2] - value * (inputColor2[2]);
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}
+
+/* ******** Mix Value Operation ******** */
+
+MixValueOperation::MixValueOperation() : MixBaseOperation()
+{
+	/* pass */
+}
+
+void MixValueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+{
+	float inputColor1[4];
+	float inputColor2[4];
+	float inputValue[4];
+
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+
+	float value = inputValue[0];
+	if (this->useValueAlphaMultiply()) {
+		value *= inputColor2[3];
+	}
+	float valuem = 1.0f - value;
+
+	float rH, rS, rV;
+	float colH, colS, colV;
+	rgb_to_hsv(inputColor1[0], inputColor1[1], inputColor1[2], &rH, &rS, &rV);
+	rgb_to_hsv(inputColor2[0], inputColor2[1], inputColor2[2], &colH, &colS, &colV);
+	hsv_to_rgb(rH, rS, (valuem * rV + value * colV), &output[0], &output[1], &output[2]);
+	output[3] = inputColor1[3];
+
+	clampIfNeeded(output);
+}