Differential D13498 Diff 45751 source/blender/nodes/shader/nodes/node_shader_valToRgb.cc

Changeset View

Standalone View

source/blender/nodes/shader/nodes/node_shader_valToRgb.cc

This file was moved from source/blender/nodes/shader/nodes/node_shader_color_ramp.cc.

/*		/*
* This program is free software; you can redistribute it and/or		* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License		* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2		* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.		* of the License, or (at your option) any later version.
*		*
* This program is distributed in the hope that it will be useful,		* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of		* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.		* GNU General Public License for more details.
*		*
* You should have received a copy of the GNU General Public License		* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,		* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.		* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*		*
* The Original Code is Copyright (C) 2021 Blender Foundation.		* The Original Code is Copyright (C) 2005 Blender Foundation.
* All rights reserved.		* All rights reserved.
*/		*/

/** \file		/** \file
* \ingroup shdnodes		* \ingroup shdnodes
*/		*/

		#include "IMB_colormanagement.h"

#include "DNA_texture_types.h"		#include "DNA_texture_types.h"

#include "BLI_color.hh"		#include "BLI_color.hh"

#include "node_shader_util.hh"		#include "node_shader_util.h"

namespace blender::nodes::node_shader_color_ramp_cc {		namespace blender::nodes {

static void sh_node_color_ramp_declare(NodeDeclarationBuilder &b)		static void sh_node_valtorgb_declare(NodeDeclarationBuilder &b)
{		{
b.is_function_node();		b.is_function_node();
b.add_input<decl::Float>(N_("Fac")).default_value(0.5f).min(0.0f).max(1.0f).subtype(PROP_FACTOR);		b.add_input<decl::Float>(N_("Fac")).default_value(0.5f).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
b.add_output<decl::Color>(N_("Color"));		b.add_output<decl::Color>(N_("Color"));
b.add_output<decl::Float>(N_("Alpha"));		b.add_output<decl::Float>(N_("Alpha"));
};		};

static void node_shader_exec_color_ramp(void *UNUSED(data),		} // namespace blender::nodes

		static void node_shader_exec_valtorgb(void *UNUSED(data),
int UNUSED(thread),		int UNUSED(thread),
bNode *node,		bNode *node,
bNodeExecData *UNUSED(execdata),		bNodeExecData *UNUSED(execdata),
bNodeStack **in,		bNodeStack **in,
bNodeStack **out)		bNodeStack **out)
{		{
/* stack order in: fac */		/* stack order in: fac */
/* stack order out: col, alpha */		/* stack order out: col, alpha */

if (node->storage) {		if (node->storage) {
float fac;		float fac;
nodestack_get_vec(&fac, SOCK_FLOAT, in[0]);		nodestack_get_vec(&fac, SOCK_FLOAT, in[0]);

BKE_colorband_evaluate((ColorBand *)node->storage, fac, out[0]->vec);		BKE_colorband_evaluate((ColorBand *)node->storage, fac, out[0]->vec);
out[1]->vec[0] = out[0]->vec[3];		out[1]->vec[0] = out[0]->vec[3];
}		}
}		}

static void node_shader_init_color_ramp(bNodeTree UNUSED(ntree), bNode node)		static void node_shader_init_valtorgb(bNodeTree UNUSED(ntree), bNode node)
{		{
node->storage = BKE_colorband_add(true);		node->storage = BKE_colorband_add(true);
}		}

static int gpu_shader_color_ramp(GPUMaterial *mat,		static int gpu_shader_valtorgb(GPUMaterial *mat,
bNode *node,		bNode *node,
bNodeExecData *UNUSED(execdata),		bNodeExecData *UNUSED(execdata),
GPUNodeStack *in,		GPUNodeStack *in,
GPUNodeStack *out)		GPUNodeStack *out)
{		{
struct ColorBand coba = (ColorBand )node->storage;		struct ColorBand coba = (ColorBand )node->storage;
float *array, layer;		float *array, layer;
int size;		int size;

/* Common / easy case optimization. */		/* Common / easy case optimization. */
if ((coba->tot <= 2) && (coba->color_mode == COLBAND_BLEND_RGB)) {		if ((coba->tot <= 2) && (coba->color_mode == COLBAND_BLEND_RGB)) {
float mul_bias[2];		float mul_bias[2];
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines	for (int64_t i : mask) {
blender::ColorGeometry4f color;		blender::ColorGeometry4f color;
BKE_colorband_evaluate(&color_band_, values[i], color);		BKE_colorband_evaluate(&color_band_, values[i], color);
colors[i] = color;		colors[i] = color;
alphas[i] = color.a;		alphas[i] = color.a;
}		}
}		}
};		};

static void sh_node_color_ramp_build_multi_function(		static void sh_node_valtorgb_build_multi_function(
blender::nodes::NodeMultiFunctionBuilder &builder)		blender::nodes::NodeMultiFunctionBuilder &builder)
{		{
bNode &bnode = builder.node();		bNode &bnode = builder.node();
const ColorBand color_band = (const ColorBand )bnode.storage;		const ColorBand color_band = (const ColorBand )bnode.storage;
builder.construct_and_set_matching_fn<ColorBandFunction>(*color_band);		builder.construct_and_set_matching_fn<ColorBandFunction>(*color_band);
}		}

} // namespace blender::nodes::node_shader_color_ramp_cc		void register_node_type_sh_valtorgb(void)

void register_node_type_sh_color_ramp()
{		{
namespace file_ns = blender::nodes::node_shader_color_ramp_cc;

static bNodeType ntype;		static bNodeType ntype;

sh_fn_node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTER, 0);		sh_fn_node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTER, 0);
ntype.declare = file_ns::sh_node_color_ramp_declare;		ntype.declare = blender::nodes::sh_node_valtorgb_declare;
node_type_init(&ntype, file_ns::node_shader_init_color_ramp);		node_type_init(&ntype, node_shader_init_valtorgb);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);		node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);		node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_color_ramp);		node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_valtorgb);
node_type_gpu(&ntype, file_ns::gpu_shader_color_ramp);		node_type_gpu(&ntype, gpu_shader_valtorgb);
ntype.build_multi_function = file_ns::sh_node_color_ramp_build_multi_function;		ntype.build_multi_function = sh_node_valtorgb_build_multi_function;

		nodeRegisterType(&ntype);
		}

		namespace blender::nodes {

		static void sh_node_rgbtobw_declare(NodeDeclarationBuilder &b)
		{
		b.add_input<decl::Color>(N_("Color")).default_value({0.5f, 0.5f, 0.5f, 1.0f});
		b.add_output<decl::Float>(N_("Val"));
		};

		} // namespace blender::nodes

		static void node_shader_exec_rgbtobw(void *UNUSED(data),
		int UNUSED(thread),
		bNode *UNUSED(node),
		bNodeExecData *UNUSED(execdata),
		bNodeStack **in,
		bNodeStack **out)
		{
		/* Stack order out: BW. */
		/* Stack order in: COL. */
		float col[3];
		nodestack_get_vec(col, SOCK_VECTOR, in[0]);

		out[0]->vec[0] = IMB_colormanagement_get_luminance(col);
		}

		static int gpu_shader_rgbtobw(GPUMaterial *mat,
		bNode *node,
		bNodeExecData *UNUSED(execdata),
		GPUNodeStack *in,
		GPUNodeStack *out)
		{
		return GPU_stack_link(mat, node, "rgbtobw", in, out);
		}

		void register_node_type_sh_rgbtobw(void)
		{
		static bNodeType ntype;

		sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTER, 0);
		ntype.declare = blender::nodes::sh_node_rgbtobw_declare;
		node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_rgbtobw);
		node_type_gpu(&ntype, gpu_shader_rgbtobw);

nodeRegisterType(&ntype);		nodeRegisterType(&ntype);
}		}
No newline at end of file