griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
2db026ef67bc66f951dc45ccba37544c200e94de
test/intern/cycles/scene/constant_fold.cpp
Weizhen Huang 54e748852a Fix #139022: Cycles: Mix Color Node using socket values when constant folded 
If Mix Color node clamps the result, we do not bypass the node, but
disconnect other inputs. However, for the case where both inputs were the
same, the disconnected one would use the stored socket value instead, so
set the factor to 0 to only use the intended input.

Pull Request: https://projects.blender.org/blender/blender/pulls/139098
2025-05-20 12:30:20 +02:00

596 lines
16 KiB
C++
Raw Blame History

/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
*
* SPDX-License-Identifier: Apache-2.0 */
#include "scene/constant_fold.h"
#include "scene/shader_graph.h"
#include "util/log.h"
CCL_NAMESPACE_BEGIN
ConstantFolder::ConstantFolder(ShaderGraph *graph,
ShaderNode *node,
ShaderOutput *output,
Scene *scene)
: graph(graph), node(node), output(output), scene(scene)
{
}
bool ConstantFolder::all_inputs_constant() const
{
for (ShaderInput *input : node->inputs) {
if (input->link) {
return false;
}
}
return true;
}
void ConstantFolder::make_constant(const float value) const
{
VLOG_DEBUG << "Folding " << node->name << "::" << output->name() << " to constant (" << value
<< ").";
for (ShaderInput *sock : output->links) {
sock->set(value);
sock->constant_folded_in = true;
}
graph->disconnect(output);
}
void ConstantFolder::make_constant(const float3 value) const
{
VLOG_DEBUG << "Folding " << node->name << "::" << output->name() << " to constant " << value
<< ".";
for (ShaderInput *sock : output->links) {
sock->set(value);
sock->constant_folded_in = true;
}
graph->disconnect(output);
}
void ConstantFolder::make_constant(const int value) const
{
VLOG_DEBUG << "Folding " << node->name << "::" << output->name() << " to constant (" << value
<< ").";
for (ShaderInput *sock : output->links) {
sock->set(value);
sock->constant_folded_in = true;
}
graph->disconnect(output);
}
void ConstantFolder::make_constant_clamp(const float value, bool clamp) const
{
make_constant(clamp ? saturatef(value) : value);
}
void ConstantFolder::make_constant_clamp(float3 value, const bool clamp) const
{
if (clamp) {
value.x = saturatef(value.x);
value.y = saturatef(value.y);
value.z = saturatef(value.z);
}
make_constant(value);
}
void ConstantFolder::make_zero() const
{
if (output->type() == SocketType::FLOAT) {
make_constant(0.0f);
}
else if (SocketType::is_float3(output->type())) {
make_constant(zero_float3());
}
else {
assert(0);
}
}
void ConstantFolder::make_one() const
{
if (output->type() == SocketType::FLOAT) {
make_constant(1.0f);
}
else if (SocketType::is_float3(output->type())) {
make_constant(one_float3());
}
else {
assert(0);
}
}
void ConstantFolder::bypass(ShaderOutput *new_output) const
{
assert(new_output);
VLOG_DEBUG << "Folding " << node->name << "::" << output->name() << " to socket "
<< new_output->parent->name << "::" << new_output->name() << ".";
/* Remove all outgoing links from socket and connect them to new_output instead.
* The graph->relink method affects node inputs, so it's not safe to use in constant
* folding if the node has multiple outputs and will thus be folded multiple times. */
const vector<ShaderInput *> outputs = output->links;
graph->disconnect(output);
for (ShaderInput *sock : outputs) {
graph->connect(new_output, sock);
}
}
void ConstantFolder::discard() const
{
assert(output->type() == SocketType::CLOSURE);
VLOG_DEBUG << "Discarding closure " << node->name << ".";
graph->disconnect(output);
}
void ConstantFolder::bypass_or_discard(ShaderInput *input) const
{
assert(input->type() == SocketType::CLOSURE);
if (input->link) {
bypass(input->link);
}
else {
discard();
}
}
bool ConstantFolder::try_bypass_or_make_constant(ShaderInput *input, bool clamp) const
{
if (input->type() != output->type()) {
return false;
}
if (!input->link) {
if (input->type() == SocketType::FLOAT) {
make_constant_clamp(node->get_float(input->socket_type), clamp);
return true;
}
if (SocketType::is_float3(input->type())) {
make_constant_clamp(node->get_float3(input->socket_type), clamp);
return true;
}
}
else if (!clamp) {
bypass(input->link);
return true;
}
else {
/* disconnect other inputs if we can't fully bypass due to clamp */
for (ShaderInput *other : node->inputs) {
if (other != input && other->link) {
graph->disconnect(other);
}
}
}
return false;
}
bool ConstantFolder::is_zero(ShaderInput *input) const
{
if (!input->link) {
if (input->type() == SocketType::FLOAT) {
return node->get_float(input->socket_type) == 0.0f;
}
if (SocketType::is_float3(input->type())) {
return node->get_float3(input->socket_type) == zero_float3();
}
}
return false;
}
bool ConstantFolder::is_one(ShaderInput *input) const
{
if (!input->link) {
if (input->type() == SocketType::FLOAT) {
return node->get_float(input->socket_type) == 1.0f;
}
if (SocketType::is_float3(input->type())) {
return node->get_float3(input->socket_type) == one_float3();
}
}
return false;
}
/* Specific nodes */
void ConstantFolder::fold_mix(NodeMix type, bool clamp) const
{
ShaderInput *fac_in = node->input("Fac");
ShaderInput *color1_in = node->input("Color1");
ShaderInput *color2_in = node->input("Color2");
const float fac = saturatef(node->get_float(fac_in->socket_type));
const bool fac_is_zero = !fac_in->link && fac == 0.0f;
const bool fac_is_one = !fac_in->link && fac == 1.0f;
/* remove no-op node when factor is 0.0 */
if (fac_is_zero) {
/* note that some of the modes will clamp out of bounds values even without use_clamp */
if (!(type == NODE_MIX_LIGHT || type == NODE_MIX_DODGE || type == NODE_MIX_BURN)) {
if (try_bypass_or_make_constant(color1_in, clamp)) {
return;
}
}
}
switch (type) {
case NODE_MIX_BLEND:
/* remove useless mix colors nodes */
if (color1_in->link && color2_in->link) {
if (color1_in->link == color2_in->link) {
try_bypass_or_make_constant(color1_in, clamp);
break;
}
}
else if (!color1_in->link && !color2_in->link) {
const float3 color1 = node->get_float3(color1_in->socket_type);
const float3 color2 = node->get_float3(color2_in->socket_type);
if (color1 == color2) {
try_bypass_or_make_constant(color1_in, clamp);
break;
}
}
/* remove no-op mix color node when factor is 1.0 */
if (fac_is_one) {
try_bypass_or_make_constant(color2_in, clamp);
break;
}
break;
case NODE_MIX_ADD:
/* 0 + X (fac 1) == X */
if (is_zero(color1_in) && fac_is_one) {
try_bypass_or_make_constant(color2_in, clamp);
}
/* X + 0 (fac ?) == X */
else if (is_zero(color2_in)) {
try_bypass_or_make_constant(color1_in, clamp);
}
break;
case NODE_MIX_SUB:
/* X - 0 (fac ?) == X */
if (is_zero(color2_in)) {
try_bypass_or_make_constant(color1_in, clamp);
}
/* X - X (fac 1) == 0 */
else if (color1_in->link && color1_in->link == color2_in->link && fac_is_one) {
make_zero();
}
break;
case NODE_MIX_MUL:
/* X * 1 (fac ?) == X, 1 * X (fac 1) == X */
if (is_one(color1_in) && fac_is_one) {
try_bypass_or_make_constant(color2_in, clamp);
}
else if (is_one(color2_in)) {
try_bypass_or_make_constant(color1_in, clamp);
}
/* 0 * ? (fac ?) == 0, ? * 0 (fac 1) == 0 */
else if (is_zero(color1_in)) {
make_zero();
}
else if (is_zero(color2_in) && fac_is_one) {
make_zero();
}
break;
case NODE_MIX_DIV:
/* X / 1 (fac ?) == X */
if (is_one(color2_in)) {
try_bypass_or_make_constant(color1_in, clamp);
}
/* 0 / ? (fac ?) == 0 */
else if (is_zero(color1_in)) {
make_zero();
}
break;
default:
break;
}
}
void ConstantFolder::fold_mix_color(NodeMix type, bool clamp_factor, bool clamp) const
{
ShaderInput *fac_in = node->input("Factor");
ShaderInput *color1_in = node->input("A");
ShaderInput *color2_in = node->input("B");
const float fac = clamp_factor ? saturatef(node->get_float(fac_in->socket_type)) :
node->get_float(fac_in->socket_type);
const bool fac_is_zero = !fac_in->link && fac == 0.0f;
const bool fac_is_one = !fac_in->link && fac == 1.0f;
/* remove no-op node when factor is 0.0 */
if (fac_is_zero) {
/* note that some of the modes will clamp out of bounds values even without use_clamp */
if (!(type == NODE_MIX_LIGHT || type == NODE_MIX_DODGE || type == NODE_MIX_BURN)) {
if (try_bypass_or_make_constant(color1_in, clamp)) {
return;
}
}
}
switch (type) {
case NODE_MIX_BLEND:
/* remove useless mix colors nodes */
if (color1_in->link && color2_in->link) {
if (color1_in->link == color2_in->link) {
if (!try_bypass_or_make_constant(color1_in, clamp)) {
/* If can't bypass, set `fac` to 0 to only use `color1_in`. */
fac_in->set(0.0f);
}
break;
}
}
else if (!color1_in->link && !color2_in->link) {
const float3 color1 = node->get_float3(color1_in->socket_type);
const float3 color2 = node->get_float3(color2_in->socket_type);
if (color1 == color2) {
try_bypass_or_make_constant(color1_in, clamp);
break;
}
}
/* remove no-op mix color node when factor is 1.0 */
if (fac_is_one) {
try_bypass_or_make_constant(color2_in, clamp);
break;
}
break;
case NODE_MIX_ADD:
/* 0 + X (fac 1) == X */
if (is_zero(color1_in) && fac_is_one) {
try_bypass_or_make_constant(color2_in, clamp);
}
/* X + 0 (fac ?) == X */
else if (is_zero(color2_in)) {
try_bypass_or_make_constant(color1_in, clamp);
}
break;
case NODE_MIX_SUB:
/* X - 0 (fac ?) == X */
if (is_zero(color2_in)) {
try_bypass_or_make_constant(color1_in, clamp);
}
/* X - X (fac 1) == 0 */
else if (color1_in->link && color1_in->link == color2_in->link && fac_is_one) {
make_zero();
}
break;
case NODE_MIX_MUL:
/* X * 1 (fac ?) == X, 1 * X (fac 1) == X */
if (is_one(color1_in) && fac_is_one) {
try_bypass_or_make_constant(color2_in, clamp);
}
else if (is_one(color2_in)) {
try_bypass_or_make_constant(color1_in, clamp);
}
/* 0 * ? (fac ?) == 0, ? * 0 (fac 1) == 0 */
else if (is_zero(color1_in)) {
make_zero();
}
else if (is_zero(color2_in) && fac_is_one) {
make_zero();
}
break;
case NODE_MIX_DIV:
/* X / 1 (fac ?) == X */
if (is_one(color2_in)) {
try_bypass_or_make_constant(color1_in, clamp);
}
/* 0 / ? (fac ?) == 0 */
else if (is_zero(color1_in)) {
make_zero();
}
break;
default:
break;
}
}
void ConstantFolder::fold_mix_float(bool clamp_factor, bool clamp) const
{
ShaderInput *fac_in = node->input("Factor");
ShaderInput *float1_in = node->input("A");
ShaderInput *float2_in = node->input("B");
const float fac = clamp_factor ? saturatef(node->get_float(fac_in->socket_type)) :
node->get_float(fac_in->socket_type);
const bool fac_is_zero = !fac_in->link && fac == 0.0f;
const bool fac_is_one = !fac_in->link && fac == 1.0f;
/* remove no-op node when factor is 0.0 */
if (fac_is_zero) {
if (try_bypass_or_make_constant(float1_in, clamp)) {
return;
}
}
/* remove useless mix floats nodes */
if (float1_in->link && float2_in->link) {
if (float1_in->link == float2_in->link) {
try_bypass_or_make_constant(float1_in, clamp);
return;
}
}
else if (!float1_in->link && !float2_in->link) {
const float value1 = node->get_float(float1_in->socket_type);
const float value2 = node->get_float(float2_in->socket_type);
if (value1 == value2) {
try_bypass_or_make_constant(float1_in, clamp);
return;
}
}
/* remove no-op mix float node when factor is 1.0 */
if (fac_is_one) {
try_bypass_or_make_constant(float2_in, clamp);
return;
}
}
void ConstantFolder::fold_math(NodeMathType type) const
{
ShaderInput *value1_in = node->input("Value1");
ShaderInput *value2_in = node->input("Value2");
switch (type) {
case NODE_MATH_ADD:
/* X + 0 == 0 + X == X */
if (is_zero(value1_in)) {
try_bypass_or_make_constant(value2_in);
}
else if (is_zero(value2_in)) {
try_bypass_or_make_constant(value1_in);
}
break;
case NODE_MATH_SUBTRACT:
/* X - 0 == X */
if (is_zero(value2_in)) {
try_bypass_or_make_constant(value1_in);
}
break;
case NODE_MATH_MULTIPLY:
/* X * 1 == 1 * X == X */
if (is_one(value1_in)) {
try_bypass_or_make_constant(value2_in);
}
else if (is_one(value2_in)) {
try_bypass_or_make_constant(value1_in);
}
/* X * 0 == 0 * X == 0 */
else if (is_zero(value1_in) || is_zero(value2_in)) {
make_zero();
}
break;
case NODE_MATH_DIVIDE:
/* X / 1 == X */
if (is_one(value2_in)) {
try_bypass_or_make_constant(value1_in);
}
/* 0 / X == 0 */
else if (is_zero(value1_in)) {
make_zero();
}
break;
case NODE_MATH_POWER:
/* 1 ^ X == X ^ 0 == 1 */
if (is_one(value1_in) || is_zero(value2_in)) {
make_one();
}
/* X ^ 1 == X */
else if (is_one(value2_in)) {
try_bypass_or_make_constant(value1_in);
}
default:
break;
}
}
void ConstantFolder::fold_vector_math(NodeVectorMathType type) const
{
ShaderInput *vector1_in = node->input("Vector1");
ShaderInput *vector2_in = node->input("Vector2");
ShaderInput *scale_in = node->input("Scale");
switch (type) {
case NODE_VECTOR_MATH_ADD:
/* X + 0 == 0 + X == X */
if (is_zero(vector1_in)) {
try_bypass_or_make_constant(vector2_in);
}
else if (is_zero(vector2_in)) {
try_bypass_or_make_constant(vector1_in);
}
break;
case NODE_VECTOR_MATH_SUBTRACT:
/* X - 0 == X */
if (is_zero(vector2_in)) {
try_bypass_or_make_constant(vector1_in);
}
break;
case NODE_VECTOR_MATH_MULTIPLY:
/* X * 0 == 0 * X == 0 */
if (is_zero(vector1_in) || is_zero(vector2_in)) {
make_zero();
} /* X * 1 == 1 * X == X */
else if (is_one(vector1_in)) {
try_bypass_or_make_constant(vector2_in);
}
else if (is_one(vector2_in)) {
try_bypass_or_make_constant(vector1_in);
}
break;
case NODE_VECTOR_MATH_DIVIDE:
/* X / 0 == 0 / X == 0 */
if (is_zero(vector1_in) || is_zero(vector2_in)) {
make_zero();
} /* X / 1 == X */
else if (is_one(vector2_in)) {
try_bypass_or_make_constant(vector1_in);
}
break;
case NODE_VECTOR_MATH_DOT_PRODUCT:
case NODE_VECTOR_MATH_CROSS_PRODUCT:
/* X * 0 == 0 * X == 0 */
if (is_zero(vector1_in) || is_zero(vector2_in)) {
make_zero();
}
break;
case NODE_VECTOR_MATH_LENGTH:
case NODE_VECTOR_MATH_ABSOLUTE:
if (is_zero(vector1_in)) {
make_zero();
}
break;
case NODE_VECTOR_MATH_SCALE:
/* X * 0 == 0 * X == 0 */
if (is_zero(vector1_in) || is_zero(scale_in)) {
make_zero();
} /* X * 1 == X */
else if (is_one(scale_in)) {
try_bypass_or_make_constant(vector1_in);
}
break;
default:
break;
}
}
void ConstantFolder::fold_mapping(NodeMappingType type) const
{
ShaderInput *vector_in = node->input("Vector");
ShaderInput *location_in = node->input("Location");
ShaderInput *rotation_in = node->input("Rotation");
ShaderInput *scale_in = node->input("Scale");
if (is_zero(scale_in)) {
make_zero();
}
else if (
/* Can't constant fold since we always need to normalize the output. */
(type != NODE_MAPPING_TYPE_NORMAL) &&
/* Check all use values are zero, note location is not used by vector and normal types. */
(is_zero(location_in) || type == NODE_MAPPING_TYPE_VECTOR ||
type == NODE_MAPPING_TYPE_NORMAL) &&
is_zero(rotation_in) && is_one(scale_in))
{
try_bypass_or_make_constant(vector_in);
}
}
CCL_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink