archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
4b9ff3cd42be427e478743648e9951bf8c189a04
blender-archive/source/blender/compositor/operations/COM_MixOperation.cc
Szymon Ulatowski 95e010a22e Fix T74680: Incorrect mixing in Glare node 
The mixing function was designed to give correct results for Mix values of
-1, 0, and +1, but the behavior between these points was not linear. This is
unavoidable, because the function depends on both Mix and Mix^2 (by
multiplying value and mf) so they could not cancel out completely.

The new formula simply calculates the weighted sum without trying to invent
a smooth function.
Value for MixGlareOperation is now passed directly without scaling because
it is then easier to use.
Note that the previous formula performed max() twice for both input image
and the result, now there is just one max() per channel because the glare
input can't be negative.

Reviewed By: jbakker

Differential Revision: https://developer.blender.org/D7138
2021-04-12 14:42:13 +02:00

855 lines
26 KiB
C++
Raw Blame History

/*
* 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.
*
* Copyright 2011, Blender Foundation.
*/
#include "COM_MixOperation.h"
#include "BLI_math.h"
namespace blender::compositor {
/* ******** Mix Base Operation ******** */
MixBaseOperation::MixBaseOperation()
{
this->addInputSocket(DataType::Value);
this->addInputSocket(DataType::Color);
this->addInputSocket(DataType::Color);
this->addOutputSocket(DataType::Color);
this->m_inputValueOperation = nullptr;
this->m_inputColor1Operation = nullptr;
this->m_inputColor2Operation = nullptr;
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::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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])
{
NodeOperationInput *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 = nullptr;
this->m_inputColor1Operation = nullptr;
this->m_inputColor2Operation = nullptr;
}
/* ******** Mix Add Operation ******** */
void MixAddOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixBlendOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
float value;
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixColorBurnOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
float tmp;
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixColorOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixDarkenOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
float value = inputValue[0];
if (this->useValueAlphaMultiply()) {
value *= inputColor2[3];
}
float valuem = 1.0f - value;
output[0] = min_ff(inputColor1[0], inputColor2[0]) * value + inputColor1[0] * valuem;
output[1] = min_ff(inputColor1[1], inputColor2[1]) * value + inputColor1[1] * valuem;
output[2] = min_ff(inputColor1[2], inputColor2[2]) * value + inputColor1[2] * valuem;
output[3] = inputColor1[3];
clampIfNeeded(output);
}
/* ******** Mix Difference Operation ******** */
void MixDifferenceOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixDivideOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixDodgeOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
float tmp;
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixGlareOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
float value, input_weight, glare_weight;
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
value = inputValue[0];
/* Linear interpolation between 3 cases:
* value=-1:output=input value=0:output=input+glare value=1:output=glare
*/
if (value < 0.0f) {
input_weight = 1.0f;
glare_weight = 1.0f + value;
}
else {
input_weight = 1.0f - value;
glare_weight = 1.0f;
}
output[0] = input_weight * MAX2(inputColor1[0], 0.0f) + glare_weight * inputColor2[0];
output[1] = input_weight * MAX2(inputColor1[1], 0.0f) + glare_weight * inputColor2[1];
output[2] = input_weight * MAX2(inputColor1[2], 0.0f) + glare_weight * inputColor2[2];
output[3] = inputColor1[3];
clampIfNeeded(output);
}
/* ******** Mix Hue Operation ******** */
void MixHueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixLightenOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixLinearLightOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixMultiplyOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 Overlay Operation ******** */
void MixOverlayOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixSaturationOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixScreenOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixSoftLightOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixSubtractOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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 ******** */
void MixValueOperation::executePixelSampled(float output[4],
float x,
float y,
PixelSampler sampler)
{
float inputColor1[4];
float inputColor2[4];
float inputValue[4];
this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
this->m_inputColor2Operation->readSampled(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);
}
} // namespace blender::compositor
View Git Blame Copy Permalink