Differential D13480 Diff 45674 source/blender/nodes/shader/nodes/node_shader_color_ramp.cc

Changeset View

Standalone View

source/blender/nodes/shader/nodes/node_shader_color_ramp.cc

This file was moved from source/blender/nodes/shader/nodes/node_shader_valToRgb.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) 2005 Blender Foundation.		* The Original Code is Copyright (C) 2021 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.hh"

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

static void sh_node_valtorgb_declare(NodeDeclarationBuilder &b)		static void sh_node_color_ramp_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"));
};		};

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

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_valtorgb(bNodeTree UNUSED(ntree), bNode node)		static void node_shader_init_color_ramp(bNodeTree UNUSED(ntree), bNode node)
{		{
node->storage = BKE_colorband_add(true);		node->storage = BKE_colorband_add(true);
}		}

static int gpu_shader_valtorgb(GPUMaterial *mat,		static int gpu_shader_color_ramp(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;
▲ Show 20 Lines • Show All 82 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_valtorgb_build_multi_function(		static void sh_node_color_ramp_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);
}		}

void register_node_type_sh_valtorgb()
{
static bNodeType ntype;

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

nodeRegisterType(&ntype);
}		}

namespace blender::nodes {		void register_node_type_sh_color_ramp()

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});		namespace file_ns = blender::nodes::node_shader_color_ramp_cc;
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()
{
static bNodeType ntype;		static bNodeType ntype;

sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTER, 0);		sh_fn_node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_rgbtobw_declare;		ntype.declare = file_ns::sh_node_color_ramp_declare;
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_rgbtobw);		node_type_init(&ntype, file_ns::node_shader_init_color_ramp);
node_type_gpu(&ntype, gpu_shader_rgbtobw);		node_type_size_preset(&ntype, NODE_SIZE_LARGE);
		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_gpu(&ntype, file_ns::gpu_shader_color_ramp);
		ntype.build_multi_function = file_ns::sh_node_color_ramp_build_multi_function;

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