Differential D10978 Diff 36215 source/blender/blenkernel/BKE_attribute_math.hh

Changeset View

Standalone View

source/blender/blenkernel/BKE_attribute_math.hh

Show All 40 Lines	case CD_PROP_FLOAT3:
break;		break;
case CD_PROP_INT32:		case CD_PROP_INT32:
func(int());		func(int());
break;		break;
case CD_PROP_BOOL:		case CD_PROP_BOOL:
func(bool());		func(bool());
break;		break;
case CD_PROP_COLOR:		case CD_PROP_COLOR:
func(Color4f());		func(ColorGeometry());
break;		break;
default:		default:
BLI_assert_unreachable();		BLI_assert_unreachable();
break;		break;
}		}
}		}

/* -------------------------------------------------------------------- */		/* -------------------------------------------------------------------- */
Show All 28 Lines

template<>		template<>
inline float3 mix3(const float3 &weights, const float3 &v0, const float3 &v1, const float3 &v2)		inline float3 mix3(const float3 &weights, const float3 &v0, const float3 &v1, const float3 &v2)
{		{
return weights.x * v0 + weights.y * v1 + weights.z * v2;		return weights.x * v0 + weights.y * v1 + weights.z * v2;
}		}

template<>		template<>
inline Color4f mix3(const float3 &weights, const Color4f &v0, const Color4f &v1, const Color4f &v2)		inline ColorGeometry mix3(const float3 &weights,
		const ColorGeometry &v0,
		const ColorGeometry &v1,
		const ColorGeometry &v2)
{		{
Color4f result;		ColorGeometry result;
interp_v4_v4v4v4(result, v0, v1, v2, weights);		interp_v4_v4v4v4(result, v0, v1, v2, weights);
return result;		return result;
}		}

/** \} */		/** \} */

/* -------------------------------------------------------------------- */		/* -------------------------------------------------------------------- */
/** \name Mix a dynamic amount of values with weights for many elements.		/** \name Mix a dynamic amount of values with weights for many elements.
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines	for (const int64_t i : buffer_.index_range()) {
}		}
else {		else {
buffer_[i] = default_value_;		buffer_[i] = default_value_;
}		}
}		}
}		}
};		};

class Color4fMixer {		class ColorGeometryMixer {
private:		private:
MutableSpan<Color4f> buffer_;		MutableSpan<ColorGeometry> buffer_;
Color4f default_color_;		ColorGeometry default_color_;
Array<float> total_weights_;		Array<float> total_weights_;

public:		public:
Color4fMixer(MutableSpan<Color4f> buffer, Color4f default_color = {0, 0, 0, 1});		ColorGeometryMixer(MutableSpan<ColorGeometry> buffer,
void mix_in(const int64_t index, const Color4f &color, const float weight = 1.0f);		ColorGeometry default_color = {0, 0, 0, 1});
		void mix_in(const int64_t index, const ColorGeometry &color, const float weight = 1.0f);
void finalize();		void finalize();
};		};

template<typename T> struct DefaultMixerStruct {		template<typename T> struct DefaultMixerStruct {
/* Use void by default. This can be check for in `if constexpr` statements. */		/* Use void by default. This can be check for in `if constexpr` statements. */
using type = void;		using type = void;
};		};
template<> struct DefaultMixerStruct<float> {		template<> struct DefaultMixerStruct<float> {
using type = SimpleMixer<float>;		using type = SimpleMixer<float>;
};		};
template<> struct DefaultMixerStruct<float2> {		template<> struct DefaultMixerStruct<float2> {
using type = SimpleMixer<float2>;		using type = SimpleMixer<float2>;
};		};
template<> struct DefaultMixerStruct<float3> {		template<> struct DefaultMixerStruct<float3> {
using type = SimpleMixer<float3>;		using type = SimpleMixer<float3>;
};		};
template<> struct DefaultMixerStruct<Color4f> {		template<> struct DefaultMixerStruct<ColorGeometry> {
/* Use a special mixer for colors. Color4f can't be added/multiplied, because this is not		/* Use a special mixer for colors. ColorGeometry can't be added/multiplied, because this is not
* something one should usually do with colors. */		* something one should usually do with colors. */
using type = Color4fMixer;		using type = ColorGeometryMixer;
};		};
template<> struct DefaultMixerStruct<int> {		template<> struct DefaultMixerStruct<int> {
static int double_to_int(const double &value)		static int double_to_int(const double &value)
{		{
return static_cast<int>(value);		return static_cast<int>(value);
}		}
/* Store interpolated ints in a double temporarily, so that weights are handled correctly. It		/* Store interpolated ints in a double temporarily, so that weights are handled correctly. It
* uses double instead of float so that it is accurate for all 32 bit integers. */		* uses double instead of float so that it is accurate for all 32 bit integers. */
Show All 19 Lines