Nixyri/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-11-24 05:04:10 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Expose Vector* component-wise and scalar min/max to scripting

Browse Source
This commit is contained in:
A Thousand Ships 2024-05-02 10:45:15 +02:00
parent a0b0b19043
commit 0f5e0d1637
No known key found for this signature in database
GPG Key ID: 2033189A662F8BD7
17 changed files with 596 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
core/variant/variant_call.cpp
View File

@ -1807,6 +1807,10 @@ static void _register_variant_builtin_methods() {
bind_method(Vector2, clampf, sarray("min", "max"), varray());
bind_method(Vector2, snapped, sarray("step"), varray());
bind_method(Vector2, snappedf, sarray("step"), varray());
bind_method(Vector2, min, sarray("with"), varray());
bind_method(Vector2, minf, sarray("with"), varray());
bind_method(Vector2, max, sarray("with"), varray());
bind_method(Vector2, maxf, sarray("with"), varray());
bind_static_method(Vector2, from_angle, sarray("angle"), varray());
@ -1825,6 +1829,10 @@ static void _register_variant_builtin_methods() {
bind_method(Vector2i, clampi, sarray("min", "max"), varray());
bind_method(Vector2i, snapped, sarray("step"), varray());
bind_method(Vector2i, snappedi, sarray("step"), varray());
bind_method(Vector2i, min, sarray("with"), varray());
bind_method(Vector2i, mini, sarray("with"), varray());
bind_method(Vector2i, max, sarray("with"), varray());
bind_method(Vector2i, maxi, sarray("with"), varray());
/* Rect2 */
@ -1905,6 +1913,10 @@ static void _register_variant_builtin_methods() {
bind_method(Vector3, reflect, sarray("n"), varray());
bind_method(Vector3, sign, sarray(), varray());
bind_method(Vector3, octahedron_encode, sarray(), varray());
bind_method(Vector3, min, sarray("with"), varray());
bind_method(Vector3, minf, sarray("with"), varray());
bind_method(Vector3, max, sarray("with"), varray());
bind_method(Vector3, maxf, sarray("with"), varray());
bind_static_method(Vector3, octahedron_decode, sarray("uv"), varray());
/* Vector3i */
@ -1921,6 +1933,10 @@ static void _register_variant_builtin_methods() {
bind_method(Vector3i, clampi, sarray("min", "max"), varray());
bind_method(Vector3i, snapped, sarray("step"), varray());
bind_method(Vector3i, snappedi, sarray("step"), varray());
bind_method(Vector3i, min, sarray("with"), varray());
bind_method(Vector3i, mini, sarray("with"), varray());
bind_method(Vector3i, max, sarray("with"), varray());
bind_method(Vector3i, maxi, sarray("with"), varray());
/* Vector4 */
@ -1952,6 +1968,10 @@ static void _register_variant_builtin_methods() {
bind_method(Vector4, is_equal_approx, sarray("to"), varray());
bind_method(Vector4, is_zero_approx, sarray(), varray());
bind_method(Vector4, is_finite, sarray(), varray());
bind_method(Vector4, min, sarray("with"), varray());
bind_method(Vector4, minf, sarray("with"), varray());
bind_method(Vector4, max, sarray("with"), varray());
bind_method(Vector4, maxf, sarray("with"), varray());
/* Vector4i */
@ -1965,6 +1985,10 @@ static void _register_variant_builtin_methods() {
bind_method(Vector4i, clampi, sarray("min", "max"), varray());
bind_method(Vector4i, snapped, sarray("step"), varray());
bind_method(Vector4i, snappedi, sarray("step"), varray());
bind_method(Vector4i, min, sarray("with"), varray());
bind_method(Vector4i, mini, sarray("with"), varray());
bind_method(Vector4i, max, sarray("with"), varray());
bind_method(Vector4i, maxi, sarray("with"), varray());
bind_method(Vector4i, distance_to, sarray("to"), varray());
bind_method(Vector4i, distance_squared_to, sarray("to"), varray());

2
doc/classes/@GlobalScope.xml
View File

@ -696,6 +696,7 @@
[codeblock]
max(1, 7, 3, -6, 5) # Returns 7
[/codeblock]
[b]Note:[/b] When using this on vectors it will [i]not[/i] perform component-wise maximum, and will pick the largest value when compared using [code]x < y[/code]. To perform component-wise maximum, use [method Vector2.max], [method Vector2i.max], [method Vector3.max], [method Vector3i.max], [method Vector4.max], and [method Vector4i.max].
</description>
</method>
<method name="maxf">
@ -729,6 +730,7 @@
[codeblock]
min(1, 7, 3, -6, 5) # Returns -6
[/codeblock]
[b]Note:[/b] When using this on vectors it will [i]not[/i] perform component-wise minimum, and will pick the smallest value when compared using [code]x &lt; y[/code]. To perform component-wise minimum, use [method Vector2.min], [method Vector2i.min], [method Vector3.min], [method Vector3i.min], [method Vector4.min], and [method Vector4i.min].
</description>
</method>
<method name="minf">

28
doc/classes/Vector2.xml
View File

@ -273,18 +273,46 @@
Returns the vector with a maximum length by limiting its length to [param length].
</description>
</method>
<method name="max" qualifiers="const">
<return type="Vector2" />
<param index="0" name="with" type="Vector2" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector2(maxf(x, with.x), maxf(y, with.y))[/code].
</description>
</method>
<method name="max_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's highest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_X].
</description>
</method>
<method name="maxf" qualifiers="const">
<return type="Vector2" />
<param index="0" name="with" type="float" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector2(maxf(x, with), maxf(y, with))[/code].
</description>
</method>
<method name="min" qualifiers="const">
<return type="Vector2" />
<param index="0" name="with" type="Vector2" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector2(minf(x, with.x), minf(y, with.y))[/code].
</description>
</method>
<method name="min_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's lowest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_Y].
</description>
</method>
<method name="minf" qualifiers="const">
<return type="Vector2" />
<param index="0" name="with" type="float" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector2(minf(x, with), minf(y, with))[/code].
</description>
</method>
<method name="move_toward" qualifiers="const">
<return type="Vector2" />
<param index="0" name="to" type="Vector2" />

28
doc/classes/Vector2i.xml
View File

@ -100,18 +100,46 @@
This method runs faster than [method length], so prefer it if you need to compare vectors or need the squared distance for some formula.
</description>
</method>
<method name="max" qualifiers="const">
<return type="Vector2i" />
<param index="0" name="with" type="Vector2i" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector2i(maxi(x, with.x), maxi(y, with.y))[/code].
</description>
</method>
<method name="max_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's highest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_X].
</description>
</method>
<method name="maxi" qualifiers="const">
<return type="Vector2i" />
<param index="0" name="with" type="int" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector2i(maxi(x, with), maxi(y, with))[/code].
</description>
</method>
<method name="min" qualifiers="const">
<return type="Vector2i" />
<param index="0" name="with" type="Vector2i" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector2i(mini(x, with.x), mini(y, with.y))[/code].
</description>
</method>
<method name="min_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's lowest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_Y].
</description>
</method>
<method name="mini" qualifiers="const">
<return type="Vector2i" />
<param index="0" name="with" type="int" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector2i(mini(x, with), mini(y, with))[/code].
</description>
</method>
<method name="sign" qualifiers="const">
<return type="Vector2i" />
<description>

28
doc/classes/Vector3.xml
View File

@ -242,18 +242,46 @@
Returns the vector with a maximum length by limiting its length to [param length].
</description>
</method>
<method name="max" qualifiers="const">
<return type="Vector3" />
<param index="0" name="with" type="Vector3" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector3(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z))[/code].
</description>
</method>
<method name="max_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's highest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_X].
</description>
</method>
<method name="maxf" qualifiers="const">
<return type="Vector3" />
<param index="0" name="with" type="float" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector3(maxf(x, with), maxf(y, with), maxf(z, with))[/code].
</description>
</method>
<method name="min" qualifiers="const">
<return type="Vector3" />
<param index="0" name="with" type="Vector3" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector3(minf(x, with.x), minf(y, with.y), minf(z, with.z))[/code].
</description>
</method>
<method name="min_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's lowest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_Z].
</description>
</method>
<method name="minf" qualifiers="const">
<return type="Vector3" />
<param index="0" name="with" type="float" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector3(minf(x, with), minf(y, with), minf(z, with))[/code].
</description>
</method>
<method name="move_toward" qualifiers="const">
<return type="Vector3" />
<param index="0" name="to" type="Vector3" />

28
doc/classes/Vector3i.xml
View File

@ -95,18 +95,46 @@
This method runs faster than [method length], so prefer it if you need to compare vectors or need the squared distance for some formula.
</description>
</method>
<method name="max" qualifiers="const">
<return type="Vector3i" />
<param index="0" name="with" type="Vector3i" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector3i(maxi(x, with.x), maxi(y, with.y), maxi(z, with.z))[/code].
</description>
</method>
<method name="max_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's highest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_X].
</description>
</method>
<method name="maxi" qualifiers="const">
<return type="Vector3i" />
<param index="0" name="with" type="int" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector3i(maxi(x, with), maxi(y, with), maxi(z, with))[/code].
</description>
</method>
<method name="min" qualifiers="const">
<return type="Vector3i" />
<param index="0" name="with" type="Vector3i" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector3i(mini(x, with.x), mini(y, with.y), mini(z, with.z))[/code].
</description>
</method>
<method name="min_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's lowest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_Z].
</description>
</method>
<method name="mini" qualifiers="const">
<return type="Vector3i" />
<param index="0" name="with" type="int" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector3i(mini(x, with), mini(y, with), mini(z, with))[/code].
</description>
</method>
<method name="sign" qualifiers="const">
<return type="Vector3i" />
<description>

28
doc/classes/Vector4.xml
View File

@ -184,18 +184,46 @@
Returns the result of the linear interpolation between this vector and [param to] by amount [param weight]. [param weight] is on the range of [code]0.0[/code] to [code]1.0[/code], representing the amount of interpolation.
</description>
</method>
<method name="max" qualifiers="const">
<return type="Vector4" />
<param index="0" name="with" type="Vector4" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w))[/code].
</description>
</method>
<method name="max_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's highest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_X].
</description>
</method>
<method name="maxf" qualifiers="const">
<return type="Vector4" />
<param index="0" name="with" type="float" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with))[/code].
</description>
</method>
<method name="min" qualifiers="const">
<return type="Vector4" />
<param index="0" name="with" type="Vector4" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w))[/code].
</description>
</method>
<method name="min_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's lowest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_W].
</description>
</method>
<method name="minf" qualifiers="const">
<return type="Vector4" />
<param index="0" name="with" type="float" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with))[/code].
</description>
</method>
<method name="normalized" qualifiers="const">
<return type="Vector4" />
<description>

28
doc/classes/Vector4i.xml
View File

@ -93,18 +93,46 @@
This method runs faster than [method length], so prefer it if you need to compare vectors or need the squared distance for some formula.
</description>
</method>
<method name="max" qualifiers="const">
<return type="Vector4i" />
<param index="0" name="with" type="Vector4i" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector4i(maxi(x, with.x), maxi(y, with.y), maxi(z, with.z), maxi(w, with.w))[/code].
</description>
</method>
<method name="max_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's highest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_X].
</description>
</method>
<method name="maxi" qualifiers="const">
<return type="Vector4i" />
<param index="0" name="with" type="int" />
<description>
Returns the component-wise maximum of this and [param with], equivalent to [code]Vector4i(maxi(x, with), maxi(y, with), maxi(z, with), maxi(w, with))[/code].
</description>
</method>
<method name="min" qualifiers="const">
<return type="Vector4i" />
<param index="0" name="with" type="Vector4i" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector4i(mini(x, with.x), mini(y, with.y), mini(z, with.z), mini(w, with.w))[/code].
</description>
</method>
<method name="min_axis_index" qualifiers="const">
<return type="int" />
<description>
Returns the axis of the vector's lowest value. See [code]AXIS_*[/code] constants. If all components are equal, this method returns [constant AXIS_W].
</description>
</method>
<method name="mini" qualifiers="const">
<return type="Vector4i" />
<param index="0" name="with" type="int" />
<description>
Returns the component-wise minimum of this and [param with], equivalent to [code]Vector4i(mini(x, with), mini(y, with), mini(z, with), mini(w, with))[/code].
</description>
</method>
<method name="sign" qualifiers="const">
<return type="Vector4i" />
<description>

2
modules/mono/glue/GodotSharp/GodotSharp/Core/Aabb.cs
View File

@ -69,7 +69,7 @@ namespace Godot
public readonly Aabb Abs()
{
Vector3 end = End;
Vector3 topLeft = new Vector3(Mathf.Min(_position.X, end.X), Mathf.Min(_position.Y, end.Y), Mathf.Min(_position.Z, end.Z));
Vector3 topLeft = end.Min(_position);
return new Aabb(topLeft, _size.Abs());
}

14
modules/mono/glue/GodotSharp/GodotSharp/Core/Rect2.cs
View File

@ -69,7 +69,7 @@ namespace Godot
public readonly Rect2 Abs()
{
Vector2 end = End;
Vector2 topLeft = new Vector2(Mathf.Min(_position.X, end.X), Mathf.Min(_position.Y, end.Y));
Vector2 topLeft = end.Min(_position);
return new Rect2(topLeft, _size.Abs());
}
@ -91,14 +91,12 @@ namespace Godot
return new Rect2();
}
newRect._position.X = Mathf.Max(b._position.X, _position.X);
newRect._position.Y = Mathf.Max(b._position.Y, _position.Y);
newRect._position = b._position.Max(_position);
Vector2 bEnd = b._position + b._size;
Vector2 end = _position + _size;
newRect._size.X = Mathf.Min(bEnd.X, end.X) - newRect._position.X;
newRect._size.Y = Mathf.Min(bEnd.Y, end.Y) - newRect._position.Y;
newRect._size = bEnd.Min(end) - newRect._position;
return newRect;
}
@ -338,11 +336,9 @@ namespace Godot
{
Rect2 newRect;
newRect._position.X = Mathf.Min(b._position.X, _position.X);
newRect._position.Y = Mathf.Min(b._position.Y, _position.Y);
newRect._position = b._position.Min(_position);
newRect._size.X = Mathf.Max(b._position.X + b._size.X, _position.X + _size.X);
newRect._size.Y = Mathf.Max(b._position.Y + b._size.Y, _position.Y + _size.Y);
newRect._size = (b._position + b._size).Max(_position + _size);
newRect._size -= newRect._position; // Make relative again

14
modules/mono/glue/GodotSharp/GodotSharp/Core/Rect2I.cs
View File

@ -69,7 +69,7 @@ namespace Godot
public readonly Rect2I Abs()
{
Vector2I end = End;
Vector2I topLeft = new Vector2I(Mathf.Min(_position.X, end.X), Mathf.Min(_position.Y, end.Y));
Vector2I topLeft = end.Min(_position);
return new Rect2I(topLeft, _size.Abs());
}
@ -91,14 +91,12 @@ namespace Godot
return new Rect2I();
}
newRect._position.X = Mathf.Max(b._position.X, _position.X);
newRect._position.Y = Mathf.Max(b._position.Y, _position.Y);
newRect._position = b._position.Max(_position);
Vector2I bEnd = b._position + b._size;
Vector2I end = _position + _size;
newRect._size.X = Mathf.Min(bEnd.X, end.X) - newRect._position.X;
newRect._size.Y = Mathf.Min(bEnd.Y, end.Y) - newRect._position.Y;
newRect._size = bEnd.Min(end) - newRect._position;
return newRect;
}
@ -295,11 +293,9 @@ namespace Godot
{
Rect2I newRect;
newRect._position.X = Mathf.Min(b._position.X, _position.X);
newRect._position.Y = Mathf.Min(b._position.Y, _position.Y);
newRect._position = b._position.Min(_position);
newRect._size.X = Mathf.Max(b._position.X + b._size.X, _position.X + _size.X);
newRect._size.Y = Mathf.Max(b._position.Y + b._size.Y, _position.Y + _size.Y);
newRect._size = (b._position + b._size).Max(_position + _size);
newRect._size -= newRect._position; // Make relative again

64
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2.cs
View File

@ -429,6 +429,70 @@ namespace Godot
return v;
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector2(Mathf.Max(X, with.X), Mathf.Max(Y, with.Y))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector2 Max(Vector2 with)
{
return new Vector2
(
Mathf.Max(X, with.X),
Mathf.Max(Y, with.Y)
);
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector2(Mathf.Max(X, with), Mathf.Max(Y, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector2 Max(real_t with)
{
return new Vector2
(
Mathf.Max(X, with),
Mathf.Max(Y, with)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector2(Mathf.Min(X, with.X), Mathf.Min(Y, with.Y))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector2 Min(Vector2 with)
{
return new Vector2
(
Mathf.Min(X, with.X),
Mathf.Min(Y, with.Y)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector2(Mathf.Min(X, with), Mathf.Min(Y, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector2 Min(real_t with)
{
return new Vector2
(
Mathf.Min(X, with),
Mathf.Min(Y, with)
);
}
/// <summary>
/// Returns the axis of the vector's highest value. See <see cref="Axis"/>.
/// If both components are equal, this method returns <see cref="Axis.X"/>.

64
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2I.cs
View File

@ -191,6 +191,70 @@ namespace Godot
return x2 + y2;
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector2I(Mathf.Max(X, with.X), Mathf.Max(Y, with.Y))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector2I Max(Vector2I with)
{
return new Vector2I
(
Mathf.Max(X, with.X),
Mathf.Max(Y, with.Y)
);
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector2I(Mathf.Max(X, with), Mathf.Max(Y, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector2I Max(int with)
{
return new Vector2I
(
Mathf.Max(X, with),
Mathf.Max(Y, with)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector2I(Mathf.Min(X, with.X), Mathf.Min(Y, with.Y))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector2I Min(Vector2I with)
{
return new Vector2I
(
Mathf.Min(X, with.X),
Mathf.Min(Y, with.Y)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector2I(Mathf.Min(X, with), Mathf.Min(Y, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector2I Min(int with)
{
return new Vector2I
(
Mathf.Min(X, with),
Mathf.Min(Y, with)
);
}
/// <summary>
/// Returns the axis of the vector's highest value. See <see cref="Axis"/>.
/// If both components are equal, this method returns <see cref="Axis.X"/>.

51
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3.cs
View File

@ -436,6 +436,57 @@ namespace Godot
return v;
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector3(Mathf.Max(X, with.X), Mathf.Max(Y, with.Y), Mathf.Max(Z, with.Z))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector3 Max(Vector3 with)
{
return new Vector3
(
Mathf.Max(X, with.X),
Mathf.Max(Y, with.Y),
Mathf.Max(Z, with.Z)
);
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector3(Mathf.Max(X, with), Mathf.Max(Y, with), Mathf.Max(Z, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector3 Max(real_t with)
{
return new Vector3
(
Mathf.Max(X, with),
Mathf.Max(Y, with),
Mathf.Max(Z, with)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector3(Mathf.Min(X, with.X), Mathf.Min(Y, with.Y), Mathf.Min(Z, with.Z))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector3 Min(Vector3 with)
{
return new Vector3
(
Mathf.Min(X, with.X),
Mathf.Min(Y, with.Y),
Mathf.Min(Z, with.Z)
);
}
/// <summary>
/// Returns the axis of the vector's highest value. See <see cref="Axis"/>.
/// If all components are equal, this method returns <see cref="Axis.X"/>.

68
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3I.cs
View File

@ -202,6 +202,74 @@ namespace Godot
return x2 + y2 + z2;
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector3I(Mathf.Max(X, with.X), Mathf.Max(Y, with.Y), Mathf.Max(Z, with.Z))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector3I Max(Vector3I with)
{
return new Vector3I
(
Mathf.Max(X, with.X),
Mathf.Max(Y, with.Y),
Mathf.Max(Z, with.Z)
);
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector3I(Mathf.Max(X, with), Mathf.Max(Y, with), Mathf.Max(Z, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector3I Max(int with)
{
return new Vector3I
(
Mathf.Max(X, with),
Mathf.Max(Y, with),
Mathf.Max(Z, with)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector3I(Mathf.Min(X, with.X), Mathf.Min(Y, with.Y), Mathf.Min(Z, with.Z))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector3I Min(Vector3I with)
{
return new Vector3I
(
Mathf.Min(X, with.X),
Mathf.Min(Y, with.Y),
Mathf.Min(Z, with.Z)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector3I(Mathf.Min(X, with), Mathf.Min(Y, with), Mathf.Min(Z, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector3I Min(int with)
{
return new Vector3I
(
Mathf.Min(X, with),
Mathf.Min(Y, with),
Mathf.Min(Z, with)
);
}
/// <summary>
/// Returns the axis of the vector's highest value. See <see cref="Axis"/>.
/// If all components are equal, this method returns <see cref="Axis.X"/>.

72
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector4.cs
View File

@ -370,6 +370,78 @@ namespace Godot
);
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector4(Mathf.Max(X, with.X), Mathf.Max(Y, with.Y), Mathf.Max(Z, with.Z), Mathf.Max(W, with.W))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector4 Max(Vector4 with)
{
return new Vector4
(
Mathf.Max(X, with.X),
Mathf.Max(Y, with.Y),
Mathf.Max(Z, with.Z),
Mathf.Max(W, with.W)
);
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector4(Mathf.Max(X, with), Mathf.Max(Y, with), Mathf.Max(Z, with), Mathf.Max(W, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector4 Max(real_t with)
{
return new Vector4
(
Mathf.Max(X, with),
Mathf.Max(Y, with),
Mathf.Max(Z, with),
Mathf.Max(W, with)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector4(Mathf.Min(X, with.X), Mathf.Min(Y, with.Y), Mathf.Min(Z, with.Z), Mathf.Min(W, with.W))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector4 Min(Vector4 with)
{
return new Vector4
(
Mathf.Min(X, with.X),
Mathf.Min(Y, with.Y),
Mathf.Min(Z, with.Z),
Mathf.Min(W, with.W)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector4(Mathf.Min(X, with), Mathf.Min(Y, with), Mathf.Min(Z, with), Mathf.Min(W, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector4 Min(real_t with)
{
return new Vector4
(
Mathf.Min(X, with),
Mathf.Min(Y, with),
Mathf.Min(Z, with),
Mathf.Min(W, with)
);
}
/// <summary>
/// Returns the axis of the vector's highest value. See <see cref="Axis"/>.
/// If all components are equal, this method returns <see cref="Axis.X"/>.

72
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector4I.cs
View File

@ -222,6 +222,78 @@ namespace Godot
return x2 + y2 + z2 + w2;
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector4I(Mathf.Max(X, with.X), Mathf.Max(Y, with.Y), Mathf.Max(Z, with.Z), Mathf.Max(W, with.W))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector4I Max(Vector4I with)
{
return new Vector4I
(
Mathf.Max(X, with.X),
Mathf.Max(Y, with.Y),
Mathf.Max(Z, with.Z),
Mathf.Max(W, with.W)
);
}
/// <summary>
/// Returns the result of the component-wise maximum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector4I(Mathf.Max(X, with), Mathf.Max(Y, with), Mathf.Max(Z, with), Mathf.Max(W, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting maximum vector.</returns>
public readonly Vector4I Max(int with)
{
return new Vector4I
(
Mathf.Max(X, with),
Mathf.Max(Y, with),
Mathf.Max(Z, with),
Mathf.Max(W, with)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector4I(Mathf.Min(X, with.X), Mathf.Min(Y, with.Y), Mathf.Min(Z, with.Z), Mathf.Min(W, with.W))</c>.
/// </summary>
/// <param name="with">The other vector to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector4I Min(Vector4I with)
{
return new Vector4I
(
Mathf.Min(X, with.X),
Mathf.Min(Y, with.Y),
Mathf.Min(Z, with.Z),
Mathf.Min(W, with.W)
);
}
/// <summary>
/// Returns the result of the component-wise minimum between
/// this vector and <paramref name="with"/>.
/// Equivalent to <c>new Vector4I(Mathf.Min(X, with), Mathf.Min(Y, with), Mathf.Min(Z, with), Mathf.Min(W, with))</c>.
/// </summary>
/// <param name="with">The other value to use.</param>
/// <returns>The resulting minimum vector.</returns>
public readonly Vector4I Min(int with)
{
return new Vector4I
(
Mathf.Min(X, with),
Mathf.Min(Y, with),
Mathf.Min(Z, with),
Mathf.Min(W, with)
);
}
/// <summary>
/// Returns the axis of the vector's highest value. See <see cref="Axis"/>.
/// If all components are equal, this method returns <see cref="Axis.X"/>.