archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Revert "Blenlib: Explicit Colors."

Browse Source 
This reverts commit fd94e03344.
does not compile against latest master.
This commit is contained in:
Jeroen Bakker
2021-05-25 17:03:54 +02:00
parent fd94e03344
commit 00955cd31e
26 changed files with 160 additions and 603 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
source/blender/nodes/geometry/nodes/node_geo_attribute_clamp.cc
View File

@@ -101,12 +101,9 @@ template<> inline float3 clamp_value(const float3 val, const float3 min, const f
return tmp;
}
template<>
inline ColorGeometry4f clamp_value(const ColorGeometry4f val,
const ColorGeometry4f min,
const ColorGeometry4f max)
template<> inline Color4f clamp_value(const Color4f val, const Color4f min, const Color4f max)
{
ColorGeometry4f tmp;
Color4f tmp;
tmp.r = std::min(std::max(val.r, min.r), max.r);
tmp.g = std::min(std::max(val.g, min.g), max.g);
tmp.b = std::min(std::max(val.b, min.b), max.b);
@@ -217,8 +214,8 @@ static void clamp_attribute(GeometryComponent &component, const GeoNodeExecParam
break;
}
case CD_PROP_COLOR: {
ColorGeometry4f min = params.get_input<ColorGeometry4f>("Min_003");
ColorGeometry4f max = params.get_input<ColorGeometry4f>("Max_003");
Color4f min = params.get_input<Color4f>("Min_003");
Color4f max = params.get_input<Color4f>("Max_003");
if (operation == NODE_CLAMP_RANGE) {
if (min.r > max.r) {
std::swap(min.r, max.r);
@@ -233,9 +230,8 @@ static void clamp_attribute(GeometryComponent &component, const GeoNodeExecParam
std::swap(min.a, max.a);
}
}
MutableSpan<ColorGeometry4f> results = attribute_result.as_span<ColorGeometry4f>();
clamp_attribute<ColorGeometry4f>(
attribute_input->typed<ColorGeometry4f>(), results, min, max);
MutableSpan<Color4f> results = attribute_result.as_span<Color4f>();
clamp_attribute<Color4f>(attribute_input->typed<Color4f>(), results, min, max);
break;
}
default: {

6
source/blender/nodes/geometry/nodes/node_geo_attribute_color_ramp.cc
View File

@@ -83,8 +83,8 @@ static void execute_on_component(const GeoNodeExecParams &params, GeometryCompon
* currently. */
const AttributeDomain result_domain = get_result_domain(component, input_name, result_name);
OutputAttribute_Typed<ColorGeometry4f> attribute_result =
component.attribute_try_get_for_output_only<ColorGeometry4f>(result_name, result_domain);
OutputAttribute_Typed<Color4f> attribute_result =
component.attribute_try_get_for_output_only<Color4f>(result_name, result_domain);
if (!attribute_result) {
return;
}
@@ -92,7 +92,7 @@ static void execute_on_component(const GeoNodeExecParams &params, GeometryCompon
GVArray_Typed<float> attribute_in = component.attribute_get_for_read<float>(
input_name, result_domain, 0.0f);
MutableSpan<ColorGeometry4f> results = attribute_result.as_span();
MutableSpan<Color4f> results = attribute_result.as_span();
ColorBand *color_ramp = &node_storage->color_ramp;
parallel_for(IndexRange(attribute_in.size()), 512, [&](IndexRange range) {

28
source/blender/nodes/geometry/nodes/node_geo_attribute_compare.cc
View File

@@ -131,16 +131,16 @@ static void do_equal_operation_float3(const VArray<float3> &input_a,
}
}
static void do_equal_operation_color4f(const VArray<ColorGeometry4f> &input_a,
const VArray<ColorGeometry4f> &input_b,
static void do_equal_operation_color4f(const VArray<Color4f> &input_a,
const VArray<Color4f> &input_b,
const float threshold,
MutableSpan<bool> span_result)
{
const float threshold_squared = pow2f(threshold);
const int size = input_a.size();
for (const int i : IndexRange(size)) {
const ColorGeometry4f a = input_a[i];
const ColorGeometry4f b = input_b[i];
const Color4f a = input_a[i];
const Color4f b = input_b[i];
span_result[i] = len_squared_v4v4(a, b) < threshold_squared;
}
}
@@ -185,16 +185,16 @@ static void do_not_equal_operation_float3(const VArray<float3> &input_a,
}
}
static void do_not_equal_operation_color4f(const VArray<ColorGeometry4f> &input_a,
const VArray<ColorGeometry4f> &input_b,
static void do_not_equal_operation_color4f(const VArray<Color4f> &input_a,
const VArray<Color4f> &input_b,
const float threshold,
MutableSpan<bool> span_result)
{
const float threshold_squared = pow2f(threshold);
const int size = input_a.size();
for (const int i : IndexRange(size)) {
const ColorGeometry4f a = input_a[i];
const ColorGeometry4f b = input_b[i];
const Color4f a = input_a[i];
const Color4f b = input_b[i];
span_result[i] = len_squared_v4v4(a, b) >= threshold_squared;
}
}
@@ -287,10 +287,8 @@ static void attribute_compare_calc(GeometryComponent &component, const GeoNodeEx
attribute_a->typed<float3>(), attribute_b->typed<float3>(), threshold, result_span);
}
else if (input_data_type == CD_PROP_COLOR) {
do_equal_operation_color4f(attribute_a->typed<ColorGeometry4f>(),
attribute_b->typed<ColorGeometry4f>(),
threshold,
result_span);
do_equal_operation_color4f(
attribute_a->typed<Color4f>(), attribute_b->typed<Color4f>(), threshold, result_span);
}
else if (input_data_type == CD_PROP_BOOL) {
do_equal_operation_bool(
@@ -307,10 +305,8 @@ static void attribute_compare_calc(GeometryComponent &component, const GeoNodeEx
attribute_a->typed<float3>(), attribute_b->typed<float3>(), threshold, result_span);
}
else if (input_data_type == CD_PROP_COLOR) {
do_not_equal_operation_color4f(attribute_a->typed<ColorGeometry4f>(),
attribute_b->typed<ColorGeometry4f>(),
threshold,
result_span);
do_not_equal_operation_color4f(
attribute_a->typed<Color4f>(), attribute_b->typed<Color4f>(), threshold, result_span);
}
else if (input_data_type == CD_PROP_BOOL) {
do_not_equal_operation_bool(

7
source/blender/nodes/geometry/nodes/node_geo_attribute_curve_map.cc
View File

@@ -165,10 +165,9 @@ static void execute_on_component(const GeoNodeExecParams &params, GeometryCompon
}
case CD_PROP_COLOR: {
const CurveMapping *cumap = (CurveMapping *)node_storage.curve_rgb;
GVArray_Typed<ColorGeometry4f> attribute_in =
component.attribute_get_for_read<ColorGeometry4f>(
input_name, result_domain, ColorGeometry4f(0.0f, 0.0f, 0.0f, 1.0f));
MutableSpan<ColorGeometry4f> results = attribute_result.as_span<ColorGeometry4f>();
GVArray_Typed<Color4f> attribute_in = component.attribute_get_for_read<Color4f>(
input_name, result_domain, Color4f(0.0f, 0.0f, 0.0f, 1.0f));
MutableSpan<Color4f> results = attribute_result.as_span<Color4f>();
parallel_for(IndexRange(attribute_in.size()), 512, [&](IndexRange range) {
for (const int i : range) {
BKE_curvemapping_evaluateRGBF(cumap, results[i], attribute_in[i]);

2
source/blender/nodes/geometry/nodes/node_geo_attribute_fill.cc
View File

@@ -110,7 +110,7 @@ static void fill_attribute(GeometryComponent &component, const GeoNodeExecParams
break;
}
case CD_PROP_COLOR: {
const ColorGeometry4f value = params.get_input<ColorGeometry4f>("Value_002");
const Color4f value = params.get_input<Color4f>("Value_002");
attribute->fill(&value);
break;
}

16
source/blender/nodes/geometry/nodes/node_geo_attribute_mix.cc
View File

@@ -120,16 +120,16 @@ static void do_mix_operation_float3(const int blend_mode,
static void do_mix_operation_color4f(const int blend_mode,
const VArray<float> &factors,
const VArray<ColorGeometry4f> &inputs_a,
const VArray<ColorGeometry4f> &inputs_b,
VMutableArray<ColorGeometry4f> &results)
const VArray<Color4f> &inputs_a,
const VArray<Color4f> &inputs_b,
VMutableArray<Color4f> &results)
{
const int size = results.size();
parallel_for(IndexRange(size), 512, [&](IndexRange range) {
for (const int i : range) {
const float factor = factors[i];
ColorGeometry4f a = inputs_a[i];
const ColorGeometry4f b = inputs_b[i];
Color4f a = inputs_a[i];
const Color4f b = inputs_b[i];
ramp_blend(blend_mode, a, factor, b);
results.set(i, a);
}
@@ -160,9 +160,9 @@ static void do_mix_operation(const CustomDataType result_type,
else if (result_type == CD_PROP_COLOR) {
do_mix_operation_color4f(blend_mode,
attribute_factor,
attribute_a.typed<ColorGeometry4f>(),
attribute_b.typed<ColorGeometry4f>(),
attribute_result.typed<ColorGeometry4f>());
attribute_a.typed<Color4f>(),
attribute_b.typed<Color4f>(),
attribute_result.typed<Color4f>());
}
}

7
source/blender/nodes/geometry/nodes/node_geo_attribute_sample_texture.cc
View File

@@ -79,9 +79,8 @@ static void execute_on_component(GeometryComponent &component, const GeoNodeExec
const AttributeDomain result_domain = get_result_domain(
component, result_attribute_name, mapping_name);
OutputAttribute_Typed<ColorGeometry4f> attribute_out =
component.attribute_try_get_for_output_only<ColorGeometry4f>(result_attribute_name,
result_domain);
OutputAttribute_Typed<Color4f> attribute_out =
component.attribute_try_get_for_output_only<Color4f>(result_attribute_name, result_domain);
if (!attribute_out) {
return;
}
@@ -89,7 +88,7 @@ static void execute_on_component(GeometryComponent &component, const GeoNodeExec
GVArray_Typed<float3> mapping_attribute = component.attribute_get_for_read<float3>(
mapping_name, result_domain, {0, 0, 0});
MutableSpan<ColorGeometry4f> colors = attribute_out.as_span();
MutableSpan<Color4f> colors = attribute_out.as_span();
parallel_for(IndexRange(mapping_attribute.size()), 128, [&](IndexRange range) {
for (const int i : range) {
TexResult texture_result = {0};

2
source/blender/nodes/geometry/nodes/node_geo_switch.cc
View File

@@ -134,7 +134,7 @@ static void geo_node_switch_exec(GeoNodeExecParams params)
break;
}
case SOCK_RGBA: {
output_input<ColorGeometry4f>(params, input, "_004", "Output_004");
output_input<Color4f>(params, input, "_004", "Output_004");
break;
}
case SOCK_STRING: {

5
source/blender/nodes/intern/node_geometry_exec.cc
View File

@@ -104,10 +104,9 @@ GVArrayPtr GeoNodeExecParams::get_input_attribute(const StringRef name,
return std::make_unique<fn::GVArray_For_SingleValue>(*cpp_type, domain_size, buffer);
}
if (found_socket->type == SOCK_RGBA) {
const ColorGeometry4f value = this->get_input<ColorGeometry4f>(found_socket->identifier);
const Color4f value = this->get_input<Color4f>(found_socket->identifier);
BUFFER_FOR_CPP_TYPE_VALUE(*cpp_type, buffer);
conversions.convert_to_uninitialized(
CPPType::get<ColorGeometry4f>(), *cpp_type, &value, buffer);
conversions.convert_to_uninitialized(CPPType::get<Color4f>(), *cpp_type, &value, buffer);
return std::make_unique<fn::GVArray_For_SingleValue>(*cpp_type, domain_size, buffer);
}
BLI_assert(false);

4
source/blender/nodes/intern/node_socket.cc
View File

@@ -637,9 +637,9 @@ static bNodeSocketType *make_socket_type_vector(PropertySubType subtype)
static bNodeSocketType *make_socket_type_rgba()
{
bNodeSocketType *socktype = make_standard_socket_type(SOCK_RGBA, PROP_NONE);
socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<blender::ColorGeometry4f>(); };
socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<blender::Color4f>(); };
socktype->get_cpp_value = [](const bNodeSocket &socket, void *r_value) {
*(blender::ColorGeometry4f *)r_value = ((bNodeSocketValueRGBA *)socket.default_value)->value;
*(blender::Color4f *)r_value = ((bNodeSocketValueRGBA *)socket.default_value)->value;
};
return socktype;
}

50
source/blender/nodes/intern/type_conversions.cc
View File

@@ -66,9 +66,9 @@ static bool float_to_bool(const float &a)
{
return a > 0.0f;
}
static ColorGeometry4f float_to_color(const float &a)
static Color4f float_to_color(const float &a)
{
return ColorGeometry4f(a, a, a, 1.0f);
return Color4f(a, a, a, 1.0f);
}
static float3 float2_to_float3(const float2 &a)
@@ -87,9 +87,9 @@ static bool float2_to_bool(const float2 &a)
{
return !is_zero_v2(a);
}
static ColorGeometry4f float2_to_color(const float2 &a)
static Color4f float2_to_color(const float2 &a)
{
return ColorGeometry4f(a.x, a.y, 0.0f, 1.0f);
return Color4f(a.x, a.y, 0.0f, 1.0f);
}
static bool float3_to_bool(const float3 &a)
@@ -108,9 +108,9 @@ static float2 float3_to_float2(const float3 &a)
{
return float2(a);
}
static ColorGeometry4f float3_to_color(const float3 &a)
static Color4f float3_to_color(const float3 &a)
{
return ColorGeometry4f(a.x, a.y, a.z, 1.0f);
return Color4f(a.x, a.y, a.z, 1.0f);
}
static bool int_to_bool(const int32_t &a)
@@ -129,9 +129,9 @@ static float3 int_to_float3(const int32_t &a)
{
return float3((float)a);
}
static ColorGeometry4f int_to_color(const int32_t &a)
static Color4f int_to_color(const int32_t &a)
{
return ColorGeometry4f((float)a, (float)a, (float)a, 1.0f);
return Color4f((float)a, (float)a, (float)a, 1.0f);
}
static float bool_to_float(const bool &a)
@@ -150,28 +150,28 @@ static float3 bool_to_float3(const bool &a)
{
return (a) ? float3(1.0f) : float3(0.0f);
}
static ColorGeometry4f bool_to_color(const bool &a)
static Color4f bool_to_color(const bool &a)
{
return (a) ? ColorGeometry4f(1.0f, 1.0f, 1.0f, 1.0f) : ColorGeometry4f(0.0f, 0.0f, 0.0f, 1.0f);
return (a) ? Color4f(1.0f, 1.0f, 1.0f, 1.0f) : Color4f(0.0f, 0.0f, 0.0f, 1.0f);
}
static bool color_to_bool(const ColorGeometry4f &a)
static bool color_to_bool(const Color4f &a)
{
return rgb_to_grayscale(a) > 0.0f;
}
static float color_to_float(const ColorGeometry4f &a)
static float color_to_float(const Color4f &a)
{
return rgb_to_grayscale(a);
}
static int32_t color_to_int(const ColorGeometry4f &a)
static int32_t color_to_int(const Color4f &a)
{
return (int)rgb_to_grayscale(a);
}
static float2 color_to_float2(const ColorGeometry4f &a)
static float2 color_to_float2(const Color4f &a)
{
return float2(a.r, a.g);
}
static float3 color_to_float3(const ColorGeometry4f &a)
static float3 color_to_float3(const Color4f &a)
{
return float3(a.r, a.g, a.b);
}
@@ -184,37 +184,37 @@ static DataTypeConversions create_implicit_conversions()
add_implicit_conversion<float, float3, float_to_float3>(conversions);
add_implicit_conversion<float, int32_t, float_to_int>(conversions);
add_implicit_conversion<float, bool, float_to_bool>(conversions);
add_implicit_conversion<float, ColorGeometry4f, float_to_color>(conversions);
add_implicit_conversion<float, Color4f, float_to_color>(conversions);
add_implicit_conversion<float2, float3, float2_to_float3>(conversions);
add_implicit_conversion<float2, float, float2_to_float>(conversions);
add_implicit_conversion<float2, int32_t, float2_to_int>(conversions);
add_implicit_conversion<float2, bool, float2_to_bool>(conversions);
add_implicit_conversion<float2, ColorGeometry4f, float2_to_color>(conversions);
add_implicit_conversion<float2, Color4f, float2_to_color>(conversions);
add_implicit_conversion<float3, bool, float3_to_bool>(conversions);
add_implicit_conversion<float3, float, float3_to_float>(conversions);
add_implicit_conversion<float3, int32_t, float3_to_int>(conversions);
add_implicit_conversion<float3, float2, float3_to_float2>(conversions);
add_implicit_conversion<float3, ColorGeometry4f, float3_to_color>(conversions);
add_implicit_conversion<float3, Color4f, float3_to_color>(conversions);
add_implicit_conversion<int32_t, bool, int_to_bool>(conversions);
add_implicit_conversion<int32_t, float, int_to_float>(conversions);
add_implicit_conversion<int32_t, float2, int_to_float2>(conversions);
add_implicit_conversion<int32_t, float3, int_to_float3>(conversions);
add_implicit_conversion<int32_t, ColorGeometry4f, int_to_color>(conversions);
add_implicit_conversion<int32_t, Color4f, int_to_color>(conversions);
add_implicit_conversion<bool, float, bool_to_float>(conversions);
add_implicit_conversion<bool, int32_t, bool_to_int>(conversions);
add_implicit_conversion<bool, float2, bool_to_float2>(conversions);
add_implicit_conversion<bool, float3, bool_to_float3>(conversions);
add_implicit_conversion<bool, ColorGeometry4f, bool_to_color>(conversions);
add_implicit_conversion<bool, Color4f, bool_to_color>(conversions);
add_implicit_conversion<ColorGeometry4f, bool, color_to_bool>(conversions);
add_implicit_conversion<ColorGeometry4f, float, color_to_float>(conversions);
add_implicit_conversion<ColorGeometry4f, int32_t, color_to_int>(conversions);
add_implicit_conversion<ColorGeometry4f, float2, color_to_float2>(conversions);
add_implicit_conversion<ColorGeometry4f, float3, color_to_float3>(conversions);
add_implicit_conversion<Color4f, bool, color_to_bool>(conversions);
add_implicit_conversion<Color4f, float, color_to_float>(conversions);
add_implicit_conversion<Color4f, int32_t, color_to_int>(conversions);
add_implicit_conversion<Color4f, float2, color_to_float2>(conversions);
add_implicit_conversion<Color4f, float3, color_to_float3>(conversions);
return conversions;
}

13
source/blender/nodes/shader/nodes/node_shader_sepcombRGB.cc
View File

@@ -70,7 +70,7 @@ class SeparateRGBFunction : public blender::fn::MultiFunction {
static blender::fn::MFSignature create_signature()
{
blender::fn::MFSignatureBuilder signature{"Separate RGB"};
signature.single_input<blender::ColorGeometry4f>("Color");
signature.single_input<blender::Color4f>("Color");
signature.single_output<float>("R");
signature.single_output<float>("G");
signature.single_output<float>("B");
@@ -81,14 +81,14 @@ class SeparateRGBFunction : public blender::fn::MultiFunction {
blender::fn::MFParams params,
blender::fn::MFContext UNUSED(context)) const override
{
const blender::VArray<blender::ColorGeometry4f> &colors =
params.readonly_single_input<blender::ColorGeometry4f>(0, "Color");
const blender::VArray<blender::Color4f> &colors =
params.readonly_single_input<blender::Color4f>(0, "Color");
blender::MutableSpan<float> rs = params.uninitialized_single_output<float>(1, "R");
blender::MutableSpan<float> gs = params.uninitialized_single_output<float>(2, "G");
blender::MutableSpan<float> bs = params.uninitialized_single_output<float>(3, "B");
for (int64_t i : mask) {
blender::ColorGeometry4f color = colors[i];
blender::Color4f color = colors[i];
rs[i] = color.r;
gs[i] = color.g;
bs[i] = color.b;
@@ -155,9 +155,8 @@ static int gpu_shader_combrgb(GPUMaterial *mat,
static void sh_node_combrgb_expand_in_mf_network(blender::nodes::NodeMFNetworkBuilder &builder)
{
static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, blender::ColorGeometry4f> fn{
"Combine RGB",
[](float r, float g, float b) { return blender::ColorGeometry4f(r, g, b, 1.0f); }};
static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, blender::Color4f> fn{
"Combine RGB", [](float r, float g, float b) { return blender::Color4f(r, g, b, 1.0f); }};
builder.set_matching_fn(fn);
}

8
source/blender/nodes/shader/nodes/node_shader_valToRgb.cc
View File

@@ -140,7 +140,7 @@ class ColorBandFunction : public blender::fn::MultiFunction {
{
blender::fn::MFSignatureBuilder signature{"Color Band"};
signature.single_input<float>("Value");
signature.single_output<blender::ColorGeometry4f>("Color");
signature.single_output<blender::Color4f>("Color");
signature.single_output<float>("Alpha");
return signature.build();
}
@@ -150,12 +150,12 @@ class ColorBandFunction : public blender::fn::MultiFunction {
blender::fn::MFContext UNUSED(context)) const override
{
const blender::VArray<float> &values = params.readonly_single_input<float>(0, "Value");
blender::MutableSpan<blender::ColorGeometry4f> colors =
params.uninitialized_single_output<blender::ColorGeometry4f>(1, "Color");
blender::MutableSpan<blender::Color4f> colors =
params.uninitialized_single_output<blender::Color4f>(1, "Color");
blender::MutableSpan<float> alphas = params.uninitialized_single_output<float>(2, "Alpha");
for (int64_t i : mask) {
blender::ColorGeometry4f color;
blender::Color4f color;
BKE_colorband_evaluate(&color_band_, values[i], color);
colors[i] = color;
alphas[i] = color.a;