Upgrade SDFGI to HDDAGI

core/math/vector2i.cpp

@@ -72,3 +72,73 @@ Vector2i::operator String() const {
 Vector2i::operator Vector2() const {
 	return Vector2((int32_t)x, (int32_t)y);
 }
+
+Vector2i &Vector2i::operator>>=(const Vector2i &p_v) {
+	x >>= p_v.x;
+	y >>= p_v.y;
+	return *this;
+}
+
+Vector2i Vector2i::operator>>(const Vector2i &p_v) const {
+	return Vector2i(x >> p_v.x, y >> p_v.y);
+}
+
+Vector2i &Vector2i::operator<<=(const Vector2i &p_v) {
+	x <<= p_v.x;
+	y <<= p_v.y;
+	return *this;
+}
+
+Vector2i Vector2i::operator<<(const Vector2i &p_v) const {
+	return Vector2i(x << p_v.x, y << p_v.y);
+}
+
+Vector2i &Vector2i::operator<<=(const int32_t p_scalar) {
+	x <<= p_scalar;
+	y <<= p_scalar;
+	return *this;
+}
+
+Vector2i Vector2i::operator<<(const int32_t p_scalar) const {
+	return Vector2i(x << p_scalar, y << p_scalar);
+}
+
+Vector2i &Vector2i::operator>>=(const int32_t p_scalar) {
+	x >>= p_scalar;
+	y >>= p_scalar;
+	return *this;
+}
+
+Vector2i Vector2i::operator>>(const int32_t p_scalar) const {
+	return Vector2i(x >> p_scalar, y >> p_scalar);
+}
+
+Vector2i Vector2i::operator|(const Vector2i &p_v) const {
+	return Vector2i(x | p_v.x, y | p_v.y);
+}
+
+Vector2i &Vector2i::operator|=(const Vector2i &p_v) {
+	x |= p_v.x;
+	y |= p_v.y;
+	return *this;
+}
+
+Vector2i Vector2i::operator&(const Vector2i &p_v) const {
+	return Vector2i(x & p_v.x, y & p_v.y);
+}
+
+Vector2i &Vector2i::operator&=(const Vector2i &p_v) {
+	x &= p_v.x;
+	y &= p_v.y;
+	return *this;
+}
+
+Vector2i Vector2i::operator^(const Vector2i &p_v) const {
+	return Vector2i(x ^ p_v.x, y ^ p_v.y);
+}
+
+Vector2i &Vector2i::operator^=(const Vector2i &p_v) {
+	x ^= p_v.x;
+	y ^= p_v.y;
+	return *this;
+}

core/math/vector2i.h

@@ -134,6 +134,23 @@ struct [[nodiscard]] Vector2i {
 	constexpr bool operator==(const Vector2i &p_vec2) const;
 	constexpr bool operator!=(const Vector2i &p_vec2) const;
 
+	Vector2i operator>>(const Vector2i &p_v) const;
+	Vector2i &operator>>=(const Vector2i &p_v);
+	Vector2i operator<<(const Vector2i &p_v) const;
+	Vector2i &operator<<=(const Vector2i &p_v);
+
+	Vector2i &operator>>=(const int32_t p_scalar);
+	Vector2i operator>>(const int32_t p_scalar) const;
+	Vector2i &operator<<=(const int32_t p_scalar);
+	Vector2i operator<<(const int32_t p_scalar) const;
+
+	Vector2i operator|(const Vector2i &p_v) const;
+	Vector2i &operator|=(const Vector2i &p_v);
+	Vector2i operator&(const Vector2i &p_v) const;
+	Vector2i &operator&=(const Vector2i &p_v);
+	Vector2i operator^(const Vector2i &p_v) const;
+	Vector2i &operator^=(const Vector2i &p_v);
+
 	int64_t length_squared() const;
 	double length() const;
 

core/math/vector3i.h

@@ -129,6 +129,23 @@ struct [[nodiscard]] Vector3i {
 	constexpr Vector3i &operator%=(int32_t p_scalar);
 	constexpr Vector3i operator%(int32_t p_scalar) const;
 
+	constexpr Vector3i operator>>(const Vector3i &p_v) const;
+	constexpr Vector3i &operator>>=(const Vector3i &p_v);
+	constexpr Vector3i operator<<(const Vector3i &p_v) const;
+	constexpr Vector3i &operator<<=(const Vector3i &p_v);
+
+	constexpr Vector3i &operator>>=(const int32_t p_scalar);
+	constexpr Vector3i operator>>(const int32_t p_scalar) const;
+	constexpr Vector3i &operator<<=(const int32_t p_scalar);
+	constexpr Vector3i operator<<(const int32_t p_scalar) const;
+
+	constexpr Vector3i operator|(const Vector3i &p_v) const;
+	constexpr Vector3i &operator|=(const Vector3i &p_v);
+	constexpr Vector3i operator&(const Vector3i &p_v) const;
+	constexpr Vector3i &operator&=(const Vector3i &p_v);
+	constexpr Vector3i operator^(const Vector3i &p_v) const;
+	constexpr Vector3i &operator^=(const Vector3i &p_v);
+
 	constexpr Vector3i operator-() const;
 
 	constexpr bool operator==(const Vector3i &p_v) const;
@@ -253,6 +270,61 @@ constexpr Vector3i Vector3i::operator*(int32_t p_scalar) const {
 	return Vector3i(x * p_scalar, y * p_scalar, z * p_scalar);
 }
 
+constexpr Vector3i &Vector3i::operator>>=(const Vector3i &p_v) {
+	x >>= p_v.x;
+	y >>= p_v.y;
+	z >>= p_v.z;
+	return *this;
+}
+
+constexpr Vector3i Vector3i::operator>>(const Vector3i &p_v) const {
+	return Vector3i(x >> p_v.x, y >> p_v.y, z >> p_v.z);
+}
+
+constexpr Vector3i &Vector3i::operator<<=(const Vector3i &p_v) {
+	x <<= p_v.x;
+	y <<= p_v.y;
+	z <<= p_v.z;
+	return *this;
+}
+
+constexpr Vector3i Vector3i::operator<<(const Vector3i &p_v) const {
+	return Vector3i(x << p_v.x, y << p_v.y, z << p_v.z);
+}
+
+constexpr Vector3i &Vector3i::operator&=(const Vector3i &p_v) {
+	x &= p_v.x;
+	y &= p_v.y;
+	z &= p_v.z;
+	return *this;
+}
+
+constexpr Vector3i Vector3i::operator&(const Vector3i &p_v) const {
+	return Vector3i(x & p_v.x, y & p_v.y, z & p_v.z);
+}
+
+constexpr Vector3i &Vector3i::operator|=(const Vector3i &p_v) {
+	x |= p_v.x;
+	y |= p_v.y;
+	z |= p_v.z;
+	return *this;
+}
+
+constexpr Vector3i Vector3i::operator|(const Vector3i &p_v) const {
+	return Vector3i(x | p_v.x, y | p_v.y, z | p_v.z);
+}
+
+constexpr Vector3i &Vector3i::operator^=(const Vector3i &p_v) {
+	x ^= p_v.x;
+	y ^= p_v.y;
+	z ^= p_v.z;
+	return *this;
+}
+
+constexpr Vector3i Vector3i::operator^(const Vector3i &p_v) const {
+	return Vector3i(x ^ p_v.x, y ^ p_v.y, z ^ p_v.z);
+}
+
 // Multiplication operators required to workaround issues with LLVM using implicit conversion.
 
 constexpr Vector3i operator*(int32_t p_scalar, const Vector3i &p_vector) {
@@ -293,6 +365,28 @@ constexpr Vector3i Vector3i::operator%(int32_t p_scalar) const {
 	return Vector3i(x % p_scalar, y % p_scalar, z % p_scalar);
 }
 
+constexpr Vector3i &Vector3i::operator<<=(const int32_t p_scalar) {
+	x <<= p_scalar;
+	y <<= p_scalar;
+	z <<= p_scalar;
+	return *this;
+}
+
+constexpr Vector3i Vector3i::operator<<(const int32_t p_scalar) const {
+	return Vector3i(x << p_scalar, y << p_scalar, z << p_scalar);
+}
+
+constexpr Vector3i &Vector3i::operator>>=(const int32_t p_scalar) {
+	x >>= p_scalar;
+	y >>= p_scalar;
+	z >>= p_scalar;
+	return *this;
+}
+
+constexpr Vector3i Vector3i::operator>>(const int32_t p_scalar) const {
+	return Vector3i(x >> p_scalar, y >> p_scalar, z >> p_scalar);
+}
+
 constexpr Vector3i Vector3i::operator-() const {
 	return Vector3i(-x, -y, -z);
 }

core/variant/variant_op.cpp

@@ -477,6 +477,24 @@ void Variant::_register_variant_operators() {
 	register_op<OperatorEvaluatorPos<Plane, Plane>>(Variant::OP_POSITIVE, Variant::PLANE, Variant::NIL);
 	register_op<OperatorEvaluatorPos<Color, Color>>(Variant::OP_POSITIVE, Variant::COLOR, Variant::NIL);
 
+	register_op<OperatorEvaluatorShiftLeft<Vector2i, Vector2i, int64_t>>(Variant::OP_SHIFT_LEFT, Variant::VECTOR2I, Variant::INT);
+	register_op<OperatorEvaluatorShiftRight<Vector2i, Vector2i, int64_t>>(Variant::OP_SHIFT_RIGHT, Variant::VECTOR2I, Variant::INT);
+	register_op<OperatorEvaluatorShiftLeftVector<Vector2i, Vector2i, Vector2i>>(Variant::OP_SHIFT_LEFT, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorShiftRightVector<Vector2i, Vector2i, Vector2i>>(Variant::OP_SHIFT_RIGHT, Variant::VECTOR2I, Variant::VECTOR2I);
+
+	register_op<OperatorEvaluatorShiftLeft<Vector3i, Vector3i, int64_t>>(Variant::OP_SHIFT_LEFT, Variant::VECTOR3I, Variant::INT);
+	register_op<OperatorEvaluatorShiftRight<Vector3i, Vector3i, int64_t>>(Variant::OP_SHIFT_RIGHT, Variant::VECTOR3I, Variant::INT);
+	register_op<OperatorEvaluatorShiftLeftVector<Vector3i, Vector3i, Vector3i>>(Variant::OP_SHIFT_LEFT, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorShiftRightVector<Vector3i, Vector3i, Vector3i>>(Variant::OP_SHIFT_RIGHT, Variant::VECTOR3I, Variant::VECTOR3I);
+
+	register_op<OperatorEvaluatorBitOr<Vector2i, Vector2i, Vector2i>>(Variant::OP_BIT_OR, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorBitAnd<Vector2i, Vector2i, Vector2i>>(Variant::OP_BIT_AND, Variant::VECTOR2I, Variant::VECTOR2I);
+	register_op<OperatorEvaluatorBitXor<Vector2i, Vector2i, Vector2i>>(Variant::OP_BIT_XOR, Variant::VECTOR2I, Variant::VECTOR2I);
+
+	register_op<OperatorEvaluatorBitOr<Vector3i, Vector3i, Vector3i>>(Variant::OP_BIT_OR, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorBitAnd<Vector3i, Vector3i, Vector3i>>(Variant::OP_BIT_AND, Variant::VECTOR3I, Variant::VECTOR3I);
+	register_op<OperatorEvaluatorBitXor<Vector3i, Vector3i, Vector3i>>(Variant::OP_BIT_XOR, Variant::VECTOR3I, Variant::VECTOR3I);
+
 	register_op<OperatorEvaluatorShiftLeft<int64_t, int64_t, int64_t>>(Variant::OP_SHIFT_LEFT, Variant::INT, Variant::INT);
 	register_op<OperatorEvaluatorShiftRight<int64_t, int64_t, int64_t>>(Variant::OP_SHIFT_RIGHT, Variant::INT, Variant::INT);
 	register_op<OperatorEvaluatorBitOr<int64_t, int64_t, int64_t>>(Variant::OP_BIT_OR, Variant::INT, Variant::INT);

core/variant/variant_op.h

@@ -364,11 +364,27 @@ class OperatorEvaluatorShiftLeft {
 		const B &b = VariantInternalAccessor<B>::get(&p_right);
 
 #if defined(DEBUG_ENABLED)
-		if (b < 0 || a < 0) {
+		if (b < 0) {
 			*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
 			r_valid = false;
 			return;
 		}
+
+		if constexpr (std::is_scalar_v<A>) {
+			if (a < 0) {
+				*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
+				r_valid = false;
+				return;
+			}
+		} else {
+			for (uint32_t i = 0; i < A::AXIS_COUNT; ++i) {
+				if (a[i] < 0) {
+					*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
+					r_valid = false;
+					return;
+				}
+			}
+		}
 #endif
 		*r_ret = a << b;
 		r_valid = true;
@@ -390,12 +406,63 @@ class OperatorEvaluatorShiftRight {
 		const B &b = VariantInternalAccessor<B>::get(&p_right);
 
 #if defined(DEBUG_ENABLED)
-		if (b < 0 || a < 0) {
+		if (b < 0) {
 			*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
 			r_valid = false;
 			return;
 		}
+
+		if constexpr (std::is_scalar_v<A>) {
+			if (a < 0) {
+				*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
+				r_valid = false;
+				return;
+			}
+		} else {
+			for (uint32_t i = 0; i < A::AXIS_COUNT; ++i) {
+				if (a[i] < 0) {
+					*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
+					r_valid = false;
+					return;
+				}
+			}
+		}
+#endif
+		*r_ret = a >> b;
+		r_valid = true;
+	}
+	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) >> VariantInternalAccessor<B>::get(right);
+	}
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) >> PtrToArg<B>::convert(right), r_ret);
+	}
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
+template <typename R, typename A, typename B>
+class OperatorEvaluatorShiftRightVector {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = VariantInternalAccessor<A>::get(&p_left);
+		const B &b = VariantInternalAccessor<B>::get(&p_right);
+
+#if defined(DEBUG_ENABLED)
+		if (A::AXIS_COUNT != B::AXIS_COUNT) {
+			*r_ret = "Axis counts must match.";
+			r_valid = false;
+			return;
+		}
+
+		for (uint32_t i = 0; i < A::AXIS_COUNT; ++i) {
+			if (b[i] < 0 || a[i] < 0) {
+				*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
+				r_valid = false;
+				return;
+			}
+		}
 #endif
+
 		*r_ret = a >> b;
 		r_valid = true;
 	}
@@ -408,6 +475,41 @@ class OperatorEvaluatorShiftRight {
 	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
 };
 
+template <typename R, typename A, typename B>
+class OperatorEvaluatorShiftLeftVector {
+public:
+	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
+		const A &a = VariantInternalAccessor<A>::get(&p_left);
+		const B &b = VariantInternalAccessor<B>::get(&p_right);
+
+#if defined(DEBUG_ENABLED)
+		if (A::AXIS_COUNT != B::AXIS_COUNT) {
+			*r_ret = "Axis counts must match.";
+			r_valid = false;
+			return;
+		}
+
+		for (uint32_t i = 0; i < A::AXIS_COUNT; ++i) {
+			if (b[i] < 0 || a[i] < 0) {
+				*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
+				r_valid = false;
+				return;
+			}
+		}
+#endif
+
+		*r_ret = a << b;
+		r_valid = true;
+	}
+	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
+		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) << VariantInternalAccessor<B>::get(right);
+	}
+	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
+		PtrToArg<R>::encode(PtrToArg<A>::convert(left) << PtrToArg<B>::convert(right), r_ret);
+	}
+	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
+};
+
 template <typename R, typename A, typename B>
 class OperatorEvaluatorBitOr : public CommonEvaluate<OperatorEvaluatorBitOr<R, A, B>> {
 public:

doc/classes/Decal.xml

@@ -108,7 +108,7 @@
 			[Texture2D] storing ambient occlusion, roughness, and metallic for the decal. Use this to add extra detail to decals.
 			[b]Note:[/b] Unlike [BaseMaterial3D] whose filter mode can be adjusted on a per-material basis, the filter mode for [Decal] textures is set globally with [member ProjectSettings.rendering/textures/decals/filter].
 			[b]Note:[/b] Setting this texture alone will not result in a visible decal, as [member texture_albedo] must also be set. To create an ORM-only decal, load an albedo texture into [member texture_albedo] and set [member albedo_mix] to [code]0.0[/code]. The albedo texture's alpha channel will be used to determine where the underlying surface's ORM map should be overridden (and its intensity).
-			[b]Note:[/b] Due to technical limitations, modifying the underlying surface's roughness using [member texture_orm] does [i]not[/i] affect screen-space reflections ([member Environment.ssr_enabled]), reflections from [VoxelGI], and reflections from SDFGI ([member Environment.sdfgi_enabled]). Only reflections from [ReflectionProbe]s are affected.
+			[b]Note:[/b] Due to technical limitations, modifying the underlying surface's roughness using [member texture_orm] does [i]not[/i] affect screen-space reflections ([member Environment.ssr_enabled]), reflections from [VoxelGI], and reflections from DynamicGI ([member Environment.dynamic_gi_enabled]). Only reflections from [ReflectionProbe]s are affected.
 		</member>
 		<member name="upper_fade" type="float" setter="set_upper_fade" getter="get_upper_fade" default="0.3">
 			Sets the curve over which the decal will fade as the surface gets further from the center of the [AABB]. Only positive values are valid (negative values will be clamped to [code]0.0[/code]). See also [member lower_fade].