Nixyri/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-11-21 19:42:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

C#: Renames to follow .NET naming conventions

Browse Source 
Renamed C# types and members to use PascalCase and follow .NET naming conventions.
This commit is contained in:
Raul Santos 2022-12-07 16:11:39 +01:00
parent 4788cb35c1
commit a968e51414
No known key found for this signature in database
GPG Key ID: B532473AE3A803E4
60 changed files with 2885 additions and 2536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/classes/AABB.xml
View File

@ -66,7 +66,7 @@
[/gdscript]
[csharp]
// position (-3, 2, 0), size (1, 1, 1)
var box = new AABB(new Vector3(-3, 2, 0), new Vector3(1, 1, 1));
var box = new Aabb(new Vector3(-3, 2, 0), new Vector3(1, 1, 1));
// position (-3, -1, 0), size (3, 4, 2), so we fit both the original AABB and Vector3(0, -1, 2)
var box2 = box.Expand(new Vector3(0, -1, 2));
[/csharp]

8
doc/classes/AStarGrid2D.xml
View File

@ -17,11 +17,11 @@
[/gdscript]
[csharp]
AStarGrid2D astarGrid = new AStarGrid2D();
astarGrid.Size = new Vector2i(32, 32);
astarGrid.CellSize = new Vector2i(16, 16);
astarGrid.Size = new Vector2I(32, 32);
astarGrid.CellSize = new Vector2I(16, 16);
astarGrid.Update();
GD.Print(astarGrid.GetIdPath(Vector2i.Zero, new Vector2i(3, 4))); // prints (0, 0), (1, 1), (2, 2), (3, 3), (3, 4)
GD.Print(astarGrid.GetPointPath(Vector2i.Zero, new Vector2i(3, 4))); // prints (0, 0), (16, 16), (32, 32), (48, 48), (48, 64)
GD.Print(astarGrid.GetIdPath(Vector2I.Zero, new Vector2I(3, 4))); // prints (0, 0), (1, 1), (2, 2), (3, 3), (3, 4)
GD.Print(astarGrid.GetPointPath(Vector2I.Zero, new Vector2I(3, 4))); // prints (0, 0), (16, 16), (32, 32), (48, 48), (48, 64)
[/csharp]
[/codeblocks]
</description>

2
doc/classes/AnimationNodeStateMachineTransition.xml
View File

@ -15,7 +15,7 @@
$animation_tree.set("parameters/conditions/idle", is_on_floor and (linear_velocity.x == 0))
[/gdscript]
[csharp]
GetNode&lt;AnimationTree&gt;("animation_tree").Set("parameters/conditions/idle", IsOnFloor &amp;&amp; (LinearVelocity.x == 0));
GetNode&lt;AnimationTree&gt;("animation_tree").Set("parameters/conditions/idle", IsOnFloor &amp;&amp; (LinearVelocity.X == 0));
[/csharp]
[/codeblocks]
</member>

2
doc/classes/Image.xml
View File

@ -525,7 +525,7 @@
var img = new Image();
img.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
img.SetPixelv(new Vector2i(1, 2), Colors.Red); // Sets the color at (1, 2) to red.
img.SetPixelv(new Vector2I(1, 2), Colors.Red); // Sets the color at (1, 2) to red.
[/csharp]
[/codeblocks]
This is the same as [method set_pixel], but with a [Vector2i] argument instead of two integer arguments.

6
doc/classes/Rect2i.xml
View File

@ -80,9 +80,9 @@
[/gdscript]
[csharp]
// position (-3, 2), size (1, 1)
var rect = new Rect2i(new Vector2i(-3, 2), new Vector2i(1, 1));
// position (-3, -1), size (3, 4), so we fit both rect and Vector2i(0, -1)
var rect2 = rect.Expand(new Vector2i(0, -1));
var rect = new Rect2I(new Vector2I(-3, 2), new Vector2I(1, 1));
// position (-3, -1), size (3, 4), so we fit both rect and Vector2I(0, -1)
var rect2 = rect.Expand(new Vector2I(0, -1));
[/csharp]
[/codeblocks]
</description>

8
doc/classes/TextEdit.xml
View File

@ -770,12 +770,12 @@
var column_number = result.x
[/gdscript]
[csharp]
Vector2i result = Search("print", (uint)TextEdit.SearchFlags.WholeWords, 0, 0);
if (result.Length &gt; 0)
Vector2I result = Search("print", (uint)TextEdit.SearchFlags.WholeWords, 0, 0);
if (result.X != -1)
{
// Result found.
int lineNumber = result.y;
int columnNumber = result.x;
int lineNumber = result.Y;
int columnNumber = result.X;
}
[/csharp]
[/codeblocks]

62
modules/mono/csharp_script.cpp
View File

@ -60,6 +60,7 @@
#include "mono_gd/gd_mono_cache.h"
#include "signal_awaiter_utils.h"
#include "utils/macros.h"
#include "utils/naming_utils.h"
#include "utils/string_utils.h"
#define CACHED_STRING_NAME(m_var) (CSharpLanguage::get_singleton()->get_string_names().m_var)
@ -333,7 +334,7 @@ void CSharpLanguage::get_string_delimiters(List<String> *p_delimiters) const {
}
static String get_base_class_name(const String &p_base_class_name, const String p_class_name) {
String base_class = p_base_class_name;
String base_class = pascal_to_pascal_case(p_base_class_name);
if (p_class_name == base_class) {
base_class = "Godot." + base_class;
}
@ -394,13 +395,18 @@ bool CSharpLanguage::supports_builtin_mode() const {
}
#ifdef TOOLS_ENABLED
struct VariantCsName {
Variant::Type variant_type;
const String cs_type;
};
static String variant_type_to_managed_name(const String &p_var_type_name) {
if (p_var_type_name.is_empty()) {
return "Variant";
}
if (ClassDB::class_exists(p_var_type_name)) {
return p_var_type_name;
return pascal_to_pascal_case(p_var_type_name);
}
if (p_var_type_name == Variant::get_type_name(Variant::OBJECT)) {
@ -459,34 +465,34 @@ static String variant_type_to_managed_name(const String &p_var_type_name) {
return "Signal";
}
Variant::Type var_types[] = {
Variant::BOOL,
Variant::INT,
Variant::VECTOR2,
Variant::VECTOR2I,
Variant::RECT2,
Variant::RECT2I,
Variant::VECTOR3,
Variant::VECTOR3I,
Variant::TRANSFORM2D,
Variant::VECTOR4,
Variant::VECTOR4I,
Variant::PLANE,
Variant::QUATERNION,
Variant::AABB,
Variant::BASIS,
Variant::TRANSFORM3D,
Variant::PROJECTION,
Variant::COLOR,
Variant::STRING_NAME,
Variant::NODE_PATH,
Variant::RID,
Variant::CALLABLE
const VariantCsName var_types[] = {
{ Variant::BOOL, "bool" },
{ Variant::INT, "long" },
{ Variant::VECTOR2, "Vector2" },
{ Variant::VECTOR2I, "Vector2I" },
{ Variant::RECT2, "Rect2" },
{ Variant::RECT2I, "Rect2I" },
{ Variant::VECTOR3, "Vector3" },
{ Variant::VECTOR3I, "Vector3I" },
{ Variant::TRANSFORM2D, "Transform2D" },
{ Variant::VECTOR4, "Vector4" },
{ Variant::VECTOR4I, "Vector4I" },
{ Variant::PLANE, "Plane" },
{ Variant::QUATERNION, "Quaternion" },
{ Variant::AABB, "Aabb" },
{ Variant::BASIS, "Basis" },
{ Variant::TRANSFORM3D, "Transform3D" },
{ Variant::PROJECTION, "Projection" },
{ Variant::COLOR, "Color" },
{ Variant::STRING_NAME, "StringName" },
{ Variant::NODE_PATH, "NodePath" },
{ Variant::RID, "Rid" },
{ Variant::CALLABLE, "Callable" },
};
for (unsigned int i = 0; i < sizeof(var_types) / sizeof(Variant::Type); i++) {
if (p_var_type_name == Variant::get_type_name(var_types[i])) {
return p_var_type_name;
for (unsigned int i = 0; i < sizeof(var_types) / sizeof(VariantCsName); i++) {
if (p_var_type_name == Variant::get_type_name(var_types[i].variant_type)) {
return var_types[i].cs_type;
}
}

14
modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Sample/ExportedFields.cs
View File

@ -29,19 +29,19 @@ namespace Godot.SourceGenerators.Sample
// Godot structs
[Export] private Vector2 field_Vector2 = new(10f, 10f);
[Export] private Vector2i field_Vector2i = Vector2i.Up;
[Export] private Vector2I field_Vector2I = Vector2I.Up;
[Export] private Rect2 field_Rect2 = new(new Vector2(10f, 10f), new Vector2(10f, 10f));
[Export] private Rect2i field_Rect2i = new(new Vector2i(10, 10), new Vector2i(10, 10));
[Export] private Rect2I field_Rect2I = new(new Vector2I(10, 10), new Vector2I(10, 10));
[Export] private Transform2D field_Transform2D = Transform2D.Identity;
[Export] private Vector3 field_Vector3 = new(10f, 10f, 10f);
[Export] private Vector3i field_Vector3i = Vector3i.Back;
[Export] private Vector3I field_Vector3I = Vector3I.Back;
[Export] private Basis field_Basis = new Basis(Quaternion.Identity);
[Export] private Quaternion field_Quaternion = new Quaternion(Basis.Identity);
[Export] private Transform3D field_Transform3D = Transform3D.Identity;
[Export] private Vector4 field_Vector4 = new(10f, 10f, 10f, 10f);
[Export] private Vector4i field_Vector4i = Vector4i.One;
[Export] private Vector4I field_Vector4I = Vector4I.One;
[Export] private Projection field_Projection = Projection.Identity;
[Export] private AABB field_AABB = new AABB(10f, 10f, 10f, new Vector3(1f, 1f, 1f));
[Export] private Aabb field_Aabb = new Aabb(10f, 10f, 10f, new Vector3(1f, 1f, 1f));
[Export] private Color field_Color = Colors.Aquamarine;
[Export] private Plane field_Plane = Plane.PlaneXZ;
[Export] private Callable field_Callable = new Callable(Engine.GetMainLoop(), "_process");
@ -83,7 +83,7 @@ namespace Godot.SourceGenerators.Sample
[Export] private Godot.Object[] field_GodotObjectOrDerivedArray = { null };
[Export] private StringName[] field_StringNameArray = { "foo", "bar" };
[Export] private NodePath[] field_NodePathArray = { "foo", "bar" };
[Export] private RID[] field_RIDArray = { default, default, default };
[Export] private Rid[] field_RidArray = { default, default, default };
// Note we use Array and not System.Array. This tests the generated namespace qualification.
[Export] private Int32[] field_empty_Int32Array = Array.Empty<Int32>();
// Note we use List and not System.Collections.Generic.
@ -97,7 +97,7 @@ namespace Godot.SourceGenerators.Sample
[Export] private Godot.Texture field_GodotResourceTexture;
[Export] private StringName field_StringName = new StringName("foo");
[Export] private NodePath field_NodePath = new NodePath("foo");
[Export] private RID field_RID;
[Export] private Rid field_Rid;
[Export]
private Godot.Collections.Dictionary field_GodotDictionary =

14
modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Sample/ExportedProperties.cs
View File

@ -117,19 +117,19 @@ namespace Godot.SourceGenerators.Sample
// Godot structs
[Export] private Vector2 property_Vector2 { get; set; } = new(10f, 10f);
[Export] private Vector2i property_Vector2i { get; set; } = Vector2i.Up;
[Export] private Vector2I property_Vector2I { get; set; } = Vector2I.Up;
[Export] private Rect2 property_Rect2 { get; set; } = new(new Vector2(10f, 10f), new Vector2(10f, 10f));
[Export] private Rect2i property_Rect2i { get; set; } = new(new Vector2i(10, 10), new Vector2i(10, 10));
[Export] private Rect2I property_Rect2I { get; set; } = new(new Vector2I(10, 10), new Vector2I(10, 10));
[Export] private Transform2D property_Transform2D { get; set; } = Transform2D.Identity;
[Export] private Vector3 property_Vector3 { get; set; } = new(10f, 10f, 10f);
[Export] private Vector3i property_Vector3i { get; set; } = Vector3i.Back;
[Export] private Vector3I property_Vector3I { get; set; } = Vector3I.Back;
[Export] private Basis property_Basis { get; set; } = new Basis(Quaternion.Identity);
[Export] private Quaternion property_Quaternion { get; set; } = new Quaternion(Basis.Identity);
[Export] private Transform3D property_Transform3D { get; set; } = Transform3D.Identity;
[Export] private Vector4 property_Vector4 { get; set; } = new(10f, 10f, 10f, 10f);
[Export] private Vector4i property_Vector4i { get; set; } = Vector4i.One;
[Export] private Vector4I property_Vector4I { get; set; } = Vector4I.One;
[Export] private Projection property_Projection { get; set; } = Projection.Identity;
[Export] private AABB property_AABB { get; set; } = new AABB(10f, 10f, 10f, new Vector3(1f, 1f, 1f));
[Export] private Aabb property_Aabb { get; set; } = new Aabb(10f, 10f, 10f, new Vector3(1f, 1f, 1f));
[Export] private Color property_Color { get; set; } = Colors.Aquamarine;
[Export] private Plane property_Plane { get; set; } = Plane.PlaneXZ;
[Export] private Callable property_Callable { get; set; } = new Callable(Engine.GetMainLoop(), "_process");
@ -171,7 +171,7 @@ namespace Godot.SourceGenerators.Sample
[Export] private Godot.Object[] property_GodotObjectOrDerivedArray { get; set; } = { null };
[Export] private StringName[] field_StringNameArray { get; set; } = { "foo", "bar" };
[Export] private NodePath[] field_NodePathArray { get; set; } = { "foo", "bar" };
[Export] private RID[] field_RIDArray { get; set; } = { default, default, default };
[Export] private Rid[] field_RidArray { get; set; } = { default, default, default };
// Variant
[Export] private Variant property_Variant { get; set; } = "foo";
@ -181,7 +181,7 @@ namespace Godot.SourceGenerators.Sample
[Export] private Godot.Texture property_GodotResourceTexture { get; set; }
[Export] private StringName property_StringName { get; set; } = new StringName("foo");
[Export] private NodePath property_NodePath { get; set; } = new NodePath("foo");
[Export] private RID property_RID { get; set; }
[Export] private Rid property_Rid { get; set; }
[Export]
private Godot.Collections.Dictionary property_GodotDictionary { get; set; } =

2
modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/GodotClasses.cs
View File

@ -10,7 +10,7 @@ namespace Godot.SourceGenerators
public const string ExportSubgroupAttr = "Godot.ExportSubgroupAttribute";
public const string SignalAttr = "Godot.SignalAttribute";
public const string MustBeVariantAttr = "Godot.MustBeVariantAttribute";
public const string GodotClassNameAttr = "Godot.GodotClassName";
public const string GodotClassNameAttr = "Godot.GodotClassNameAttribute";
public const string SystemFlagsAttr = "System.FlagsAttribute";
}
}

24
modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/GodotEnums.cs
View File

@ -12,19 +12,19 @@ namespace Godot.SourceGenerators
Float = 3,
String = 4,
Vector2 = 5,
Vector2i = 6,
Vector2I = 6,
Rect2 = 7,
Rect2i = 8,
Rect2I = 8,
Vector3 = 9,
Vector3i = 10,
Transform2d = 11,
Vector3I = 10,
Transform2D = 11,
Vector4 = 12,
Vector4i = 13,
Vector4I = 13,
Plane = 14,
Quaternion = 15,
Aabb = 16,
Basis = 17,
Transform3d = 18,
Transform3D = 18,
Projection = 19,
Color = 20,
StringName = 21,
@ -56,12 +56,12 @@ namespace Godot.SourceGenerators
ExpEasing = 4,
Link = 5,
Flags = 6,
Layers2dRender = 7,
Layers2dPhysics = 8,
Layers2dNavigation = 9,
Layers3dRender = 10,
Layers3dPhysics = 11,
Layers3dNavigation = 12,
Layers2DRender = 7,
Layers2DPhysics = 8,
Layers2DNavigation = 9,
Layers3DRender = 10,
Layers3DPhysics = 11,
Layers3DNavigation = 12,
File = 13,
Dir = 14,
GlobalFile = 15,

14
modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/MarshalType.cs
View File

@ -21,19 +21,19 @@ namespace Godot.SourceGenerators
// Godot structs
Vector2,
Vector2i,
Vector2I,
Rect2,
Rect2i,
Rect2I,
Transform2D,
Vector3,
Vector3i,
Vector3I,
Basis,
Quaternion,
Transform3D,
Vector4,
Vector4i,
Vector4I,
Projection,
AABB,
Aabb,
Color,
Plane,
Callable,
@ -55,7 +55,7 @@ namespace Godot.SourceGenerators
GodotObjectOrDerivedArray,
SystemArrayOfStringName,
SystemArrayOfNodePath,
SystemArrayOfRID,
SystemArrayOfRid,
// Variant
Variant,
@ -64,7 +64,7 @@ namespace Godot.SourceGenerators
GodotObjectOrDerived,
StringName,
NodePath,
RID,
Rid,
GodotDictionary,
GodotArray,
GodotGenericDictionary,

34
modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators/MarshalUtils.cs
View File

@ -40,19 +40,19 @@ namespace Godot.SourceGenerators
MarshalType.Double => VariantType.Float,
MarshalType.String => VariantType.String,
MarshalType.Vector2 => VariantType.Vector2,
MarshalType.Vector2i => VariantType.Vector2i,
MarshalType.Vector2I => VariantType.Vector2I,
MarshalType.Rect2 => VariantType.Rect2,
MarshalType.Rect2i => VariantType.Rect2i,
MarshalType.Transform2D => VariantType.Transform2d,
MarshalType.Rect2I => VariantType.Rect2I,
MarshalType.Transform2D => VariantType.Transform2D,
MarshalType.Vector3 => VariantType.Vector3,
MarshalType.Vector3i => VariantType.Vector3i,
MarshalType.Vector3I => VariantType.Vector3I,
MarshalType.Basis => VariantType.Basis,
MarshalType.Quaternion => VariantType.Quaternion,
MarshalType.Transform3D => VariantType.Transform3d,
MarshalType.Transform3D => VariantType.Transform3D,
MarshalType.Vector4 => VariantType.Vector4,
MarshalType.Vector4i => VariantType.Vector4i,
MarshalType.Vector4I => VariantType.Vector4I,
MarshalType.Projection => VariantType.Projection,
MarshalType.AABB => VariantType.Aabb,
MarshalType.Aabb => VariantType.Aabb,
MarshalType.Color => VariantType.Color,
MarshalType.Plane => VariantType.Plane,
MarshalType.Callable => VariantType.Callable,
@ -70,12 +70,12 @@ namespace Godot.SourceGenerators
MarshalType.GodotObjectOrDerivedArray => VariantType.Array,
MarshalType.SystemArrayOfStringName => VariantType.Array,
MarshalType.SystemArrayOfNodePath => VariantType.Array,
MarshalType.SystemArrayOfRID => VariantType.Array,
MarshalType.SystemArrayOfRid => VariantType.Array,
MarshalType.Variant => VariantType.Nil,
MarshalType.GodotObjectOrDerived => VariantType.Object,
MarshalType.StringName => VariantType.StringName,
MarshalType.NodePath => VariantType.NodePath,
MarshalType.RID => VariantType.Rid,
MarshalType.Rid => VariantType.Rid,
MarshalType.GodotDictionary => VariantType.Dictionary,
MarshalType.GodotArray => VariantType.Array,
MarshalType.GodotGenericDictionary => VariantType.Dictionary,
@ -130,22 +130,22 @@ namespace Godot.SourceGenerators
return type switch
{
{ Name: "Vector2" } => MarshalType.Vector2,
{ Name: "Vector2i" } => MarshalType.Vector2i,
{ Name: "Vector2I" } => MarshalType.Vector2I,
{ Name: "Rect2" } => MarshalType.Rect2,
{ Name: "Rect2i" } => MarshalType.Rect2i,
{ Name: "Rect2I" } => MarshalType.Rect2I,
{ Name: "Transform2D" } => MarshalType.Transform2D,
{ Name: "Vector3" } => MarshalType.Vector3,
{ Name: "Vector3i" } => MarshalType.Vector3i,
{ Name: "Vector3I" } => MarshalType.Vector3I,
{ Name: "Basis" } => MarshalType.Basis,
{ Name: "Quaternion" } => MarshalType.Quaternion,
{ Name: "Transform3D" } => MarshalType.Transform3D,
{ Name: "Vector4" } => MarshalType.Vector4,
{ Name: "Vector4i" } => MarshalType.Vector4i,
{ Name: "Vector4I" } => MarshalType.Vector4I,
{ Name: "Projection" } => MarshalType.Projection,
{ Name: "AABB" } => MarshalType.AABB,
{ Name: "Aabb" } => MarshalType.Aabb,
{ Name: "Color" } => MarshalType.Color,
{ Name: "Plane" } => MarshalType.Plane,
{ Name: "RID" } => MarshalType.RID,
{ Name: "Rid" } => MarshalType.Rid,
{ Name: "Callable" } => MarshalType.Callable,
{ Name: "Signal" } => MarshalType.Signal,
{ Name: "Variant" } => MarshalType.Variant,
@ -196,8 +196,8 @@ namespace Godot.SourceGenerators
return MarshalType.SystemArrayOfStringName;
case { Name: "NodePath" }:
return MarshalType.SystemArrayOfNodePath;
case { Name: "RID" }:
return MarshalType.SystemArrayOfRID;
case { Name: "Rid" }:
return MarshalType.SystemArrayOfRid;
}
}

2
modules/mono/editor/GodotTools/GodotTools/Build/BuildInfo.cs
View File

@ -23,7 +23,7 @@ namespace GodotTools.Build
public Godot.Collections.Array CustomProperties { get; private set; } = new();
public string LogsDirPath =>
Path.Combine(GodotSharpDirs.BuildLogsDirs, $"{Solution.MD5Text()}_{Configuration}");
Path.Combine(GodotSharpDirs.BuildLogsDirs, $"{Solution.Md5Text()}_{Configuration}");
public override bool Equals(object? obj)
{

2
modules/mono/editor/GodotTools/GodotTools/Build/BuildManager.cs
View File

@ -55,7 +55,7 @@ namespace GodotTools.Build
private static void PrintVerbose(string text)
{
if (OS.IsStdoutVerbose())
if (OS.IsStdOutVerbose())
GD.Print(text);
}

4
modules/mono/editor/GodotTools/GodotTools/Build/BuildOutputView.cs
View File

@ -336,7 +336,7 @@ namespace GodotTools.Build
_ = index; // Unused
_issuesListContextMenu.Clear();
_issuesListContextMenu.Size = new Vector2i(1, 1);
_issuesListContextMenu.Size = new Vector2I(1, 1);
if (_issuesList.IsAnythingSelected())
{
@ -347,7 +347,7 @@ namespace GodotTools.Build
if (_issuesListContextMenu.ItemCount > 0)
{
_issuesListContextMenu.Position = (Vector2i)(_issuesList.GlobalPosition + atPosition);
_issuesListContextMenu.Position = (Vector2I)(_issuesList.GlobalPosition + atPosition);
_issuesListContextMenu.Popup();
}
}

4
modules/mono/editor/GodotTools/GodotTools/Build/BuildSystem.cs
View File

@ -28,7 +28,7 @@ namespace GodotTools.Build
string launchMessage = startInfo.GetCommandLineDisplay(new StringBuilder("Running: ")).ToString();
stdOutHandler?.Invoke(launchMessage);
if (Godot.OS.IsStdoutVerbose())
if (Godot.OS.IsStdOutVerbose())
Console.WriteLine(launchMessage);
startInfo.RedirectStandardOutput = true;
@ -89,7 +89,7 @@ namespace GodotTools.Build
string launchMessage = startInfo.GetCommandLineDisplay(new StringBuilder("Running: ")).ToString();
stdOutHandler?.Invoke(launchMessage);
if (Godot.OS.IsStdoutVerbose())
if (Godot.OS.IsStdOutVerbose())
Console.WriteLine(launchMessage);
startInfo.RedirectStandardOutput = true;

2
modules/mono/editor/GodotTools/GodotTools/Build/MSBuildPanel.cs
View File

@ -122,7 +122,7 @@ namespace GodotTools.Build
{
base._Ready();
CustomMinimumSize = new Vector2i(0, (int)(228 * EditorScale));
CustomMinimumSize = new Vector2(0, 228 * EditorScale);
SizeFlagsVertical = SizeFlags.ExpandFill;
var toolBarHBox = new HBoxContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };

8
modules/mono/editor/GodotTools/GodotTools/GodotSharpEditor.cs
View File

@ -192,7 +192,7 @@ namespace GodotTools
try
{
if (Godot.OS.IsStdoutVerbose())
if (Godot.OS.IsStdOutVerbose())
Console.WriteLine(
$"Running: \"{command}\" {string.Join(" ", args.Select(a => $"\"{a}\""))}");
@ -385,7 +385,7 @@ namespace GodotTools
// correct version first (`RegisterDefaults` always picks the latest).
if (DotNetFinder.TryFindDotNetSdk(dotNetSdkSearchVersion, out var sdkVersion, out string sdkPath))
{
if (Godot.OS.IsStdoutVerbose())
if (Godot.OS.IsStdOutVerbose())
Console.WriteLine($"Found .NET Sdk version '{sdkVersion}': {sdkPath}");
ProjectUtils.MSBuildLocatorRegisterMSBuildPath(sdkPath);
@ -395,12 +395,12 @@ namespace GodotTools
try
{
ProjectUtils.MSBuildLocatorRegisterDefaults(out sdkVersion, out sdkPath);
if (Godot.OS.IsStdoutVerbose())
if (Godot.OS.IsStdOutVerbose())
Console.WriteLine($"Found .NET Sdk version '{sdkVersion}': {sdkPath}");
}
catch (InvalidOperationException e)
{
if (Godot.OS.IsStdoutVerbose())
if (Godot.OS.IsStdOutVerbose())
GD.PrintErr(e.ToString());
GD.PushError($".NET Sdk not found. The required version is '{dotNetSdkSearchVersion}'.");
}

2
modules/mono/editor/GodotTools/GodotTools/HotReloadAssemblyWatcher.cs
View File

@ -11,7 +11,7 @@ namespace GodotTools
public override void _Notification(long what)
{
if (what == Node.NotificationWmWindowFocusIn)
if (what == Node.NotificationWMWindowFocusIn)
{
RestartTimer();

4
modules/mono/editor/GodotTools/GodotTools/Ides/GodotIdeManager.cs
View File

@ -200,13 +200,13 @@ namespace GodotTools.Ides
{
public void LogDebug(string message)
{
if (OS.IsStdoutVerbose())
if (OS.IsStdOutVerbose())
Console.WriteLine(message);
}
public void LogInfo(string message)
{
if (OS.IsStdoutVerbose())
if (OS.IsStdOutVerbose())
Console.WriteLine(message);
}

146
modules/mono/editor/bindings_generator.cpp
View File

@ -38,10 +38,10 @@
#include "core/io/dir_access.h"
#include "core/io/file_access.h"
#include "core/os/os.h"
#include "core/string/ucaps.h"
#include "main/main.h"
#include "../godotsharp_defs.h"
#include "../utils/naming_utils.h"
#include "../utils/path_utils.h"
#include "../utils/string_utils.h"
@ -146,74 +146,6 @@ static String fix_doc_description(const String &p_bbcode) {
.strip_edges();
}
static String snake_to_pascal_case(const String &p_identifier, bool p_input_is_upper = false) {
String ret;
Vector<String> parts = p_identifier.split("_", true);
for (int i = 0; i < parts.size(); i++) {
String part = parts[i];
if (part.length()) {
part[0] = _find_upper(part[0]);
if (p_input_is_upper) {
for (int j = 1; j < part.length(); j++) {
part[j] = _find_lower(part[j]);
}
}
ret += part;
} else {
if (i == 0 || i == (parts.size() - 1)) {
// Preserve underscores at the beginning and end
ret += "_";
} else {
// Preserve contiguous underscores
if (parts[i - 1].length()) {
ret += "__";
} else {
ret += "_";
}
}
}
}
return ret;
}
static String snake_to_camel_case(const String &p_identifier, bool p_input_is_upper = false) {
String ret;
Vector<String> parts = p_identifier.split("_", true);
for (int i = 0; i < parts.size(); i++) {
String part = parts[i];
if (part.length()) {
if (i != 0) {
part[0] = _find_upper(part[0]);
}
if (p_input_is_upper) {
for (int j = i != 0 ? 1 : 0; j < part.length(); j++) {
part[j] = _find_lower(part[j]);
}
}
ret += part;
} else {
if (i == 0 || i == (parts.size() - 1)) {
// Preserve underscores at the beginning and end
ret += "_";
} else {
// Preserve contiguous underscores
if (parts[i - 1].length()) {
ret += "__";
} else {
ret += "_";
}
}
}
}
return ret;
}
String BindingsGenerator::bbcode_to_xml(const String &p_bbcode, const TypeInterface *p_itype) {
// Based on the version in EditorHelp
@ -967,11 +899,11 @@ void BindingsGenerator::_generate_array_extensions(StringBuilder &p_output) {
ARRAY_ALL(string);
ARRAY_ALL(Color);
ARRAY_ALL(Vector2);
ARRAY_ALL(Vector2i);
ARRAY_ALL(Vector2I);
ARRAY_ALL(Vector3);
ARRAY_ALL(Vector3i);
ARRAY_ALL(Vector3I);
ARRAY_ALL(Vector4);
ARRAY_ALL(Vector4i);
ARRAY_ALL(Vector4I);
#undef ARRAY_ALL
#undef ARRAY_IS_EMPTY
@ -1041,7 +973,7 @@ void BindingsGenerator::_generate_global_constants(StringBuilder &p_output) {
_log("Declaring global enum '%s' inside struct '%s'\n", enum_proxy_name.utf8().get_data(), enum_class_name.utf8().get_data());
p_output.append("\npublic partial struct ");
p_output.append(enum_class_name);
p_output.append(pascal_to_pascal_case(enum_class_name));
p_output.append("\n" OPEN_BLOCK);
}
@ -1050,7 +982,7 @@ void BindingsGenerator::_generate_global_constants(StringBuilder &p_output) {
}
p_output.append("\npublic enum ");
p_output.append(enum_proxy_name);
p_output.append(pascal_to_pascal_case(enum_proxy_name));
p_output.append(" : long");
p_output.append("\n" OPEN_BLOCK);
@ -1502,7 +1434,7 @@ Error BindingsGenerator::_generate_cs_type(const TypeInterface &itype, const Str
}
output.append(MEMBER_BEGIN "public enum ");
output.append(ienum.cname.operator String());
output.append(pascal_to_pascal_case(ienum.cname.operator String()));
output.append(" : long");
output.append(MEMBER_BEGIN OPEN_BLOCK);
@ -2896,7 +2828,7 @@ bool BindingsGenerator::_populate_object_type_interfaces() {
ClassDB::ClassInfo *class_info = ClassDB::classes.getptr(type_cname);
TypeInterface itype = TypeInterface::create_object_type(type_cname, api_type);
TypeInterface itype = TypeInterface::create_object_type(type_cname, pascal_to_pascal_case(type_cname), api_type);
itype.base_name = ClassDB::get_parent_class(type_cname);
itype.is_singleton = Engine::get_singleton()->has_singleton(itype.proxy_name);
@ -3241,7 +3173,7 @@ bool BindingsGenerator::_populate_object_type_interfaces() {
for (const KeyValue<StringName, ClassDB::ClassInfo::EnumInfo> &E : enum_map) {
StringName enum_proxy_cname = E.key;
String enum_proxy_name = enum_proxy_cname.operator String();
String enum_proxy_name = pascal_to_pascal_case(enum_proxy_cname.operator String());
if (itype.find_property_by_proxy_name(enum_proxy_name) || itype.find_method_by_proxy_name(enum_proxy_name) || itype.find_signal_by_proxy_name(enum_proxy_name)) {
// In case the enum name conflicts with other PascalCase members,
// we append 'Enum' to the enum name in those cases.
@ -3369,7 +3301,7 @@ bool BindingsGenerator::_arg_default_value_from_variant(const Variant &p_val, Ar
} break;
case Variant::AABB: {
AABB aabb = p_val.operator ::AABB();
r_iarg.default_argument = "new AABB(new Vector3" + aabb.position.operator String() + ", new Vector3" + aabb.size.operator String() + ")";
r_iarg.default_argument = "new Aabb(new Vector3" + aabb.position.operator String() + ", new Vector3" + aabb.size.operator String() + ")";
r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL;
} break;
case Variant::RECT2: {
@ -3379,7 +3311,7 @@ bool BindingsGenerator::_arg_default_value_from_variant(const Variant &p_val, Ar
} break;
case Variant::RECT2I: {
Rect2i rect = p_val.operator Rect2i();
r_iarg.default_argument = "new Rect2i(new Vector2i" + rect.position.operator String() + ", new Vector2i" + rect.size.operator String() + ")";
r_iarg.default_argument = "new Rect2I(new Vector2I" + rect.position.operator String() + ", new Vector2I" + rect.size.operator String() + ")";
r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL;
} break;
case Variant::COLOR:
@ -3513,32 +3445,30 @@ void BindingsGenerator::_populate_builtin_type_interfaces() {
TypeInterface itype;
#define INSERT_STRUCT_TYPE(m_type) \
{ \
itype = TypeInterface::create_value_type(String(#m_type)); \
itype.c_type_in = #m_type "*"; \
itype.c_type_out = itype.cs_type; \
itype.cs_in_expr = "&%0"; \
itype.cs_in_expr_is_unsafe = true; \
builtin_types.insert(itype.cname, itype); \
#define INSERT_STRUCT_TYPE(m_type, m_proxy_name) \
{ \
itype = TypeInterface::create_value_type(String(#m_type), String(#m_proxy_name)); \
itype.cs_in_expr = "&%0"; \
itype.cs_in_expr_is_unsafe = true; \
builtin_types.insert(itype.cname, itype); \
}
INSERT_STRUCT_TYPE(Vector2)
INSERT_STRUCT_TYPE(Vector2i)
INSERT_STRUCT_TYPE(Rect2)
INSERT_STRUCT_TYPE(Rect2i)
INSERT_STRUCT_TYPE(Transform2D)
INSERT_STRUCT_TYPE(Vector3)
INSERT_STRUCT_TYPE(Vector3i)
INSERT_STRUCT_TYPE(Basis)
INSERT_STRUCT_TYPE(Quaternion)
INSERT_STRUCT_TYPE(Transform3D)
INSERT_STRUCT_TYPE(AABB)
INSERT_STRUCT_TYPE(Color)
INSERT_STRUCT_TYPE(Plane)
INSERT_STRUCT_TYPE(Vector4)
INSERT_STRUCT_TYPE(Vector4i)
INSERT_STRUCT_TYPE(Projection)
INSERT_STRUCT_TYPE(Vector2, Vector2)
INSERT_STRUCT_TYPE(Vector2i, Vector2I)
INSERT_STRUCT_TYPE(Rect2, Rect2)
INSERT_STRUCT_TYPE(Rect2i, Rect2I)
INSERT_STRUCT_TYPE(Transform2D, Transform2D)
INSERT_STRUCT_TYPE(Vector3, Vector3)
INSERT_STRUCT_TYPE(Vector3i, Vector3I)
INSERT_STRUCT_TYPE(Basis, Basis)
INSERT_STRUCT_TYPE(Quaternion, Quaternion)
INSERT_STRUCT_TYPE(Transform3D, Transform3D)
INSERT_STRUCT_TYPE(AABB, Aabb)
INSERT_STRUCT_TYPE(Color, Color)
INSERT_STRUCT_TYPE(Plane, Plane)
INSERT_STRUCT_TYPE(Vector4, Vector4)
INSERT_STRUCT_TYPE(Vector4i, Vector4I)
INSERT_STRUCT_TYPE(Projection, Projection)
#undef INSERT_STRUCT_TYPE
@ -3677,7 +3607,7 @@ void BindingsGenerator::_populate_builtin_type_interfaces() {
itype = TypeInterface();
itype.name = "RID";
itype.cname = itype.name;
itype.proxy_name = "RID";
itype.proxy_name = "Rid";
itype.cs_type = itype.proxy_name;
itype.c_arg_in = "&%s";
itype.c_type = itype.cs_type;
@ -3891,7 +3821,7 @@ void BindingsGenerator::_populate_global_constants() {
enum_itype.is_enum = true;
enum_itype.name = ienum.cname.operator String();
enum_itype.cname = ienum.cname;
enum_itype.proxy_name = enum_itype.name;
enum_itype.proxy_name = pascal_to_pascal_case(enum_itype.name);
TypeInterface::postsetup_enum_type(enum_itype);
enum_types.insert(enum_itype.cname, enum_itype);
@ -3913,9 +3843,9 @@ void BindingsGenerator::_populate_global_constants() {
// HARDCODED
List<StringName> hardcoded_enums;
hardcoded_enums.push_back("Vector2.Axis");
hardcoded_enums.push_back("Vector2i.Axis");
hardcoded_enums.push_back("Vector2I.Axis");
hardcoded_enums.push_back("Vector3.Axis");
hardcoded_enums.push_back("Vector3i.Axis");
hardcoded_enums.push_back("Vector3I.Axis");
for (const StringName &enum_cname : hardcoded_enums) {
// These enums are not generated and must be written manually (e.g.: Vector3.Axis)
// Here, we assume core types do not begin with underscore
@ -3923,7 +3853,7 @@ void BindingsGenerator::_populate_global_constants() {
enum_itype.is_enum = true;
enum_itype.name = enum_cname.operator String();
enum_itype.cname = enum_cname;
enum_itype.proxy_name = enum_itype.name;
enum_itype.proxy_name = pascal_to_pascal_case(enum_itype.name);
TypeInterface::postsetup_enum_type(enum_itype);
enum_types.insert(enum_itype.cname, enum_itype);
}

77
modules/mono/editor/bindings_generator.h
View File

@ -472,43 +472,88 @@ class BindingsGenerator {
}
private:
static void _init_value_type(TypeInterface &itype) {
itype.proxy_name = itype.name;
static DocData::ClassDoc *_get_type_doc(TypeInterface &itype) {
String doc_name = itype.name.begins_with("_") ? itype.name.substr(1) : itype.name;
return &EditorHelp::get_doc_data()->class_list[doc_name];
}
static void _init_value_type(TypeInterface &itype) {
if (itype.proxy_name.is_empty()) {
itype.proxy_name = itype.name;
}
itype.c_type = itype.name;
itype.cs_type = itype.proxy_name;
itype.c_type_in = itype.proxy_name + "*";
itype.c_type_out = itype.proxy_name;
itype.class_doc = &EditorHelp::get_doc_data()->class_list[itype.proxy_name];
itype.c_type = itype.cs_type;
itype.c_type_in = itype.cs_type + "*";
itype.c_type_out = itype.cs_type;
itype.class_doc = _get_type_doc(itype);
}
static void _init_object_type(TypeInterface &itype, ClassDB::APIType p_api_type) {
if (itype.proxy_name.is_empty()) {
itype.proxy_name = itype.name;
}
if (itype.proxy_name.begins_with("_")) {
itype.proxy_name = itype.proxy_name.substr(1);
}
itype.api_type = p_api_type;
itype.is_object_type = true;
itype.class_doc = _get_type_doc(itype);
}
public:
static TypeInterface create_value_type(const String &p_name) {
static TypeInterface create_value_type(const String &p_name, const String &p_proxy_name) {
TypeInterface itype;
itype.name = p_name;
itype.cname = StringName(p_name);
itype.cname = p_name;
itype.proxy_name = p_proxy_name;
_init_value_type(itype);
return itype;
}
static TypeInterface create_value_type(const StringName &p_name) {
static TypeInterface create_value_type(const StringName &p_cname, const String &p_proxy_name) {
TypeInterface itype;
itype.name = p_name.operator String();
itype.name = p_cname;
itype.cname = p_cname;
itype.proxy_name = p_proxy_name;
_init_value_type(itype);
return itype;
}
static TypeInterface create_value_type(const String &p_name) {
TypeInterface itype;
itype.name = p_name;
itype.cname = p_name;
_init_value_type(itype);
return itype;
}
static TypeInterface create_object_type(const StringName &p_cname, ClassDB::APIType p_api_type) {
static TypeInterface create_value_type(const StringName &p_cname) {
TypeInterface itype;
itype.name = p_cname;
itype.cname = p_cname;
itype.proxy_name = itype.name.begins_with("_") ? itype.name.substr(1, itype.name.length()) : itype.name;
itype.api_type = p_api_type;
itype.is_object_type = true;
itype.class_doc = &EditorHelp::get_doc_data()->class_list[itype.proxy_name];
_init_value_type(itype);
return itype;
}
static TypeInterface create_object_type(const StringName &p_cname, const String &p_proxy_name, ClassDB::APIType p_api_type) {
TypeInterface itype;
itype.name = p_cname;
itype.cname = p_cname;
itype.proxy_name = p_proxy_name;
_init_object_type(itype, p_api_type);
return itype;
}
static TypeInterface create_object_type(const StringName &p_cname, ClassDB::APIType p_api_type) {
TypeInterface itype;
itype.name = p_cname;
itype.cname = p_cname;
_init_object_type(itype, p_api_type);
return itype;
}

8
modules/mono/editor/script_templates/CharacterBody2D/basic_movement.cs
View File

@ -17,22 +17,22 @@ public partial class _CLASS_ : _BASE_
// Add the gravity.
if (!IsOnFloor())
velocity.y += gravity * (float)delta;
velocity.Y += gravity * (float)delta;
// Handle Jump.
if (Input.IsActionJustPressed("ui_accept") && IsOnFloor())
velocity.y = JumpVelocity;
velocity.Y = JumpVelocity;
// Get the input direction and handle the movement/deceleration.
// As good practice, you should replace UI actions with custom gameplay actions.
Vector2 direction = Input.GetVector("ui_left", "ui_right", "ui_up", "ui_down");
if (direction != Vector2.Zero)
{
velocity.x = direction.x * Speed;
velocity.X = direction.X * Speed;
}
else
{
velocity.x = Mathf.MoveToward(Velocity.x, 0, Speed);
velocity.X = Mathf.MoveToward(Velocity.X, 0, Speed);
}
Velocity = velocity;

14
modules/mono/editor/script_templates/CharacterBody3D/basic_movement.cs
View File

@ -17,25 +17,25 @@ public partial class _CLASS_ : _BASE_
// Add the gravity.
if (!IsOnFloor())
velocity.y -= gravity * (float)delta;
velocity.Y -= gravity * (float)delta;
// Handle Jump.
if (Input.IsActionJustPressed("ui_accept") && IsOnFloor())
velocity.y = JumpVelocity;
velocity.Y = JumpVelocity;
// Get the input direction and handle the movement/deceleration.
// As good practice, you should replace UI actions with custom gameplay actions.
Vector2 inputDir = Input.GetVector("ui_left", "ui_right", "ui_up", "ui_down");
Vector3 direction = (Transform.basis * new Vector3(inputDir.x, 0, inputDir.y)).Normalized();
Vector3 direction = (Transform.Basis * new Vector3(inputDir.X, 0, inputDir.Y)).Normalized();
if (direction != Vector3.Zero)
{
velocity.x = direction.x * Speed;
velocity.z = direction.z * Speed;
velocity.X = direction.X * Speed;
velocity.Z = direction.Z * Speed;
}
else
{
velocity.x = Mathf.MoveToward(Velocity.x, 0, Speed);
velocity.z = Mathf.MoveToward(Velocity.z, 0, Speed);
velocity.X = Mathf.MoveToward(Velocity.X, 0, Speed);
velocity.Z = Mathf.MoveToward(Velocity.Z, 0, Speed);
}
Velocity = velocity;

356
modules/mono/glue/GodotSharp/GodotSharp/Core/AABB.cs → modules/mono/glue/GodotSharp/GodotSharp/Core/Aabb.cs
View File

@ -9,7 +9,7 @@ namespace Godot
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct AABB : IEquatable<AABB>
public struct Aabb : IEquatable<Aabb>
{
private Vector3 _position;
private Vector3 _size;
@ -50,19 +50,19 @@ namespace Godot
}
/// <summary>
/// Returns an <see cref="AABB"/> with equivalent position and size, modified so that
/// Returns an <see cref="Aabb"/> with equivalent position and size, modified so that
/// the most-negative corner is the origin and the size is positive.
/// </summary>
/// <returns>The modified <see cref="AABB"/>.</returns>
public readonly AABB Abs()
/// <returns>The modified <see cref="Aabb"/>.</returns>
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));
return new AABB(topLeft, _size.Abs());
Vector3 topLeft = new Vector3(Mathf.Min(_position.X, end.X), Mathf.Min(_position.Y, end.Y), Mathf.Min(_position.Z, end.Z));
return new Aabb(topLeft, _size.Abs());
}
/// <summary>
/// Returns the center of the <see cref="AABB"/>, which is equal
/// Returns the center of the <see cref="Aabb"/>, which is equal
/// to <see cref="Position"/> + (<see cref="Size"/> / 2).
/// </summary>
/// <returns>The center.</returns>
@ -72,94 +72,94 @@ namespace Godot
}
/// <summary>
/// Returns <see langword="true"/> if this <see cref="AABB"/> completely encloses another one.
/// Returns <see langword="true"/> if this <see cref="Aabb"/> completely encloses another one.
/// </summary>
/// <param name="with">The other <see cref="AABB"/> that may be enclosed.</param>
/// <param name="with">The other <see cref="Aabb"/> that may be enclosed.</param>
/// <returns>
/// A <see langword="bool"/> for whether or not this <see cref="AABB"/> encloses <paramref name="with"/>.
/// A <see langword="bool"/> for whether or not this <see cref="Aabb"/> encloses <paramref name="with"/>.
/// </returns>
public readonly bool Encloses(AABB with)
public readonly bool Encloses(Aabb with)
{
Vector3 srcMin = _position;
Vector3 srcMax = _position + _size;
Vector3 dstMin = with._position;
Vector3 dstMax = with._position + with._size;
return srcMin.x <= dstMin.x &&
srcMax.x > dstMax.x &&
srcMin.y <= dstMin.y &&
srcMax.y > dstMax.y &&
srcMin.z <= dstMin.z &&
srcMax.z > dstMax.z;
return srcMin.X <= dstMin.X &&
srcMax.X > dstMax.X &&
srcMin.Y <= dstMin.Y &&
srcMax.Y > dstMax.Y &&
srcMin.Z <= dstMin.Z &&
srcMax.Z > dstMax.Z;
}
/// <summary>
/// Returns this <see cref="AABB"/> expanded to include a given point.
/// Returns this <see cref="Aabb"/> expanded to include a given point.
/// </summary>
/// <param name="point">The point to include.</param>
/// <returns>The expanded <see cref="AABB"/>.</returns>
public readonly AABB Expand(Vector3 point)
/// <returns>The expanded <see cref="Aabb"/>.</returns>
public readonly Aabb Expand(Vector3 point)
{
Vector3 begin = _position;
Vector3 end = _position + _size;
if (point.x < begin.x)
if (point.X < begin.X)
{
begin.x = point.x;
begin.X = point.X;
}
if (point.y < begin.y)
if (point.Y < begin.Y)
{
begin.y = point.y;
begin.Y = point.Y;
}
if (point.z < begin.z)
if (point.Z < begin.Z)
{
begin.z = point.z;
begin.Z = point.Z;
}
if (point.x > end.x)
if (point.X > end.X)
{
end.x = point.x;
end.X = point.X;
}
if (point.y > end.y)
if (point.Y > end.Y)
{
end.y = point.y;
end.Y = point.Y;
}
if (point.z > end.z)
if (point.Z > end.Z)
{
end.z = point.z;
end.Z = point.Z;
}
return new AABB(begin, end - begin);
return new Aabb(begin, end - begin);
}
/// <summary>
/// Gets the position of one of the 8 endpoints of the <see cref="AABB"/>.
/// Gets the position of one of the 8 endpoints of the <see cref="Aabb"/>.
/// </summary>
/// <param name="idx">Which endpoint to get.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="idx"/> is less than 0 or greater than 7.
/// </exception>
/// <returns>An endpoint of the <see cref="AABB"/>.</returns>
/// <returns>An endpoint of the <see cref="Aabb"/>.</returns>
public readonly Vector3 GetEndpoint(int idx)
{
switch (idx)
{
case 0:
return new Vector3(_position.x, _position.y, _position.z);
return new Vector3(_position.X, _position.Y, _position.Z);
case 1:
return new Vector3(_position.x, _position.y, _position.z + _size.z);
return new Vector3(_position.X, _position.Y, _position.Z + _size.Z);
case 2:
return new Vector3(_position.x, _position.y + _size.y, _position.z);
return new Vector3(_position.X, _position.Y + _size.Y, _position.Z);
case 3:
return new Vector3(_position.x, _position.y + _size.y, _position.z + _size.z);
return new Vector3(_position.X, _position.Y + _size.Y, _position.Z + _size.Z);
case 4:
return new Vector3(_position.x + _size.x, _position.y, _position.z);
return new Vector3(_position.X + _size.X, _position.Y, _position.Z);
case 5:
return new Vector3(_position.x + _size.x, _position.y, _position.z + _size.z);
return new Vector3(_position.X + _size.X, _position.Y, _position.Z + _size.Z);
case 6:
return new Vector3(_position.x + _size.x, _position.y + _size.y, _position.z);
return new Vector3(_position.X + _size.X, _position.Y + _size.Y, _position.Z);
case 7:
return new Vector3(_position.x + _size.x, _position.y + _size.y, _position.z + _size.z);
return new Vector3(_position.X + _size.X, _position.Y + _size.Y, _position.Z + _size.Z);
default:
{
throw new ArgumentOutOfRangeException(nameof(idx),
@ -169,21 +169,21 @@ namespace Godot
}
/// <summary>
/// Returns the normalized longest axis of the <see cref="AABB"/>.
/// Returns the normalized longest axis of the <see cref="Aabb"/>.
/// </summary>
/// <returns>A vector representing the normalized longest axis of the <see cref="AABB"/>.</returns>
/// <returns>A vector representing the normalized longest axis of the <see cref="Aabb"/>.</returns>
public readonly Vector3 GetLongestAxis()
{
var axis = new Vector3(1f, 0f, 0f);
real_t maxSize = _size.x;
real_t maxSize = _size.X;
if (_size.y > maxSize)
if (_size.Y > maxSize)
{
axis = new Vector3(0f, 1f, 0f);
maxSize = _size.y;
maxSize = _size.Y;
}
if (_size.z > maxSize)
if (_size.Z > maxSize)
{
axis = new Vector3(0f, 0f, 1f);
}
@ -192,21 +192,21 @@ namespace Godot
}
/// <summary>
/// Returns the <see cref="Vector3.Axis"/> index of the longest axis of the <see cref="AABB"/>.
/// Returns the <see cref="Vector3.Axis"/> index of the longest axis of the <see cref="Aabb"/>.
/// </summary>
/// <returns>A <see cref="Vector3.Axis"/> index for which axis is longest.</returns>
public readonly Vector3.Axis GetLongestAxisIndex()
{
var axis = Vector3.Axis.X;
real_t maxSize = _size.x;
real_t maxSize = _size.X;
if (_size.y > maxSize)
if (_size.Y > maxSize)
{
axis = Vector3.Axis.Y;
maxSize = _size.y;
maxSize = _size.Y;
}
if (_size.z > maxSize)
if (_size.Z > maxSize)
{
axis = Vector3.Axis.Z;
}
@ -215,38 +215,38 @@ namespace Godot
}
/// <summary>
/// Returns the scalar length of the longest axis of the <see cref="AABB"/>.
/// Returns the scalar length of the longest axis of the <see cref="Aabb"/>.
/// </summary>
/// <returns>The scalar length of the longest axis of the <see cref="AABB"/>.</returns>
/// <returns>The scalar length of the longest axis of the <see cref="Aabb"/>.</returns>
public readonly real_t GetLongestAxisSize()
{
real_t maxSize = _size.x;
real_t maxSize = _size.X;
if (_size.y > maxSize)
maxSize = _size.y;
if (_size.Y > maxSize)
maxSize = _size.Y;
if (_size.z > maxSize)
maxSize = _size.z;
if (_size.Z > maxSize)
maxSize = _size.Z;
return maxSize;
}
/// <summary>
/// Returns the normalized shortest axis of the <see cref="AABB"/>.
/// Returns the normalized shortest axis of the <see cref="Aabb"/>.
/// </summary>
/// <returns>A vector representing the normalized shortest axis of the <see cref="AABB"/>.</returns>
/// <returns>A vector representing the normalized shortest axis of the <see cref="Aabb"/>.</returns>
public readonly Vector3 GetShortestAxis()
{
var axis = new Vector3(1f, 0f, 0f);
real_t maxSize = _size.x;
real_t maxSize = _size.X;
if (_size.y < maxSize)
if (_size.Y < maxSize)
{
axis = new Vector3(0f, 1f, 0f);
maxSize = _size.y;
maxSize = _size.Y;
}
if (_size.z < maxSize)
if (_size.Z < maxSize)
{
axis = new Vector3(0f, 0f, 1f);
}
@ -255,21 +255,21 @@ namespace Godot
}
/// <summary>
/// Returns the <see cref="Vector3.Axis"/> index of the shortest axis of the <see cref="AABB"/>.
/// Returns the <see cref="Vector3.Axis"/> index of the shortest axis of the <see cref="Aabb"/>.
/// </summary>
/// <returns>A <see cref="Vector3.Axis"/> index for which axis is shortest.</returns>
public readonly Vector3.Axis GetShortestAxisIndex()
{
var axis = Vector3.Axis.X;
real_t maxSize = _size.x;
real_t maxSize = _size.X;
if (_size.y < maxSize)
if (_size.Y < maxSize)
{
axis = Vector3.Axis.Y;
maxSize = _size.y;
maxSize = _size.Y;
}
if (_size.z < maxSize)
if (_size.Z < maxSize)
{
axis = Vector3.Axis.Z;
}
@ -278,18 +278,18 @@ namespace Godot
}
/// <summary>
/// Returns the scalar length of the shortest axis of the <see cref="AABB"/>.
/// Returns the scalar length of the shortest axis of the <see cref="Aabb"/>.
/// </summary>
/// <returns>The scalar length of the shortest axis of the <see cref="AABB"/>.</returns>
/// <returns>The scalar length of the shortest axis of the <see cref="Aabb"/>.</returns>
public readonly real_t GetShortestAxisSize()
{
real_t maxSize = _size.x;
real_t maxSize = _size.X;
if (_size.y < maxSize)
maxSize = _size.y;
if (_size.Y < maxSize)
maxSize = _size.Y;
if (_size.z < maxSize)
maxSize = _size.z;
if (_size.Z < maxSize)
maxSize = _size.Z;
return maxSize;
}
@ -306,99 +306,99 @@ namespace Godot
Vector3 ofs = _position + halfExtents;
return ofs + new Vector3(
dir.x > 0f ? -halfExtents.x : halfExtents.x,
dir.y > 0f ? -halfExtents.y : halfExtents.y,
dir.z > 0f ? -halfExtents.z : halfExtents.z);
dir.X > 0f ? -halfExtents.X : halfExtents.X,
dir.Y > 0f ? -halfExtents.Y : halfExtents.Y,
dir.Z > 0f ? -halfExtents.Z : halfExtents.Z);
}
/// <summary>
/// Returns the volume of the <see cref="AABB"/>.
/// Returns the volume of the <see cref="Aabb"/>.
/// </summary>
/// <returns>The volume.</returns>
public readonly real_t GetVolume()
{
return _size.x * _size.y * _size.z;
return _size.X * _size.Y * _size.Z;
}
/// <summary>
/// Returns a copy of the <see cref="AABB"/> grown a given amount of units towards all the sides.
/// Returns a copy of the <see cref="Aabb"/> grown a given amount of units towards all the sides.
/// </summary>
/// <param name="by">The amount to grow by.</param>
/// <returns>The grown <see cref="AABB"/>.</returns>
public readonly AABB Grow(real_t by)
/// <returns>The grown <see cref="Aabb"/>.</returns>
public readonly Aabb Grow(real_t by)
{
AABB res = this;
Aabb res = this;
res._position.x -= by;
res._position.y -= by;
res._position.z -= by;
res._size.x += 2.0f * by;
res._size.y += 2.0f * by;
res._size.z += 2.0f * by;
res._position.X -= by;
res._position.Y -= by;
res._position.Z -= by;
res._size.X += 2.0f * by;
res._size.Y += 2.0f * by;
res._size.Z += 2.0f * by;
return res;
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="AABB"/> contains a point,
/// Returns <see langword="true"/> if the <see cref="Aabb"/> contains a point,
/// or <see langword="false"/> otherwise.
/// </summary>
/// <param name="point">The point to check.</param>
/// <returns>
/// A <see langword="bool"/> for whether or not the <see cref="AABB"/> contains <paramref name="point"/>.
/// A <see langword="bool"/> for whether or not the <see cref="Aabb"/> contains <paramref name="point"/>.
/// </returns>
public readonly bool HasPoint(Vector3 point)
{
if (point.x < _position.x)
if (point.X < _position.X)
return false;
if (point.y < _position.y)
if (point.Y < _position.Y)
return false;
if (point.z < _position.z)
if (point.Z < _position.Z)
return false;
if (point.x > _position.x + _size.x)
if (point.X > _position.X + _size.X)
return false;
if (point.y > _position.y + _size.y)
if (point.Y > _position.Y + _size.Y)
return false;
if (point.z > _position.z + _size.z)
if (point.Z > _position.Z + _size.Z)
return false;
return true;
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="AABB"/>
/// Returns <see langword="true"/> if the <see cref="Aabb"/>
/// has a surface or a length, and <see langword="false"/>
/// if the <see cref="AABB"/> is empty (all components
/// if the <see cref="Aabb"/> is empty (all components
/// of <see cref="Size"/> are zero or negative).
/// </summary>
/// <returns>
/// A <see langword="bool"/> for whether or not the <see cref="AABB"/> has surface.
/// A <see langword="bool"/> for whether or not the <see cref="Aabb"/> has surface.
/// </returns>
public readonly bool HasSurface()
{
return _size.x > 0.0f || _size.y > 0.0f || _size.z > 0.0f;
return _size.X > 0.0f || _size.Y > 0.0f || _size.Z > 0.0f;
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="AABB"/> has
/// area, and <see langword="false"/> if the <see cref="AABB"/>
/// Returns <see langword="true"/> if the <see cref="Aabb"/> has
/// area, and <see langword="false"/> if the <see cref="Aabb"/>
/// is linear, empty, or has a negative <see cref="Size"/>.
/// See also <see cref="GetVolume"/>.
/// </summary>
/// <returns>
/// A <see langword="bool"/> for whether or not the <see cref="AABB"/> has volume.
/// A <see langword="bool"/> for whether or not the <see cref="Aabb"/> has volume.
/// </returns>
public readonly bool HasVolume()
{
return _size.x > 0.0f && _size.y > 0.0f && _size.z > 0.0f;
return _size.X > 0.0f && _size.Y > 0.0f && _size.Z > 0.0f;
}
/// <summary>
/// Returns the intersection of this <see cref="AABB"/> and <paramref name="with"/>.
/// Returns the intersection of this <see cref="Aabb"/> and <paramref name="with"/>.
/// </summary>
/// <param name="with">The other <see cref="AABB"/>.</param>
/// <returns>The clipped <see cref="AABB"/>.</returns>
public readonly AABB Intersection(AABB with)
/// <param name="with">The other <see cref="Aabb"/>.</param>
/// <returns>The clipped <see cref="Aabb"/>.</returns>
public readonly Aabb Intersection(Aabb with)
{
Vector3 srcMin = _position;
Vector3 srcMax = _position + _size;
@ -407,78 +407,78 @@ namespace Godot
Vector3 min, max;
if (srcMin.x > dstMax.x || srcMax.x < dstMin.x)
if (srcMin.X > dstMax.X || srcMax.X < dstMin.X)
{
return new AABB();
return new Aabb();
}
min.x = srcMin.x > dstMin.x ? srcMin.x : dstMin.x;
max.x = srcMax.x < dstMax.x ? srcMax.x : dstMax.x;
min.X = srcMin.X > dstMin.X ? srcMin.X : dstMin.X;
max.X = srcMax.X < dstMax.X ? srcMax.X : dstMax.X;
if (srcMin.y > dstMax.y || srcMax.y < dstMin.y)
if (srcMin.Y > dstMax.Y || srcMax.Y < dstMin.Y)
{
return new AABB();
return new Aabb();
}
min.y = srcMin.y > dstMin.y ? srcMin.y : dstMin.y;
max.y = srcMax.y < dstMax.y ? srcMax.y : dstMax.y;
min.Y = srcMin.Y > dstMin.Y ? srcMin.Y : dstMin.Y;
max.Y = srcMax.Y < dstMax.Y ? srcMax.Y : dstMax.Y;
if (srcMin.z > dstMax.z || srcMax.z < dstMin.z)
if (srcMin.Z > dstMax.Z || srcMax.Z < dstMin.Z)
{
return new AABB();
return new Aabb();
}
min.z = srcMin.z > dstMin.z ? srcMin.z : dstMin.z;
max.z = srcMax.z < dstMax.z ? srcMax.z : dstMax.z;
min.Z = srcMin.Z > dstMin.Z ? srcMin.Z : dstMin.Z;
max.Z = srcMax.Z < dstMax.Z ? srcMax.Z : dstMax.Z;
return new AABB(min, max - min);
return new Aabb(min, max - min);
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="AABB"/> overlaps with <paramref name="with"/>
/// Returns <see langword="true"/> if the <see cref="Aabb"/> overlaps with <paramref name="with"/>
/// (i.e. they have at least one point in common).
/// </summary>
/// <param name="with">The other <see cref="AABB"/> to check for intersections with.</param>
/// <param name="with">The other <see cref="Aabb"/> to check for intersections with.</param>
/// <returns>
/// A <see langword="bool"/> for whether or not they are intersecting.
/// </returns>
public readonly bool Intersects(AABB with)
public readonly bool Intersects(Aabb with)
{
if (_position.x >= with._position.x + with._size.x)
if (_position.X >= with._position.X + with._size.X)
return false;
if (_position.x + _size.x <= with._position.x)
if (_position.X + _size.X <= with._position.X)
return false;
if (_position.y >= with._position.y + with._size.y)
if (_position.Y >= with._position.Y + with._size.Y)
return false;
if (_position.y + _size.y <= with._position.y)
if (_position.Y + _size.Y <= with._position.Y)
return false;
if (_position.z >= with._position.z + with._size.z)
if (_position.Z >= with._position.Z + with._size.Z)
return false;
if (_position.z + _size.z <= with._position.z)
if (_position.Z + _size.Z <= with._position.Z)
return false;
return true;
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="AABB"/> is on both sides of <paramref name="plane"/>.
/// Returns <see langword="true"/> if the <see cref="Aabb"/> is on both sides of <paramref name="plane"/>.
/// </summary>
/// <param name="plane">The <see cref="Plane"/> to check for intersection.</param>
/// <returns>
/// A <see langword="bool"/> for whether or not the <see cref="AABB"/> intersects the <see cref="Plane"/>.
/// A <see langword="bool"/> for whether or not the <see cref="Aabb"/> intersects the <see cref="Plane"/>.
/// </returns>
public readonly bool IntersectsPlane(Plane plane)
{
Vector3[] points =
{
new Vector3(_position.x, _position.y, _position.z),
new Vector3(_position.x, _position.y, _position.z + _size.z),
new Vector3(_position.x, _position.y + _size.y, _position.z),
new Vector3(_position.x, _position.y + _size.y, _position.z + _size.z),
new Vector3(_position.x + _size.x, _position.y, _position.z),
new Vector3(_position.x + _size.x, _position.y, _position.z + _size.z),
new Vector3(_position.x + _size.x, _position.y + _size.y, _position.z),
new Vector3(_position.x + _size.x, _position.y + _size.y, _position.z + _size.z)
new Vector3(_position.X, _position.Y, _position.Z),
new Vector3(_position.X, _position.Y, _position.Z + _size.Z),
new Vector3(_position.X, _position.Y + _size.Y, _position.Z),
new Vector3(_position.X, _position.Y + _size.Y, _position.Z + _size.Z),
new Vector3(_position.X + _size.X, _position.Y, _position.Z),
new Vector3(_position.X + _size.X, _position.Y, _position.Z + _size.Z),
new Vector3(_position.X + _size.X, _position.Y + _size.Y, _position.Z),
new Vector3(_position.X + _size.X, _position.Y + _size.Y, _position.Z + _size.Z)
};
bool over = false;
@ -500,13 +500,13 @@ namespace Godot
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="AABB"/> intersects
/// Returns <see langword="true"/> if the <see cref="Aabb"/> intersects
/// the line segment between <paramref name="from"/> and <paramref name="to"/>.
/// </summary>
/// <param name="from">The start of the line segment.</param>
/// <param name="to">The end of the line segment.</param>
/// <returns>
/// A <see langword="bool"/> for whether or not the <see cref="AABB"/> intersects the line segment.
/// A <see langword="bool"/> for whether or not the <see cref="Aabb"/> intersects the line segment.
/// </returns>
public readonly bool IntersectsSegment(Vector3 from, Vector3 to)
{
@ -563,7 +563,7 @@ namespace Godot
}
/// <summary>
/// Returns <see langword="true"/> if this <see cref="AABB"/> is finite, by calling
/// Returns <see langword="true"/> if this <see cref="Aabb"/> is finite, by calling
/// <see cref="Mathf.IsFinite"/> on each component.
/// </summary>
/// <returns>Whether this vector is finite or not.</returns>
@ -573,73 +573,73 @@ namespace Godot
}
/// <summary>
/// Returns a larger <see cref="AABB"/> that contains this <see cref="AABB"/> and <paramref name="with"/>.
/// Returns a larger <see cref="Aabb"/> that contains this <see cref="Aabb"/> and <paramref name="with"/>.
/// </summary>
/// <param name="with">The other <see cref="AABB"/>.</param>
/// <returns>The merged <see cref="AABB"/>.</returns>
public readonly AABB Merge(AABB with)
/// <param name="with">The other <see cref="Aabb"/>.</param>
/// <returns>The merged <see cref="Aabb"/>.</returns>
public readonly Aabb Merge(Aabb with)
{
Vector3 beg1 = _position;
Vector3 beg2 = with._position;
var end1 = new Vector3(_size.x, _size.y, _size.z) + beg1;
var end2 = new Vector3(with._size.x, with._size.y, with._size.z) + beg2;
var end1 = new Vector3(_size.X, _size.Y, _size.Z) + beg1;
var end2 = new Vector3(with._size.X, with._size.Y, with._size.Z) + beg2;
var min = new Vector3(
beg1.x < beg2.x ? beg1.x : beg2.x,
beg1.y < beg2.y ? beg1.y : beg2.y,
beg1.z < beg2.z ? beg1.z : beg2.z
beg1.X < beg2.X ? beg1.X : beg2.X,
beg1.Y < beg2.Y ? beg1.Y : beg2.Y,
beg1.Z < beg2.Z ? beg1.Z : beg2.Z
);
var max = new Vector3(
end1.x > end2.x ? end1.x : end2.x,
end1.y > end2.y ? end1.y : end2.y,
end1.z > end2.z ? end1.z : end2.z
end1.X > end2.X ? end1.X : end2.X,
end1.Y > end2.Y ? end1.Y : end2.Y,
end1.Z > end2.Z ? end1.Z : end2.Z
);
return new AABB(min, max - min);
return new Aabb(min, max - min);
}
/// <summary>
/// Constructs an <see cref="AABB"/> from a position and size.
/// Constructs an <see cref="Aabb"/> from a position and size.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="size">The size, typically positive.</param>
public AABB(Vector3 position, Vector3 size)
public Aabb(Vector3 position, Vector3 size)
{
_position = position;
_size = size;
}
/// <summary>
/// Constructs an <see cref="AABB"/> from a <paramref name="position"/>,
/// Constructs an <see cref="Aabb"/> from a <paramref name="position"/>,
/// <paramref name="width"/>, <paramref name="height"/>, and <paramref name="depth"/>.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="width">The width, typically positive.</param>
/// <param name="height">The height, typically positive.</param>
/// <param name="depth">The depth, typically positive.</param>
public AABB(Vector3 position, real_t width, real_t height, real_t depth)
public Aabb(Vector3 position, real_t width, real_t height, real_t depth)
{
_position = position;
_size = new Vector3(width, height, depth);
}
/// <summary>
/// Constructs an <see cref="AABB"/> from <paramref name="x"/>,
/// Constructs an <see cref="Aabb"/> from <paramref name="x"/>,
/// <paramref name="y"/>, <paramref name="z"/>, and <paramref name="size"/>.
/// </summary>
/// <param name="x">The position's X coordinate.</param>
/// <param name="y">The position's Y coordinate.</param>
/// <param name="z">The position's Z coordinate.</param>
/// <param name="size">The size, typically positive.</param>
public AABB(real_t x, real_t y, real_t z, Vector3 size)
public Aabb(real_t x, real_t y, real_t z, Vector3 size)
{
_position = new Vector3(x, y, z);
_size = size;
}
/// <summary>
/// Constructs an <see cref="AABB"/> from <paramref name="x"/>,
/// Constructs an <see cref="Aabb"/> from <paramref name="x"/>,
/// <paramref name="y"/>, <paramref name="z"/>, <paramref name="width"/>,
/// <paramref name="height"/>, and <paramref name="depth"/>.
/// </summary>
@ -649,7 +649,7 @@ namespace Godot
/// <param name="width">The width, typically positive.</param>
/// <param name="height">The height, typically positive.</param>
/// <param name="depth">The depth, typically positive.</param>
public AABB(real_t x, real_t y, real_t z, real_t width, real_t height, real_t depth)
public Aabb(real_t x, real_t y, real_t z, real_t width, real_t height, real_t depth)
{
_position = new Vector3(x, y, z);
_size = new Vector3(width, height, depth);
@ -663,7 +663,7 @@ namespace Godot
/// <param name="left">The left AABB.</param>
/// <param name="right">The right AABB.</param>
/// <returns>Whether or not the AABBs are exactly equal.</returns>
public static bool operator ==(AABB left, AABB right)
public static bool operator ==(Aabb left, Aabb right)
{
return left.Equals(right);
}
@ -676,7 +676,7 @@ namespace Godot
/// <param name="left">The left AABB.</param>
/// <param name="right">The right AABB.</param>
/// <returns>Whether or not the AABBs are not equal.</returns>
public static bool operator !=(AABB left, AABB right)
public static bool operator !=(Aabb left, Aabb right)
{
return !left.Equals(right);
}
@ -691,7 +691,7 @@ namespace Godot
/// <returns>Whether or not the AABB and the object are equal.</returns>
public override readonly bool Equals(object obj)
{
return obj is AABB other && Equals(other);
return obj is Aabb other && Equals(other);
}
/// <summary>
@ -701,7 +701,7 @@ namespace Godot
/// </summary>
/// <param name="other">The other AABB.</param>
/// <returns>Whether or not the AABBs are exactly equal.</returns>
public readonly bool Equals(AABB other)
public readonly bool Equals(Aabb other)
{
return _position == other._position && _size == other._size;
}
@ -712,13 +712,13 @@ namespace Godot
/// </summary>
/// <param name="other">The other AABB to compare.</param>
/// <returns>Whether or not the AABBs structures are approximately equal.</returns>
public readonly bool IsEqualApprox(AABB other)
public readonly bool IsEqualApprox(Aabb other)
{
return _position.IsEqualApprox(other._position) && _size.IsEqualApprox(other._size);
}
/// <summary>
/// Serves as the hash function for <see cref="AABB"/>.
/// Serves as the hash function for <see cref="Aabb"/>.
/// </summary>
/// <returns>A hash code for this AABB.</returns>
public override readonly int GetHashCode()
@ -727,7 +727,7 @@ namespace Godot
}
/// <summary>
/// Converts this <see cref="AABB"/> to a string.
/// Converts this <see cref="Aabb"/> to a string.
/// </summary>
/// <returns>A string representation of this AABB.</returns>
public override readonly string ToString()
@ -736,7 +736,7 @@ namespace Godot
}
/// <summary>
/// Converts this <see cref="AABB"/> to a string with the given <paramref name="format"/>.
/// Converts this <see cref="Aabb"/> to a string with the given <paramref name="format"/>.
/// </summary>
/// <returns>A string representation of this AABB.</returns>
public readonly string ToString(string format)

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

@ -99,7 +99,7 @@ namespace Godot.Collections
this[i] = array[i];
}
public Array(Span<RID> array) : this()
public Array(Span<Rid> array) : this()
{
if (array == null)
throw new ArgumentNullException(nameof(array));

24
modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/GodotClassNameAttribute.cs Normal file
View File

@ -0,0 +1,24 @@
using System;
namespace Godot
{
/// <summary>
/// Attribute that specifies the engine class name when it's not the same
/// as the generated C# class name. This allows introspection code to find
/// the name associated with the class. If the attribute is not present,
/// the C# class name can be used instead.
/// </summary>
[AttributeUsage(AttributeTargets.Class)]
public class GodotClassNameAttribute : Attribute
{
/// <summary>
/// Original engine class name.
/// </summary>
public string Name { get; }
public GodotClassNameAttribute(string name)
{
Name = name;
}
}
}

10
modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/RPCAttribute.cs → modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/RpcAttribute.cs
View File

@ -5,16 +5,16 @@ namespace Godot
/// <summary>
/// Attribute that changes the RPC mode for the annotated <c>method</c> to the given <see cref="Mode"/>,
/// optionally specifying the <see cref="TransferMode"/> and <see cref="TransferChannel"/> (on supported peers).
/// See <see cref="MultiplayerAPI.RPCMode"/> and <see cref="MultiplayerPeer.TransferModeEnum"/>.
/// See <see cref="MultiplayerApi.RpcMode"/> and <see cref="MultiplayerPeer.TransferModeEnum"/>.
/// By default, methods are not exposed to networking (and RPCs).
/// </summary>
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public sealed class RPCAttribute : Attribute
public sealed class RpcAttribute : Attribute
{
/// <summary>
/// RPC mode for the annotated method.
/// </summary>
public MultiplayerAPI.RPCMode Mode { get; } = MultiplayerAPI.RPCMode.Disabled;
public MultiplayerApi.RpcMode Mode { get; } = MultiplayerApi.RpcMode.Disabled;
/// <summary>
/// If the method will also be called locally; otherwise, it is only called remotely.
@ -32,10 +32,10 @@ namespace Godot
public int TransferChannel { get; init; } = 0;
/// <summary>
/// Constructs a <see cref="RPCAttribute"/> instance.
/// Constructs a <see cref="RpcAttribute"/> instance.
/// </summary>
/// <param name="mode">The RPC mode to use.</param>
public RPCAttribute(MultiplayerAPI.RPCMode mode = MultiplayerAPI.RPCMode.Authority)
public RpcAttribute(MultiplayerApi.RpcMode mode = MultiplayerApi.RpcMode.Authority)
{
Mode = mode;
}

272
modules/mono/glue/GodotSharp/GodotSharp/Core/Basis.cs
View File

@ -27,7 +27,7 @@ namespace Godot
/// The basis matrix's X vector (column 0).
/// </summary>
/// <value>Equivalent to <see cref="Column0"/> and array index <c>[0]</c>.</value>
public Vector3 x
public Vector3 X
{
readonly get => Column0;
set => Column0 = value;
@ -37,7 +37,7 @@ namespace Godot
/// The basis matrix's Y vector (column 1).
/// </summary>
/// <value>Equivalent to <see cref="Column1"/> and array index <c>[1]</c>.</value>
public Vector3 y
public Vector3 Y
{
readonly get => Column1;
set => Column1 = value;
@ -47,7 +47,7 @@ namespace Godot
/// The basis matrix's Z vector (column 2).
/// </summary>
/// <value>Equivalent to <see cref="Column2"/> and array index <c>[2]</c>.</value>
public Vector3 z
public Vector3 Z
{
readonly get => Column2;
set => Column2 = value;
@ -77,45 +77,45 @@ namespace Godot
/// <summary>
/// Column 0 of the basis matrix (the X vector).
/// </summary>
/// <value>Equivalent to <see cref="x"/> and array index <c>[0]</c>.</value>
/// <value>Equivalent to <see cref="X"/> and array index <c>[0]</c>.</value>
public Vector3 Column0
{
readonly get => new Vector3(Row0.x, Row1.x, Row2.x);
readonly get => new Vector3(Row0.X, Row1.X, Row2.X);
set
{
Row0.x = value.x;
Row1.x = value.y;
Row2.x = value.z;
Row0.X = value.X;
Row1.X = value.Y;
Row2.X = value.Z;
}
}
/// <summary>
/// Column 1 of the basis matrix (the Y vector).
/// </summary>
/// <value>Equivalent to <see cref="y"/> and array index <c>[1]</c>.</value>
/// <value>Equivalent to <see cref="Y"/> and array index <c>[1]</c>.</value>
public Vector3 Column1
{
readonly get => new Vector3(Row0.y, Row1.y, Row2.y);
readonly get => new Vector3(Row0.Y, Row1.Y, Row2.Y);
set
{
Row0.y = value.x;
Row1.y = value.y;
Row2.y = value.z;
Row0.Y = value.X;
Row1.Y = value.Y;
Row2.Y = value.Z;
}
}
/// <summary>
/// Column 2 of the basis matrix (the Z vector).
/// </summary>
/// <value>Equivalent to <see cref="z"/> and array index <c>[2]</c>.</value>
/// <value>Equivalent to <see cref="Z"/> and array index <c>[2]</c>.</value>
public Vector3 Column2
{
readonly get => new Vector3(Row0.z, Row1.z, Row2.z);
readonly get => new Vector3(Row0.Z, Row1.Z, Row2.Z);
set
{
Row0.z = value.x;
Row1.z = value.y;
Row2.z = value.z;
Row0.Z = value.X;
Row1.Z = value.Y;
Row2.Z = value.Z;
}
}
@ -213,9 +213,9 @@ namespace Godot
private void SetDiagonal(Vector3 diagonal)
{
Row0 = new Vector3(diagonal.x, 0, 0);
Row1 = new Vector3(0, diagonal.y, 0);
Row2 = new Vector3(0, 0, diagonal.z);
Row0 = new Vector3(diagonal.X, 0, 0);
Row1 = new Vector3(0, diagonal.Y, 0);
Row2 = new Vector3(0, 0, diagonal.Z);
}
/// <summary>
@ -270,29 +270,29 @@ namespace Godot
if (Row1[0] == 0 && Row0[1] == 0 && Row1[2] == 0 && Row2[1] == 0 && Row1[1] == 1)
{
// return the simplest form (human friendlier in editor and scripts)
euler.x = 0;
euler.y = Mathf.Atan2(Row0[2], Row0[0]);
euler.z = 0;
euler.X = 0;
euler.Y = Mathf.Atan2(Row0[2], Row0[0]);
euler.Z = 0;
}
else
{
euler.x = Mathf.Atan2(-Row1[2], Row2[2]);
euler.y = Mathf.Asin(sy);
euler.z = Mathf.Atan2(-Row0[1], Row0[0]);
euler.X = Mathf.Atan2(-Row1[2], Row2[2]);
euler.Y = Mathf.Asin(sy);
euler.Z = Mathf.Atan2(-Row0[1], Row0[0]);
}
}
else
{
euler.x = Mathf.Atan2(Row2[1], Row1[1]);
euler.y = -Mathf.Tau / 4.0f;
euler.z = 0.0f;
euler.X = Mathf.Atan2(Row2[1], Row1[1]);
euler.Y = -Mathf.Tau / 4.0f;
euler.Z = 0.0f;
}
}
else
{
euler.x = Mathf.Atan2(Row2[1], Row1[1]);
euler.y = Mathf.Tau / 4.0f;
euler.z = 0.0f;
euler.X = Mathf.Atan2(Row2[1], Row1[1]);
euler.Y = Mathf.Tau / 4.0f;
euler.Z = 0.0f;
}
return euler;
}
@ -310,24 +310,24 @@ namespace Godot
{
if (sz > -(1.0f - Mathf.Epsilon))
{
euler.x = Mathf.Atan2(Row2[1], Row1[1]);
euler.y = Mathf.Atan2(Row0[2], Row0[0]);
euler.z = Mathf.Asin(-sz);
euler.X = Mathf.Atan2(Row2[1], Row1[1]);
euler.Y = Mathf.Atan2(Row0[2], Row0[0]);
euler.Z = Mathf.Asin(-sz);
}
else
{
// It's -1
euler.x = -Mathf.Atan2(Row1[2], Row2[2]);
euler.y = 0.0f;
euler.z = Mathf.Tau / 4.0f;
euler.X = -Mathf.Atan2(Row1[2], Row2[2]);
euler.Y = 0.0f;
euler.Z = Mathf.Tau / 4.0f;
}
}
else
{
// It's 1
euler.x = -Mathf.Atan2(Row1[2], Row2[2]);
euler.y = 0.0f;
euler.z = -Mathf.Tau / 4.0f;
euler.X = -Mathf.Atan2(Row1[2], Row2[2]);
euler.Y = 0.0f;
euler.Z = -Mathf.Tau / 4.0f;
}
return euler;
}
@ -349,29 +349,29 @@ namespace Godot
if (Row1[0] == 0 && Row0[1] == 0 && Row0[2] == 0 && Row2[0] == 0 && Row0[0] == 1)
{
// return the simplest form (human friendlier in editor and scripts)
euler.x = Mathf.Atan2(-m12, Row1[1]);
euler.y = 0;
euler.z = 0;
euler.X = Mathf.Atan2(-m12, Row1[1]);
euler.Y = 0;
euler.Z = 0;
}
else
{
euler.x = Mathf.Asin(-m12);
euler.y = Mathf.Atan2(Row0[2], Row2[2]);
euler.z = Mathf.Atan2(Row1[0], Row1[1]);
euler.X = Mathf.Asin(-m12);
euler.Y = Mathf.Atan2(Row0[2], Row2[2]);
euler.Z = Mathf.Atan2(Row1[0], Row1[1]);
}
}
else
{ // m12 == -1
euler.x = Mathf.Tau / 4.0f;
euler.y = Mathf.Atan2(Row0[1], Row0[0]);
euler.z = 0;
euler.X = Mathf.Tau / 4.0f;
euler.Y = Mathf.Atan2(Row0[1], Row0[0]);
euler.Z = 0;
}
}
else
{ // m12 == 1
euler.x = -Mathf.Tau / 4.0f;
euler.y = -Mathf.Atan2(Row0[1], Row0[0]);
euler.z = 0;
euler.X = -Mathf.Tau / 4.0f;
euler.Y = -Mathf.Atan2(Row0[1], Row0[0]);
euler.Z = 0;
}
return euler;
@ -390,24 +390,24 @@ namespace Godot
{
if (sz > -(1.0f - Mathf.Epsilon))
{
euler.x = Mathf.Atan2(-Row1[2], Row1[1]);
euler.y = Mathf.Atan2(-Row2[0], Row0[0]);
euler.z = Mathf.Asin(sz);
euler.X = Mathf.Atan2(-Row1[2], Row1[1]);
euler.Y = Mathf.Atan2(-Row2[0], Row0[0]);
euler.Z = Mathf.Asin(sz);
}
else
{
// It's -1
euler.x = Mathf.Atan2(Row2[1], Row2[2]);
euler.y = 0.0f;
euler.z = -Mathf.Tau / 4.0f;
euler.X = Mathf.Atan2(Row2[1], Row2[2]);
euler.Y = 0.0f;
euler.Z = -Mathf.Tau / 4.0f;
}
}
else
{
// It's 1
euler.x = Mathf.Atan2(Row2[1], Row2[2]);
euler.y = 0.0f;
euler.z = Mathf.Tau / 4.0f;
euler.X = Mathf.Atan2(Row2[1], Row2[2]);
euler.Y = 0.0f;
euler.Z = Mathf.Tau / 4.0f;
}
return euler;
}
@ -425,24 +425,24 @@ namespace Godot
{
if (sx > -(1.0f - Mathf.Epsilon))
{
euler.x = Mathf.Asin(sx);
euler.y = Mathf.Atan2(-Row2[0], Row2[2]);
euler.z = Mathf.Atan2(-Row0[1], Row1[1]);
euler.X = Mathf.Asin(sx);
euler.Y = Mathf.Atan2(-Row2[0], Row2[2]);
euler.Z = Mathf.Atan2(-Row0[1], Row1[1]);
}
else
{
// It's -1
euler.x = -Mathf.Tau / 4.0f;
euler.y = Mathf.Atan2(Row0[2], Row0[0]);
euler.z = 0;
euler.X = -Mathf.Tau / 4.0f;
euler.Y = Mathf.Atan2(Row0[2], Row0[0]);
euler.Z = 0;
}
}
else
{
// It's 1
euler.x = Mathf.Tau / 4.0f;
euler.y = Mathf.Atan2(Row0[2], Row0[0]);
euler.z = 0;
euler.X = Mathf.Tau / 4.0f;
euler.Y = Mathf.Atan2(Row0[2], Row0[0]);
euler.Z = 0;
}
return euler;
}
@ -460,24 +460,24 @@ namespace Godot
{
if (sy > -(1.0f - Mathf.Epsilon))
{
euler.x = Mathf.Atan2(Row2[1], Row2[2]);
euler.y = Mathf.Asin(-sy);
euler.z = Mathf.Atan2(Row1[0], Row0[0]);
euler.X = Mathf.Atan2(Row2[1], Row2[2]);
euler.Y = Mathf.Asin(-sy);
euler.Z = Mathf.Atan2(Row1[0], Row0[0]);
}
else
{
// It's -1
euler.x = 0;
euler.y = Mathf.Tau / 4.0f;
euler.z = -Mathf.Atan2(Row0[1], Row1[1]);
euler.X = 0;
euler.Y = Mathf.Tau / 4.0f;
euler.Z = -Mathf.Atan2(Row0[1], Row1[1]);
}
}
else
{
// It's 1
euler.x = 0;
euler.y = -Mathf.Tau / 4.0f;
euler.z = -Mathf.Atan2(Row0[1], Row1[1]);
euler.X = 0;
euler.Y = -Mathf.Tau / 4.0f;
euler.Z = -Mathf.Atan2(Row0[1], Row1[1]);
}
return euler;
}
@ -653,9 +653,9 @@ namespace Godot
public readonly Basis Scaled(Vector3 scale)
{
Basis b = this;
b.Row0 *= scale.x;
b.Row1 *= scale.y;
b.Row2 *= scale.z;
b.Row0 *= scale.X;
b.Row1 *= scale.Y;
b.Row2 *= scale.Z;
return b;
}
@ -792,18 +792,18 @@ namespace Godot
{
real_t s = 2.0f / quaternion.LengthSquared();
real_t xs = quaternion.x * s;
real_t ys = quaternion.y * s;
real_t zs = quaternion.z * s;
real_t wx = quaternion.w * xs;
real_t wy = quaternion.w * ys;
real_t wz = quaternion.w * zs;
real_t xx = quaternion.x * xs;
real_t xy = quaternion.x * ys;
real_t xz = quaternion.x * zs;
real_t yy = quaternion.y * ys;
real_t yz = quaternion.y * zs;
real_t zz = quaternion.z * zs;
real_t xs = quaternion.X * s;
real_t ys = quaternion.Y * s;
real_t zs = quaternion.Z * s;
real_t wx = quaternion.W * xs;
real_t wy = quaternion.W * ys;
real_t wz = quaternion.W * zs;
real_t xx = quaternion.X * xs;
real_t xy = quaternion.X * ys;
real_t xz = quaternion.X * zs;
real_t yy = quaternion.Y * ys;
real_t yz = quaternion.Y * zs;
real_t zz = quaternion.Z * zs;
Row0 = new Vector3(1.0f - (yy + zz), xy - wz, xz + wy);
Row1 = new Vector3(xy + wz, 1.0f - (xx + zz), yz - wx);
@ -818,29 +818,29 @@ namespace Godot
/// <param name="angle">The angle to rotate, in radians.</param>
public Basis(Vector3 axis, real_t angle)
{
Vector3 axisSq = new Vector3(axis.x * axis.x, axis.y * axis.y, axis.z * axis.z);
Vector3 axisSq = new Vector3(axis.X * axis.X, axis.Y * axis.Y, axis.Z * axis.Z);
(real_t sin, real_t cos) = Mathf.SinCos(angle);
Row0.x = axisSq.x + cos * (1.0f - axisSq.x);
Row1.y = axisSq.y + cos * (1.0f - axisSq.y);
Row2.z = axisSq.z + cos * (1.0f - axisSq.z);
Row0.X = axisSq.X + cos * (1.0f - axisSq.X);
Row1.Y = axisSq.Y + cos * (1.0f - axisSq.Y);
Row2.Z = axisSq.Z + cos * (1.0f - axisSq.Z);
real_t t = 1.0f - cos;
real_t xyzt = axis.x * axis.y * t;
real_t zyxs = axis.z * sin;
Row0.y = xyzt - zyxs;
Row1.x = xyzt + zyxs;
real_t xyzt = axis.X * axis.Y * t;
real_t zyxs = axis.Z * sin;
Row0.Y = xyzt - zyxs;
Row1.X = xyzt + zyxs;
xyzt = axis.x * axis.z * t;
zyxs = axis.y * sin;
Row0.z = xyzt + zyxs;
Row2.x = xyzt - zyxs;
xyzt = axis.X * axis.Z * t;
zyxs = axis.Y * sin;
Row0.Z = xyzt + zyxs;
Row2.X = xyzt - zyxs;
xyzt = axis.y * axis.z * t;
zyxs = axis.x * sin;
Row1.z = xyzt - zyxs;
Row2.y = xyzt + zyxs;
xyzt = axis.Y * axis.Z * t;
zyxs = axis.X * sin;
Row1.Z = xyzt - zyxs;
Row2.Y = xyzt + zyxs;
}
/// <summary>
@ -851,9 +851,9 @@ namespace Godot
/// <param name="column2">The Z vector, or Column2.</param>
public Basis(Vector3 column0, Vector3 column1, Vector3 column2)
{
Row0 = new Vector3(column0.x, column1.x, column2.x);
Row1 = new Vector3(column0.y, column1.y, column2.y);
Row2 = new Vector3(column0.z, column1.z, column2.z);
Row0 = new Vector3(column0.X, column1.X, column2.X);
Row1 = new Vector3(column0.Y, column1.Y, column2.Y);
Row2 = new Vector3(column0.Z, column1.Z, column2.Z);
// Same as:
// Column0 = column0;
// Column1 = column1;
@ -863,17 +863,17 @@ namespace Godot
/// <summary>
/// Constructs a transformation matrix from the given components.
/// Arguments are named such that xy is equal to calling <c>x.y</c>.
/// Arguments are named such that xy is equal to calling <c>X.Y</c>.
/// </summary>
/// <param name="xx">The X component of the X column vector, accessed via <c>b.x.x</c> or <c>[0][0]</c>.</param>
/// <param name="yx">The X component of the Y column vector, accessed via <c>b.y.x</c> or <c>[1][0]</c>.</param>
/// <param name="zx">The X component of the Z column vector, accessed via <c>b.z.x</c> or <c>[2][0]</c>.</param>
/// <param name="xy">The Y component of the X column vector, accessed via <c>b.x.y</c> or <c>[0][1]</c>.</param>
/// <param name="yy">The Y component of the Y column vector, accessed via <c>b.y.y</c> or <c>[1][1]</c>.</param>
/// <param name="zy">The Y component of the Z column vector, accessed via <c>b.y.y</c> or <c>[2][1]</c>.</param>
/// <param name="xz">The Z component of the X column vector, accessed via <c>b.x.y</c> or <c>[0][2]</c>.</param>
/// <param name="yz">The Z component of the Y column vector, accessed via <c>b.y.y</c> or <c>[1][2]</c>.</param>
/// <param name="zz">The Z component of the Z column vector, accessed via <c>b.y.y</c> or <c>[2][2]</c>.</param>
/// <param name="xx">The X component of the X column vector, accessed via <c>b.X.X</c> or <c>[0][0]</c>.</param>
/// <param name="yx">The X component of the Y column vector, accessed via <c>b.Y.X</c> or <c>[1][0]</c>.</param>
/// <param name="zx">The X component of the Z column vector, accessed via <c>b.Z.X</c> or <c>[2][0]</c>.</param>
/// <param name="xy">The Y component of the X column vector, accessed via <c>b.X.Y</c> or <c>[0][1]</c>.</param>
/// <param name="yy">The Y component of the Y column vector, accessed via <c>b.Y.Y</c> or <c>[1][1]</c>.</param>
/// <param name="zy">The Y component of the Z column vector, accessed via <c>b.Y.Y</c> or <c>[2][1]</c>.</param>
/// <param name="xz">The Z component of the X column vector, accessed via <c>b.X.Y</c> or <c>[0][2]</c>.</param>
/// <param name="yz">The Z component of the Y column vector, accessed via <c>b.Y.Y</c> or <c>[1][2]</c>.</param>
/// <param name="zz">The Z component of the Z column vector, accessed via <c>b.Y.Y</c> or <c>[2][2]</c>.</param>
public Basis(real_t xx, real_t yx, real_t zx, real_t xy, real_t yy, real_t zy, real_t xz, real_t yz, real_t zz)
{
Row0 = new Vector3(xx, yx, zx);
@ -888,7 +888,7 @@ namespace Godot
/// <param name="order">The order to compose the Euler angles.</param>
public static Basis FromEuler(Vector3 euler, EulerOrder order = EulerOrder.Yxz)
{
(real_t sin, real_t cos) = Mathf.SinCos(euler.x);
(real_t sin, real_t cos) = Mathf.SinCos(euler.X);
Basis xmat = new Basis
(
new Vector3(1, 0, 0),
@ -896,7 +896,7 @@ namespace Godot
new Vector3(0, -sin, cos)
);
(sin, cos) = Mathf.SinCos(euler.y);
(sin, cos) = Mathf.SinCos(euler.Y);
Basis ymat = new Basis
(
new Vector3(cos, 0, -sin),
@ -904,7 +904,7 @@ namespace Godot
new Vector3(sin, 0, cos)
);
(sin, cos) = Mathf.SinCos(euler.z);
(sin, cos) = Mathf.SinCos(euler.Z);
Basis zmat = new Basis
(
new Vector3(cos, sin, 0),
@ -941,9 +941,9 @@ namespace Godot
public static Basis FromScale(Vector3 scale)
{
return new Basis(
scale.x, 0, 0,
0, scale.y, 0,
0, 0, scale.z
scale.X, 0, 0,
0, scale.Y, 0,
0, 0, scale.Z
);
}
@ -994,9 +994,9 @@ namespace Godot
{
return new Vector3
(
basis.Row0[0] * vector.x + basis.Row1[0] * vector.y + basis.Row2[0] * vector.z,
basis.Row0[1] * vector.x + basis.Row1[1] * vector.y + basis.Row2[1] * vector.z,
basis.Row0[2] * vector.x + basis.Row1[2] * vector.y + basis.Row2[2] * vector.z
basis.Row0[0] * vector.X + basis.Row1[0] * vector.Y + basis.Row2[0] * vector.Z,
basis.Row0[1] * vector.X + basis.Row1[1] * vector.Y + basis.Row2[1] * vector.Z,
basis.Row0[2] * vector.X + basis.Row1[2] * vector.Y + basis.Row2[2] * vector.Z
);
}
@ -1077,7 +1077,7 @@ namespace Godot
/// <returns>A string representation of this basis.</returns>
public override readonly string ToString()
{
return $"[X: {x}, Y: {y}, Z: {z}]";
return $"[X: {X}, Y: {Y}, Z: {Z}]";
}
/// <summary>
@ -1086,7 +1086,7 @@ namespace Godot
/// <returns>A string representation of this basis.</returns>
public readonly string ToString(string format)
{
return $"[X: {x.ToString(format)}, Y: {y.ToString(format)}, Z: {z.ToString(format)}]";
return $"[X: {X.ToString(format)}, Y: {Y.ToString(format)}, Z: {Z.ToString(format)}]";
}
}
}

4
modules/mono/glue/GodotSharp/GodotSharp/Core/Bridge/GodotSerializationInfo.cs
View File

@ -48,7 +48,7 @@ public sealed class GodotSerializationInfo : IDisposable
{
_signalEvents[name] = serializedData;
}
else if (OS.IsStdoutVerbose())
else if (OS.IsStdOutVerbose())
{
Console.WriteLine($"Failed to serialize event signal delegate: {name}");
}
@ -72,7 +72,7 @@ public sealed class GodotSerializationInfo : IDisposable
return true;
}
else if (OS.IsStdoutVerbose())
else if (OS.IsStdOutVerbose())
{
Console.WriteLine($"Failed to deserialize event signal delegate: {name}");
}

2
modules/mono/glue/GodotSharp/GodotSharp/Core/Bridge/ScriptManagerBridge.cs
View File

@ -650,7 +650,7 @@ namespace Godot.Bridge
continue;
var rpcAttr = method.GetCustomAttributes(inherit: false)
.OfType<RPCAttribute>().FirstOrDefault();
.OfType<RpcAttribute>().FirstOrDefault();
if (rpcAttr == null)
continue;

440
modules/mono/glue/GodotSharp/GodotSharp/Core/Color.cs
View File

@ -21,97 +21,97 @@ namespace Godot
/// <summary>
/// The color's red component, typically on the range of 0 to 1.
/// </summary>
public float r;
public float R;
/// <summary>
/// The color's green component, typically on the range of 0 to 1.
/// </summary>
public float g;
public float G;
/// <summary>
/// The color's blue component, typically on the range of 0 to 1.
/// </summary>
public float b;
public float B;
/// <summary>
/// The color's alpha (transparency) component, typically on the range of 0 to 1.
/// </summary>
public float a;
public float A;
/// <summary>
/// Wrapper for <see cref="r"/> that uses the range 0 to 255 instead of 0 to 1.
/// Wrapper for <see cref="R"/> that uses the range 0 to 255 instead of 0 to 1.
/// </summary>
/// <value>Getting is equivalent to multiplying by 255 and rounding. Setting is equivalent to dividing by 255.</value>
public int r8
public int R8
{
readonly get
{
return (int)Math.Round(r * 255.0f);
return (int)Math.Round(R * 255.0f);
}
set
{
r = value / 255.0f;
R = value / 255.0f;
}
}
/// <summary>
/// Wrapper for <see cref="g"/> that uses the range 0 to 255 instead of 0 to 1.
/// Wrapper for <see cref="G"/> that uses the range 0 to 255 instead of 0 to 1.
/// </summary>
/// <value>Getting is equivalent to multiplying by 255 and rounding. Setting is equivalent to dividing by 255.</value>
public int g8
public int G8
{
readonly get
{
return (int)Math.Round(g * 255.0f);
return (int)Math.Round(G * 255.0f);
}
set
{
g = value / 255.0f;
G = value / 255.0f;
}
}
/// <summary>
/// Wrapper for <see cref="b"/> that uses the range 0 to 255 instead of 0 to 1.
/// Wrapper for <see cref="B"/> that uses the range 0 to 255 instead of 0 to 1.
/// </summary>
/// <value>Getting is equivalent to multiplying by 255 and rounding. Setting is equivalent to dividing by 255.</value>
public int b8
public int B8
{
readonly get
{
return (int)Math.Round(b * 255.0f);
return (int)Math.Round(B * 255.0f);
}
set
{
b = value / 255.0f;
B = value / 255.0f;
}
}
/// <summary>
/// Wrapper for <see cref="a"/> that uses the range 0 to 255 instead of 0 to 1.
/// Wrapper for <see cref="A"/> that uses the range 0 to 255 instead of 0 to 1.
/// </summary>
/// <value>Getting is equivalent to multiplying by 255 and rounding. Setting is equivalent to dividing by 255.</value>
public int a8
public int A8
{
readonly get
{
return (int)Math.Round(a * 255.0f);
return (int)Math.Round(A * 255.0f);
}
set
{
a = value / 255.0f;
A = value / 255.0f;
}
}
/// <summary>
/// The HSV hue of this color, on the range 0 to 1.
/// </summary>
/// <value>Getting is a long process, refer to the source code for details. Setting uses <see cref="FromHSV"/>.</value>
public float h
/// <value>Getting is a long process, refer to the source code for details. Setting uses <see cref="FromHsv"/>.</value>
public float H
{
readonly get
{
float max = Math.Max(r, Math.Max(g, b));
float min = Math.Min(r, Math.Min(g, b));
float max = Math.Max(R, Math.Max(G, B));
float min = Math.Min(R, Math.Min(G, B));
float delta = max - min;
@ -122,17 +122,17 @@ namespace Godot
float h;
if (r == max)
if (R == max)
{
h = (g - b) / delta; // Between yellow & magenta
h = (G - B) / delta; // Between yellow & magenta
}
else if (g == max)
else if (G == max)
{
h = 2 + ((b - r) / delta); // Between cyan & yellow
h = 2 + ((B - R) / delta); // Between cyan & yellow
}
else
{
h = 4 + ((r - g) / delta); // Between magenta & cyan
h = 4 + ((R - G) / delta); // Between magenta & cyan
}
h /= 6.0f;
@ -146,20 +146,20 @@ namespace Godot
}
set
{
this = FromHSV(value, s, v, a);
this = FromHsv(value, S, V, A);
}
}
/// <summary>
/// The HSV saturation of this color, on the range 0 to 1.
/// </summary>
/// <value>Getting is equivalent to the ratio between the min and max RGB value. Setting uses <see cref="FromHSV"/>.</value>
public float s
/// <value>Getting is equivalent to the ratio between the min and max RGB value. Setting uses <see cref="FromHsv"/>.</value>
public float S
{
readonly get
{
float max = Math.Max(r, Math.Max(g, b));
float min = Math.Min(r, Math.Min(g, b));
float max = Math.Max(R, Math.Max(G, B));
float min = Math.Min(R, Math.Min(G, B));
float delta = max - min;
@ -167,23 +167,23 @@ namespace Godot
}
set
{
this = FromHSV(h, value, v, a);
this = FromHsv(H, value, V, A);
}
}
/// <summary>
/// The HSV value (brightness) of this color, on the range 0 to 1.
/// </summary>
/// <value>Getting is equivalent to using <see cref="Math.Max(float, float)"/> on the RGB components. Setting uses <see cref="FromHSV"/>.</value>
public float v
/// <value>Getting is equivalent to using <see cref="Math.Max(float, float)"/> on the RGB components. Setting uses <see cref="FromHsv"/>.</value>
public float V
{
readonly get
{
return Math.Max(r, Math.Max(g, b));
return Math.Max(R, Math.Max(G, B));
}
set
{
this = FromHSV(h, s, value, a);
this = FromHsv(H, S, value, A);
}
}
@ -197,17 +197,17 @@ namespace Godot
/// </summary>
public readonly float Luminance
{
get { return 0.2126f * r + 0.7152f * g + 0.0722f * b; }
get { return 0.2126f * R + 0.7152f * G + 0.0722f * B; }
}
/// <summary>
/// Access color components using their index.
/// </summary>
/// <value>
/// <c>[0]</c> is equivalent to <see cref="r"/>,
/// <c>[1]</c> is equivalent to <see cref="g"/>,
/// <c>[2]</c> is equivalent to <see cref="b"/>,
/// <c>[3]</c> is equivalent to <see cref="a"/>.
/// <c>[0]</c> is equivalent to <see cref="R"/>,
/// <c>[1]</c> is equivalent to <see cref="G"/>,
/// <c>[2]</c> is equivalent to <see cref="B"/>,
/// <c>[3]</c> is equivalent to <see cref="A"/>.
/// </value>
public float this[int index]
{
@ -216,13 +216,13 @@ namespace Godot
switch (index)
{
case 0:
return r;
return R;
case 1:
return g;
return G;
case 2:
return b;
return B;
case 3:
return a;
return A;
default:
throw new ArgumentOutOfRangeException(nameof(index));
}
@ -232,16 +232,16 @@ namespace Godot
switch (index)
{
case 0:
r = value;
R = value;
return;
case 1:
g = value;
G = value;
return;
case 2:
b = value;
B = value;
return;
case 3:
a = value;
A = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(index));
@ -260,17 +260,17 @@ namespace Godot
{
Color res;
float sa = 1.0f - over.a;
res.a = (a * sa) + over.a;
float sa = 1.0f - over.A;
res.A = (A * sa) + over.A;
if (res.a == 0)
if (res.A == 0)
{
return new Color(0, 0, 0, 0);
}
res.r = ((r * a * sa) + (over.r * over.a)) / res.a;
res.g = ((g * a * sa) + (over.g * over.a)) / res.a;
res.b = ((b * a * sa) + (over.b * over.a)) / res.a;
res.R = ((R * A * sa) + (over.R * over.A)) / res.A;
res.G = ((G * A * sa) + (over.G * over.A)) / res.A;
res.B = ((B * A * sa) + (over.B * over.A)) / res.A;
return res;
}
@ -289,10 +289,10 @@ namespace Godot
Color maximum = max ?? new Color(1, 1, 1, 1);
return new Color
(
(float)Mathf.Clamp(r, minimum.r, maximum.r),
(float)Mathf.Clamp(g, minimum.g, maximum.g),
(float)Mathf.Clamp(b, minimum.b, maximum.b),
(float)Mathf.Clamp(a, minimum.a, maximum.a)
(float)Mathf.Clamp(R, minimum.R, maximum.R),
(float)Mathf.Clamp(G, minimum.G, maximum.G),
(float)Mathf.Clamp(B, minimum.B, maximum.B),
(float)Mathf.Clamp(A, minimum.A, maximum.A)
);
}
@ -305,9 +305,9 @@ namespace Godot
public readonly Color Darkened(float amount)
{
Color res = this;
res.r *= 1.0f - amount;
res.g *= 1.0f - amount;
res.b *= 1.0f - amount;
res.R *= 1.0f - amount;
res.G *= 1.0f - amount;
res.B *= 1.0f - amount;
return res;
}
@ -318,10 +318,10 @@ namespace Godot
public readonly Color Inverted()
{
return new Color(
1.0f - r,
1.0f - g,
1.0f - b,
a
1.0f - R,
1.0f - G,
1.0f - B,
A
);
}
@ -334,9 +334,9 @@ namespace Godot
public readonly Color Lightened(float amount)
{
Color res = this;
res.r += (1.0f - res.r) * amount;
res.g += (1.0f - res.g) * amount;
res.b += (1.0f - res.b) * amount;
res.R += (1.0f - res.R) * amount;
res.G += (1.0f - res.G) * amount;
res.B += (1.0f - res.B) * amount;
return res;
}
@ -351,10 +351,10 @@ namespace Godot
{
return new Color
(
(float)Mathf.Lerp(r, to.r, weight),
(float)Mathf.Lerp(g, to.g, weight),
(float)Mathf.Lerp(b, to.b, weight),
(float)Mathf.Lerp(a, to.a, weight)
(float)Mathf.Lerp(R, to.R, weight),
(float)Mathf.Lerp(G, to.G, weight),
(float)Mathf.Lerp(B, to.B, weight),
(float)Mathf.Lerp(A, to.A, weight)
);
}
@ -367,9 +367,9 @@ namespace Godot
public readonly Color LinearToSrgb()
{
return new Color(
r < 0.0031308f ? 12.92f * r : (1.0f + 0.055f) * (float)Mathf.Pow(r, 1.0f / 2.4f) - 0.055f,
g < 0.0031308f ? 12.92f * g : (1.0f + 0.055f) * (float)Mathf.Pow(g, 1.0f / 2.4f) - 0.055f,
b < 0.0031308f ? 12.92f * b : (1.0f + 0.055f) * (float)Mathf.Pow(b, 1.0f / 2.4f) - 0.055f, a);
R < 0.0031308f ? 12.92f * R : (1.0f + 0.055f) * (float)Mathf.Pow(R, 1.0f / 2.4f) - 0.055f,
G < 0.0031308f ? 12.92f * G : (1.0f + 0.055f) * (float)Mathf.Pow(G, 1.0f / 2.4f) - 0.055f,
B < 0.0031308f ? 12.92f * B : (1.0f + 0.055f) * (float)Mathf.Pow(B, 1.0f / 2.4f) - 0.055f, A);
}
/// <summary>
@ -381,10 +381,10 @@ namespace Godot
public readonly Color SrgbToLinear()
{
return new Color(
r < 0.04045f ? r * (1.0f / 12.92f) : (float)Mathf.Pow((r + 0.055f) * (float)(1.0 / (1.0 + 0.055)), 2.4f),
g < 0.04045f ? g * (1.0f / 12.92f) : (float)Mathf.Pow((g + 0.055f) * (float)(1.0 / (1.0 + 0.055)), 2.4f),
b < 0.04045f ? b * (1.0f / 12.92f) : (float)Mathf.Pow((b + 0.055f) * (float)(1.0 / (1.0 + 0.055)), 2.4f),
a);
R < 0.04045f ? R * (1.0f / 12.92f) : (float)Mathf.Pow((R + 0.055f) * (float)(1.0 / (1.0 + 0.055)), 2.4f),
G < 0.04045f ? G * (1.0f / 12.92f) : (float)Mathf.Pow((G + 0.055f) * (float)(1.0 / (1.0 + 0.055)), 2.4f),
B < 0.04045f ? B * (1.0f / 12.92f) : (float)Mathf.Pow((B + 0.055f) * (float)(1.0 / (1.0 + 0.055)), 2.4f),
A);
}
/// <summary>
@ -395,13 +395,13 @@ namespace Godot
/// <returns>A <see langword="uint"/> representing this color in ABGR32 format.</returns>
public readonly uint ToAbgr32()
{
uint c = (byte)Math.Round(a * 255);
uint c = (byte)Math.Round(A * 255);
c <<= 8;
c |= (byte)Math.Round(b * 255);
c |= (byte)Math.Round(B * 255);
c <<= 8;
c |= (byte)Math.Round(g * 255);
c |= (byte)Math.Round(G * 255);
c <<= 8;
c |= (byte)Math.Round(r * 255);
c |= (byte)Math.Round(R * 255);
return c;
}
@ -414,13 +414,13 @@ namespace Godot
/// <returns>A <see langword="ulong"/> representing this color in ABGR64 format.</returns>
public readonly ulong ToAbgr64()
{
ulong c = (ushort)Math.Round(a * 65535);
ulong c = (ushort)Math.Round(A * 65535);
c <<= 16;
c |= (ushort)Math.Round(b * 65535);
c |= (ushort)Math.Round(B * 65535);
c <<= 16;
c |= (ushort)Math.Round(g * 65535);
c |= (ushort)Math.Round(G * 65535);
c <<= 16;
c |= (ushort)Math.Round(r * 65535);
c |= (ushort)Math.Round(R * 65535);
return c;
}
@ -433,13 +433,13 @@ namespace Godot
/// <returns>A <see langword="uint"/> representing this color in ARGB32 format.</returns>
public readonly uint ToArgb32()
{
uint c = (byte)Math.Round(a * 255);
uint c = (byte)Math.Round(A * 255);
c <<= 8;
c |= (byte)Math.Round(r * 255);
c |= (byte)Math.Round(R * 255);
c <<= 8;
c |= (byte)Math.Round(g * 255);
c |= (byte)Math.Round(G * 255);
c <<= 8;
c |= (byte)Math.Round(b * 255);
c |= (byte)Math.Round(B * 255);
return c;
}
@ -452,13 +452,13 @@ namespace Godot
/// <returns>A <see langword="ulong"/> representing this color in ARGB64 format.</returns>
public readonly ulong ToArgb64()
{
ulong c = (ushort)Math.Round(a * 65535);
ulong c = (ushort)Math.Round(A * 65535);
c <<= 16;
c |= (ushort)Math.Round(r * 65535);
c |= (ushort)Math.Round(R * 65535);
c <<= 16;
c |= (ushort)Math.Round(g * 65535);
c |= (ushort)Math.Round(G * 65535);
c <<= 16;
c |= (ushort)Math.Round(b * 65535);
c |= (ushort)Math.Round(B * 65535);
return c;
}
@ -471,13 +471,13 @@ namespace Godot
/// <returns>A <see langword="uint"/> representing this color in RGBA32 format.</returns>
public readonly uint ToRgba32()
{
uint c = (byte)Math.Round(r * 255);
uint c = (byte)Math.Round(R * 255);
c <<= 8;
c |= (byte)Math.Round(g * 255);
c |= (byte)Math.Round(G * 255);
c <<= 8;
c |= (byte)Math.Round(b * 255);
c |= (byte)Math.Round(B * 255);
c <<= 8;
c |= (byte)Math.Round(a * 255);
c |= (byte)Math.Round(A * 255);
return c;
}
@ -490,13 +490,13 @@ namespace Godot
/// <returns>A <see langword="ulong"/> representing this color in RGBA64 format.</returns>
public readonly ulong ToRgba64()
{
ulong c = (ushort)Math.Round(r * 65535);
ulong c = (ushort)Math.Round(R * 65535);
c <<= 16;
c |= (ushort)Math.Round(g * 65535);
c |= (ushort)Math.Round(G * 65535);
c <<= 16;
c |= (ushort)Math.Round(b * 65535);
c |= (ushort)Math.Round(B * 65535);
c <<= 16;
c |= (ushort)Math.Round(a * 65535);
c |= (ushort)Math.Round(A * 65535);
return c;
}
@ -508,17 +508,17 @@ namespace Godot
/// Whether or not to include alpha. If <see langword="false"/>, the color is RGB instead of RGBA.
/// </param>
/// <returns>A string for the HTML hexadecimal representation of this color.</returns>
public readonly string ToHTML(bool includeAlpha = true)
public readonly string ToHtml(bool includeAlpha = true)
{
string txt = string.Empty;
txt += ToHex32(r);
txt += ToHex32(g);
txt += ToHex32(b);
txt += ToHex32(R);
txt += ToHex32(G);
txt += ToHex32(B);
if (includeAlpha)
{
txt += ToHex32(a);
txt += ToHex32(A);
}
return txt;
@ -533,10 +533,10 @@ namespace Godot
/// <param name="a">The color's alpha (transparency) value, typically on the range of 0 to 1. Default: 1.</param>
public Color(float r, float g, float b, float a = 1.0f)
{
this.r = r;
this.g = g;
this.b = b;
this.a = a;
R = r;
G = g;
B = b;
A = a;
}
/// <summary>
@ -546,10 +546,10 @@ namespace Godot
/// <param name="a">The color's alpha (transparency) value, typically on the range of 0 to 1. Default: 1.</param>
public Color(Color c, float a = 1.0f)
{
r = c.r;
g = c.g;
b = c.b;
this.a = a;
R = c.R;
G = c.G;
B = c.B;
A = a;
}
/// <summary>
@ -559,13 +559,13 @@ namespace Godot
/// <param name="rgba">The <see langword="uint"/> representing the color.</param>
public Color(uint rgba)
{
a = (rgba & 0xFF) / 255.0f;
A = (rgba & 0xFF) / 255.0f;
rgba >>= 8;
b = (rgba & 0xFF) / 255.0f;
B = (rgba & 0xFF) / 255.0f;
rgba >>= 8;
g = (rgba & 0xFF) / 255.0f;
G = (rgba & 0xFF) / 255.0f;
rgba >>= 8;
r = (rgba & 0xFF) / 255.0f;
R = (rgba & 0xFF) / 255.0f;
}
/// <summary>
@ -575,13 +575,13 @@ namespace Godot
/// <param name="rgba">The <see langword="ulong"/> representing the color.</param>
public Color(ulong rgba)
{
a = (rgba & 0xFFFF) / 65535.0f;
A = (rgba & 0xFFFF) / 65535.0f;
rgba >>= 16;
b = (rgba & 0xFFFF) / 65535.0f;
B = (rgba & 0xFFFF) / 65535.0f;
rgba >>= 16;
g = (rgba & 0xFFFF) / 65535.0f;
G = (rgba & 0xFFFF) / 65535.0f;
rgba >>= 16;
r = (rgba & 0xFFFF) / 65535.0f;
R = (rgba & 0xFFFF) / 65535.0f;
}
/// <summary>
@ -598,7 +598,7 @@ namespace Godot
{
if (HtmlIsValid(code))
{
this = FromHTML(code);
this = FromHtml(code);
}
else
{
@ -616,7 +616,7 @@ namespace Godot
public Color(string code, float alpha)
{
this = new Color(code);
a = alpha;
A = alpha;
}
/// <summary>
@ -626,15 +626,15 @@ namespace Godot
/// <exception name="ArgumentOutOfRangeException">
/// <paramref name="rgba"/> color code is invalid.
/// </exception>
public static Color FromHTML(ReadOnlySpan<char> rgba)
public static Color FromHtml(ReadOnlySpan<char> rgba)
{
Color c;
if (rgba.Length == 0)
{
c.r = 0f;
c.g = 0f;
c.b = 0f;
c.a = 1.0f;
c.R = 0f;
c.G = 0f;
c.B = 0f;
c.A = 1.0f;
return c;
}
@ -670,44 +670,44 @@ namespace Godot
$"Invalid color code. Length is {rgba.Length}, but a length of 6 or 8 is expected: {rgba}");
}
c.a = 1.0f;
c.A = 1.0f;
if (isShorthand)
{
c.r = ParseCol4(rgba, 0) / 15f;
c.g = ParseCol4(rgba, 1) / 15f;
c.b = ParseCol4(rgba, 2) / 15f;
c.R = ParseCol4(rgba, 0) / 15f;
c.G = ParseCol4(rgba, 1) / 15f;
c.B = ParseCol4(rgba, 2) / 15f;
if (alpha)
{
c.a = ParseCol4(rgba, 3) / 15f;
c.A = ParseCol4(rgba, 3) / 15f;
}
}
else
{
c.r = ParseCol8(rgba, 0) / 255f;
c.g = ParseCol8(rgba, 2) / 255f;
c.b = ParseCol8(rgba, 4) / 255f;
c.R = ParseCol8(rgba, 0) / 255f;
c.G = ParseCol8(rgba, 2) / 255f;
c.B = ParseCol8(rgba, 4) / 255f;
if (alpha)
{
c.a = ParseCol8(rgba, 6) / 255f;
c.A = ParseCol8(rgba, 6) / 255f;
}
}
if (c.r < 0)
if (c.R < 0)
{
throw new ArgumentOutOfRangeException($"Invalid color code. Red part is not valid hexadecimal: {rgba}");
}
if (c.g < 0)
if (c.G < 0)
{
throw new ArgumentOutOfRangeException($"Invalid color code. Green part is not valid hexadecimal: {rgba}");
}
if (c.b < 0)
if (c.B < 0)
{
throw new ArgumentOutOfRangeException($"Invalid color code. Blue part is not valid hexadecimal: {rgba}");
}
if (c.a < 0)
if (c.A < 0)
{
throw new ArgumentOutOfRangeException($"Invalid color code. Alpha part is not valid hexadecimal: {rgba}");
}
@ -793,7 +793,7 @@ namespace Godot
/// <param name="value">The HSV value (brightness), typically on the range of 0 to 1.</param>
/// <param name="alpha">The alpha (transparency) value, typically on the range of 0 to 1.</param>
/// <returns>The constructed color.</returns>
public static Color FromHSV(float hue, float saturation, float value, float alpha = 1.0f)
public static Color FromHsv(float hue, float saturation, float value, float alpha = 1.0f)
{
if (saturation == 0)
{
@ -837,10 +837,10 @@ namespace Godot
/// <param name="hue">Output parameter for the HSV hue.</param>
/// <param name="saturation">Output parameter for the HSV saturation.</param>
/// <param name="value">Output parameter for the HSV value.</param>
public readonly void ToHSV(out float hue, out float saturation, out float value)
public readonly void ToHsv(out float hue, out float saturation, out float value)
{
float max = (float)Mathf.Max(r, Mathf.Max(g, b));
float min = (float)Mathf.Min(r, Mathf.Min(g, b));
float max = (float)Mathf.Max(R, Mathf.Max(G, B));
float min = (float)Mathf.Min(R, Mathf.Min(G, B));
float delta = max - min;
@ -850,17 +850,17 @@ namespace Godot
}
else
{
if (r == max)
if (R == max)
{
hue = (g - b) / delta; // Between yellow & magenta
hue = (G - B) / delta; // Between yellow & magenta
}
else if (g == max)
else if (G == max)
{
hue = 2 + ((b - r) / delta); // Between cyan & yellow
hue = 2 + ((B - R) / delta); // Between cyan & yellow
}
else
{
hue = 4 + ((r - g) / delta); // Between magenta & cyan
hue = 4 + ((R - G) / delta); // Between magenta & cyan
}
hue /= 6.0f;
@ -950,7 +950,7 @@ namespace Godot
{
if (HtmlIsValid(str))
{
return FromHTML(str);
return FromHtml(str);
}
else
{
@ -1012,10 +1012,10 @@ namespace Godot
/// <returns>The added color.</returns>
public static Color operator +(Color left, Color right)
{
left.r += right.r;
left.g += right.g;
left.b += right.b;
left.a += right.a;
left.R += right.R;
left.G += right.G;
left.B += right.B;
left.A += right.A;
return left;
}
@ -1028,17 +1028,17 @@ namespace Godot
/// <returns>The subtracted color.</returns>
public static Color operator -(Color left, Color right)
{
left.r -= right.r;
left.g -= right.g;
left.b -= right.b;
left.a -= right.a;
left.R -= right.R;
left.G -= right.G;
left.B -= right.B;
left.A -= right.A;
return left;
}
/// <summary>
/// Inverts the given color. This is equivalent to
/// <c>Colors.White - c</c> or
/// <c>new Color(1 - c.r, 1 - c.g, 1 - c.b, 1 - c.a)</c>.
/// <c>new Color(1 - c.R, 1 - c.G, 1 - c.B, 1 - c.A)</c>.
/// </summary>
/// <param name="color">The color to invert.</param>
/// <returns>The inverted color.</returns>
@ -1056,10 +1056,10 @@ namespace Godot
/// <returns>The multiplied color.</returns>
public static Color operator *(Color color, float scale)
{
color.r *= scale;
color.g *= scale;
color.b *= scale;
color.a *= scale;
color.R *= scale;
color.G *= scale;
color.B *= scale;
color.A *= scale;
return color;
}
@ -1072,10 +1072,10 @@ namespace Godot
/// <returns>The multiplied color.</returns>
public static Color operator *(float scale, Color color)
{
color.r *= scale;
color.g *= scale;
color.b *= scale;
color.a *= scale;
color.R *= scale;
color.G *= scale;
color.B *= scale;
color.A *= scale;
return color;
}
@ -1088,10 +1088,10 @@ namespace Godot
/// <returns>The multiplied color.</returns>
public static Color operator *(Color left, Color right)
{
left.r *= right.r;
left.g *= right.g;
left.b *= right.b;
left.a *= right.a;
left.R *= right.R;
left.G *= right.G;
left.B *= right.B;
left.A *= right.A;
return left;
}
@ -1104,10 +1104,10 @@ namespace Godot
/// <returns>The divided color.</returns>
public static Color operator /(Color color, float scale)
{
color.r /= scale;
color.g /= scale;
color.b /= scale;
color.a /= scale;
color.R /= scale;
color.G /= scale;
color.B /= scale;
color.A /= scale;
return color;
}
@ -1120,10 +1120,10 @@ namespace Godot
/// <returns>The divided color.</returns>
public static Color operator /(Color left, Color right)
{
left.r /= right.r;
left.g /= right.g;
left.b /= right.b;
left.a /= right.a;
left.R /= right.R;
left.G /= right.G;
left.B /= right.B;
left.A /= right.A;
return left;
}
@ -1167,19 +1167,19 @@ namespace Godot
/// <returns>Whether or not the left is less than the right.</returns>
public static bool operator <(Color left, Color right)
{
if (left.r == right.r)
if (left.R == right.R)
{
if (left.g == right.g)
if (left.G == right.G)
{
if (left.b == right.b)
if (left.B == right.B)
{
return left.a < right.a;
return left.A < right.A;
}
return left.b < right.b;
return left.B < right.B;
}
return left.g < right.g;
return left.G < right.G;
}
return left.r < right.r;
return left.R < right.R;
}
/// <summary>
@ -1196,19 +1196,19 @@ namespace Godot
/// <returns>Whether or not the left is greater than the right.</returns>
public static bool operator >(Color left, Color right)
{
if (left.r == right.r)
if (left.R == right.R)
{
if (left.g == right.g)
if (left.G == right.G)
{
if (left.b == right.b)
if (left.B == right.B)
{
return left.a > right.a;
return left.A > right.A;
}
return left.b > right.b;
return left.B > right.B;
}
return left.g > right.g;
return left.G > right.G;
}
return left.r > right.r;
return left.R > right.R;
}
/// <summary>
@ -1225,19 +1225,19 @@ namespace Godot
/// <returns>Whether or not the left is less than or equal to the right.</returns>
public static bool operator <=(Color left, Color right)
{
if (left.r == right.r)
if (left.R == right.R)
{
if (left.g == right.g)
if (left.G == right.G)
{
if (left.b == right.b)
if (left.B == right.B)
{
return left.a <= right.a;
return left.A <= right.A;
}
return left.b < right.b;
return left.B < right.B;
}
return left.g < right.g;
return left.G < right.G;
}
return left.r < right.r;
return left.R < right.R;
}
/// <summary>
@ -1254,19 +1254,19 @@ namespace Godot
/// <returns>Whether or not the left is greater than or equal to the right.</returns>
public static bool operator >=(Color left, Color right)
{
if (left.r == right.r)
if (left.R == right.R)
{
if (left.g == right.g)
if (left.G == right.G)
{
if (left.b == right.b)
if (left.B == right.B)
{
return left.a >= right.a;
return left.A >= right.A;
}
return left.b > right.b;
return left.B > right.B;
}
return left.g > right.g;
return left.G > right.G;
}
return left.r > right.r;
return left.R > right.R;
}
/// <summary>
@ -1288,7 +1288,7 @@ namespace Godot
/// <returns>Whether or not the colors are equal.</returns>
public readonly bool Equals(Color other)
{
return r == other.r && g == other.g && b == other.b && a == other.a;
return R == other.R && G == other.G && B == other.B && A == other.A;
}
/// <summary>
@ -1299,7 +1299,7 @@ namespace Godot
/// <returns>Whether or not the colors are approximately equal.</returns>
public readonly bool IsEqualApprox(Color other)
{
return Mathf.IsEqualApprox(r, other.r) && Mathf.IsEqualApprox(g, other.g) && Mathf.IsEqualApprox(b, other.b) && Mathf.IsEqualApprox(a, other.a);
return Mathf.IsEqualApprox(R, other.R) && Mathf.IsEqualApprox(G, other.G) && Mathf.IsEqualApprox(B, other.B) && Mathf.IsEqualApprox(A, other.A);
}
/// <summary>
@ -1308,7 +1308,7 @@ namespace Godot
/// <returns>A hash code for this color.</returns>
public override readonly int GetHashCode()
{
return r.GetHashCode() ^ g.GetHashCode() ^ b.GetHashCode() ^ a.GetHashCode();
return R.GetHashCode() ^ G.GetHashCode() ^ B.GetHashCode() ^ A.GetHashCode();
}
/// <summary>
@ -1317,7 +1317,7 @@ namespace Godot
/// <returns>A string representation of this color.</returns>
public override readonly string ToString()
{
return $"({r}, {g}, {b}, {a})";
return $"({R}, {G}, {B}, {A})";
}
/// <summary>
@ -1326,7 +1326,7 @@ namespace Godot
/// <returns>A string representation of this color.</returns>
public readonly string ToString(string format)
{
return $"({r.ToString(format)}, {g.ToString(format)}, {b.ToString(format)}, {a.ToString(format)})";
return $"({R.ToString(format)}, {G.ToString(format)}, {B.ToString(format)}, {A.ToString(format)})";
}
}
}

32
modules/mono/glue/GodotSharp/GodotSharp/Core/DelegateUtils.cs
View File

@ -581,31 +581,31 @@ namespace Godot
return VariantUtils.CreateFrom(@double);
case Vector2 vector2:
return VariantUtils.CreateFrom(vector2);
case Vector2i vector2I:
case Vector2I vector2I:
return VariantUtils.CreateFrom(vector2I);
case Rect2 rect2:
return VariantUtils.CreateFrom(rect2);
case Rect2i rect2I:
case Rect2I rect2I:
return VariantUtils.CreateFrom(rect2I);
case Transform2D transform2D:
return VariantUtils.CreateFrom(transform2D);
case Vector3 vector3:
return VariantUtils.CreateFrom(vector3);
case Vector3i vector3I:
case Vector3I vector3I:
return VariantUtils.CreateFrom(vector3I);
case Vector4 vector4:
return VariantUtils.CreateFrom(vector4);
case Vector4i vector4I:
case Vector4I vector4I:
return VariantUtils.CreateFrom(vector4I);
case Basis basis:
return VariantUtils.CreateFrom(basis);
case Quaternion quaternion:
return VariantUtils.CreateFrom(quaternion);
case Transform3D transform3d:
return VariantUtils.CreateFrom(transform3d);
case Transform3D transform3D:
return VariantUtils.CreateFrom(transform3D);
case Projection projection:
return VariantUtils.CreateFrom(projection);
case AABB aabb:
case Aabb aabb:
return VariantUtils.CreateFrom(aabb);
case Color color:
return VariantUtils.CreateFrom(color);
@ -639,7 +639,7 @@ namespace Godot
return VariantUtils.CreateFrom(stringNameArray);
case NodePath[] nodePathArray:
return VariantUtils.CreateFrom(nodePathArray);
case RID[] ridArray:
case Rid[] ridArray:
return VariantUtils.CreateFrom(ridArray);
case Godot.Object[] godotObjectArray:
return VariantUtils.CreateFrom(godotObjectArray);
@ -647,7 +647,7 @@ namespace Godot
return VariantUtils.CreateFrom(stringName);
case NodePath nodePath:
return VariantUtils.CreateFrom(nodePath);
case RID rid:
case Rid rid:
return VariantUtils.CreateFrom(rid);
case Collections.Dictionary godotDictionary:
return VariantUtils.CreateFrom(godotDictionary);
@ -690,18 +690,18 @@ namespace Godot
[typeof(float)] = (in godot_variant variant) => VariantUtils.ConvertTo<float>(variant),
[typeof(double)] = (in godot_variant variant) => VariantUtils.ConvertTo<double>(variant),
[typeof(Vector2)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector2>(variant),
[typeof(Vector2i)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector2i>(variant),
[typeof(Vector2I)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector2I>(variant),
[typeof(Rect2)] = (in godot_variant variant) => VariantUtils.ConvertTo<Rect2>(variant),
[typeof(Rect2i)] = (in godot_variant variant) => VariantUtils.ConvertTo<Rect2i>(variant),
[typeof(Rect2I)] = (in godot_variant variant) => VariantUtils.ConvertTo<Rect2I>(variant),
[typeof(Transform2D)] = (in godot_variant variant) => VariantUtils.ConvertTo<Transform2D>(variant),
[typeof(Vector3)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector3>(variant),
[typeof(Vector3i)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector3i>(variant),
[typeof(Vector3I)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector3I>(variant),
[typeof(Basis)] = (in godot_variant variant) => VariantUtils.ConvertTo<Basis>(variant),
[typeof(Quaternion)] = (in godot_variant variant) => VariantUtils.ConvertTo<Quaternion>(variant),
[typeof(Transform3D)] = (in godot_variant variant) => VariantUtils.ConvertTo<Transform3D>(variant),
[typeof(Vector4)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector4>(variant),
[typeof(Vector4i)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector4i>(variant),
[typeof(AABB)] = (in godot_variant variant) => VariantUtils.ConvertTo<AABB>(variant),
[typeof(Vector4I)] = (in godot_variant variant) => VariantUtils.ConvertTo<Vector4I>(variant),
[typeof(Aabb)] = (in godot_variant variant) => VariantUtils.ConvertTo<Aabb>(variant),
[typeof(Color)] = (in godot_variant variant) => VariantUtils.ConvertTo<Color>(variant),
[typeof(Plane)] = (in godot_variant variant) => VariantUtils.ConvertTo<Plane>(variant),
[typeof(Callable)] = (in godot_variant variant) => VariantUtils.ConvertTo<Callable>(variant),
@ -719,10 +719,10 @@ namespace Godot
[typeof(StringName[])] =
(in godot_variant variant) => VariantUtils.ConvertTo<StringName[]>(variant),
[typeof(NodePath[])] = (in godot_variant variant) => VariantUtils.ConvertTo<NodePath[]>(variant),
[typeof(RID[])] = (in godot_variant variant) => VariantUtils.ConvertTo<RID[]>(variant),
[typeof(Rid[])] = (in godot_variant variant) => VariantUtils.ConvertTo<Rid[]>(variant),
[typeof(StringName)] = (in godot_variant variant) => VariantUtils.ConvertTo<StringName>(variant),
[typeof(NodePath)] = (in godot_variant variant) => VariantUtils.ConvertTo<NodePath>(variant),
[typeof(RID)] = (in godot_variant variant) => VariantUtils.ConvertTo<RID>(variant),
[typeof(Rid)] = (in godot_variant variant) => VariantUtils.ConvertTo<Rid>(variant),
[typeof(Godot.Collections.Dictionary)] = (in godot_variant variant) =>
VariantUtils.ConvertTo<Godot.Collections.Dictionary>(variant),
[typeof(Godot.Collections.Array)] =

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

@ -28,7 +28,7 @@ namespace Godot
try
{
isStdoutVerbose = OS.IsStdoutVerbose();
isStdoutVerbose = OS.IsStdOutVerbose();
}
catch (ObjectDisposedException)
{

40
modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/InteropStructs.cs
View File

@ -126,10 +126,10 @@ namespace Godot.NativeInterop
[FieldOffset(0)] public godot_bool _bool;
[FieldOffset(0)] public long _int;
[FieldOffset(0)] public double _float;
[FieldOffset(0)] public Transform2D* _transform2D;
[FieldOffset(0)] public AABB* _aabb;
[FieldOffset(0)] public Transform2D* _transform2d;
[FieldOffset(0)] public Aabb* _aabb;
[FieldOffset(0)] public Basis* _basis;
[FieldOffset(0)] public Transform3D* _transform3D;
[FieldOffset(0)] public Transform3D* _transform3d;
[FieldOffset(0)] public Projection* _projection;
[FieldOffset(0)] private godot_variant_data_mem _mem;
@ -137,18 +137,18 @@ namespace Godot.NativeInterop
[FieldOffset(0)] public godot_string_name _m_string_name;
[FieldOffset(0)] public godot_string _m_string;
[FieldOffset(0)] public Vector4 _m_vector4;
[FieldOffset(0)] public Vector4i _m_vector4i;
[FieldOffset(0)] public Vector4I _m_vector4i;
[FieldOffset(0)] public Vector3 _m_vector3;
[FieldOffset(0)] public Vector3i _m_vector3i;
[FieldOffset(0)] public Vector3I _m_vector3i;
[FieldOffset(0)] public Vector2 _m_vector2;
[FieldOffset(0)] public Vector2i _m_vector2i;
[FieldOffset(0)] public Vector2I _m_vector2i;
[FieldOffset(0)] public Rect2 _m_rect2;
[FieldOffset(0)] public Rect2i _m_rect2i;
[FieldOffset(0)] public Rect2I _m_rect2i;
[FieldOffset(0)] public Plane _m_plane;
[FieldOffset(0)] public Quaternion _m_quaternion;
[FieldOffset(0)] public Color _m_color;
[FieldOffset(0)] public godot_node_path _m_node_path;
[FieldOffset(0)] public RID _m_rid;
[FieldOffset(0)] public Rid _m_rid;
[FieldOffset(0)] public godot_variant_obj_data _m_obj_data;
[FieldOffset(0)] public godot_callable _m_callable;
[FieldOffset(0)] public godot_signal _m_signal;
@ -211,10 +211,10 @@ namespace Godot.NativeInterop
public readonly unsafe Transform2D* Transform2D
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => _data._transform2D;
get => _data._transform2d;
}
public readonly unsafe AABB* AABB
public readonly unsafe Aabb* Aabb
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => _data._aabb;
@ -229,7 +229,7 @@ namespace Godot.NativeInterop
public readonly unsafe Transform3D* Transform3D
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => _data._transform3D;
get => _data._transform3d;
}
public readonly unsafe Projection* Projection
@ -262,7 +262,7 @@ namespace Godot.NativeInterop
set => _data._m_vector4 = value;
}
public Vector4i Vector4i
public Vector4I Vector4I
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
readonly get => _data._m_vector4i;
@ -278,7 +278,7 @@ namespace Godot.NativeInterop
set => _data._m_vector3 = value;
}
public Vector3i Vector3i
public Vector3I Vector3I
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
readonly get => _data._m_vector3i;
@ -294,7 +294,7 @@ namespace Godot.NativeInterop
set => _data._m_vector2 = value;
}
public Vector2i Vector2i
public Vector2I Vector2I
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
readonly get => _data._m_vector2i;
@ -310,7 +310,7 @@ namespace Godot.NativeInterop
set => _data._m_rect2 = value;
}
public Rect2i Rect2i
public Rect2I Rect2I
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
readonly get => _data._m_rect2i;
@ -350,7 +350,7 @@ namespace Godot.NativeInterop
set => _data._m_node_path = value;
}
public RID RID
public Rid Rid
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
readonly get => _data._m_rid;
@ -405,13 +405,13 @@ namespace Godot.NativeInterop
case Variant.Type.Int:
case Variant.Type.Float:
case Variant.Type.Vector2:
case Variant.Type.Vector2i:
case Variant.Type.Vector2I:
case Variant.Type.Rect2:
case Variant.Type.Rect2i:
case Variant.Type.Rect2I:
case Variant.Type.Vector3:
case Variant.Type.Vector3i:
case Variant.Type.Vector3I:
case Variant.Type.Vector4:
case Variant.Type.Vector4i:
case Variant.Type.Vector4I:
case Variant.Type.Plane:
case Variant.Type.Quaternion:
case Variant.Type.Color:

32
modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/Marshaling.cs
View File

@ -51,29 +51,29 @@ namespace Godot.NativeInterop
if (type == typeof(Vector2))
return Variant.Type.Vector2;
if (type == typeof(Vector2i))
return Variant.Type.Vector2i;
if (type == typeof(Vector2I))
return Variant.Type.Vector2I;
if (type == typeof(Rect2))
return Variant.Type.Rect2;
if (type == typeof(Rect2i))
return Variant.Type.Rect2i;
if (type == typeof(Rect2I))
return Variant.Type.Rect2I;
if (type == typeof(Transform2D))
return Variant.Type.Transform2d;
return Variant.Type.Transform2D;
if (type == typeof(Vector3))
return Variant.Type.Vector3;
if (type == typeof(Vector3i))
return Variant.Type.Vector3i;
if (type == typeof(Vector3I))
return Variant.Type.Vector3I;
if (type == typeof(Vector4))
return Variant.Type.Vector4;
if (type == typeof(Vector4i))
return Variant.Type.Vector4i;
if (type == typeof(Vector4I))
return Variant.Type.Vector4I;
if (type == typeof(Basis))
return Variant.Type.Basis;
@ -82,12 +82,12 @@ namespace Godot.NativeInterop
return Variant.Type.Quaternion;
if (type == typeof(Transform3D))
return Variant.Type.Transform3d;
return Variant.Type.Transform3D;
if (type == typeof(Projection))
return Variant.Type.Projection;
if (type == typeof(AABB))
if (type == typeof(Aabb))
return Variant.Type.Aabb;
if (type == typeof(Color))
@ -140,7 +140,7 @@ namespace Godot.NativeInterop
if (type == typeof(NodePath[]))
return Variant.Type.Array;
if (type == typeof(RID[]))
if (type == typeof(Rid[]))
return Variant.Type.Array;
if (typeof(Godot.Object[]).IsAssignableFrom(type))
@ -176,7 +176,7 @@ namespace Godot.NativeInterop
if (typeof(NodePath) == type)
return Variant.Type.NodePath;
if (typeof(RID) == type)
if (typeof(Rid) == type)
return Variant.Type.Rid;
if (typeof(Collections.Dictionary) == type)
@ -361,16 +361,16 @@ namespace Godot.NativeInterop
return ret;
}
internal static RID[] ConvertNativeGodotArrayToSystemArrayOfRID(in godot_array p_array)
internal static Rid[] ConvertNativeGodotArrayToSystemArrayOfRid(in godot_array p_array)
{
var array = Collections.Array.CreateTakingOwnershipOfDisposableValue(
NativeFuncs.godotsharp_array_new_copy(p_array));
int length = array.Count;
var ret = new RID[length];
var ret = new Rid[length];
for (int i = 0; i < length; i++)
ret[i] = array[i].AsRID();
ret[i] = array[i].AsRid();
return ret;
}

14
modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/NativeFuncs.cs
View File

@ -184,7 +184,7 @@ namespace Godot.NativeInterop
public static partial void godotsharp_variant_new_projection(out godot_variant r_dest, in Projection p_proj);
public static partial void godotsharp_variant_new_aabb(out godot_variant r_dest, in AABB p_aabb);
public static partial void godotsharp_variant_new_aabb(out godot_variant r_dest, in Aabb p_aabb);
public static partial void godotsharp_variant_new_dictionary(out godot_variant r_dest,
in godot_dictionary p_dict);
@ -228,27 +228,27 @@ namespace Godot.NativeInterop
public static partial Vector2 godotsharp_variant_as_vector2(in godot_variant p_self);
public static partial Vector2i godotsharp_variant_as_vector2i(in godot_variant p_self);
public static partial Vector2I godotsharp_variant_as_vector2i(in godot_variant p_self);
public static partial Rect2 godotsharp_variant_as_rect2(in godot_variant p_self);
public static partial Rect2i godotsharp_variant_as_rect2i(in godot_variant p_self);
public static partial Rect2I godotsharp_variant_as_rect2i(in godot_variant p_self);
public static partial Vector3 godotsharp_variant_as_vector3(in godot_variant p_self);
public static partial Vector3i godotsharp_variant_as_vector3i(in godot_variant p_self);
public static partial Vector3I godotsharp_variant_as_vector3i(in godot_variant p_self);
public static partial Transform2D godotsharp_variant_as_transform2d(in godot_variant p_self);
public static partial Vector4 godotsharp_variant_as_vector4(in godot_variant p_self);
public static partial Vector4i godotsharp_variant_as_vector4i(in godot_variant p_self);
public static partial Vector4I godotsharp_variant_as_vector4i(in godot_variant p_self);
public static partial Plane godotsharp_variant_as_plane(in godot_variant p_self);
public static partial Quaternion godotsharp_variant_as_quaternion(in godot_variant p_self);
public static partial AABB godotsharp_variant_as_aabb(in godot_variant p_self);
public static partial Aabb godotsharp_variant_as_aabb(in godot_variant p_self);
public static partial Basis godotsharp_variant_as_basis(in godot_variant p_self);
@ -262,7 +262,7 @@ namespace Godot.NativeInterop
public static partial godot_node_path godotsharp_variant_as_node_path(in godot_variant p_self);
public static partial RID godotsharp_variant_as_rid(in godot_variant p_self);
public static partial Rid godotsharp_variant_as_rid(in godot_variant p_self);
public static partial godot_callable godotsharp_variant_as_callable(in godot_variant p_self);

18
modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/NativeFuncs.extended.cs
View File

@ -18,20 +18,20 @@ namespace Godot.NativeInterop
return new godot_variant() { Float = src.Float, Type = Variant.Type.Float };
case Variant.Type.Vector2:
return new godot_variant() { Vector2 = src.Vector2, Type = Variant.Type.Vector2 };
case Variant.Type.Vector2i:
return new godot_variant() { Vector2i = src.Vector2i, Type = Variant.Type.Vector2i };
case Variant.Type.Vector2I:
return new godot_variant() { Vector2I = src.Vector2I, Type = Variant.Type.Vector2I };
case Variant.Type.Rect2:
return new godot_variant() { Rect2 = src.Rect2, Type = Variant.Type.Rect2 };
case Variant.Type.Rect2i:
return new godot_variant() { Rect2i = src.Rect2i, Type = Variant.Type.Rect2i };
case Variant.Type.Rect2I:
return new godot_variant() { Rect2I = src.Rect2I, Type = Variant.Type.Rect2I };
case Variant.Type.Vector3:
return new godot_variant() { Vector3 = src.Vector3, Type = Variant.Type.Vector3 };
case Variant.Type.Vector3i:
return new godot_variant() { Vector3i = src.Vector3i, Type = Variant.Type.Vector3i };
case Variant.Type.Vector3I:
return new godot_variant() { Vector3I = src.Vector3I, Type = Variant.Type.Vector3I };
case Variant.Type.Vector4:
return new godot_variant() { Vector4 = src.Vector4, Type = Variant.Type.Vector4 };
case Variant.Type.Vector4i:
return new godot_variant() { Vector4i = src.Vector4i, Type = Variant.Type.Vector4i };
case Variant.Type.Vector4I:
return new godot_variant() { Vector4I = src.Vector4I, Type = Variant.Type.Vector4I };
case Variant.Type.Plane:
return new godot_variant() { Plane = src.Plane, Type = Variant.Type.Plane };
case Variant.Type.Quaternion:
@ -39,7 +39,7 @@ namespace Godot.NativeInterop
case Variant.Type.Color:
return new godot_variant() { Color = src.Color, Type = Variant.Type.Color };
case Variant.Type.Rid:
return new godot_variant() { RID = src.RID, Type = Variant.Type.Rid };
return new godot_variant() { Rid = src.Rid, Type = Variant.Type.Rid };
}
godotsharp_variant_new_copy(out godot_variant ret, src);

64
modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/VariantUtils.cs
View File

@ -10,8 +10,8 @@ namespace Godot.NativeInterop
{
public static partial class VariantUtils
{
public static godot_variant CreateFromRID(RID from)
=> new() { Type = Variant.Type.Rid, RID = from };
public static godot_variant CreateFromRid(Rid from)
=> new() { Type = Variant.Type.Rid, Rid = from };
public static godot_variant CreateFromBool(bool from)
=> new() { Type = Variant.Type.Bool, Bool = from.ToGodotBool() };
@ -28,26 +28,26 @@ namespace Godot.NativeInterop
public static godot_variant CreateFromVector2(Vector2 from)
=> new() { Type = Variant.Type.Vector2, Vector2 = from };
public static godot_variant CreateFromVector2i(Vector2i from)
=> new() { Type = Variant.Type.Vector2i, Vector2i = from };
public static godot_variant CreateFromVector2I(Vector2I from)
=> new() { Type = Variant.Type.Vector2I, Vector2I = from };
public static godot_variant CreateFromVector3(Vector3 from)
=> new() { Type = Variant.Type.Vector3, Vector3 = from };
public static godot_variant CreateFromVector3i(Vector3i from)
=> new() { Type = Variant.Type.Vector3i, Vector3i = from };
public static godot_variant CreateFromVector3I(Vector3I from)
=> new() { Type = Variant.Type.Vector3I, Vector3I = from };
public static godot_variant CreateFromVector4(Vector4 from)
=> new() { Type = Variant.Type.Vector4, Vector4 = from };
public static godot_variant CreateFromVector4i(Vector4i from)
=> new() { Type = Variant.Type.Vector4i, Vector4i = from };
public static godot_variant CreateFromVector4I(Vector4I from)
=> new() { Type = Variant.Type.Vector4I, Vector4I = from };
public static godot_variant CreateFromRect2(Rect2 from)
=> new() { Type = Variant.Type.Rect2, Rect2 = from };
public static godot_variant CreateFromRect2i(Rect2i from)
=> new() { Type = Variant.Type.Rect2i, Rect2i = from };
public static godot_variant CreateFromRect2I(Rect2I from)
=> new() { Type = Variant.Type.Rect2I, Rect2I = from };
public static godot_variant CreateFromQuaternion(Quaternion from)
=> new() { Type = Variant.Type.Quaternion, Quaternion = from };
@ -82,7 +82,7 @@ namespace Godot.NativeInterop
return ret;
}
public static godot_variant CreateFromAABB(AABB from)
public static godot_variant CreateFromAabb(Aabb from)
{
NativeFuncs.godotsharp_variant_new_aabb(out godot_variant ret, from);
return ret;
@ -237,7 +237,7 @@ namespace Godot.NativeInterop
public static godot_variant CreateFromSystemArrayOfNodePath(Span<NodePath> from)
=> CreateFromArray(new Collections.Array(from));
public static godot_variant CreateFromSystemArrayOfRID(Span<RID> from)
public static godot_variant CreateFromSystemArrayOfRid(Span<Rid> from)
=> CreateFromArray(new Collections.Array(from));
// ReSharper disable once RedundantNameQualifier
@ -375,9 +375,9 @@ namespace Godot.NativeInterop
p_var.Vector2 :
NativeFuncs.godotsharp_variant_as_vector2(p_var);
public static Vector2i ConvertToVector2i(in godot_variant p_var)
=> p_var.Type == Variant.Type.Vector2i ?
p_var.Vector2i :
public static Vector2I ConvertToVector2I(in godot_variant p_var)
=> p_var.Type == Variant.Type.Vector2I ?
p_var.Vector2I :
NativeFuncs.godotsharp_variant_as_vector2i(p_var);
public static Rect2 ConvertToRect2(in godot_variant p_var)
@ -385,13 +385,13 @@ namespace Godot.NativeInterop
p_var.Rect2 :
NativeFuncs.godotsharp_variant_as_rect2(p_var);
public static Rect2i ConvertToRect2i(in godot_variant p_var)
=> p_var.Type == Variant.Type.Rect2i ?
p_var.Rect2i :
public static Rect2I ConvertToRect2I(in godot_variant p_var)
=> p_var.Type == Variant.Type.Rect2I ?
p_var.Rect2I :
NativeFuncs.godotsharp_variant_as_rect2i(p_var);
public static unsafe Transform2D ConvertToTransform2D(in godot_variant p_var)
=> p_var.Type == Variant.Type.Transform2d ?
=> p_var.Type == Variant.Type.Transform2D ?
*p_var.Transform2D :
NativeFuncs.godotsharp_variant_as_transform2d(p_var);
@ -400,9 +400,9 @@ namespace Godot.NativeInterop
p_var.Vector3 :
NativeFuncs.godotsharp_variant_as_vector3(p_var);
public static Vector3i ConvertToVector3i(in godot_variant p_var)
=> p_var.Type == Variant.Type.Vector3i ?
p_var.Vector3i :
public static Vector3I ConvertToVector3I(in godot_variant p_var)
=> p_var.Type == Variant.Type.Vector3I ?
p_var.Vector3I :
NativeFuncs.godotsharp_variant_as_vector3i(p_var);
public static unsafe Vector4 ConvertToVector4(in godot_variant p_var)
@ -410,9 +410,9 @@ namespace Godot.NativeInterop
p_var.Vector4 :
NativeFuncs.godotsharp_variant_as_vector4(p_var);
public static unsafe Vector4i ConvertToVector4i(in godot_variant p_var)
=> p_var.Type == Variant.Type.Vector4i ?
p_var.Vector4i :
public static unsafe Vector4I ConvertToVector4I(in godot_variant p_var)
=> p_var.Type == Variant.Type.Vector4I ?
p_var.Vector4I :
NativeFuncs.godotsharp_variant_as_vector4i(p_var);
public static unsafe Basis ConvertToBasis(in godot_variant p_var)
@ -426,7 +426,7 @@ namespace Godot.NativeInterop
NativeFuncs.godotsharp_variant_as_quaternion(p_var);
public static unsafe Transform3D ConvertToTransform3D(in godot_variant p_var)
=> p_var.Type == Variant.Type.Transform3d ?
=> p_var.Type == Variant.Type.Transform3D ?
*p_var.Transform3D :
NativeFuncs.godotsharp_variant_as_transform3d(p_var);
@ -435,9 +435,9 @@ namespace Godot.NativeInterop
*p_var.Projection :
NativeFuncs.godotsharp_variant_as_projection(p_var);
public static unsafe AABB ConvertToAABB(in godot_variant p_var)
public static unsafe Aabb ConvertToAabb(in godot_variant p_var)
=> p_var.Type == Variant.Type.Aabb ?
*p_var.AABB :
*p_var.Aabb :
NativeFuncs.godotsharp_variant_as_aabb(p_var);
public static Color ConvertToColor(in godot_variant p_var)
@ -450,9 +450,9 @@ namespace Godot.NativeInterop
p_var.Plane :
NativeFuncs.godotsharp_variant_as_plane(p_var);
public static RID ConvertToRID(in godot_variant p_var)
public static Rid ConvertToRid(in godot_variant p_var)
=> p_var.Type == Variant.Type.Rid ?
p_var.RID :
p_var.Rid :
NativeFuncs.godotsharp_variant_as_rid(p_var);
public static IntPtr ConvertToGodotObjectPtr(in godot_variant p_var)
@ -608,10 +608,10 @@ namespace Godot.NativeInterop
return Marshaling.ConvertNativeGodotArrayToSystemArrayOfNodePath(godotArray);
}
public static RID[] ConvertToSystemArrayOfRID(in godot_variant p_var)
public static Rid[] ConvertToSystemArrayOfRid(in godot_variant p_var)
{
using var godotArray = NativeFuncs.godotsharp_variant_as_array(p_var);
return Marshaling.ConvertNativeGodotArrayToSystemArrayOfRID(godotArray);
return Marshaling.ConvertNativeGodotArrayToSystemArrayOfRid(godotArray);
}
public static T[] ConvertToSystemArrayOfGodotObject<T>(in godot_variant p_var)

56
modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/VariantUtils.generic.cs
View File

@ -80,14 +80,14 @@ public partial class VariantUtils
if (typeof(T) == typeof(Vector2))
return CreateFromVector2(UnsafeAs<Vector2>(from));
if (typeof(T) == typeof(Vector2i))
return CreateFromVector2i(UnsafeAs<Vector2i>(from));
if (typeof(T) == typeof(Vector2I))
return CreateFromVector2I(UnsafeAs<Vector2I>(from));
if (typeof(T) == typeof(Rect2))
return CreateFromRect2(UnsafeAs<Rect2>(from));
if (typeof(T) == typeof(Rect2i))
return CreateFromRect2i(UnsafeAs<Rect2i>(from));
if (typeof(T) == typeof(Rect2I))
return CreateFromRect2I(UnsafeAs<Rect2I>(from));
if (typeof(T) == typeof(Transform2D))
return CreateFromTransform2D(UnsafeAs<Transform2D>(from));
@ -98,8 +98,8 @@ public partial class VariantUtils
if (typeof(T) == typeof(Vector3))
return CreateFromVector3(UnsafeAs<Vector3>(from));
if (typeof(T) == typeof(Vector3i))
return CreateFromVector3i(UnsafeAs<Vector3i>(from));
if (typeof(T) == typeof(Vector3I))
return CreateFromVector3I(UnsafeAs<Vector3I>(from));
if (typeof(T) == typeof(Basis))
return CreateFromBasis(UnsafeAs<Basis>(from));
@ -113,11 +113,11 @@ public partial class VariantUtils
if (typeof(T) == typeof(Vector4))
return CreateFromVector4(UnsafeAs<Vector4>(from));
if (typeof(T) == typeof(Vector4i))
return CreateFromVector4i(UnsafeAs<Vector4i>(from));
if (typeof(T) == typeof(Vector4I))
return CreateFromVector4I(UnsafeAs<Vector4I>(from));
if (typeof(T) == typeof(AABB))
return CreateFromAABB(UnsafeAs<AABB>(from));
if (typeof(T) == typeof(Aabb))
return CreateFromAabb(UnsafeAs<Aabb>(from));
if (typeof(T) == typeof(Color))
return CreateFromColor(UnsafeAs<Color>(from));
@ -167,8 +167,8 @@ public partial class VariantUtils
if (typeof(T) == typeof(NodePath[]))
return CreateFromSystemArrayOfNodePath(UnsafeAs<NodePath[]>(from));
if (typeof(T) == typeof(RID[]))
return CreateFromSystemArrayOfRID(UnsafeAs<RID[]>(from));
if (typeof(T) == typeof(Rid[]))
return CreateFromSystemArrayOfRid(UnsafeAs<Rid[]>(from));
if (typeof(T) == typeof(StringName))
return CreateFromStringName(UnsafeAs<StringName>(from));
@ -176,8 +176,8 @@ public partial class VariantUtils
if (typeof(T) == typeof(NodePath))
return CreateFromNodePath(UnsafeAs<NodePath>(from));
if (typeof(T) == typeof(RID))
return CreateFromRID(UnsafeAs<RID>(from));
if (typeof(T) == typeof(Rid))
return CreateFromRid(UnsafeAs<Rid>(from));
if (typeof(T) == typeof(Godot.Collections.Dictionary))
return CreateFromDictionary(UnsafeAs<Godot.Collections.Dictionary>(from));
@ -269,14 +269,14 @@ public partial class VariantUtils
if (typeof(T) == typeof(Vector2))
return UnsafeAsT(ConvertToVector2(variant));
if (typeof(T) == typeof(Vector2i))
return UnsafeAsT(ConvertToVector2i(variant));
if (typeof(T) == typeof(Vector2I))
return UnsafeAsT(ConvertToVector2I(variant));
if (typeof(T) == typeof(Rect2))
return UnsafeAsT(ConvertToRect2(variant));
if (typeof(T) == typeof(Rect2i))
return UnsafeAsT(ConvertToRect2i(variant));
if (typeof(T) == typeof(Rect2I))
return UnsafeAsT(ConvertToRect2I(variant));
if (typeof(T) == typeof(Transform2D))
return UnsafeAsT(ConvertToTransform2D(variant));
@ -284,8 +284,8 @@ public partial class VariantUtils
if (typeof(T) == typeof(Vector3))
return UnsafeAsT(ConvertToVector3(variant));
if (typeof(T) == typeof(Vector3i))
return UnsafeAsT(ConvertToVector3i(variant));
if (typeof(T) == typeof(Vector3I))
return UnsafeAsT(ConvertToVector3I(variant));
if (typeof(T) == typeof(Basis))
return UnsafeAsT(ConvertToBasis(variant));
@ -302,11 +302,11 @@ public partial class VariantUtils
if (typeof(T) == typeof(Vector4))
return UnsafeAsT(ConvertToVector4(variant));
if (typeof(T) == typeof(Vector4i))
return UnsafeAsT(ConvertToVector4i(variant));
if (typeof(T) == typeof(Vector4I))
return UnsafeAsT(ConvertToVector4I(variant));
if (typeof(T) == typeof(AABB))
return UnsafeAsT(ConvertToAABB(variant));
if (typeof(T) == typeof(Aabb))
return UnsafeAsT(ConvertToAabb(variant));
if (typeof(T) == typeof(Color))
return UnsafeAsT(ConvertToColor(variant));
@ -356,8 +356,8 @@ public partial class VariantUtils
if (typeof(T) == typeof(NodePath[]))
return UnsafeAsT(ConvertToSystemArrayOfNodePath(variant));
if (typeof(T) == typeof(RID[]))
return UnsafeAsT(ConvertToSystemArrayOfRID(variant));
if (typeof(T) == typeof(Rid[]))
return UnsafeAsT(ConvertToSystemArrayOfRid(variant));
if (typeof(T) == typeof(StringName))
return UnsafeAsT(ConvertToStringName(variant));
@ -365,8 +365,8 @@ public partial class VariantUtils
if (typeof(T) == typeof(NodePath))
return UnsafeAsT(ConvertToNodePath(variant));
if (typeof(T) == typeof(RID))
return UnsafeAsT(ConvertToRID(variant));
if (typeof(T) == typeof(Rid))
return UnsafeAsT(ConvertToRid(variant));
if (typeof(T) == typeof(Godot.Collections.Dictionary))
return UnsafeAsT(ConvertToDictionary(variant));

147
modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs
View File

@ -13,67 +13,20 @@ namespace Godot
public struct Plane : IEquatable<Plane>
{
private Vector3 _normal;
private real_t _d;
/// <summary>
/// The normal of the plane, which must be a unit vector.
/// In the scalar equation of the plane <c>ax + by + cz = d</c>, this is
/// the vector <c>(a, b, c)</c>, where <c>d</c> is the <see cref="D"/> property.
/// </summary>
/// <value>Equivalent to <see cref="x"/>, <see cref="y"/>, and <see cref="z"/>.</value>
/// <value>Equivalent to <see cref="X"/>, <see cref="Y"/>, and <see cref="Z"/>.</value>
public Vector3 Normal
{
readonly get { return _normal; }
set { _normal = value; }
}
/// <summary>
/// The X component of the plane's normal vector.
/// </summary>
/// <value>Equivalent to <see cref="Normal"/>'s X value.</value>
public real_t x
{
readonly get
{
return _normal.x;
}
set
{
_normal.x = value;
}
}
/// <summary>
/// The Y component of the plane's normal vector.
/// </summary>
/// <value>Equivalent to <see cref="Normal"/>'s Y value.</value>
public real_t y
{
readonly get
{
return _normal.y;
}
set
{
_normal.y = value;
}
}
/// <summary>
/// The Z component of the plane's normal vector.
/// </summary>
/// <value>Equivalent to <see cref="Normal"/>'s Z value.</value>
public real_t z
{
readonly get
{
return _normal.z;
}
set
{
_normal.z = value;
}
}
/// <summary>
/// The distance from the origin to the plane (in the direction of
/// <see cref="Normal"/>). This value is typically non-negative.
@ -82,7 +35,59 @@ namespace Godot
/// by the <see cref="Normal"/> property.
/// </summary>
/// <value>The plane's distance from the origin.</value>
public real_t D { get; set; }
public real_t D
{
readonly get { return _d; }
set { _d = value; }
}
/// <summary>
/// The X component of the plane's normal vector.
/// </summary>
/// <value>Equivalent to <see cref="Normal"/>'s X value.</value>
public real_t X
{
readonly get
{
return _normal.X;
}
set
{
_normal.X = value;
}
}
/// <summary>
/// The Y component of the plane's normal vector.
/// </summary>
/// <value>Equivalent to <see cref="Normal"/>'s Y value.</value>
public real_t Y
{
readonly get
{
return _normal.Y;
}
set
{
_normal.Y = value;
}
}
/// <summary>
/// The Z component of the plane's normal vector.
/// </summary>
/// <value>Equivalent to <see cref="Normal"/>'s Z value.</value>
public real_t Z
{
readonly get
{
return _normal.Z;
}
set
{
_normal.Z = value;
}
}
/// <summary>
/// Returns the shortest distance from this plane to the position <paramref name="point"/>.
@ -91,7 +96,7 @@ namespace Godot
/// <returns>The shortest distance.</returns>
public readonly real_t DistanceTo(Vector3 point)
{
return _normal.Dot(point) - D;
return _normal.Dot(point) - _d;
}
/// <summary>
@ -101,7 +106,7 @@ namespace Godot
/// <value>Equivalent to <see cref="Normal"/> multiplied by <see cref="D"/>.</value>
public readonly Vector3 GetCenter()
{
return _normal * D;
return _normal * _d;
}
/// <summary>
@ -113,7 +118,7 @@ namespace Godot
/// <returns>A <see langword="bool"/> for whether or not the plane has the point.</returns>
public readonly bool HasPoint(Vector3 point, real_t tolerance = Mathf.Epsilon)
{
real_t dist = _normal.Dot(point) - D;
real_t dist = _normal.Dot(point) - _d;
return Mathf.Abs(dist) <= tolerance;
}
@ -133,9 +138,9 @@ namespace Godot
return null;
}
Vector3 result = (b._normal.Cross(c._normal) * D) +
(c._normal.Cross(_normal) * b.D) +
(_normal.Cross(b._normal) * c.D);
Vector3 result = (b._normal.Cross(c._normal) * _d) +
(c._normal.Cross(_normal) * b._d) +
(_normal.Cross(b._normal) * c._d);
return result / denom;
}
@ -157,7 +162,7 @@ namespace Godot
return null;
}
real_t dist = (_normal.Dot(from) - D) / den;
real_t dist = (_normal.Dot(from) - _d) / den;
// This is a ray, before the emitting pos (from) does not exist
if (dist > Mathf.Epsilon)
@ -186,7 +191,7 @@ namespace Godot
return null;
}
real_t dist = (_normal.Dot(begin) - D) / den;
real_t dist = (_normal.Dot(begin) - _d) / den;
// Only allow dist to be in the range of 0 to 1, with tolerance.
if (dist < -Mathf.Epsilon || dist > 1.0f + Mathf.Epsilon)
@ -214,7 +219,7 @@ namespace Godot
/// <returns>A <see langword="bool"/> for whether or not the point is above the plane.</returns>
public readonly bool IsPointOver(Vector3 point)
{
return _normal.Dot(point) > D;
return _normal.Dot(point) > _d;
}
/// <summary>
@ -230,7 +235,7 @@ namespace Godot
return new Plane(0, 0, 0, 0);
}
return new Plane(_normal / len, D / len);
return new Plane(_normal / len, _d / len);
}
/// <summary>
@ -279,7 +284,7 @@ namespace Godot
public Plane(real_t a, real_t b, real_t c, real_t d)
{
_normal = new Vector3(a, b, c);
D = d;
_d = d;
}
/// <summary>
@ -290,7 +295,7 @@ namespace Godot
public Plane(Vector3 normal)
{
_normal = normal;
D = 0;
_d = 0;
}
/// <summary>
@ -302,7 +307,7 @@ namespace Godot
public Plane(Vector3 normal, real_t d)
{
_normal = normal;
D = d;
_d = d;
}
/// <summary>
@ -314,7 +319,7 @@ namespace Godot
public Plane(Vector3 normal, Vector3 point)
{
_normal = normal;
D = _normal.Dot(point);
_d = _normal.Dot(point);
}
/// <summary>
@ -327,7 +332,7 @@ namespace Godot
{
_normal = (v1 - v3).Cross(v1 - v2);
_normal.Normalize();
D = _normal.Dot(v1);
_d = _normal.Dot(v1);
}
/// <summary>
@ -341,7 +346,7 @@ namespace Godot
/// <returns>The negated/flipped plane.</returns>
public static Plane operator -(Plane plane)
{
return new Plane(-plane._normal, -plane.D);
return new Plane(-plane._normal, -plane._d);
}
/// <summary>
@ -389,7 +394,7 @@ namespace Godot
/// <returns>Whether or not the planes are exactly equal.</returns>
public readonly bool Equals(Plane other)
{
return _normal == other._normal && D == other.D;
return _normal == other._normal && _d == other._d;
}
/// <summary>
@ -400,7 +405,7 @@ namespace Godot
/// <returns>Whether or not the planes are approximately equal.</returns>
public readonly bool IsEqualApprox(Plane other)
{
return _normal.IsEqualApprox(other._normal) && Mathf.IsEqualApprox(D, other.D);
return _normal.IsEqualApprox(other._normal) && Mathf.IsEqualApprox(_d, other._d);
}
/// <summary>
@ -409,7 +414,7 @@ namespace Godot
/// <returns>A hash code for this plane.</returns>
public override readonly int GetHashCode()
{
return _normal.GetHashCode() ^ D.GetHashCode();
return _normal.GetHashCode() ^ _d.GetHashCode();
}
/// <summary>
@ -418,7 +423,7 @@ namespace Godot
/// <returns>A string representation of this plane.</returns>
public override readonly string ToString()
{
return $"{_normal}, {D}";
return $"{_normal}, {_d}";
}
/// <summary>
@ -427,7 +432,7 @@ namespace Godot
/// <returns>A string representation of this plane.</returns>
public readonly string ToString(string format)
{
return $"{_normal.ToString(format)}, {D.ToString(format)}";
return $"{_normal.ToString(format)}, {_d.ToString(format)}";
}
}
}

254
modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs
View File

@ -49,22 +49,22 @@ namespace Godot
/// <summary>
/// The projection's X column. Also accessible by using the index position <c>[0]</c>.
/// </summary>
public Vector4 x;
public Vector4 X;
/// <summary>
/// The projection's Y column. Also accessible by using the index position <c>[1]</c>.
/// </summary>
public Vector4 y;
public Vector4 Y;
/// <summary>
/// The projection's Z column. Also accessible by using the index position <c>[2]</c>.
/// </summary>
public Vector4 z;
public Vector4 Z;
/// <summary>
/// The projection's W column. Also accessible by using the index position <c>[3]</c>.
/// </summary>
public Vector4 w;
public Vector4 W;
/// <summary>
/// Access whole columns in the form of <see cref="Vector4"/>.
@ -80,13 +80,13 @@ namespace Godot
switch (column)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
case 2:
return z;
return Z;
case 3:
return w;
return W;
default:
throw new ArgumentOutOfRangeException(nameof(column));
}
@ -96,16 +96,16 @@ namespace Godot
switch (column)
{
case 0:
x = value;
X = value;
return;
case 1:
y = value;
Y = value;
return;
case 2:
z = value;
Z = value;
return;
case 3:
w = value;
W = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(column));
@ -128,13 +128,13 @@ namespace Godot
switch (column)
{
case 0:
return x[row];
return X[row];
case 1:
return y[row];
return Y[row];
case 2:
return z[row];
return Z[row];
case 3:
return w[row];
return W[row];
default:
throw new ArgumentOutOfRangeException(nameof(column));
}
@ -144,16 +144,16 @@ namespace Godot
switch (column)
{
case 0:
x[row] = value;
X[row] = value;
return;
case 1:
y[row] = value;
Y[row] = value;
return;
case 2:
z[row] = value;
Z[row] = value;
return;
case 3:
w[row] = value;
W[row] = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(column));
@ -180,20 +180,20 @@ namespace Godot
/// <summary>
/// Creates a new <see cref="Projection"/> that scales a given projection to fit around
/// a given <see cref="AABB"/> in projection space.
/// a given <see cref="Aabb"/> in projection space.
/// </summary>
/// <param name="aabb">The AABB to fit the projection around.</param>
/// <param name="aabb">The Aabb to fit the projection around.</param>
/// <returns>The created projection.</returns>
public static Projection CreateFitAabb(AABB aabb)
public static Projection CreateFitAabb(Aabb aabb)
{
Vector3 min = aabb.Position;
Vector3 max = aabb.Position + aabb.Size;
return new Projection(
new Vector4(2 / (max.x - min.x), 0, 0, 0),
new Vector4(0, 2 / (max.y - min.y), 0, 0),
new Vector4(0, 0, 2 / (max.z - min.z), 0),
new Vector4(-(max.x + min.x) / (max.x - min.x), -(max.y + min.y) / (max.y - min.y), -(max.z + min.z) / (max.z - min.z), 1)
new Vector4(2 / (max.X - min.X), 0, 0, 0),
new Vector4(0, 2 / (max.Y - min.Y), 0, 0),
new Vector4(0, 0, 2 / (max.Z - min.Z), 0),
new Vector4(-(max.X + min.X) / (max.X - min.X), -(max.Y + min.Y) / (max.Y - min.Y), -(max.Z + min.Z) / (max.Z - min.Z), 1)
);
}
@ -300,7 +300,7 @@ namespace Godot
{
size *= aspect;
}
return CreateFrustum(-size / 2 + offset.x, +size / 2 + offset.x, -size / aspect / 2 + offset.y, +size / aspect / 2 + offset.y, near, far);
return CreateFrustum(-size / 2 + offset.X, +size / 2 + offset.X, -size / aspect / 2 + offset.Y, +size / aspect / 2 + offset.Y, near, far);
}
/// <summary>
@ -311,10 +311,10 @@ namespace Godot
public static Projection CreateLightAtlasRect(Rect2 rect)
{
return new Projection(
new Vector4(rect.Size.x, 0, 0, 0),
new Vector4(0, rect.Size.y, 0, 0),
new Vector4(rect.Size.X, 0, 0, 0),
new Vector4(0, rect.Size.Y, 0, 0),
new Vector4(0, 0, 1, 0),
new Vector4(rect.Position.x, rect.Position.y, 0, 1)
new Vector4(rect.Position.X, rect.Position.Y, 0, 1)
);
}
@ -332,13 +332,13 @@ namespace Godot
public static Projection CreateOrthogonal(real_t left, real_t right, real_t bottom, real_t top, real_t zNear, real_t zFar)
{
Projection proj = Projection.Identity;
proj.x.x = (real_t)2.0 / (right - left);
proj.w.x = -((right + left) / (right - left));
proj.y.y = (real_t)2.0 / (top - bottom);
proj.w.y = -((top + bottom) / (top - bottom));
proj.z.z = (real_t)(-2.0) / (zFar - zNear);
proj.w.z = -((zFar + zNear) / (zFar - zNear));
proj.w.w = (real_t)1.0;
proj.X.X = (real_t)2.0 / (right - left);
proj.W.X = -((right + left) / (right - left));
proj.Y.Y = (real_t)2.0 / (top - bottom);
proj.W.Y = -((top + bottom) / (top - bottom));
proj.Z.Z = (real_t)(-2.0) / (zFar - zNear);
proj.W.Z = -((zFar + zNear) / (zFar - zNear));
proj.W.W = (real_t)1.0;
return proj;
}
@ -392,12 +392,12 @@ namespace Godot
Projection proj = Projection.Identity;
proj.x.x = cotangent / aspect;
proj.y.y = cotangent;
proj.z.z = -(zFar + zNear) / deltaZ;
proj.z.w = -1;
proj.w.z = -2 * zNear * zFar / deltaZ;
proj.w.w = 0;
proj.X.X = cotangent / aspect;
proj.Y.Y = cotangent;
proj.Z.Z = -(zFar + zNear) / deltaZ;
proj.Z.W = -1;
proj.W.Z = -2 * zNear * zFar / deltaZ;
proj.W.W = 0;
return proj;
}
@ -456,7 +456,7 @@ namespace Godot
}
Projection proj = CreateFrustum(left, right, -ymax, ymax, zNear, zFar);
Projection cm = Projection.Identity;
cm.w.x = modeltranslation;
cm.W.X = modeltranslation;
return proj * cm;
}
@ -469,18 +469,18 @@ namespace Godot
/// <returns>The determinant calculated from this projection.</returns>
public readonly real_t Determinant()
{
return x.w * y.z * z.y * w.x - x.z * y.w * z.y * w.x -
x.w * y.y * z.z * w.x + x.y * y.w * z.z * w.x +
x.z * y.y * z.w * w.x - x.y * y.z * z.w * w.x -
x.w * y.z * z.x * w.y + x.z * y.w * z.x * w.y +
x.w * y.x * z.z * w.y - x.x * y.w * z.z * w.y -
x.z * y.x * z.w * w.y + x.x * y.z * z.w * w.y +
x.w * y.y * z.x * w.z - x.y * y.w * z.x * w.z -
x.w * y.x * z.y * w.z + x.x * y.w * z.y * w.z +
x.y * y.x * z.w * w.z - x.x * y.y * z.w * w.z -
x.z * y.y * z.x * w.w + x.y * y.z * z.x * w.w +
x.z * y.x * z.y * w.w - x.x * y.z * z.y * w.w -
x.y * y.x * z.z * w.w + x.x * y.y * z.z * w.w;
return X.W * Y.Z * Z.Y * W.X - X.Z * Y.W * Z.Y * W.X -
X.W * Y.Y * Z.Z * W.X + X.Y * Y.W * Z.Z * W.X +
X.Z * Y.Y * Z.W * W.X - X.Y * Y.Z * Z.W * W.X -
X.W * Y.Z * Z.X * W.Y + X.Z * Y.W * Z.X * W.Y +
X.W * Y.X * Z.Z * W.Y - X.X * Y.W * Z.Z * W.Y -
X.Z * Y.X * Z.W * W.Y + X.X * Y.Z * Z.W * W.Y +
X.W * Y.Y * Z.X * W.Z - X.Y * Y.W * Z.X * W.Z -
X.W * Y.X * Z.Y * W.Z + X.X * Y.W * Z.Y * W.Z +
X.Y * Y.X * Z.W * W.Z - X.X * Y.Y * Z.W * W.Z -
X.Z * Y.Y * Z.X * W.W + X.Y * Y.Z * Z.X * W.W +
X.Z * Y.X * Z.Y * W.W - X.X * Y.Z * Z.Y * W.W -
X.Y * Y.X * Z.Z * W.W + X.X * Y.Y * Z.Z * W.W;
}
/// <summary>
@ -490,7 +490,7 @@ namespace Godot
public readonly real_t GetAspect()
{
Vector2 vpHe = GetViewportHalfExtents();
return vpHe.x / vpHe.y;
return vpHe.X / vpHe.Y;
}
/// <summary>
@ -499,15 +499,15 @@ namespace Godot
/// <returns>The horizontal field of view of this projection.</returns>
public readonly real_t GetFov()
{
Plane rightPlane = new Plane(x.w - x.x, y.w - y.x, z.w - z.x, -w.w + w.x).Normalized();
if (z.x == 0 && z.y == 0)
Plane rightPlane = new Plane(X.W - X.X, Y.W - Y.X, Z.W - Z.X, -W.W + W.X).Normalized();
if (Z.X == 0 && Z.Y == 0)
{
return Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(rightPlane.Normal.x))) * (real_t)2.0;
return Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(rightPlane.Normal.X))) * (real_t)2.0;
}
else
{
Plane leftPlane = new Plane(x.w + x.x, y.w + y.x, z.w + z.x, w.w + w.x).Normalized();
return Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(leftPlane.Normal.x))) + Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(rightPlane.Normal.x)));
Plane leftPlane = new Plane(X.W + X.X, Y.W + Y.X, Z.W + Z.X, W.W + W.X).Normalized();
return Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(leftPlane.Normal.X))) + Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(rightPlane.Normal.X)));
}
}
@ -531,12 +531,12 @@ namespace Godot
{
if (IsOrthogonal())
{
return GetViewportHalfExtents().x;
return GetViewportHalfExtents().X;
}
else
{
real_t zn = GetZNear();
real_t width = GetViewportHalfExtents().x * (real_t)2.0;
real_t width = GetViewportHalfExtents().X * (real_t)2.0;
return (real_t)1.0 / (zn / width);
}
}
@ -551,7 +551,7 @@ namespace Godot
{
Vector3 result = this * new Vector3(1, 0, -1);
return (int)((result.x * (real_t)0.5 + (real_t)0.5) * forPixelWidth);
return (int)((result.X * (real_t)0.5 + (real_t)0.5) * forPixelWidth);
}
/// <summary>
@ -567,12 +567,12 @@ namespace Godot
{
Plane newPlane = plane switch
{
Planes.Near => new Plane(x.w + x.z, y.w + y.z, z.w + z.z, w.w + w.z),
Planes.Far => new Plane(x.w - x.z, y.w - y.z, z.w - z.z, w.w - w.z),
Planes.Left => new Plane(x.w + x.x, y.w + y.x, z.w + z.x, w.w + w.x),
Planes.Top => new Plane(x.w - x.y, y.w - y.y, z.w - z.y, w.w - w.y),
Planes.Right => new Plane(x.w - x.x, y.w - y.x, z.w - z.x, w.w - w.x),
Planes.Bottom => new Plane(x.w + x.y, y.w + y.y, z.w + z.y, w.w + w.y),
Planes.Near => new Plane(X.W + X.Z, Y.W + Y.Z, Z.W + Z.Z, W.W + W.Z),
Planes.Far => new Plane(X.W - X.Z, Y.W - Y.Z, Z.W - Z.Z, W.W - W.Z),
Planes.Left => new Plane(X.W + X.X, Y.W + Y.X, Z.W + Z.X, W.W + W.X),
Planes.Top => new Plane(X.W - X.Y, Y.W - Y.Y, Z.W - Z.Y, W.W - W.Y),
Planes.Right => new Plane(X.W - X.X, Y.W - Y.X, Z.W - Z.X, W.W - W.X),
Planes.Bottom => new Plane(X.W + X.Y, Y.W + Y.Y, Z.W + Z.Y, W.W + W.Y),
_ => new Plane(),
};
newPlane.Normal = -newPlane.Normal;
@ -586,7 +586,7 @@ namespace Godot
public readonly Vector2 GetFarPlaneHalfExtents()
{
var res = GetProjectionPlane(Planes.Far).Intersect3(GetProjectionPlane(Planes.Right), GetProjectionPlane(Planes.Top));
return new Vector2(res.Value.x, res.Value.y);
return new Vector2(res.Value.X, res.Value.Y);
}
/// <summary>
@ -597,7 +597,7 @@ namespace Godot
public readonly Vector2 GetViewportHalfExtents()
{
var res = GetProjectionPlane(Planes.Near).Intersect3(GetProjectionPlane(Planes.Right), GetProjectionPlane(Planes.Top));
return new Vector2(res.Value.x, res.Value.y);
return new Vector2(res.Value.X, res.Value.Y);
}
/// <summary>
@ -625,7 +625,7 @@ namespace Godot
public readonly Projection FlippedY()
{
Projection proj = this;
proj.y = -proj.y;
proj.Y = -proj.Y;
return proj;
}
@ -642,8 +642,8 @@ namespace Godot
real_t zFar = GetZFar();
real_t zNear = newZNear;
real_t deltaZ = zFar - zNear;
proj.z.z = -(zFar + zNear) / deltaZ;
proj.w.z = -2 * zNear * zFar / deltaZ;
proj.Z.Z = -(zFar + zNear) / deltaZ;
proj.W.Z = -2 * zNear * zFar / deltaZ;
return proj;
}
@ -656,8 +656,8 @@ namespace Godot
public readonly Projection JitterOffseted(Vector2 offset)
{
Projection proj = this;
proj.w.x += offset.x;
proj.w.y += offset.y;
proj.W.X += offset.X;
proj.W.Y += offset.Y;
return proj;
}
@ -795,7 +795,7 @@ namespace Godot
/// <returns>If the projection performs an orthogonal projection.</returns>
public readonly bool IsOrthogonal()
{
return w.w == (real_t)1.0;
return W.W == (real_t)1.0;
}
// Constants
@ -835,10 +835,10 @@ namespace Godot
/// <param name="w">The W column, or column index 3.</param>
public Projection(Vector4 x, Vector4 y, Vector4 z, Vector4 w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
X = x;
Y = y;
Z = z;
W = w;
}
/// <summary>
@ -847,10 +847,10 @@ namespace Godot
/// <param name="transform">The <see cref="Transform3D"/>.</param>
public Projection(Transform3D transform)
{
x = new Vector4(transform.basis.Row0.x, transform.basis.Row1.x, transform.basis.Row2.x, 0);
y = new Vector4(transform.basis.Row0.y, transform.basis.Row1.y, transform.basis.Row2.y, 0);
z = new Vector4(transform.basis.Row0.z, transform.basis.Row1.z, transform.basis.Row2.z, 0);
w = new Vector4(transform.origin.x, transform.origin.y, transform.origin.z, 1);
X = new Vector4(transform.Basis.Row0.X, transform.Basis.Row1.X, transform.Basis.Row2.X, 0);
Y = new Vector4(transform.Basis.Row0.Y, transform.Basis.Row1.Y, transform.Basis.Row2.Y, 0);
Z = new Vector4(transform.Basis.Row0.Z, transform.Basis.Row1.Z, transform.Basis.Row2.Z, 0);
W = new Vector4(transform.Origin.X, transform.Origin.Y, transform.Origin.Z, 1);
}
/// <summary>
@ -865,25 +865,25 @@ namespace Godot
{
return new Projection(
new Vector4(
left.x.x * right.x.x + left.y.x * right.x.y + left.z.x * right.x.z + left.w.x * right.x.w,
left.x.y * right.x.x + left.y.y * right.x.y + left.z.y * right.x.z + left.w.y * right.x.w,
left.x.z * right.x.x + left.y.z * right.x.y + left.z.z * right.x.z + left.w.z * right.x.w,
left.x.w * right.x.x + left.y.w * right.x.y + left.z.w * right.x.z + left.w.w * right.x.w
left.X.X * right.X.X + left.Y.X * right.X.Y + left.Z.X * right.X.Z + left.W.X * right.X.W,
left.X.Y * right.X.X + left.Y.Y * right.X.Y + left.Z.Y * right.X.Z + left.W.Y * right.X.W,
left.X.Z * right.X.X + left.Y.Z * right.X.Y + left.Z.Z * right.X.Z + left.W.Z * right.X.W,
left.X.W * right.X.X + left.Y.W * right.X.Y + left.Z.W * right.X.Z + left.W.W * right.X.W
), new Vector4(
left.x.x * right.y.x + left.y.x * right.y.y + left.z.x * right.y.z + left.w.x * right.y.w,
left.x.y * right.y.x + left.y.y * right.y.y + left.z.y * right.y.z + left.w.y * right.y.w,
left.x.z * right.y.x + left.y.z * right.y.y + left.z.z * right.y.z + left.w.z * right.y.w,
left.x.w * right.y.x + left.y.w * right.y.y + left.z.w * right.y.z + left.w.w * right.y.w
left.X.X * right.Y.X + left.Y.X * right.Y.Y + left.Z.X * right.Y.Z + left.W.X * right.Y.W,
left.X.Y * right.Y.X + left.Y.Y * right.Y.Y + left.Z.Y * right.Y.Z + left.W.Y * right.Y.W,
left.X.Z * right.Y.X + left.Y.Z * right.Y.Y + left.Z.Z * right.Y.Z + left.W.Z * right.Y.W,
left.X.W * right.Y.X + left.Y.W * right.Y.Y + left.Z.W * right.Y.Z + left.W.W * right.Y.W
), new Vector4(
left.x.x * right.z.x + left.y.x * right.z.y + left.z.x * right.z.z + left.w.x * right.z.w,
left.x.y * right.z.x + left.y.y * right.z.y + left.z.y * right.z.z + left.w.y * right.z.w,
left.x.z * right.z.x + left.y.z * right.z.y + left.z.z * right.z.z + left.w.z * right.z.w,
left.x.w * right.z.x + left.y.w * right.z.y + left.z.w * right.z.z + left.w.w * right.z.w
left.X.X * right.Z.X + left.Y.X * right.Z.Y + left.Z.X * right.Z.Z + left.W.X * right.Z.W,
left.X.Y * right.Z.X + left.Y.Y * right.Z.Y + left.Z.Y * right.Z.Z + left.W.Y * right.Z.W,
left.X.Z * right.Z.X + left.Y.Z * right.Z.Y + left.Z.Z * right.Z.Z + left.W.Z * right.Z.W,
left.X.W * right.Z.X + left.Y.W * right.Z.Y + left.Z.W * right.Z.Z + left.W.W * right.Z.W
), new Vector4(
left.x.x * right.w.x + left.y.x * right.w.y + left.z.x * right.w.z + left.w.x * right.w.w,
left.x.y * right.w.x + left.y.y * right.w.y + left.z.y * right.w.z + left.w.y * right.w.w,
left.x.z * right.w.x + left.y.z * right.w.y + left.z.z * right.w.z + left.w.z * right.w.w,
left.x.w * right.w.x + left.y.w * right.w.y + left.z.w * right.w.z + left.w.w * right.w.w
left.X.X * right.W.X + left.Y.X * right.W.Y + left.Z.X * right.W.Z + left.W.X * right.W.W,
left.X.Y * right.W.X + left.Y.Y * right.W.Y + left.Z.Y * right.W.Z + left.W.Y * right.W.W,
left.X.Z * right.W.X + left.Y.Z * right.W.Y + left.Z.Z * right.W.Z + left.W.Z * right.W.W,
left.X.W * right.W.X + left.Y.W * right.W.Y + left.Z.W * right.W.Z + left.W.W * right.W.W
)
);
}
@ -897,10 +897,10 @@ namespace Godot
public static Vector4 operator *(Projection proj, Vector4 vector)
{
return new Vector4(
proj.x.x * vector.x + proj.y.x * vector.y + proj.z.x * vector.z + proj.w.x * vector.w,
proj.x.y * vector.x + proj.y.y * vector.y + proj.z.y * vector.z + proj.w.y * vector.w,
proj.x.z * vector.x + proj.y.z * vector.y + proj.z.z * vector.z + proj.w.z * vector.w,
proj.x.w * vector.x + proj.y.w * vector.y + proj.z.w * vector.z + proj.w.w * vector.w
proj.X.X * vector.X + proj.Y.X * vector.Y + proj.Z.X * vector.Z + proj.W.X * vector.W,
proj.X.Y * vector.X + proj.Y.Y * vector.Y + proj.Z.Y * vector.Z + proj.W.Y * vector.W,
proj.X.Z * vector.X + proj.Y.Z * vector.Y + proj.Z.Z * vector.Z + proj.W.Z * vector.W,
proj.X.W * vector.X + proj.Y.W * vector.Y + proj.Z.W * vector.Z + proj.W.W * vector.W
);
}
@ -913,10 +913,10 @@ namespace Godot
public static Vector4 operator *(Vector4 vector, Projection proj)
{
return new Vector4(
proj.x.x * vector.x + proj.x.y * vector.y + proj.x.z * vector.z + proj.x.w * vector.w,
proj.y.x * vector.x + proj.y.y * vector.y + proj.y.z * vector.z + proj.y.w * vector.w,
proj.z.x * vector.x + proj.z.y * vector.y + proj.z.z * vector.z + proj.z.w * vector.w,
proj.w.x * vector.x + proj.w.y * vector.y + proj.w.z * vector.z + proj.w.w * vector.w
proj.X.X * vector.X + proj.X.Y * vector.Y + proj.X.Z * vector.Z + proj.X.W * vector.W,
proj.Y.X * vector.X + proj.Y.Y * vector.Y + proj.Y.Z * vector.Z + proj.Y.W * vector.W,
proj.Z.X * vector.X + proj.Z.Y * vector.Y + proj.Z.Z * vector.Z + proj.Z.W * vector.W,
proj.W.X * vector.X + proj.W.Y * vector.Y + proj.W.Z * vector.Z + proj.W.W * vector.W
);
}
@ -929,11 +929,11 @@ namespace Godot
public static Vector3 operator *(Projection proj, Vector3 vector)
{
Vector3 ret = new Vector3(
proj.x.x * vector.x + proj.y.x * vector.y + proj.z.x * vector.z + proj.w.x,
proj.x.y * vector.x + proj.y.y * vector.y + proj.z.y * vector.z + proj.w.y,
proj.x.z * vector.x + proj.y.z * vector.y + proj.z.z * vector.z + proj.w.z
proj.X.X * vector.X + proj.Y.X * vector.Y + proj.Z.X * vector.Z + proj.W.X,
proj.X.Y * vector.X + proj.Y.Y * vector.Y + proj.Z.Y * vector.Z + proj.W.Y,
proj.X.Z * vector.X + proj.Y.Z * vector.Y + proj.Z.Z * vector.Z + proj.W.Z
);
return ret / (proj.x.w * vector.x + proj.y.w * vector.y + proj.z.w * vector.z + proj.w.w);
return ret / (proj.X.W * vector.X + proj.Y.W * vector.Y + proj.Z.W * vector.Z + proj.W.W);
}
/// <summary>
@ -966,11 +966,11 @@ namespace Godot
{
return new Transform3D(
new Basis(
new Vector3(proj.x.x, proj.x.y, proj.x.z),
new Vector3(proj.y.x, proj.y.y, proj.y.z),
new Vector3(proj.z.x, proj.z.y, proj.z.z)
new Vector3(proj.X.X, proj.X.Y, proj.X.Z),
new Vector3(proj.Y.X, proj.Y.Y, proj.Y.Z),
new Vector3(proj.Z.X, proj.Z.Y, proj.Z.Z)
),
new Vector3(proj.w.x, proj.w.y, proj.w.z)
new Vector3(proj.W.X, proj.W.Y, proj.W.Z)
);
}
@ -992,7 +992,7 @@ namespace Godot
/// <returns>Whether or not the projections are exactly equal.</returns>
public readonly bool Equals(Projection other)
{
return x == other.x && y == other.y && z == other.z && w == other.w;
return X == other.X && Y == other.Y && Z == other.Z && W == other.W;
}
/// <summary>
@ -1001,7 +1001,7 @@ namespace Godot
/// <returns>A hash code for this projection.</returns>
public override readonly int GetHashCode()
{
return y.GetHashCode() ^ x.GetHashCode() ^ z.GetHashCode() ^ w.GetHashCode();
return Y.GetHashCode() ^ X.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
}
/// <summary>
@ -1010,7 +1010,7 @@ namespace Godot
/// <returns>A string representation of this projection.</returns>
public override readonly string ToString()
{
return $"{x.x}, {x.y}, {x.z}, {x.w}\n{y.x}, {y.y}, {y.z}, {y.w}\n{z.x}, {z.y}, {z.z}, {z.w}\n{w.x}, {w.y}, {w.z}, {w.w}\n";
return $"{X.X}, {X.Y}, {X.Z}, {X.W}\n{Y.X}, {Y.Y}, {Y.Z}, {Y.W}\n{Z.X}, {Z.Y}, {Z.Z}, {Z.W}\n{W.X}, {W.Y}, {W.Z}, {W.W}\n";
}
/// <summary>
@ -1019,10 +1019,10 @@ namespace Godot
/// <returns>A string representation of this projection.</returns>
public readonly string ToString(string format)
{
return $"{x.x.ToString(format)}, {x.y.ToString(format)}, {x.z.ToString(format)}, {x.w.ToString(format)}\n" +
$"{y.x.ToString(format)}, {y.y.ToString(format)}, {y.z.ToString(format)}, {y.w.ToString(format)}\n" +
$"{z.x.ToString(format)}, {z.y.ToString(format)}, {z.z.ToString(format)}, {z.w.ToString(format)}\n" +
$"{w.x.ToString(format)}, {w.y.ToString(format)}, {w.z.ToString(format)}, {w.w.ToString(format)}\n";
return $"{X.X.ToString(format)}, {X.Y.ToString(format)}, {X.Z.ToString(format)}, {X.W.ToString(format)}\n" +
$"{Y.X.ToString(format)}, {Y.Y.ToString(format)}, {Y.Z.ToString(format)}, {Y.W.ToString(format)}\n" +
$"{Z.X.ToString(format)}, {Z.Y.ToString(format)}, {Z.Z.ToString(format)}, {Z.W.ToString(format)}\n" +
$"{W.X.ToString(format)}, {W.Y.ToString(format)}, {W.Z.ToString(format)}, {W.W.ToString(format)}\n";
}
}
}

172
modules/mono/glue/GodotSharp/GodotSharp/Core/Quaternion.cs
View File

@ -24,25 +24,25 @@ namespace Godot
/// X component of the quaternion (imaginary <c>i</c> axis part).
/// Quaternion components should usually not be manipulated directly.
/// </summary>
public real_t x;
public real_t X;
/// <summary>
/// Y component of the quaternion (imaginary <c>j</c> axis part).
/// Quaternion components should usually not be manipulated directly.
/// </summary>
public real_t y;
public real_t Y;
/// <summary>
/// Z component of the quaternion (imaginary <c>k</c> axis part).
/// Quaternion components should usually not be manipulated directly.
/// </summary>
public real_t z;
public real_t Z;
/// <summary>
/// W component of the quaternion (real part).
/// Quaternion components should usually not be manipulated directly.
/// </summary>
public real_t w;
public real_t W;
/// <summary>
/// Access quaternion components using their index.
@ -51,10 +51,10 @@ namespace Godot
/// <paramref name="index"/> is not 0, 1, 2 or 3.
/// </exception>
/// <value>
/// <c>[0]</c> is equivalent to <see cref="x"/>,
/// <c>[1]</c> is equivalent to <see cref="y"/>,
/// <c>[2]</c> is equivalent to <see cref="z"/>,
/// <c>[3]</c> is equivalent to <see cref="w"/>.
/// <c>[0]</c> is equivalent to <see cref="X"/>,
/// <c>[1]</c> is equivalent to <see cref="Y"/>,
/// <c>[2]</c> is equivalent to <see cref="Z"/>,
/// <c>[3]</c> is equivalent to <see cref="W"/>.
/// </value>
public real_t this[int index]
{
@ -63,13 +63,13 @@ namespace Godot
switch (index)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
case 2:
return z;
return Z;
case 3:
return w;
return W;
default:
throw new ArgumentOutOfRangeException(nameof(index));
}
@ -79,16 +79,16 @@ namespace Godot
switch (index)
{
case 0:
x = value;
X = value;
break;
case 1:
y = value;
Y = value;
break;
case 2:
z = value;
Z = value;
break;
case 3:
w = value;
W = value;
break;
default:
throw new ArgumentOutOfRangeException(nameof(index));
@ -155,9 +155,9 @@ namespace Godot
Quaternion lnPre = (fromQ.Inverse() * preQ).Log();
Quaternion lnPost = (fromQ.Inverse() * postQ).Log();
Quaternion ln = new Quaternion(
Mathf.CubicInterpolate(lnFrom.x, lnTo.x, lnPre.x, lnPost.x, weight),
Mathf.CubicInterpolate(lnFrom.y, lnTo.y, lnPre.y, lnPost.y, weight),
Mathf.CubicInterpolate(lnFrom.z, lnTo.z, lnPre.z, lnPost.z, weight),
Mathf.CubicInterpolate(lnFrom.X, lnTo.X, lnPre.X, lnPost.X, weight),
Mathf.CubicInterpolate(lnFrom.Y, lnTo.Y, lnPre.Y, lnPost.Y, weight),
Mathf.CubicInterpolate(lnFrom.Z, lnTo.Z, lnPre.Z, lnPost.Z, weight),
0);
Quaternion q1 = fromQ * ln.Exp();
@ -167,9 +167,9 @@ namespace Godot
lnPre = (toQ.Inverse() * preQ).Log();
lnPost = (toQ.Inverse() * postQ).Log();
ln = new Quaternion(
Mathf.CubicInterpolate(lnFrom.x, lnTo.x, lnPre.x, lnPost.x, weight),
Mathf.CubicInterpolate(lnFrom.y, lnTo.y, lnPre.y, lnPost.y, weight),
Mathf.CubicInterpolate(lnFrom.z, lnTo.z, lnPre.z, lnPost.z, weight),
Mathf.CubicInterpolate(lnFrom.X, lnTo.X, lnPre.X, lnPost.X, weight),
Mathf.CubicInterpolate(lnFrom.Y, lnTo.Y, lnPre.Y, lnPost.Y, weight),
Mathf.CubicInterpolate(lnFrom.Z, lnTo.Z, lnPre.Z, lnPost.Z, weight),
0);
Quaternion q2 = toQ * ln.Exp();
@ -224,9 +224,9 @@ namespace Godot
Quaternion lnPre = (fromQ.Inverse() * preQ).Log();
Quaternion lnPost = (fromQ.Inverse() * postQ).Log();
Quaternion ln = new Quaternion(
Mathf.CubicInterpolateInTime(lnFrom.x, lnTo.x, lnPre.x, lnPost.x, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.y, lnTo.y, lnPre.y, lnPost.y, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.z, lnTo.z, lnPre.z, lnPost.z, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.X, lnTo.X, lnPre.X, lnPost.X, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.Y, lnTo.Y, lnPre.Y, lnPost.Y, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.Z, lnTo.Z, lnPre.Z, lnPost.Z, weight, bT, preAT, postBT),
0);
Quaternion q1 = fromQ * ln.Exp();
@ -236,9 +236,9 @@ namespace Godot
lnPre = (toQ.Inverse() * preQ).Log();
lnPost = (toQ.Inverse() * postQ).Log();
ln = new Quaternion(
Mathf.CubicInterpolateInTime(lnFrom.x, lnTo.x, lnPre.x, lnPost.x, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.y, lnTo.y, lnPre.y, lnPost.y, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.z, lnTo.z, lnPre.z, lnPost.z, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.X, lnTo.X, lnPre.X, lnPost.X, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.Y, lnTo.Y, lnPre.Y, lnPost.Y, weight, bT, preAT, postBT),
Mathf.CubicInterpolateInTime(lnFrom.Z, lnTo.Z, lnPre.Z, lnPost.Z, weight, bT, preAT, postBT),
0);
Quaternion q2 = toQ * ln.Exp();
@ -253,12 +253,12 @@ namespace Godot
/// <returns>The dot product.</returns>
public readonly real_t Dot(Quaternion b)
{
return (x * b.x) + (y * b.y) + (z * b.z) + (w * b.w);
return (X * b.X) + (Y * b.Y) + (Z * b.Z) + (W * b.W);
}
public readonly Quaternion Exp()
{
Vector3 v = new Vector3(x, y, z);
Vector3 v = new Vector3(X, Y, Z);
real_t theta = v.Length();
v = v.Normalized();
if (theta < Mathf.Epsilon || !v.IsNormalized())
@ -270,18 +270,18 @@ namespace Godot
public readonly real_t GetAngle()
{
return 2 * Mathf.Acos(w);
return 2 * Mathf.Acos(W);
}
public readonly Vector3 GetAxis()
{
if (Mathf.Abs(w) > 1 - Mathf.Epsilon)
if (Mathf.Abs(W) > 1 - Mathf.Epsilon)
{
return new Vector3(x, y, z);
return new Vector3(X, Y, Z);
}
real_t r = 1 / Mathf.Sqrt(1 - w * w);
return new Vector3(x * r, y * r, z * r);
real_t r = 1 / Mathf.Sqrt(1 - W * W);
return new Vector3(X * r, Y * r, Z * r);
}
/// <summary>
@ -315,7 +315,7 @@ namespace Godot
throw new InvalidOperationException("Quaternion is not normalized.");
}
#endif
return new Quaternion(-x, -y, -z, w);
return new Quaternion(-X, -Y, -Z, W);
}
/// <summary>
@ -325,7 +325,7 @@ namespace Godot
/// <returns>Whether this vector is finite or not.</returns>
public readonly bool IsFinite()
{
return Mathf.IsFinite(x) && Mathf.IsFinite(y) && Mathf.IsFinite(z) && Mathf.IsFinite(w);
return Mathf.IsFinite(X) && Mathf.IsFinite(Y) && Mathf.IsFinite(Z) && Mathf.IsFinite(W);
}
/// <summary>
@ -340,7 +340,7 @@ namespace Godot
public readonly Quaternion Log()
{
Vector3 v = GetAxis() * GetAngle();
return new Quaternion(v.x, v.y, v.z, 0);
return new Quaternion(v.X, v.Y, v.Z, 0);
}
/// <summary>
@ -432,10 +432,10 @@ namespace Godot
// Calculate final values.
return new Quaternion
(
(scale0 * x) + (scale1 * to1.x),
(scale0 * y) + (scale1 * to1.y),
(scale0 * z) + (scale1 * to1.z),
(scale0 * w) + (scale1 * to1.w)
(scale0 * X) + (scale1 * to1.X),
(scale0 * Y) + (scale1 * to1.Y),
(scale0 * Z) + (scale1 * to1.Z),
(scale0 * W) + (scale1 * to1.W)
);
}
@ -474,10 +474,10 @@ namespace Godot
return new Quaternion
(
(invFactor * x) + (newFactor * to.x),
(invFactor * y) + (newFactor * to.y),
(invFactor * z) + (newFactor * to.z),
(invFactor * w) + (newFactor * to.w)
(invFactor * X) + (newFactor * to.X),
(invFactor * Y) + (newFactor * to.Y),
(invFactor * Z) + (newFactor * to.Z),
(invFactor * W) + (newFactor * to.W)
);
}
@ -501,10 +501,10 @@ namespace Godot
/// <param name="w">W component of the quaternion (real part).</param>
public Quaternion(real_t x, real_t y, real_t z, real_t w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
X = x;
Y = y;
Z = z;
W = w;
}
/// <summary>
@ -535,20 +535,20 @@ namespace Godot
if (d == 0f)
{
x = 0f;
y = 0f;
z = 0f;
w = 0f;
X = 0f;
Y = 0f;
Z = 0f;
W = 0f;
}
else
{
(real_t sin, real_t cos) = Mathf.SinCos(angle * 0.5f);
real_t s = sin / d;
x = axis.x * s;
y = axis.y * s;
z = axis.z * s;
w = cos;
X = axis.X * s;
Y = axis.Y * s;
Z = axis.Z * s;
W = cos;
}
}
@ -559,20 +559,20 @@ namespace Godot
if (d < -1.0f + Mathf.Epsilon)
{
x = 0f;
y = 1f;
z = 0f;
w = 0f;
X = 0f;
Y = 1f;
Z = 0f;
W = 0f;
}
else
{
real_t s = Mathf.Sqrt((1.0f + d) * 2.0f);
real_t rs = 1.0f / s;
x = c.x * rs;
y = c.y * rs;
z = c.z * rs;
w = s * 0.5f;
X = c.X * rs;
Y = c.Y * rs;
Z = c.Z * rs;
W = s * 0.5f;
}
}
@ -584,9 +584,9 @@ namespace Godot
/// <param name="eulerYXZ">Euler angles that the quaternion will be rotated by.</param>
public static Quaternion FromEuler(Vector3 eulerYXZ)
{
real_t halfA1 = eulerYXZ.y * 0.5f;
real_t halfA2 = eulerYXZ.x * 0.5f;
real_t halfA3 = eulerYXZ.z * 0.5f;
real_t halfA1 = eulerYXZ.Y * 0.5f;
real_t halfA2 = eulerYXZ.X * 0.5f;
real_t halfA3 = eulerYXZ.Z * 0.5f;
// R = Y(a1).X(a2).Z(a3) convention for Euler angles.
// Conversion to quaternion as listed in https://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19770024290.pdf (page A-6)
@ -616,10 +616,10 @@ namespace Godot
{
return new Quaternion
(
(left.w * right.x) + (left.x * right.w) + (left.y * right.z) - (left.z * right.y),
(left.w * right.y) + (left.y * right.w) + (left.z * right.x) - (left.x * right.z),
(left.w * right.z) + (left.z * right.w) + (left.x * right.y) - (left.y * right.x),
(left.w * right.w) - (left.x * right.x) - (left.y * right.y) - (left.z * right.z)
(left.W * right.X) + (left.X * right.W) + (left.Y * right.Z) - (left.Z * right.Y),
(left.W * right.Y) + (left.Y * right.W) + (left.Z * right.X) - (left.X * right.Z),
(left.W * right.Z) + (left.Z * right.W) + (left.X * right.Y) - (left.Y * right.X),
(left.W * right.W) - (left.X * right.X) - (left.Y * right.Y) - (left.Z * right.Z)
);
}
@ -637,9 +637,9 @@ namespace Godot
throw new InvalidOperationException("Quaternion is not normalized.");
}
#endif
var u = new Vector3(quaternion.x, quaternion.y, quaternion.z);
var u = new Vector3(quaternion.X, quaternion.Y, quaternion.Z);
Vector3 uv = u.Cross(vector);
return vector + (((uv * quaternion.w) + u.Cross(uv)) * 2);
return vector + (((uv * quaternion.W) + u.Cross(uv)) * 2);
}
/// <summary>
@ -665,7 +665,7 @@ namespace Godot
/// <returns>The added quaternion.</returns>
public static Quaternion operator +(Quaternion left, Quaternion right)
{
return new Quaternion(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w);
return new Quaternion(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
}
/// <summary>
@ -679,20 +679,20 @@ namespace Godot
/// <returns>The subtracted quaternion.</returns>
public static Quaternion operator -(Quaternion left, Quaternion right)
{
return new Quaternion(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w);
return new Quaternion(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
}
/// <summary>
/// Returns the negative value of the <see cref="Quaternion"/>.
/// This is the same as writing
/// <c>new Quaternion(-q.x, -q.y, -q.z, -q.w)</c>. This operation
/// <c>new Quaternion(-q.X, -q.Y, -q.Z, -q.W)</c>. This operation
/// results in a quaternion that represents the same rotation.
/// </summary>
/// <param name="quat">The quaternion to negate.</param>
/// <returns>The negated quaternion.</returns>
public static Quaternion operator -(Quaternion quat)
{
return new Quaternion(-quat.x, -quat.y, -quat.z, -quat.w);
return new Quaternion(-quat.X, -quat.Y, -quat.Z, -quat.W);
}
/// <summary>
@ -706,7 +706,7 @@ namespace Godot
/// <returns>The multiplied quaternion.</returns>
public static Quaternion operator *(Quaternion left, real_t right)
{
return new Quaternion(left.x * right, left.y * right, left.z * right, left.w * right);
return new Quaternion(left.X * right, left.Y * right, left.Z * right, left.W * right);
}
/// <summary>
@ -720,7 +720,7 @@ namespace Godot
/// <returns>The multiplied quaternion.</returns>
public static Quaternion operator *(real_t left, Quaternion right)
{
return new Quaternion(right.x * left, right.y * left, right.z * left, right.w * left);
return new Quaternion(right.X * left, right.Y * left, right.Z * left, right.W * left);
}
/// <summary>
@ -780,7 +780,7 @@ namespace Godot
/// <returns>Whether or not the quaternions are exactly equal.</returns>
public readonly bool Equals(Quaternion other)
{
return x == other.x && y == other.y && z == other.z && w == other.w;
return X == other.X && Y == other.Y && Z == other.Z && W == other.W;
}
/// <summary>
@ -791,7 +791,7 @@ namespace Godot
/// <returns>Whether or not the quaternions are approximately equal.</returns>
public readonly bool IsEqualApprox(Quaternion other)
{
return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y) && Mathf.IsEqualApprox(z, other.z) && Mathf.IsEqualApprox(w, other.w);
return Mathf.IsEqualApprox(X, other.X) && Mathf.IsEqualApprox(Y, other.Y) && Mathf.IsEqualApprox(Z, other.Z) && Mathf.IsEqualApprox(W, other.W);
}
/// <summary>
@ -800,7 +800,7 @@ namespace Godot
/// <returns>A hash code for this quaternion.</returns>
public override readonly int GetHashCode()
{
return y.GetHashCode() ^ x.GetHashCode() ^ z.GetHashCode() ^ w.GetHashCode();
return Y.GetHashCode() ^ X.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
}
/// <summary>
@ -809,7 +809,7 @@ namespace Godot
/// <returns>A string representation of this quaternion.</returns>
public override readonly string ToString()
{
return $"({x}, {y}, {z}, {w})";
return $"({X}, {Y}, {Z}, {W})";
}
/// <summary>
@ -818,7 +818,7 @@ namespace Godot
/// <returns>A string representation of this quaternion.</returns>
public readonly string ToString(string format)
{
return $"({x.ToString(format)}, {y.ToString(format)}, {z.ToString(format)}, {w.ToString(format)})";
return $"({X.ToString(format)}, {Y.ToString(format)}, {Z.ToString(format)}, {W.ToString(format)})";
}
}
}

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

@ -66,7 +66,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 = new Vector2(Mathf.Min(_position.X, end.X), Mathf.Min(_position.Y, end.Y));
return new Rect2(topLeft, _size.Abs());
}
@ -88,14 +88,14 @@ 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.X = Mathf.Max(b._position.X, _position.X);
newRect._position.Y = Mathf.Max(b._position.Y, _position.Y);
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.X = Mathf.Min(bEnd.X, end.X) - newRect._position.X;
newRect._size.Y = Mathf.Min(bEnd.Y, end.Y) - newRect._position.Y;
return newRect;
}
@ -119,9 +119,9 @@ namespace Godot
/// </returns>
public readonly bool Encloses(Rect2 b)
{
return b._position.x >= _position.x && b._position.y >= _position.y &&
b._position.x + b._size.x < _position.x + _size.x &&
b._position.y + b._size.y < _position.y + _size.y;
return b._position.X >= _position.X && b._position.Y >= _position.Y &&
b._position.X + b._size.X < _position.X + _size.X &&
b._position.Y + b._size.Y < _position.Y + _size.Y;
}
/// <summary>
@ -136,22 +136,22 @@ namespace Godot
Vector2 begin = expanded._position;
Vector2 end = expanded._position + expanded._size;
if (to.x < begin.x)
if (to.X < begin.X)
{
begin.x = to.x;
begin.X = to.X;
}
if (to.y < begin.y)
if (to.Y < begin.Y)
{
begin.y = to.y;
begin.Y = to.Y;
}
if (to.x > end.x)
if (to.X > end.X)
{
end.x = to.x;
end.X = to.X;
}
if (to.y > end.y)
if (to.Y > end.Y)
{
end.y = to.y;
end.Y = to.Y;
}
expanded._position = begin;
@ -166,7 +166,7 @@ namespace Godot
/// <returns>The area.</returns>
public readonly real_t GetArea()
{
return _size.x * _size.y;
return _size.X * _size.Y;
}
/// <summary>
@ -191,10 +191,10 @@ namespace Godot
{
Rect2 g = this;
g._position.x -= by;
g._position.y -= by;
g._size.x += by * 2;
g._size.y += by * 2;
g._position.X -= by;
g._position.Y -= by;
g._size.X += by * 2;
g._size.Y += by * 2;
return g;
}
@ -214,10 +214,10 @@ namespace Godot
{
Rect2 g = this;
g._position.x -= left;
g._position.y -= top;
g._size.x += left + right;
g._size.y += top + bottom;
g._position.X -= left;
g._position.Y -= top;
g._size.X += left + right;
g._size.Y += top + bottom;
return g;
}
@ -254,7 +254,7 @@ namespace Godot
/// </returns>
public readonly bool HasArea()
{
return _size.x > 0.0f && _size.y > 0.0f;
return _size.X > 0.0f && _size.Y > 0.0f;
}
/// <summary>
@ -267,14 +267,14 @@ namespace Godot
/// </returns>
public readonly bool HasPoint(Vector2 point)
{
if (point.x < _position.x)
if (point.X < _position.X)
return false;
if (point.y < _position.y)
if (point.Y < _position.Y)
return false;
if (point.x >= _position.x + _size.x)
if (point.X >= _position.X + _size.X)
return false;
if (point.y >= _position.y + _size.y)
if (point.Y >= _position.Y + _size.Y)
return false;
return true;
@ -295,38 +295,38 @@ namespace Godot
{
if (includeBorders)
{
if (_position.x > b._position.x + b._size.x)
if (_position.X > b._position.X + b._size.X)
{
return false;
}
if (_position.x + _size.x < b._position.x)
if (_position.X + _size.X < b._position.X)
{
return false;
}
if (_position.y > b._position.y + b._size.y)
if (_position.Y > b._position.Y + b._size.Y)
{
return false;
}
if (_position.y + _size.y < b._position.y)
if (_position.Y + _size.Y < b._position.Y)
{
return false;
}
}
else
{
if (_position.x >= b._position.x + b._size.x)
if (_position.X >= b._position.X + b._size.X)
{
return false;
}
if (_position.x + _size.x <= b._position.x)
if (_position.X + _size.X <= b._position.X)
{
return false;
}
if (_position.y >= b._position.y + b._size.y)
if (_position.Y >= b._position.Y + b._size.Y)
{
return false;
}
if (_position.y + _size.y <= b._position.y)
if (_position.Y + _size.Y <= b._position.Y)
{
return false;
}
@ -344,11 +344,11 @@ 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.X = Mathf.Min(b._position.X, _position.X);
newRect._position.Y = Mathf.Min(b._position.Y, _position.Y);
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.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 -= newRect._position; // Make relative again

252
modules/mono/glue/GodotSharp/GodotSharp/Core/Rect2i.cs → modules/mono/glue/GodotSharp/GodotSharp/Core/Rect2I.cs
View File

@ -4,21 +4,21 @@ using System.Runtime.InteropServices;
namespace Godot
{
/// <summary>
/// 2D axis-aligned bounding box using integers. Rect2i consists of a position, a size, and
/// 2D axis-aligned bounding box using integers. Rect2I consists of a position, a size, and
/// several utility functions. It is typically used for fast overlap tests.
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct Rect2i : IEquatable<Rect2i>
public struct Rect2I : IEquatable<Rect2I>
{
private Vector2i _position;
private Vector2i _size;
private Vector2I _position;
private Vector2I _size;
/// <summary>
/// Beginning corner. Typically has values lower than <see cref="End"/>.
/// </summary>
/// <value>Directly uses a private field.</value>
public Vector2i Position
public Vector2I Position
{
readonly get { return _position; }
set { _position = value; }
@ -29,7 +29,7 @@ namespace Godot
/// If the size is negative, you can use <see cref="Abs"/> to fix it.
/// </summary>
/// <value>Directly uses a private field.</value>
public Vector2i Size
public Vector2I Size
{
readonly get { return _size; }
set { _size = value; }
@ -43,14 +43,14 @@ namespace Godot
/// Getting is equivalent to <paramref name="value"/> = <see cref="Position"/> + <see cref="Size"/>,
/// setting is equivalent to <see cref="Size"/> = <paramref name="value"/> - <see cref="Position"/>
/// </value>
public Vector2i End
public Vector2I End
{
readonly get { return _position + _size; }
set { _size = value - _position; }
}
/// <summary>
/// The area of this <see cref="Rect2i"/>.
/// The area of this <see cref="Rect2I"/>.
/// </summary>
/// <value>Equivalent to <see cref="GetArea()"/>.</value>
public readonly int Area
@ -59,89 +59,89 @@ namespace Godot
}
/// <summary>
/// Returns a <see cref="Rect2i"/> with equivalent position and size, modified so that
/// Returns a <see cref="Rect2I"/> with equivalent position and size, modified so that
/// the top-left corner is the origin and width and height are positive.
/// </summary>
/// <returns>The modified <see cref="Rect2i"/>.</returns>
public readonly Rect2i Abs()
/// <returns>The modified <see cref="Rect2I"/>.</returns>
public readonly Rect2I Abs()
{
Vector2i end = End;
Vector2i topLeft = new Vector2i(Mathf.Min(_position.x, end.x), Mathf.Min(_position.y, end.y));
return new Rect2i(topLeft, _size.Abs());
Vector2I end = End;
Vector2I topLeft = new Vector2I(Mathf.Min(_position.X, end.X), Mathf.Min(_position.Y, end.Y));
return new Rect2I(topLeft, _size.Abs());
}
/// <summary>
/// Returns the intersection of this <see cref="Rect2i"/> and <paramref name="b"/>.
/// If the rectangles do not intersect, an empty <see cref="Rect2i"/> is returned.
/// Returns the intersection of this <see cref="Rect2I"/> and <paramref name="b"/>.
/// If the rectangles do not intersect, an empty <see cref="Rect2I"/> is returned.
/// </summary>
/// <param name="b">The other <see cref="Rect2i"/>.</param>
/// <param name="b">The other <see cref="Rect2I"/>.</param>
/// <returns>
/// The intersection of this <see cref="Rect2i"/> and <paramref name="b"/>,
/// or an empty <see cref="Rect2i"/> if they do not intersect.
/// The intersection of this <see cref="Rect2I"/> and <paramref name="b"/>,
/// or an empty <see cref="Rect2I"/> if they do not intersect.
/// </returns>
public readonly Rect2i Intersection(Rect2i b)
public readonly Rect2I Intersection(Rect2I b)
{
Rect2i newRect = b;
Rect2I newRect = b;
if (!Intersects(newRect))
{
return new Rect2i();
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.X = Mathf.Max(b._position.X, _position.X);
newRect._position.Y = Mathf.Max(b._position.Y, _position.Y);
Vector2i bEnd = b._position + b._size;
Vector2i end = _position + _size;
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.X = Mathf.Min(bEnd.X, end.X) - newRect._position.X;
newRect._size.Y = Mathf.Min(bEnd.Y, end.Y) - newRect._position.Y;
return newRect;
}
/// <summary>
/// Returns <see langword="true"/> if this <see cref="Rect2i"/> completely encloses another one.
/// Returns <see langword="true"/> if this <see cref="Rect2I"/> completely encloses another one.
/// </summary>
/// <param name="b">The other <see cref="Rect2i"/> that may be enclosed.</param>
/// <param name="b">The other <see cref="Rect2I"/> that may be enclosed.</param>
/// <returns>
/// A <see langword="bool"/> for whether or not this <see cref="Rect2i"/> encloses <paramref name="b"/>.
/// A <see langword="bool"/> for whether or not this <see cref="Rect2I"/> encloses <paramref name="b"/>.
/// </returns>
public readonly bool Encloses(Rect2i b)
public readonly bool Encloses(Rect2I b)
{
return b._position.x >= _position.x && b._position.y >= _position.y &&
b._position.x + b._size.x < _position.x + _size.x &&
b._position.y + b._size.y < _position.y + _size.y;
return b._position.X >= _position.X && b._position.Y >= _position.Y &&
b._position.X + b._size.X < _position.X + _size.X &&
b._position.Y + b._size.Y < _position.Y + _size.Y;
}
/// <summary>
/// Returns this <see cref="Rect2i"/> expanded to include a given point.
/// Returns this <see cref="Rect2I"/> expanded to include a given point.
/// </summary>
/// <param name="to">The point to include.</param>
/// <returns>The expanded <see cref="Rect2i"/>.</returns>
public readonly Rect2i Expand(Vector2i to)
/// <returns>The expanded <see cref="Rect2I"/>.</returns>
public readonly Rect2I Expand(Vector2I to)
{
Rect2i expanded = this;
Rect2I expanded = this;
Vector2i begin = expanded._position;
Vector2i end = expanded._position + expanded._size;
Vector2I begin = expanded._position;
Vector2I end = expanded._position + expanded._size;
if (to.x < begin.x)
if (to.X < begin.X)
{
begin.x = to.x;
begin.X = to.X;
}
if (to.y < begin.y)
if (to.Y < begin.Y)
{
begin.y = to.y;
begin.Y = to.Y;
}
if (to.x > end.x)
if (to.X > end.X)
{
end.x = to.x;
end.X = to.X;
}
if (to.y > end.y)
if (to.Y > end.Y)
{
end.y = to.y;
end.Y = to.Y;
}
expanded._position = begin;
@ -151,48 +151,48 @@ namespace Godot
}
/// <summary>
/// Returns the area of the <see cref="Rect2i"/>.
/// Returns the area of the <see cref="Rect2I"/>.
/// </summary>
/// <returns>The area.</returns>
public readonly int GetArea()
{
return _size.x * _size.y;
return _size.X * _size.Y;
}
/// <summary>
/// Returns the center of the <see cref="Rect2i"/>, which is equal
/// Returns the center of the <see cref="Rect2I"/>, which is equal
/// to <see cref="Position"/> + (<see cref="Size"/> / 2).
/// If <see cref="Size"/> is an odd number, the returned center
/// value will be rounded towards <see cref="Position"/>.
/// </summary>
/// <returns>The center.</returns>
public readonly Vector2i GetCenter()
public readonly Vector2I GetCenter()
{
return _position + (_size / 2);
}
/// <summary>
/// Returns a copy of the <see cref="Rect2i"/> grown by the specified amount
/// Returns a copy of the <see cref="Rect2I"/> grown by the specified amount
/// on all sides.
/// </summary>
/// <seealso cref="GrowIndividual(int, int, int, int)"/>
/// <seealso cref="GrowSide(Side, int)"/>
/// <param name="by">The amount to grow by.</param>
/// <returns>The grown <see cref="Rect2i"/>.</returns>
public readonly Rect2i Grow(int by)
/// <returns>The grown <see cref="Rect2I"/>.</returns>
public readonly Rect2I Grow(int by)
{
Rect2i g = this;
Rect2I g = this;
g._position.x -= by;
g._position.y -= by;
g._size.x += by * 2;
g._size.y += by * 2;
g._position.X -= by;
g._position.Y -= by;
g._size.X += by * 2;
g._size.Y += by * 2;
return g;
}
/// <summary>
/// Returns a copy of the <see cref="Rect2i"/> grown by the specified amount
/// Returns a copy of the <see cref="Rect2I"/> grown by the specified amount
/// on each side individually.
/// </summary>
/// <seealso cref="Grow(int)"/>
@ -201,31 +201,31 @@ namespace Godot
/// <param name="top">The amount to grow by on the top side.</param>
/// <param name="right">The amount to grow by on the right side.</param>
/// <param name="bottom">The amount to grow by on the bottom side.</param>
/// <returns>The grown <see cref="Rect2i"/>.</returns>
public readonly Rect2i GrowIndividual(int left, int top, int right, int bottom)
/// <returns>The grown <see cref="Rect2I"/>.</returns>
public readonly Rect2I GrowIndividual(int left, int top, int right, int bottom)
{
Rect2i g = this;
Rect2I g = this;
g._position.x -= left;
g._position.y -= top;
g._size.x += left + right;
g._size.y += top + bottom;
g._position.X -= left;
g._position.Y -= top;
g._size.X += left + right;
g._size.Y += top + bottom;
return g;
}
/// <summary>
/// Returns a copy of the <see cref="Rect2i"/> grown by the specified amount
/// Returns a copy of the <see cref="Rect2I"/> grown by the specified amount
/// on the specified <see cref="Side"/>.
/// </summary>
/// <seealso cref="Grow(int)"/>
/// <seealso cref="GrowIndividual(int, int, int, int)"/>
/// <param name="side">The side to grow.</param>
/// <param name="by">The amount to grow by.</param>
/// <returns>The grown <see cref="Rect2i"/>.</returns>
public readonly Rect2i GrowSide(Side side, int by)
/// <returns>The grown <see cref="Rect2I"/>.</returns>
public readonly Rect2I GrowSide(Side side, int by)
{
Rect2i g = this;
Rect2I g = this;
g = g.GrowIndividual(Side.Left == side ? by : 0,
Side.Top == side ? by : 0,
@ -236,76 +236,76 @@ namespace Godot
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="Rect2i"/> has
/// area, and <see langword="false"/> if the <see cref="Rect2i"/>
/// Returns <see langword="true"/> if the <see cref="Rect2I"/> has
/// area, and <see langword="false"/> if the <see cref="Rect2I"/>
/// is linear, empty, or has a negative <see cref="Size"/>.
/// See also <see cref="GetArea"/>.
/// </summary>
/// <returns>
/// A <see langword="bool"/> for whether or not the <see cref="Rect2i"/> has area.
/// A <see langword="bool"/> for whether or not the <see cref="Rect2I"/> has area.
/// </returns>
public readonly bool HasArea()
{
return _size.x > 0 && _size.y > 0;
return _size.X > 0 && _size.Y > 0;
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="Rect2i"/> contains a point,
/// Returns <see langword="true"/> if the <see cref="Rect2I"/> contains a point,
/// or <see langword="false"/> otherwise.
/// </summary>
/// <param name="point">The point to check.</param>
/// <returns>
/// A <see langword="bool"/> for whether or not the <see cref="Rect2i"/> contains <paramref name="point"/>.
/// A <see langword="bool"/> for whether or not the <see cref="Rect2I"/> contains <paramref name="point"/>.
/// </returns>
public readonly bool HasPoint(Vector2i point)
public readonly bool HasPoint(Vector2I point)
{
if (point.x < _position.x)
if (point.X < _position.X)
return false;
if (point.y < _position.y)
if (point.Y < _position.Y)
return false;
if (point.x >= _position.x + _size.x)
if (point.X >= _position.X + _size.X)
return false;
if (point.y >= _position.y + _size.y)
if (point.Y >= _position.Y + _size.Y)
return false;
return true;
}
/// <summary>
/// Returns <see langword="true"/> if the <see cref="Rect2i"/> overlaps with <paramref name="b"/>
/// Returns <see langword="true"/> if the <see cref="Rect2I"/> overlaps with <paramref name="b"/>
/// (i.e. they have at least one point in common).
/// </summary>
/// <param name="b">The other <see cref="Rect2i"/> to check for intersections with.</param>
/// <param name="b">The other <see cref="Rect2I"/> to check for intersections with.</param>
/// <returns>A <see langword="bool"/> for whether or not they are intersecting.</returns>
public readonly bool Intersects(Rect2i b)
public readonly bool Intersects(Rect2I b)
{
if (_position.x >= b._position.x + b._size.x)
if (_position.X >= b._position.X + b._size.X)
return false;
if (_position.x + _size.x <= b._position.x)
if (_position.X + _size.X <= b._position.X)
return false;
if (_position.y >= b._position.y + b._size.y)
if (_position.Y >= b._position.Y + b._size.Y)
return false;
if (_position.y + _size.y <= b._position.y)
if (_position.Y + _size.Y <= b._position.Y)
return false;
return true;
}
/// <summary>
/// Returns a larger <see cref="Rect2i"/> that contains this <see cref="Rect2i"/> and <paramref name="b"/>.
/// Returns a larger <see cref="Rect2I"/> that contains this <see cref="Rect2I"/> and <paramref name="b"/>.
/// </summary>
/// <param name="b">The other <see cref="Rect2i"/>.</param>
/// <returns>The merged <see cref="Rect2i"/>.</returns>
public readonly Rect2i Merge(Rect2i b)
/// <param name="b">The other <see cref="Rect2I"/>.</param>
/// <returns>The merged <see cref="Rect2I"/>.</returns>
public readonly Rect2I Merge(Rect2I b)
{
Rect2i newRect;
Rect2I newRect;
newRect._position.x = Mathf.Min(b._position.x, _position.x);
newRect._position.y = Mathf.Min(b._position.y, _position.y);
newRect._position.X = Mathf.Min(b._position.X, _position.X);
newRect._position.Y = Mathf.Min(b._position.Y, _position.Y);
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.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 -= newRect._position; // Make relative again
@ -313,93 +313,93 @@ namespace Godot
}
/// <summary>
/// Constructs a <see cref="Rect2i"/> from a position and size.
/// Constructs a <see cref="Rect2I"/> from a position and size.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="size">The size.</param>
public Rect2i(Vector2i position, Vector2i size)
public Rect2I(Vector2I position, Vector2I size)
{
_position = position;
_size = size;
}
/// <summary>
/// Constructs a <see cref="Rect2i"/> from a position, width, and height.
/// Constructs a <see cref="Rect2I"/> from a position, width, and height.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
public Rect2i(Vector2i position, int width, int height)
public Rect2I(Vector2I position, int width, int height)
{
_position = position;
_size = new Vector2i(width, height);
_size = new Vector2I(width, height);
}
/// <summary>
/// Constructs a <see cref="Rect2i"/> from x, y, and size.
/// Constructs a <see cref="Rect2I"/> from x, y, and size.
/// </summary>
/// <param name="x">The position's X coordinate.</param>
/// <param name="y">The position's Y coordinate.</param>
/// <param name="size">The size.</param>
public Rect2i(int x, int y, Vector2i size)
public Rect2I(int x, int y, Vector2I size)
{
_position = new Vector2i(x, y);
_position = new Vector2I(x, y);
_size = size;
}
/// <summary>
/// Constructs a <see cref="Rect2i"/> from x, y, width, and height.
/// Constructs a <see cref="Rect2I"/> from x, y, width, and height.
/// </summary>
/// <param name="x">The position's X coordinate.</param>
/// <param name="y">The position's Y coordinate.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
public Rect2i(int x, int y, int width, int height)
public Rect2I(int x, int y, int width, int height)
{
_position = new Vector2i(x, y);
_size = new Vector2i(width, height);
_position = new Vector2I(x, y);
_size = new Vector2I(width, height);
}
/// <summary>
/// Returns <see langword="true"/> if the
/// <see cref="Rect2i"/>s are exactly equal.
/// <see cref="Rect2I"/>s are exactly equal.
/// </summary>
/// <param name="left">The left rect.</param>
/// <param name="right">The right rect.</param>
/// <returns>Whether or not the rects are equal.</returns>
public static bool operator ==(Rect2i left, Rect2i right)
public static bool operator ==(Rect2I left, Rect2I right)
{
return left.Equals(right);
}
/// <summary>
/// Returns <see langword="true"/> if the
/// <see cref="Rect2i"/>s are not equal.
/// <see cref="Rect2I"/>s are not equal.
/// </summary>
/// <param name="left">The left rect.</param>
/// <param name="right">The right rect.</param>
/// <returns>Whether or not the rects are not equal.</returns>
public static bool operator !=(Rect2i left, Rect2i right)
public static bool operator !=(Rect2I left, Rect2I right)
{
return !left.Equals(right);
}
/// <summary>
/// Converts this <see cref="Rect2i"/> to a <see cref="Rect2"/>.
/// Converts this <see cref="Rect2I"/> to a <see cref="Rect2"/>.
/// </summary>
/// <param name="value">The rect to convert.</param>
public static implicit operator Rect2(Rect2i value)
public static implicit operator Rect2(Rect2I value)
{
return new Rect2(value._position, value._size);
}
/// <summary>
/// Converts a <see cref="Rect2"/> to a <see cref="Rect2i"/>.
/// Converts a <see cref="Rect2"/> to a <see cref="Rect2I"/>.
/// </summary>
/// <param name="value">The rect to convert.</param>
public static explicit operator Rect2i(Rect2 value)
public static explicit operator Rect2I(Rect2 value)
{
return new Rect2i((Vector2i)value.Position, (Vector2i)value.Size);
return new Rect2I((Vector2I)value.Position, (Vector2I)value.Size);
}
/// <summary>
@ -409,7 +409,7 @@ namespace Godot
/// <returns>Whether or not the rect and the other object are equal.</returns>
public override readonly bool Equals(object obj)
{
return obj is Rect2i other && Equals(other);
return obj is Rect2I other && Equals(other);
}
/// <summary>
@ -417,13 +417,13 @@ namespace Godot
/// </summary>
/// <param name="other">The other rect to compare.</param>
/// <returns>Whether or not the rects are equal.</returns>
public readonly bool Equals(Rect2i other)
public readonly bool Equals(Rect2I other)
{
return _position.Equals(other._position) && _size.Equals(other._size);
}
/// <summary>
/// Serves as the hash function for <see cref="Rect2i"/>.
/// Serves as the hash function for <see cref="Rect2I"/>.
/// </summary>
/// <returns>A hash code for this rect.</returns>
public override readonly int GetHashCode()
@ -432,7 +432,7 @@ namespace Godot
}
/// <summary>
/// Converts this <see cref="Rect2i"/> to a string.
/// Converts this <see cref="Rect2I"/> to a string.
/// </summary>
/// <returns>A string representation of this rect.</returns>
public override readonly string ToString()
@ -441,7 +441,7 @@ namespace Godot
}
/// <summary>
/// Converts this <see cref="Rect2i"/> to a string with the given <paramref name="format"/>.
/// Converts this <see cref="Rect2I"/> to a string with the given <paramref name="format"/>.
/// </summary>
/// <returns>A string representation of this rect.</returns>
public readonly string ToString(string format)

16
modules/mono/glue/GodotSharp/GodotSharp/Core/RID.cs → modules/mono/glue/GodotSharp/GodotSharp/Core/Rid.cs
View File

@ -6,25 +6,25 @@ using Godot.NativeInterop;
namespace Godot
{
/// <summary>
/// The RID type is used to access the unique integer ID of a resource.
/// The Rid type is used to access the unique integer ID of a resource.
/// They are opaque, which means they do not grant access to the associated
/// resource by themselves. They are used by and with the low-level Server
/// classes such as <see cref="RenderingServer"/>.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
public readonly struct RID
public readonly struct Rid
{
private readonly ulong _id; // Default is 0
internal RID(ulong id)
internal Rid(ulong id)
{
_id = id;
}
/// <summary>
/// Constructs a new <see cref="RID"/> for the given <see cref="Object"/> <paramref name="from"/>.
/// Constructs a new <see cref="Rid"/> for the given <see cref="GodotObject"/> <paramref name="from"/>.
/// </summary>
public RID(Object from)
public Rid(Godot.Object from)
=> _id = from is Resource res ? res.GetRid()._id : default;
/// <summary>
@ -34,9 +34,9 @@ namespace Godot
public ulong Id => _id;
/// <summary>
/// Converts this <see cref="RID"/> to a string.
/// Converts this <see cref="Rid"/> to a string.
/// </summary>
/// <returns>A string representation of this RID.</returns>
public override string ToString() => $"RID({Id})";
/// <returns>A string representation of this Rid.</returns>
public override string ToString() => $"Rid({Id})";
}
}

82
modules/mono/glue/GodotSharp/GodotSharp/Core/StringExtensions.cs
View File

@ -675,15 +675,15 @@ namespace Godot
/// <summary>
/// Converts ASCII encoded array to string.
/// Fast alternative to <see cref="GetStringFromUTF8"/> if the
/// Fast alternative to <see cref="GetStringFromUtf8"/> if the
/// content is ASCII-only. Unlike the UTF-8 function this function
/// maps every byte to a character in the array. Multibyte sequences
/// will not be interpreted correctly. For parsing user input always
/// use <see cref="GetStringFromUTF8"/>.
/// use <see cref="GetStringFromUtf8"/>.
/// </summary>
/// <param name="bytes">A byte array of ASCII characters (on the range of 0-127).</param>
/// <returns>A string created from the bytes.</returns>
public static string GetStringFromASCII(this byte[] bytes)
public static string GetStringFromAscii(this byte[] bytes)
{
return Encoding.ASCII.GetString(bytes);
}
@ -693,7 +693,7 @@ namespace Godot
/// </summary>
/// <param name="bytes">A byte array of UTF-16 characters.</param>
/// <returns>A string created from the bytes.</returns>
public static string GetStringFromUTF16(this byte[] bytes)
public static string GetStringFromUtf16(this byte[] bytes)
{
return Encoding.Unicode.GetString(bytes);
}
@ -703,14 +703,14 @@ namespace Godot
/// </summary>
/// <param name="bytes">A byte array of UTF-32 characters.</param>
/// <returns>A string created from the bytes.</returns>
public static string GetStringFromUTF32(this byte[] bytes)
public static string GetStringFromUtf32(this byte[] bytes)
{
return Encoding.UTF32.GetString(bytes);
}
/// <summary>
/// Converts UTF-8 encoded array to string.
/// Slower than <see cref="GetStringFromASCII"/> but supports UTF-8
/// Slower than <see cref="GetStringFromAscii"/> but supports UTF-8
/// encoded data. Use this function if you are unsure about the
/// source of the data. For user input this function
/// should always be preferred.
@ -719,7 +719,7 @@ namespace Godot
/// A byte array of UTF-8 characters (a character may take up multiple bytes).
/// </param>
/// <returns>A string created from the bytes.</returns>
public static string GetStringFromUTF8(this byte[] bytes)
public static string GetStringFromUtf8(this byte[] bytes)
{
return Encoding.UTF8.GetString(bytes);
}
@ -1287,10 +1287,10 @@ namespace Godot
/// <summary>
/// Returns the MD5 hash of the string as an array of bytes.
/// </summary>
/// <seealso cref="MD5Text(string)"/>
/// <seealso cref="Md5Text(string)"/>
/// <param name="instance">The string to hash.</param>
/// <returns>The MD5 hash of the string.</returns>
public static byte[] MD5Buffer(this string instance)
public static byte[] Md5Buffer(this string instance)
{
#pragma warning disable CA5351 // Do Not Use Broken Cryptographic Algorithms
return MD5.HashData(Encoding.UTF8.GetBytes(instance));
@ -1300,12 +1300,12 @@ namespace Godot
/// <summary>
/// Returns the MD5 hash of the string as a string.
/// </summary>
/// <seealso cref="MD5Buffer(string)"/>
/// <seealso cref="Md5Buffer(string)"/>
/// <param name="instance">The string to hash.</param>
/// <returns>The MD5 hash of the string.</returns>
public static string MD5Text(this string instance)
public static string Md5Text(this string instance)
{
return instance.MD5Buffer().HexEncode();
return instance.Md5Buffer().HexEncode();
}
/// <summary>
@ -1523,10 +1523,10 @@ namespace Godot
/// <summary>
/// Returns the SHA-1 hash of the string as an array of bytes.
/// </summary>
/// <seealso cref="SHA1Text(string)"/>
/// <seealso cref="Sha1Text(string)"/>
/// <param name="instance">The string to hash.</param>
/// <returns>The SHA-1 hash of the string.</returns>
public static byte[] SHA1Buffer(this string instance)
public static byte[] Sha1Buffer(this string instance)
{
#pragma warning disable CA5350 // Do Not Use Weak Cryptographic Algorithms
return SHA1.HashData(Encoding.UTF8.GetBytes(instance));
@ -1536,21 +1536,21 @@ namespace Godot
/// <summary>
/// Returns the SHA-1 hash of the string as a string.
/// </summary>
/// <seealso cref="SHA1Buffer(string)"/>
/// <seealso cref="Sha1Buffer(string)"/>
/// <param name="instance">The string to hash.</param>
/// <returns>The SHA-1 hash of the string.</returns>
public static string SHA1Text(this string instance)
public static string Sha1Text(this string instance)
{
return instance.SHA1Buffer().HexEncode();
return instance.Sha1Buffer().HexEncode();
}
/// <summary>
/// Returns the SHA-256 hash of the string as an array of bytes.
/// </summary>
/// <seealso cref="SHA256Text(string)"/>
/// <seealso cref="Sha256Text(string)"/>
/// <param name="instance">The string to hash.</param>
/// <returns>The SHA-256 hash of the string.</returns>
public static byte[] SHA256Buffer(this string instance)
public static byte[] Sha256Buffer(this string instance)
{
return SHA256.HashData(Encoding.UTF8.GetBytes(instance));
}
@ -1558,12 +1558,12 @@ namespace Godot
/// <summary>
/// Returns the SHA-256 hash of the string as a string.
/// </summary>
/// <seealso cref="SHA256Buffer(string)"/>
/// <seealso cref="Sha256Buffer(string)"/>
/// <param name="instance">The string to hash.</param>
/// <returns>The SHA-256 hash of the string.</returns>
public static string SHA256Text(this string instance)
public static string Sha256Text(this string instance)
{
return instance.SHA256Buffer().HexEncode();
return instance.Sha256Buffer().HexEncode();
}
/// <summary>
@ -1745,15 +1745,15 @@ namespace Godot
/// <summary>
/// Converts the String (which is a character array) to PackedByteArray (which is an array of bytes).
/// The conversion is faster compared to <see cref="ToUTF8Buffer(string)"/>,
/// The conversion is faster compared to <see cref="ToUtf8Buffer(string)"/>,
/// as this method assumes that all the characters in the String are ASCII characters.
/// </summary>
/// <seealso cref="ToUTF8Buffer(string)"/>
/// <seealso cref="ToUTF16Buffer(string)"/>
/// <seealso cref="ToUTF32Buffer(string)"/>
/// <seealso cref="ToUtf8Buffer(string)"/>
/// <seealso cref="ToUtf16Buffer(string)"/>
/// <seealso cref="ToUtf32Buffer(string)"/>
/// <param name="instance">The string to convert.</param>
/// <returns>The string as ASCII encoded bytes.</returns>
public static byte[] ToASCIIBuffer(this string instance)
public static byte[] ToAsciiBuffer(this string instance)
{
return Encoding.ASCII.GetBytes(instance);
}
@ -1783,12 +1783,12 @@ namespace Godot
/// <summary>
/// Converts the string (which is an array of characters) to an UTF-16 encoded array of bytes.
/// </summary>
/// <seealso cref="ToASCIIBuffer(string)"/>
/// <seealso cref="ToUTF32Buffer(string)"/>
/// <seealso cref="ToUTF8Buffer(string)"/>
/// <seealso cref="ToAsciiBuffer(string)"/>
/// <seealso cref="ToUtf32Buffer(string)"/>
/// <seealso cref="ToUtf8Buffer(string)"/>
/// <param name="instance">The string to convert.</param>
/// <returns>The string as UTF-16 encoded bytes.</returns>
public static byte[] ToUTF16Buffer(this string instance)
public static byte[] ToUtf16Buffer(this string instance)
{
return Encoding.Unicode.GetBytes(instance);
}
@ -1796,28 +1796,28 @@ namespace Godot
/// <summary>
/// Converts the string (which is an array of characters) to an UTF-32 encoded array of bytes.
/// </summary>
/// <seealso cref="ToASCIIBuffer(string)"/>
/// <seealso cref="ToUTF16Buffer(string)"/>
/// <seealso cref="ToUTF8Buffer(string)"/>
/// <seealso cref="ToAsciiBuffer(string)"/>
/// <seealso cref="ToUtf16Buffer(string)"/>
/// <seealso cref="ToUtf8Buffer(string)"/>
/// <param name="instance">The string to convert.</param>
/// <returns>The string as UTF-32 encoded bytes.</returns>
public static byte[] ToUTF32Buffer(this string instance)
public static byte[] ToUtf32Buffer(this string instance)
{
return Encoding.UTF32.GetBytes(instance);
}
/// <summary>
/// Converts the string (which is an array of characters) to an UTF-8 encoded array of bytes.
/// The conversion is a bit slower than <see cref="ToASCIIBuffer(string)"/>,
/// The conversion is a bit slower than <see cref="ToAsciiBuffer(string)"/>,
/// but supports all UTF-8 characters. Therefore, you should prefer this function
/// over <see cref="ToASCIIBuffer(string)"/>.
/// over <see cref="ToAsciiBuffer(string)"/>.
/// </summary>
/// <seealso cref="ToASCIIBuffer(string)"/>
/// <seealso cref="ToUTF16Buffer(string)"/>
/// <seealso cref="ToUTF32Buffer(string)"/>
/// <seealso cref="ToAsciiBuffer(string)"/>
/// <seealso cref="ToUtf16Buffer(string)"/>
/// <seealso cref="ToUtf32Buffer(string)"/>
/// <param name="instance">The string to convert.</param>
/// <returns>The string as UTF-8 encoded bytes.</returns>
public static byte[] ToUTF8Buffer(this string instance)
public static byte[] ToUtf8Buffer(this string instance)
{
return Encoding.UTF8.GetBytes(instance);
}

162
modules/mono/glue/GodotSharp/GodotSharp/Core/Transform2D.cs
View File

@ -19,23 +19,23 @@ namespace Godot
/// <summary>
/// The basis matrix's X vector (column 0). Equivalent to array index <c>[0]</c>.
/// </summary>
public Vector2 x;
public Vector2 X;
/// <summary>
/// The basis matrix's Y vector (column 1). Equivalent to array index <c>[1]</c>.
/// </summary>
public Vector2 y;
public Vector2 Y;
/// <summary>
/// The origin vector (column 2, the third column). Equivalent to array index <c>[2]</c>.
/// The origin vector represents translation.
/// </summary>
public Vector2 origin;
public Vector2 Origin;
/// <summary>
/// Returns the transform's rotation (in radians).
/// </summary>
public readonly real_t Rotation => Mathf.Atan2(x.y, x.x);
public readonly real_t Rotation => Mathf.Atan2(X.Y, X.X);
/// <summary>
/// Returns the scale.
@ -45,13 +45,13 @@ namespace Godot
get
{
real_t detSign = Mathf.Sign(BasisDeterminant());
return new Vector2(x.Length(), detSign * y.Length());
return new Vector2(X.Length(), detSign * Y.Length());
}
}
/// <summary>
/// Access whole columns in the form of <see cref="Vector2"/>.
/// The third column is the <see cref="origin"/> vector.
/// The third column is the <see cref="Origin"/> vector.
/// </summary>
/// <param name="column">Which column vector.</param>
/// <exception cref="ArgumentOutOfRangeException">
@ -64,11 +64,11 @@ namespace Godot
switch (column)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
case 2:
return origin;
return Origin;
default:
throw new ArgumentOutOfRangeException(nameof(column));
}
@ -78,13 +78,13 @@ namespace Godot
switch (column)
{
case 0:
x = value;
X = value;
return;
case 1:
y = value;
Y = value;
return;
case 2:
origin = value;
Origin = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(column));
@ -94,7 +94,7 @@ namespace Godot
/// <summary>
/// Access matrix elements in column-major order.
/// The third column is the <see cref="origin"/> vector.
/// The third column is the <see cref="Origin"/> vector.
/// </summary>
/// <param name="column">Which column, the matrix horizontal position.</param>
/// <param name="row">Which row, the matrix vertical position.</param>
@ -152,12 +152,12 @@ namespace Godot
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private readonly real_t BasisDeterminant()
{
return (x.x * y.y) - (x.y * y.x);
return (X.X * Y.Y) - (X.Y * Y.X);
}
/// <summary>
/// Returns a vector transformed (multiplied) by the basis matrix.
/// This method does not account for translation (the <see cref="origin"/> vector).
/// This method does not account for translation (the <see cref="Origin"/> vector).
/// </summary>
/// <seealso cref="BasisXformInv(Vector2)"/>
/// <param name="v">A vector to transform.</param>
@ -169,7 +169,7 @@ namespace Godot
/// <summary>
/// Returns a vector transformed (multiplied) by the inverse basis matrix.
/// This method does not account for translation (the <see cref="origin"/> vector).
/// This method does not account for translation (the <see cref="Origin"/> vector).
///
/// Note: This results in a multiplication by the inverse of the
/// basis matrix only if it represents a rotation-reflection.
@ -179,7 +179,7 @@ namespace Godot
/// <returns>The inversely transformed vector.</returns>
public readonly Vector2 BasisXformInv(Vector2 v)
{
return new Vector2(x.Dot(v), y.Dot(v));
return new Vector2(X.Dot(v), Y.Dot(v));
}
/// <summary>
@ -222,14 +222,14 @@ namespace Godot
}
// Extract parameters
Vector2 p1 = origin;
Vector2 p2 = transform.origin;
Vector2 p1 = Origin;
Vector2 p2 = transform.Origin;
// Construct matrix
var res = new Transform2D(Mathf.Atan2(v.y, v.x), p1.Lerp(p2, weight));
var res = new Transform2D(Mathf.Atan2(v.Y, v.X), p1.Lerp(p2, weight));
Vector2 scale = s1.Lerp(s2, weight);
res.x *= scale;
res.y *= scale;
res.X *= scale;
res.Y *= scale;
return res;
}
@ -245,10 +245,10 @@ namespace Godot
Transform2D inv = this;
// Swap
inv.x.y = y.x;
inv.y.x = x.y;
inv.X.Y = Y.X;
inv.Y.X = X.Y;
inv.origin = inv.BasisXform(-inv.origin);
inv.Origin = inv.BasisXform(-inv.Origin);
return inv;
}
@ -260,7 +260,7 @@ namespace Godot
/// <returns>Whether this vector is finite or not.</returns>
public readonly bool IsFinite()
{
return x.IsFinite() && y.IsFinite() && origin.IsFinite();
return X.IsFinite() && Y.IsFinite() && Origin.IsFinite();
}
/// <summary>
@ -272,15 +272,15 @@ namespace Godot
{
Transform2D on = this;
Vector2 onX = on.x;
Vector2 onY = on.y;
Vector2 onX = on.X;
Vector2 onY = on.Y;
onX.Normalize();
onY = onY - (onX * onX.Dot(onY));
onY.Normalize();
on.x = onX;
on.y = onY;
on.X = onX;
on.Y = onY;
return on;
}
@ -319,9 +319,9 @@ namespace Godot
public readonly Transform2D Scaled(Vector2 scale)
{
Transform2D copy = this;
copy.x *= scale;
copy.y *= scale;
copy.origin *= scale;
copy.X *= scale;
copy.Y *= scale;
copy.Origin *= scale;
return copy;
}
@ -335,8 +335,8 @@ namespace Godot
public readonly Transform2D ScaledLocal(Vector2 scale)
{
Transform2D copy = this;
copy.x *= scale;
copy.y *= scale;
copy.X *= scale;
copy.Y *= scale;
return copy;
}
@ -360,7 +360,7 @@ namespace Godot
public readonly Transform2D Translated(Vector2 offset)
{
Transform2D copy = this;
copy.origin += offset;
copy.Origin += offset;
return copy;
}
@ -374,7 +374,7 @@ namespace Godot
public readonly Transform2D TranslatedLocal(Vector2 offset)
{
Transform2D copy = this;
copy.origin += copy.BasisXform(offset);
copy.Origin += copy.BasisXform(offset);
return copy;
}
@ -409,26 +409,26 @@ namespace Godot
/// <param name="originPos">The origin vector, or column index 2.</param>
public Transform2D(Vector2 xAxis, Vector2 yAxis, Vector2 originPos)
{
x = xAxis;
y = yAxis;
origin = originPos;
X = xAxis;
Y = yAxis;
Origin = originPos;
}
/// <summary>
/// Constructs a transformation matrix from the given components.
/// Arguments are named such that xy is equal to calling <c>x.y</c>.
/// Arguments are named such that xy is equal to calling <c>X.Y</c>.
/// </summary>
/// <param name="xx">The X component of the X column vector, accessed via <c>t.x.x</c> or <c>[0][0]</c>.</param>
/// <param name="xy">The Y component of the X column vector, accessed via <c>t.x.y</c> or <c>[0][1]</c>.</param>
/// <param name="yx">The X component of the Y column vector, accessed via <c>t.y.x</c> or <c>[1][0]</c>.</param>
/// <param name="yy">The Y component of the Y column vector, accessed via <c>t.y.y</c> or <c>[1][1]</c>.</param>
/// <param name="ox">The X component of the origin vector, accessed via <c>t.origin.x</c> or <c>[2][0]</c>.</param>
/// <param name="oy">The Y component of the origin vector, accessed via <c>t.origin.y</c> or <c>[2][1]</c>.</param>
/// <param name="xx">The X component of the X column vector, accessed via <c>t.X.X</c> or <c>[0][0]</c>.</param>
/// <param name="xy">The Y component of the X column vector, accessed via <c>t.X.Y</c> or <c>[0][1]</c>.</param>
/// <param name="yx">The X component of the Y column vector, accessed via <c>t.Y.X</c> or <c>[1][0]</c>.</param>
/// <param name="yy">The Y component of the Y column vector, accessed via <c>t.Y.Y</c> or <c>[1][1]</c>.</param>
/// <param name="ox">The X component of the origin vector, accessed via <c>t.Origin.X</c> or <c>[2][0]</c>.</param>
/// <param name="oy">The Y component of the origin vector, accessed via <c>t.Origin.Y</c> or <c>[2][1]</c>.</param>
public Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy)
{
x = new Vector2(xx, xy);
y = new Vector2(yx, yy);
origin = new Vector2(ox, oy);
X = new Vector2(xx, xy);
Y = new Vector2(yx, yy);
Origin = new Vector2(ox, oy);
}
/// <summary>
@ -440,10 +440,10 @@ namespace Godot
public Transform2D(real_t rotation, Vector2 origin)
{
(real_t sin, real_t cos) = Mathf.SinCos(rotation);
x.x = y.y = cos;
x.y = y.x = sin;
y.x *= -1;
this.origin = origin;
X.X = Y.Y = cos;
X.Y = Y.X = sin;
Y.X *= -1;
Origin = origin;
}
/// <summary>
@ -459,11 +459,11 @@ namespace Godot
{
(real_t rotationSin, real_t rotationCos) = Mathf.SinCos(rotation);
(real_t rotationSkewSin, real_t rotationSkewCos) = Mathf.SinCos(rotation + skew);
x.x = rotationCos * scale.x;
y.y = rotationSkewCos * scale.y;
y.x = -rotationSkewSin * scale.y;
x.y = rotationSin * scale.x;
this.origin = origin;
X.X = rotationCos * scale.X;
Y.Y = rotationSkewCos * scale.Y;
Y.X = -rotationSkewSin * scale.Y;
X.Y = rotationSin * scale.X;
Origin = origin;
}
/// <summary>
@ -476,17 +476,17 @@ namespace Godot
/// <returns>The composed transform.</returns>
public static Transform2D operator *(Transform2D left, Transform2D right)
{
left.origin = left * right.origin;
left.Origin = left * right.Origin;
real_t x0 = left.Tdotx(right.x);
real_t x1 = left.Tdoty(right.x);
real_t y0 = left.Tdotx(right.y);
real_t y1 = left.Tdoty(right.y);
real_t x0 = left.Tdotx(right.X);
real_t x1 = left.Tdoty(right.X);
real_t y0 = left.Tdotx(right.Y);
real_t y1 = left.Tdoty(right.Y);
left.x.x = x0;
left.x.y = x1;
left.y.x = y0;
left.y.y = y1;
left.X.X = x0;
left.X.Y = x1;
left.Y.X = y0;
left.Y.Y = y1;
return left;
}
@ -499,7 +499,7 @@ namespace Godot
/// <returns>The transformed Vector2.</returns>
public static Vector2 operator *(Transform2D transform, Vector2 vector)
{
return new Vector2(transform.Tdotx(vector), transform.Tdoty(vector)) + transform.origin;
return new Vector2(transform.Tdotx(vector), transform.Tdoty(vector)) + transform.Origin;
}
/// <summary>
@ -510,8 +510,8 @@ namespace Godot
/// <returns>The inversely transformed Vector2.</returns>
public static Vector2 operator *(Vector2 vector, Transform2D transform)
{
Vector2 vInv = vector - transform.origin;
return new Vector2(transform.x.Dot(vInv), transform.y.Dot(vInv));
Vector2 vInv = vector - transform.Origin;
return new Vector2(transform.X.Dot(vInv), transform.Y.Dot(vInv));
}
/// <summary>
@ -523,8 +523,8 @@ namespace Godot
public static Rect2 operator *(Transform2D transform, Rect2 rect)
{
Vector2 pos = transform * rect.Position;
Vector2 toX = transform.x * rect.Size.x;
Vector2 toY = transform.y * rect.Size.y;
Vector2 toX = transform.X * rect.Size.X;
Vector2 toY = transform.Y * rect.Size.Y;
return new Rect2(pos, new Vector2()).Expand(pos + toX).Expand(pos + toY).Expand(pos + toX + toY);
}
@ -538,9 +538,9 @@ namespace Godot
public static Rect2 operator *(Rect2 rect, Transform2D transform)
{
Vector2 pos = rect.Position * transform;
Vector2 to1 = new Vector2(rect.Position.x, rect.Position.y + rect.Size.y) * transform;
Vector2 to2 = new Vector2(rect.Position.x + rect.Size.x, rect.Position.y + rect.Size.y) * transform;
Vector2 to3 = new Vector2(rect.Position.x + rect.Size.x, rect.Position.y) * transform;
Vector2 to1 = new Vector2(rect.Position.X, rect.Position.Y + rect.Size.Y) * transform;
Vector2 to2 = new Vector2(rect.Position.X + rect.Size.X, rect.Position.Y + rect.Size.Y) * transform;
Vector2 to3 = new Vector2(rect.Position.X + rect.Size.X, rect.Position.Y) * transform;
return new Rect2(pos, new Vector2()).Expand(to1).Expand(to2).Expand(to3);
}
@ -629,7 +629,7 @@ namespace Godot
/// <returns>Whether or not the matrices are exactly equal.</returns>
public readonly bool Equals(Transform2D other)
{
return x.Equals(other.x) && y.Equals(other.y) && origin.Equals(other.origin);
return X.Equals(other.X) && Y.Equals(other.Y) && Origin.Equals(other.Origin);
}
/// <summary>
@ -640,7 +640,7 @@ namespace Godot
/// <returns>Whether or not the matrices are approximately equal.</returns>
public readonly bool IsEqualApprox(Transform2D other)
{
return x.IsEqualApprox(other.x) && y.IsEqualApprox(other.y) && origin.IsEqualApprox(other.origin);
return X.IsEqualApprox(other.X) && Y.IsEqualApprox(other.Y) && Origin.IsEqualApprox(other.Origin);
}
/// <summary>
@ -649,7 +649,7 @@ namespace Godot
/// <returns>A hash code for this transform.</returns>
public override readonly int GetHashCode()
{
return x.GetHashCode() ^ y.GetHashCode() ^ origin.GetHashCode();
return X.GetHashCode() ^ Y.GetHashCode() ^ Origin.GetHashCode();
}
/// <summary>
@ -658,7 +658,7 @@ namespace Godot
/// <returns>A string representation of this transform.</returns>
public override readonly string ToString()
{
return $"[X: {x}, Y: {y}, O: {origin}]";
return $"[X: {X}, Y: {Y}, O: {Origin}]";
}
/// <summary>
@ -667,7 +667,7 @@ namespace Godot
/// <returns>A string representation of this transform.</returns>
public readonly string ToString(string format)
{
return $"[X: {x.ToString(format)}, Y: {y.ToString(format)}, O: {origin.ToString(format)}]";
return $"[X: {X.ToString(format)}, Y: {Y.ToString(format)}, O: {Origin.ToString(format)}]";
}
}
}

210
modules/mono/glue/GodotSharp/GodotSharp/Core/Transform3D.cs
View File

@ -6,7 +6,7 @@ namespace Godot
/// <summary>
/// 3×4 matrix (3 rows, 4 columns) used for 3D linear transformations.
/// It can represent transformations such as translation, rotation, or scaling.
/// It consists of a <see cref="Basis"/> (first 3 columns) and a
/// It consists of a <see cref="Godot.Basis"/> (first 3 columns) and a
/// <see cref="Vector3"/> for the origin (last column).
///
/// For more information, read this documentation article:
@ -17,19 +17,19 @@ namespace Godot
public struct Transform3D : IEquatable<Transform3D>
{
/// <summary>
/// The <see cref="Basis"/> of this transform. Contains the X, Y, and Z basis
/// The <see cref="Godot.Basis"/> of this transform. Contains the X, Y, and Z basis
/// vectors (columns 0 to 2) and is responsible for rotation and scale.
/// </summary>
public Basis basis;
public Basis Basis;
/// <summary>
/// The origin vector (column 3, the fourth column). Equivalent to array index <c>[3]</c>.
/// </summary>
public Vector3 origin;
public Vector3 Origin;
/// <summary>
/// Access whole columns in the form of <see cref="Vector3"/>.
/// The fourth column is the <see cref="origin"/> vector.
/// The fourth column is the <see cref="Origin"/> vector.
/// </summary>
/// <param name="column">Which column vector.</param>
/// <exception cref="ArgumentOutOfRangeException">
@ -42,13 +42,13 @@ namespace Godot
switch (column)
{
case 0:
return basis.Column0;
return Basis.Column0;
case 1:
return basis.Column1;
return Basis.Column1;
case 2:
return basis.Column2;
return Basis.Column2;
case 3:
return origin;
return Origin;
default:
throw new ArgumentOutOfRangeException(nameof(column));
}
@ -58,16 +58,16 @@ namespace Godot
switch (column)
{
case 0:
basis.Column0 = value;
Basis.Column0 = value;
return;
case 1:
basis.Column1 = value;
Basis.Column1 = value;
return;
case 2:
basis.Column2 = value;
Basis.Column2 = value;
return;
case 3:
origin = value;
Origin = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(column));
@ -77,7 +77,7 @@ namespace Godot
/// <summary>
/// Access matrix elements in column-major order.
/// The fourth column is the <see cref="origin"/> vector.
/// The fourth column is the <see cref="Origin"/> vector.
/// </summary>
/// <param name="column">Which column, the matrix horizontal position.</param>
/// <param name="row">Which row, the matrix vertical position.</param>
@ -87,18 +87,18 @@ namespace Godot
{
if (column == 3)
{
return origin[row];
return Origin[row];
}
return basis[column, row];
return Basis[column, row];
}
set
{
if (column == 3)
{
origin[row] = value;
Origin[row] = value;
return;
}
basis[column, row] = value;
Basis[column, row] = value;
}
}
@ -110,8 +110,8 @@ namespace Godot
/// <returns>The inverse transformation matrix.</returns>
public readonly Transform3D AffineInverse()
{
Basis basisInv = basis.Inverse();
return new Transform3D(basisInv, basisInv * -origin);
Basis basisInv = Basis.Inverse();
return new Transform3D(basisInv, basisInv * -Origin);
}
/// <summary>
@ -124,19 +124,19 @@ namespace Godot
/// <returns>The interpolated transform.</returns>
public readonly Transform3D InterpolateWith(Transform3D transform, real_t weight)
{
Vector3 sourceScale = basis.Scale;
Quaternion sourceRotation = basis.GetRotationQuaternion();
Vector3 sourceLocation = origin;
Vector3 sourceScale = Basis.Scale;
Quaternion sourceRotation = Basis.GetRotationQuaternion();
Vector3 sourceLocation = Origin;
Vector3 destinationScale = transform.basis.Scale;
Quaternion destinationRotation = transform.basis.GetRotationQuaternion();
Vector3 destinationLocation = transform.origin;
Vector3 destinationScale = transform.Basis.Scale;
Quaternion destinationRotation = transform.Basis.GetRotationQuaternion();
Vector3 destinationLocation = transform.Origin;
var interpolated = new Transform3D();
Quaternion quaternion = sourceRotation.Slerp(destinationRotation, weight).Normalized();
Vector3 scale = sourceScale.Lerp(destinationScale, weight);
interpolated.basis.SetQuaternionScale(quaternion, scale);
interpolated.origin = sourceLocation.Lerp(destinationLocation, weight);
interpolated.Basis.SetQuaternionScale(quaternion, scale);
interpolated.Origin = sourceLocation.Lerp(destinationLocation, weight);
return interpolated;
}
@ -149,8 +149,8 @@ namespace Godot
/// <returns>The inverse matrix.</returns>
public readonly Transform3D Inverse()
{
Basis basisTr = basis.Transposed();
return new Transform3D(basisTr, basisTr * -origin);
Basis basisTr = Basis.Transposed();
return new Transform3D(basisTr, basisTr * -Origin);
}
/// <summary>
@ -160,7 +160,7 @@ namespace Godot
/// <returns>Whether this vector is finite or not.</returns>
public readonly bool IsFinite()
{
return basis.IsFinite() && origin.IsFinite();
return Basis.IsFinite() && Origin.IsFinite();
}
/// <summary>
@ -179,7 +179,7 @@ namespace Godot
public readonly Transform3D LookingAt(Vector3 target, Vector3 up)
{
Transform3D t = this;
t.SetLookAt(origin, target, up);
t.SetLookAt(Origin, target, up);
return t;
}
@ -190,7 +190,7 @@ namespace Godot
/// <returns>The orthonormalized transform.</returns>
public readonly Transform3D Orthonormalized()
{
return new Transform3D(basis.Orthonormalized(), origin);
return new Transform3D(Basis.Orthonormalized(), Origin);
}
/// <summary>
@ -219,7 +219,7 @@ namespace Godot
public readonly Transform3D RotatedLocal(Vector3 axis, real_t angle)
{
Basis tmpBasis = new Basis(axis, angle);
return new Transform3D(basis * tmpBasis, origin);
return new Transform3D(Basis * tmpBasis, Origin);
}
/// <summary>
@ -231,7 +231,7 @@ namespace Godot
/// <returns>The scaled transformation matrix.</returns>
public readonly Transform3D Scaled(Vector3 scale)
{
return new Transform3D(basis.Scaled(scale), origin * scale);
return new Transform3D(Basis.Scaled(scale), Origin * scale);
}
/// <summary>
@ -244,7 +244,7 @@ namespace Godot
public readonly Transform3D ScaledLocal(Vector3 scale)
{
Basis tmpBasis = Basis.FromScale(scale);
return new Transform3D(basis * tmpBasis, origin);
return new Transform3D(Basis * tmpBasis, Origin);
}
private void SetLookAt(Vector3 eye, Vector3 target, Vector3 up)
@ -265,9 +265,9 @@ namespace Godot
column0.Normalize();
column1.Normalize();
basis = new Basis(column0, column1, column2);
Basis = new Basis(column0, column1, column2);
origin = eye;
Origin = eye;
}
/// <summary>
@ -279,7 +279,7 @@ namespace Godot
/// <returns>The translated matrix.</returns>
public readonly Transform3D Translated(Vector3 offset)
{
return new Transform3D(basis, origin + offset);
return new Transform3D(Basis, Origin + offset);
}
/// <summary>
@ -291,11 +291,11 @@ namespace Godot
/// <returns>The translated matrix.</returns>
public readonly Transform3D TranslatedLocal(Vector3 offset)
{
return new Transform3D(basis, new Vector3
return new Transform3D(Basis, new Vector3
(
origin[0] + basis.Row0.Dot(offset),
origin[1] + basis.Row1.Dot(offset),
origin[2] + basis.Row2.Dot(offset)
Origin[0] + Basis.Row0.Dot(offset),
Origin[1] + Basis.Row1.Dot(offset),
Origin[2] + Basis.Row2.Dot(offset)
));
}
@ -337,64 +337,64 @@ namespace Godot
/// <param name="origin">The origin vector, or column index 3.</param>
public Transform3D(Vector3 column0, Vector3 column1, Vector3 column2, Vector3 origin)
{
basis = new Basis(column0, column1, column2);
this.origin = origin;
Basis = new Basis(column0, column1, column2);
Origin = origin;
}
/// <summary>
/// Constructs a transformation matrix from the given components.
/// Arguments are named such that xy is equal to calling <c>basis.x.y</c>.
/// Arguments are named such that xy is equal to calling <c>Basis.X.Y</c>.
/// </summary>
/// <param name="xx">The X component of the X column vector, accessed via <c>t.basis.x.x</c> or <c>[0][0]</c>.</param>
/// <param name="yx">The X component of the Y column vector, accessed via <c>t.basis.y.x</c> or <c>[1][0]</c>.</param>
/// <param name="zx">The X component of the Z column vector, accessed via <c>t.basis.z.x</c> or <c>[2][0]</c>.</param>
/// <param name="xy">The Y component of the X column vector, accessed via <c>t.basis.x.y</c> or <c>[0][1]</c>.</param>
/// <param name="yy">The Y component of the Y column vector, accessed via <c>t.basis.y.y</c> or <c>[1][1]</c>.</param>
/// <param name="zy">The Y component of the Z column vector, accessed via <c>t.basis.y.y</c> or <c>[2][1]</c>.</param>
/// <param name="xz">The Z component of the X column vector, accessed via <c>t.basis.x.y</c> or <c>[0][2]</c>.</param>
/// <param name="yz">The Z component of the Y column vector, accessed via <c>t.basis.y.y</c> or <c>[1][2]</c>.</param>
/// <param name="zz">The Z component of the Z column vector, accessed via <c>t.basis.y.y</c> or <c>[2][2]</c>.</param>
/// <param name="ox">The X component of the origin vector, accessed via <c>t.origin.x</c> or <c>[2][0]</c>.</param>
/// <param name="oy">The Y component of the origin vector, accessed via <c>t.origin.y</c> or <c>[2][1]</c>.</param>
/// <param name="oz">The Z component of the origin vector, accessed via <c>t.origin.z</c> or <c>[2][2]</c>.</param>
/// <param name="xx">The X component of the X column vector, accessed via <c>t.Basis.X.X</c> or <c>[0][0]</c>.</param>
/// <param name="yx">The X component of the Y column vector, accessed via <c>t.Basis.Y.X</c> or <c>[1][0]</c>.</param>
/// <param name="zx">The X component of the Z column vector, accessed via <c>t.Basis.Z.X</c> or <c>[2][0]</c>.</param>
/// <param name="xy">The Y component of the X column vector, accessed via <c>t.Basis.X.Y</c> or <c>[0][1]</c>.</param>
/// <param name="yy">The Y component of the Y column vector, accessed via <c>t.Basis.Y.Y</c> or <c>[1][1]</c>.</param>
/// <param name="zy">The Y component of the Z column vector, accessed via <c>t.Basis.Y.Y</c> or <c>[2][1]</c>.</param>
/// <param name="xz">The Z component of the X column vector, accessed via <c>t.Basis.X.Y</c> or <c>[0][2]</c>.</param>
/// <param name="yz">The Z component of the Y column vector, accessed via <c>t.Basis.Y.Y</c> or <c>[1][2]</c>.</param>
/// <param name="zz">The Z component of the Z column vector, accessed via <c>t.Basis.Y.Y</c> or <c>[2][2]</c>.</param>
/// <param name="ox">The X component of the origin vector, accessed via <c>t.Origin.X</c> or <c>[2][0]</c>.</param>
/// <param name="oy">The Y component of the origin vector, accessed via <c>t.Origin.Y</c> or <c>[2][1]</c>.</param>
/// <param name="oz">The Z component of the origin vector, accessed via <c>t.Origin.Z</c> or <c>[2][2]</c>.</param>
public Transform3D(real_t xx, real_t yx, real_t zx, real_t xy, real_t yy, real_t zy, real_t xz, real_t yz, real_t zz, real_t ox, real_t oy, real_t oz)
{
basis = new Basis(xx, yx, zx, xy, yy, zy, xz, yz, zz);
origin = new Vector3(ox, oy, oz);
Basis = new Basis(xx, yx, zx, xy, yy, zy, xz, yz, zz);
Origin = new Vector3(ox, oy, oz);
}
/// <summary>
/// Constructs a transformation matrix from the given <paramref name="basis"/> and
/// <paramref name="origin"/> vector.
/// </summary>
/// <param name="basis">The <see cref="Basis"/> to create the basis from.</param>
/// <param name="basis">The <see cref="Godot.Basis"/> to create the basis from.</param>
/// <param name="origin">The origin vector, or column index 3.</param>
public Transform3D(Basis basis, Vector3 origin)
{
this.basis = basis;
this.origin = origin;
Basis = basis;
Origin = origin;
}
/// <summary>
/// Constructs a transformation matrix from the given <paramref name="projection"/>
/// by trimming the last row of the projection matrix (<c>projection.x.w</c>,
/// <c>projection.y.w</c>, <c>projection.z.w</c>, and <c>projection.w.w</c>
/// by trimming the last row of the projection matrix (<c>projection.X.W</c>,
/// <c>projection.Y.W</c>, <c>projection.Z.W</c>, and <c>projection.W.W</c>
/// are not copied over).
/// </summary>
/// <param name="projection">The <see cref="Projection"/> to create the transform from.</param>
public Transform3D(Projection projection)
{
basis = new Basis
Basis = new Basis
(
projection.x.x, projection.y.x, projection.z.x,
projection.x.y, projection.y.y, projection.z.y,
projection.x.z, projection.y.z, projection.z.z
projection.X.X, projection.Y.X, projection.Z.X,
projection.X.Y, projection.Y.Y, projection.Z.Y,
projection.X.Z, projection.Y.Z, projection.Z.Z
);
origin = new Vector3
Origin = new Vector3
(
projection.w.x,
projection.w.y,
projection.w.z
projection.W.X,
projection.W.Y,
projection.W.Z
);
}
@ -408,8 +408,8 @@ namespace Godot
/// <returns>The composed transform.</returns>
public static Transform3D operator *(Transform3D left, Transform3D right)
{
left.origin = left * right.origin;
left.basis *= right.basis;
left.Origin = left * right.Origin;
left.Basis *= right.Basis;
return left;
}
@ -423,9 +423,9 @@ namespace Godot
{
return new Vector3
(
transform.basis.Row0.Dot(vector) + transform.origin.x,
transform.basis.Row1.Dot(vector) + transform.origin.y,
transform.basis.Row2.Dot(vector) + transform.origin.z
transform.Basis.Row0.Dot(vector) + transform.Origin.X,
transform.Basis.Row1.Dot(vector) + transform.Origin.Y,
transform.Basis.Row2.Dot(vector) + transform.Origin.Z
);
}
@ -440,13 +440,13 @@ namespace Godot
/// <returns>The inversely transformed Vector3.</returns>
public static Vector3 operator *(Vector3 vector, Transform3D transform)
{
Vector3 vInv = vector - transform.origin;
Vector3 vInv = vector - transform.Origin;
return new Vector3
(
(transform.basis.Row0[0] * vInv.x) + (transform.basis.Row1[0] * vInv.y) + (transform.basis.Row2[0] * vInv.z),
(transform.basis.Row0[1] * vInv.x) + (transform.basis.Row1[1] * vInv.y) + (transform.basis.Row2[1] * vInv.z),
(transform.basis.Row0[2] * vInv.x) + (transform.basis.Row1[2] * vInv.y) + (transform.basis.Row2[2] * vInv.z)
(transform.Basis.Row0[0] * vInv.X) + (transform.Basis.Row1[0] * vInv.Y) + (transform.Basis.Row2[0] * vInv.Z),
(transform.Basis.Row0[1] * vInv.X) + (transform.Basis.Row1[1] * vInv.Y) + (transform.Basis.Row2[1] * vInv.Z),
(transform.Basis.Row0[2] * vInv.X) + (transform.Basis.Row1[2] * vInv.Y) + (transform.Basis.Row2[2] * vInv.Z)
);
}
@ -456,19 +456,19 @@ namespace Godot
/// <param name="transform">The transformation to apply.</param>
/// <param name="aabb">An AABB to transform.</param>
/// <returns>The transformed AABB.</returns>
public static AABB operator *(Transform3D transform, AABB aabb)
public static Aabb operator *(Transform3D transform, Aabb aabb)
{
Vector3 min = aabb.Position;
Vector3 max = aabb.Position + aabb.Size;
Vector3 tmin = transform.origin;
Vector3 tmax = transform.origin;
Vector3 tmin = transform.Origin;
Vector3 tmax = transform.Origin;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
real_t e = transform.basis[i][j] * min[j];
real_t f = transform.basis[i][j] * max[j];
real_t e = transform.Basis[i][j] * min[j];
real_t f = transform.Basis[i][j] * max[j];
if (e < f)
{
tmin[i] += e;
@ -482,7 +482,7 @@ namespace Godot
}
}
return new AABB(tmin, tmax - tmin);
return new Aabb(tmin, tmax - tmin);
}
/// <summary>
@ -491,18 +491,18 @@ namespace Godot
/// <param name="aabb">An AABB to inversely transform.</param>
/// <param name="transform">The transformation to apply.</param>
/// <returns>The inversely transformed AABB.</returns>
public static AABB operator *(AABB aabb, Transform3D transform)
public static Aabb operator *(Aabb aabb, Transform3D transform)
{
Vector3 pos = new Vector3(aabb.Position.x + aabb.Size.x, aabb.Position.y + aabb.Size.y, aabb.Position.z + aabb.Size.z) * transform;
Vector3 to1 = new Vector3(aabb.Position.x + aabb.Size.x, aabb.Position.y + aabb.Size.y, aabb.Position.z) * transform;
Vector3 to2 = new Vector3(aabb.Position.x + aabb.Size.x, aabb.Position.y, aabb.Position.z + aabb.Size.z) * transform;
Vector3 to3 = new Vector3(aabb.Position.x + aabb.Size.x, aabb.Position.y, aabb.Position.z) * transform;
Vector3 to4 = new Vector3(aabb.Position.x, aabb.Position.y + aabb.Size.y, aabb.Position.z + aabb.Size.z) * transform;
Vector3 to5 = new Vector3(aabb.Position.x, aabb.Position.y + aabb.Size.y, aabb.Position.z) * transform;
Vector3 to6 = new Vector3(aabb.Position.x, aabb.Position.y, aabb.Position.z + aabb.Size.z) * transform;
Vector3 to7 = new Vector3(aabb.Position.x, aabb.Position.y, aabb.Position.z) * transform;
Vector3 pos = new Vector3(aabb.Position.X + aabb.Size.X, aabb.Position.Y + aabb.Size.Y, aabb.Position.Z + aabb.Size.Z) * transform;
Vector3 to1 = new Vector3(aabb.Position.X + aabb.Size.X, aabb.Position.Y + aabb.Size.Y, aabb.Position.Z) * transform;
Vector3 to2 = new Vector3(aabb.Position.X + aabb.Size.X, aabb.Position.Y, aabb.Position.Z + aabb.Size.Z) * transform;
Vector3 to3 = new Vector3(aabb.Position.X + aabb.Size.X, aabb.Position.Y, aabb.Position.Z) * transform;
Vector3 to4 = new Vector3(aabb.Position.X, aabb.Position.Y + aabb.Size.Y, aabb.Position.Z + aabb.Size.Z) * transform;
Vector3 to5 = new Vector3(aabb.Position.X, aabb.Position.Y + aabb.Size.Y, aabb.Position.Z) * transform;
Vector3 to6 = new Vector3(aabb.Position.X, aabb.Position.Y, aabb.Position.Z + aabb.Size.Z) * transform;
Vector3 to7 = new Vector3(aabb.Position.X, aabb.Position.Y, aabb.Position.Z) * transform;
return new AABB(pos, new Vector3()).Expand(to1).Expand(to2).Expand(to3).Expand(to4).Expand(to5).Expand(to6).Expand(to7);
return new Aabb(pos, new Vector3()).Expand(to1).Expand(to2).Expand(to3).Expand(to4).Expand(to5).Expand(to6).Expand(to7);
}
/// <summary>
@ -513,7 +513,7 @@ namespace Godot
/// <returns>The transformed Plane.</returns>
public static Plane operator *(Transform3D transform, Plane plane)
{
Basis bInvTrans = transform.basis.Inverse().Transposed();
Basis bInvTrans = transform.Basis.Inverse().Transposed();
// Transform a single point on the plane.
Vector3 point = transform * (plane.Normal * plane.D);
@ -534,7 +534,7 @@ namespace Godot
public static Plane operator *(Plane plane, Transform3D transform)
{
Transform3D tInv = transform.AffineInverse();
Basis bTrans = transform.basis.Transposed();
Basis bTrans = transform.Basis.Transposed();
// Transform a single point on the plane.
Vector3 point = tInv * (plane.Normal * plane.D);
@ -637,7 +637,7 @@ namespace Godot
/// <returns>Whether or not the matrices are exactly equal.</returns>
public readonly bool Equals(Transform3D other)
{
return basis.Equals(other.basis) && origin.Equals(other.origin);
return Basis.Equals(other.Basis) && Origin.Equals(other.Origin);
}
/// <summary>
@ -648,7 +648,7 @@ namespace Godot
/// <returns>Whether or not the matrices are approximately equal.</returns>
public readonly bool IsEqualApprox(Transform3D other)
{
return basis.IsEqualApprox(other.basis) && origin.IsEqualApprox(other.origin);
return Basis.IsEqualApprox(other.Basis) && Origin.IsEqualApprox(other.Origin);
}
/// <summary>
@ -657,7 +657,7 @@ namespace Godot
/// <returns>A hash code for this transform.</returns>
public override readonly int GetHashCode()
{
return basis.GetHashCode() ^ origin.GetHashCode();
return Basis.GetHashCode() ^ Origin.GetHashCode();
}
/// <summary>
@ -666,7 +666,7 @@ namespace Godot
/// <returns>A string representation of this transform.</returns>
public override readonly string ToString()
{
return $"[X: {basis.x}, Y: {basis.y}, Z: {basis.z}, O: {origin}]";
return $"[X: {Basis.X}, Y: {Basis.Y}, Z: {Basis.Z}, O: {Origin}]";
}
/// <summary>
@ -675,7 +675,7 @@ namespace Godot
/// <returns>A string representation of this transform.</returns>
public readonly string ToString(string format)
{
return $"[X: {basis.x.ToString(format)}, Y: {basis.y.ToString(format)}, Z: {basis.z.ToString(format)}, O: {origin.ToString(format)}]";
return $"[X: {Basis.X.ToString(format)}, Y: {Basis.Y.ToString(format)}, Z: {Basis.Z.ToString(format)}, O: {Origin.ToString(format)}]";
}
}
}

110
modules/mono/glue/GodotSharp/GodotSharp/Core/Variant.cs
View File

@ -60,13 +60,13 @@ public partial struct Variant : IDisposable
case Type.Int:
case Type.Float:
case Type.Vector2:
case Type.Vector2i:
case Type.Vector2I:
case Type.Rect2:
case Type.Rect2i:
case Type.Rect2I:
case Type.Vector3:
case Type.Vector3i:
case Type.Vector3I:
case Type.Vector4:
case Type.Vector4i:
case Type.Vector4I:
case Type.Plane:
case Type.Quaternion:
case Type.Color:
@ -117,24 +117,24 @@ public partial struct Variant : IDisposable
Type.Float => AsDouble(),
Type.String => AsString(),
Type.Vector2 => AsVector2(),
Type.Vector2i => AsVector2i(),
Type.Vector2I => AsVector2I(),
Type.Rect2 => AsRect2(),
Type.Rect2i => AsRect2i(),
Type.Rect2I => AsRect2I(),
Type.Vector3 => AsVector3(),
Type.Vector3i => AsVector3i(),
Type.Transform2d => AsTransform2D(),
Type.Vector3I => AsVector3I(),
Type.Transform2D => AsTransform2D(),
Type.Vector4 => AsVector4(),
Type.Vector4i => AsVector4i(),
Type.Vector4I => AsVector4I(),
Type.Plane => AsPlane(),
Type.Quaternion => AsQuaternion(),
Type.Aabb => AsAABB(),
Type.Aabb => AsAabb(),
Type.Basis => AsBasis(),
Type.Transform3d => AsTransform3D(),
Type.Transform3D => AsTransform3D(),
Type.Projection => AsProjection(),
Type.Color => AsColor(),
Type.StringName => AsStringName(),
Type.NodePath => AsNodePath(),
Type.Rid => AsRID(),
Type.Rid => AsRid(),
Type.Object => AsGodotObject(),
Type.Callable => AsCallable(),
Type.Signal => AsSignal(),
@ -219,16 +219,16 @@ public partial struct Variant : IDisposable
VariantUtils.ConvertToVector2((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Vector2i AsVector2i() =>
VariantUtils.ConvertToVector2i((godot_variant)NativeVar);
public Vector2I AsVector2I() =>
VariantUtils.ConvertToVector2I((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Rect2 AsRect2() =>
VariantUtils.ConvertToRect2((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Rect2i AsRect2i() =>
VariantUtils.ConvertToRect2i((godot_variant)NativeVar);
public Rect2I AsRect2I() =>
VariantUtils.ConvertToRect2I((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Transform2D AsTransform2D() =>
@ -239,8 +239,8 @@ public partial struct Variant : IDisposable
VariantUtils.ConvertToVector3((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Vector3i AsVector3i() =>
VariantUtils.ConvertToVector3i((godot_variant)NativeVar);
public Vector3I AsVector3I() =>
VariantUtils.ConvertToVector3I((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Basis AsBasis() =>
@ -259,16 +259,16 @@ public partial struct Variant : IDisposable
VariantUtils.ConvertToVector4((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Vector4i AsVector4i() =>
VariantUtils.ConvertToVector4i((godot_variant)NativeVar);
public Vector4I AsVector4I() =>
VariantUtils.ConvertToVector4I((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Projection AsProjection() =>
VariantUtils.ConvertToProjection((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public AABB AsAABB() =>
VariantUtils.ConvertToAABB((godot_variant)NativeVar);
public Aabb AsAabb() =>
VariantUtils.ConvertToAabb((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Color AsColor() =>
@ -344,8 +344,8 @@ public partial struct Variant : IDisposable
VariantUtils.ConvertToSystemArrayOfNodePath((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public RID[] AsSystemArrayOfRID() =>
VariantUtils.ConvertToSystemArrayOfRID((godot_variant)NativeVar);
public Rid[] AsSystemArrayOfRid() =>
VariantUtils.ConvertToSystemArrayOfRid((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Godot.Object AsGodotObject() =>
@ -360,8 +360,8 @@ public partial struct Variant : IDisposable
VariantUtils.ConvertToNodePath((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public RID AsRID() =>
VariantUtils.ConvertToRID((godot_variant)NativeVar);
public Rid AsRid() =>
VariantUtils.ConvertToRid((godot_variant)NativeVar);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Collections.Dictionary AsGodotDictionary() =>
@ -416,13 +416,13 @@ public partial struct Variant : IDisposable
public static explicit operator Vector2(Variant from) => from.AsVector2();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Vector2i(Variant from) => from.AsVector2i();
public static explicit operator Vector2I(Variant from) => from.AsVector2I();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Rect2(Variant from) => from.AsRect2();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Rect2i(Variant from) => from.AsRect2i();
public static explicit operator Rect2I(Variant from) => from.AsRect2I();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Transform2D(Variant from) => from.AsTransform2D();
@ -431,7 +431,7 @@ public partial struct Variant : IDisposable
public static explicit operator Vector3(Variant from) => from.AsVector3();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Vector3i(Variant from) => from.AsVector3i();
public static explicit operator Vector3I(Variant from) => from.AsVector3I();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Basis(Variant from) => from.AsBasis();
@ -446,13 +446,13 @@ public partial struct Variant : IDisposable
public static explicit operator Vector4(Variant from) => from.AsVector4();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Vector4i(Variant from) => from.AsVector4i();
public static explicit operator Vector4I(Variant from) => from.AsVector4I();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Projection(Variant from) => from.AsProjection();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator AABB(Variant from) => from.AsAABB();
public static explicit operator Aabb(Variant from) => from.AsAabb();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Color(Variant from) => from.AsColor();
@ -500,7 +500,7 @@ public partial struct Variant : IDisposable
public static explicit operator NodePath[](Variant from) => from.AsSystemArrayOfNodePath();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator RID[](Variant from) => from.AsSystemArrayOfRID();
public static explicit operator Rid[](Variant from) => from.AsSystemArrayOfRid();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Godot.Object(Variant from) => from.AsGodotObject();
@ -512,7 +512,7 @@ public partial struct Variant : IDisposable
public static explicit operator NodePath(Variant from) => from.AsNodePath();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator RID(Variant from) => from.AsRID();
public static explicit operator Rid(Variant from) => from.AsRid();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Collections.Dictionary(Variant from) => from.AsGodotDictionary();
@ -566,13 +566,13 @@ public partial struct Variant : IDisposable
public static Variant CreateFrom(Vector2 from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Vector2i from) => from;
public static Variant CreateFrom(Vector2I from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Rect2 from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Rect2i from) => from;
public static Variant CreateFrom(Rect2I from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Transform2D from) => from;
@ -581,7 +581,7 @@ public partial struct Variant : IDisposable
public static Variant CreateFrom(Vector3 from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Vector3i from) => from;
public static Variant CreateFrom(Vector3I from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Basis from) => from;
@ -596,13 +596,13 @@ public partial struct Variant : IDisposable
public static Variant CreateFrom(Vector4 from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Vector4i from) => from;
public static Variant CreateFrom(Vector4I from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Projection from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(AABB from) => from;
public static Variant CreateFrom(Aabb from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Color from) => from;
@ -661,7 +661,7 @@ public partial struct Variant : IDisposable
public static Variant CreateFrom(Span<NodePath> from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Span<RID> from) => from;
public static Variant CreateFrom(Span<Rid> from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Godot.Object from) => from;
@ -673,7 +673,7 @@ public partial struct Variant : IDisposable
public static Variant CreateFrom(NodePath from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(RID from) => from;
public static Variant CreateFrom(Rid from) => from;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Variant CreateFrom(Collections.Dictionary from) => from;
@ -740,16 +740,16 @@ public partial struct Variant : IDisposable
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector2(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Vector2i from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector2i(from));
public static implicit operator Variant(Vector2I from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector2I(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Rect2 from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromRect2(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Rect2i from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromRect2i(from));
public static implicit operator Variant(Rect2I from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromRect2I(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Transform2D from) =>
@ -760,8 +760,8 @@ public partial struct Variant : IDisposable
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector3(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Vector3i from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector3i(from));
public static implicit operator Variant(Vector3I from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector3I(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Basis from) =>
@ -780,16 +780,16 @@ public partial struct Variant : IDisposable
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector4(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Vector4i from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector4i(from));
public static implicit operator Variant(Vector4I from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromVector4I(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Projection from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromProjection(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(AABB from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromAABB(from));
public static implicit operator Variant(Aabb from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromAabb(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Color from) =>
@ -856,7 +856,7 @@ public partial struct Variant : IDisposable
(Variant)from.AsSpan();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(RID[] from) =>
public static implicit operator Variant(Rid[] from) =>
(Variant)from.AsSpan();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
@ -904,8 +904,8 @@ public partial struct Variant : IDisposable
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromSystemArrayOfNodePath(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Span<RID> from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromSystemArrayOfRID(from));
public static implicit operator Variant(Span<Rid> from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromSystemArrayOfRid(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Godot.Object from) =>
@ -920,8 +920,8 @@ public partial struct Variant : IDisposable
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromNodePath(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(RID from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromRID(from));
public static implicit operator Variant(Rid from) =>
CreateTakingOwnershipOfDisposableValue(VariantUtils.CreateFromRid(from));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Variant(Collections.Dictionary from) =>

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

@ -29,12 +29,12 @@ namespace Godot
/// <summary>
/// The vector's X component. Also accessible by using the index position <c>[0]</c>.
/// </summary>
public real_t x;
public real_t X;
/// <summary>
/// The vector's Y component. Also accessible by using the index position <c>[1]</c>.
/// </summary>
public real_t y;
public real_t Y;
/// <summary>
/// Access vector components using their index.
@ -43,8 +43,8 @@ namespace Godot
/// <paramref name="index"/> is not 0 or 1.
/// </exception>
/// <value>
/// <c>[0]</c> is equivalent to <see cref="x"/>,
/// <c>[1]</c> is equivalent to <see cref="y"/>.
/// <c>[0]</c> is equivalent to <see cref="X"/>,
/// <c>[1]</c> is equivalent to <see cref="Y"/>.
/// </value>
public real_t this[int index]
{
@ -53,9 +53,9 @@ namespace Godot
switch (index)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
default:
throw new ArgumentOutOfRangeException(nameof(index));
}
@ -65,10 +65,10 @@ namespace Godot
switch (index)
{
case 0:
x = value;
X = value;
return;
case 1:
y = value;
Y = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(index));
@ -81,8 +81,8 @@ namespace Godot
/// </summary>
public readonly void Deconstruct(out real_t x, out real_t y)
{
x = this.x;
y = this.y;
x = X;
y = Y;
}
internal void Normalize()
@ -91,13 +91,13 @@ namespace Godot
if (lengthsq == 0)
{
x = y = 0f;
X = Y = 0f;
}
else
{
real_t length = Mathf.Sqrt(lengthsq);
x /= length;
y /= length;
X /= length;
Y /= length;
}
}
@ -107,19 +107,19 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Abs(real_t)"/> called on each component.</returns>
public readonly Vector2 Abs()
{
return new Vector2(Mathf.Abs(x), Mathf.Abs(y));
return new Vector2(Mathf.Abs(X), Mathf.Abs(Y));
}
/// <summary>
/// Returns this vector's angle with respect to the X axis, or (1, 0) vector, in radians.
///
/// Equivalent to the result of <see cref="Mathf.Atan2(real_t, real_t)"/> when
/// called with the vector's <see cref="y"/> and <see cref="x"/> as parameters: <c>Mathf.Atan2(v.y, v.x)</c>.
/// called with the vector's <see cref="Y"/> and <see cref="X"/> as parameters: <c>Mathf.Atan2(v.Y, v.X)</c>.
/// </summary>
/// <returns>The angle of this vector, in radians.</returns>
public readonly real_t Angle()
{
return Mathf.Atan2(y, x);
return Mathf.Atan2(Y, X);
}
/// <summary>
@ -139,16 +139,16 @@ namespace Godot
/// <returns>The angle between the two vectors, in radians.</returns>
public readonly real_t AngleToPoint(Vector2 to)
{
return Mathf.Atan2(to.y - y, to.x - x);
return Mathf.Atan2(to.Y - Y, to.X - X);
}
/// <summary>
/// Returns the aspect ratio of this vector, the ratio of <see cref="x"/> to <see cref="y"/>.
/// Returns the aspect ratio of this vector, the ratio of <see cref="X"/> to <see cref="Y"/>.
/// </summary>
/// <returns>The <see cref="x"/> component divided by the <see cref="y"/> component.</returns>
/// <returns>The <see cref="X"/> component divided by the <see cref="Y"/> component.</returns>
public readonly real_t Aspect()
{
return x / y;
return X / Y;
}
/// <summary>
@ -167,7 +167,7 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Ceil"/> called on each component.</returns>
public readonly Vector2 Ceil()
{
return new Vector2(Mathf.Ceil(x), Mathf.Ceil(y));
return new Vector2(Mathf.Ceil(X), Mathf.Ceil(Y));
}
/// <summary>
@ -182,8 +182,8 @@ namespace Godot
{
return new Vector2
(
Mathf.Clamp(x, min.x, max.x),
Mathf.Clamp(y, min.y, max.y)
Mathf.Clamp(X, min.X, max.X),
Mathf.Clamp(Y, min.Y, max.Y)
);
}
@ -194,7 +194,7 @@ namespace Godot
/// <returns>The cross product value.</returns>
public readonly real_t Cross(Vector2 with)
{
return (x * with.y) - (y * with.x);
return (X * with.Y) - (Y * with.X);
}
/// <summary>
@ -210,8 +210,8 @@ namespace Godot
{
return new Vector2
(
Mathf.CubicInterpolate(x, b.x, preA.x, postB.x, weight),
Mathf.CubicInterpolate(y, b.y, preA.y, postB.y, weight)
Mathf.CubicInterpolate(X, b.X, preA.X, postB.X, weight),
Mathf.CubicInterpolate(Y, b.Y, preA.Y, postB.Y, weight)
);
}
@ -233,8 +233,8 @@ namespace Godot
{
return new Vector2
(
Mathf.CubicInterpolateInTime(x, b.x, preA.x, postB.x, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(y, b.y, preA.y, postB.y, weight, t, preAT, postBT)
Mathf.CubicInterpolateInTime(X, b.X, preA.X, postB.X, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(Y, b.Y, preA.Y, postB.Y, weight, t, preAT, postBT)
);
}
@ -251,8 +251,8 @@ namespace Godot
{
return new Vector2
(
Mathf.BezierInterpolate(x, control1.x, control2.x, end.x, t),
Mathf.BezierInterpolate(y, control1.y, control2.y, end.y, t)
Mathf.BezierInterpolate(X, control1.X, control2.X, end.X, t),
Mathf.BezierInterpolate(Y, control1.Y, control2.Y, end.Y, t)
);
}
@ -268,8 +268,8 @@ namespace Godot
public readonly Vector2 BezierDerivative(Vector2 control1, Vector2 control2, Vector2 end, real_t t)
{
return new Vector2(
Mathf.BezierDerivative(x, control1.x, control2.x, end.x, t),
Mathf.BezierDerivative(y, control1.y, control2.y, end.y, t)
Mathf.BezierDerivative(X, control1.X, control2.X, end.X, t),
Mathf.BezierDerivative(Y, control1.Y, control2.Y, end.Y, t)
);
}
@ -280,7 +280,7 @@ namespace Godot
/// <returns>The direction from this vector to <paramref name="to"/>.</returns>
public readonly Vector2 DirectionTo(Vector2 to)
{
return new Vector2(to.x - x, to.y - y).Normalized();
return new Vector2(to.X - X, to.Y - Y).Normalized();
}
/// <summary>
@ -292,7 +292,7 @@ namespace Godot
/// <returns>The squared distance between the two vectors.</returns>
public readonly real_t DistanceSquaredTo(Vector2 to)
{
return (x - to.x) * (x - to.x) + (y - to.y) * (y - to.y);
return (X - to.X) * (X - to.X) + (Y - to.Y) * (Y - to.Y);
}
/// <summary>
@ -302,7 +302,7 @@ namespace Godot
/// <returns>The distance between the two vectors.</returns>
public readonly real_t DistanceTo(Vector2 to)
{
return Mathf.Sqrt((x - to.x) * (x - to.x) + (y - to.y) * (y - to.y));
return Mathf.Sqrt((X - to.X) * (X - to.X) + (Y - to.Y) * (Y - to.Y));
}
/// <summary>
@ -312,7 +312,7 @@ namespace Godot
/// <returns>The dot product of the two vectors.</returns>
public readonly real_t Dot(Vector2 with)
{
return (x * with.x) + (y * with.y);
return (X * with.X) + (Y * with.Y);
}
/// <summary>
@ -321,16 +321,16 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Floor"/> called on each component.</returns>
public readonly Vector2 Floor()
{
return new Vector2(Mathf.Floor(x), Mathf.Floor(y));
return new Vector2(Mathf.Floor(X), Mathf.Floor(Y));
}
/// <summary>
/// Returns the inverse of this vector. This is the same as <c>new Vector2(1 / v.x, 1 / v.y)</c>.
/// Returns the inverse of this vector. This is the same as <c>new Vector2(1 / v.X, 1 / v.Y)</c>.
/// </summary>
/// <returns>The inverse of this vector.</returns>
public readonly Vector2 Inverse()
{
return new Vector2(1 / x, 1 / y);
return new Vector2(1 / X, 1 / Y);
}
/// <summary>
@ -340,7 +340,7 @@ namespace Godot
/// <returns>Whether this vector is finite or not.</returns>
public readonly bool IsFinite()
{
return Mathf.IsFinite(x) && Mathf.IsFinite(y);
return Mathf.IsFinite(X) && Mathf.IsFinite(Y);
}
/// <summary>
@ -359,7 +359,7 @@ namespace Godot
/// <returns>The length of this vector.</returns>
public readonly real_t Length()
{
return Mathf.Sqrt((x * x) + (y * y));
return Mathf.Sqrt((X * X) + (Y * Y));
}
/// <summary>
@ -370,7 +370,7 @@ namespace Godot
/// <returns>The squared length of this vector.</returns>
public readonly real_t LengthSquared()
{
return (x * x) + (y * y);
return (X * X) + (Y * Y);
}
/// <summary>
@ -384,8 +384,8 @@ namespace Godot
{
return new Vector2
(
Mathf.Lerp(x, to.x, weight),
Mathf.Lerp(y, to.y, weight)
Mathf.Lerp(X, to.X, weight),
Mathf.Lerp(Y, to.Y, weight)
);
}
@ -415,7 +415,7 @@ namespace Godot
/// <returns>The index of the highest axis.</returns>
public readonly Axis MaxAxisIndex()
{
return x < y ? Axis.Y : Axis.X;
return X < Y ? Axis.Y : Axis.X;
}
/// <summary>
@ -425,7 +425,7 @@ namespace Godot
/// <returns>The index of the lowest axis.</returns>
public readonly Axis MinAxisIndex()
{
return x < y ? Axis.X : Axis.Y;
return X < Y ? Axis.X : Axis.Y;
}
/// <summary>
@ -467,8 +467,8 @@ namespace Godot
public readonly Vector2 PosMod(real_t mod)
{
Vector2 v;
v.x = Mathf.PosMod(x, mod);
v.y = Mathf.PosMod(y, mod);
v.X = Mathf.PosMod(X, mod);
v.Y = Mathf.PosMod(Y, mod);
return v;
}
@ -483,8 +483,8 @@ namespace Godot
public readonly Vector2 PosMod(Vector2 modv)
{
Vector2 v;
v.x = Mathf.PosMod(x, modv.x);
v.y = Mathf.PosMod(y, modv.y);
v.X = Mathf.PosMod(X, modv.X);
v.Y = Mathf.PosMod(Y, modv.Y);
return v;
}
@ -524,8 +524,8 @@ namespace Godot
(real_t sin, real_t cos) = Mathf.SinCos(angle);
return new Vector2
(
x * cos - y * sin,
x * sin + y * cos
X * cos - Y * sin,
X * sin + Y * cos
);
}
@ -536,7 +536,7 @@ namespace Godot
/// <returns>The rounded vector.</returns>
public readonly Vector2 Round()
{
return new Vector2(Mathf.Round(x), Mathf.Round(y));
return new Vector2(Mathf.Round(X), Mathf.Round(Y));
}
/// <summary>
@ -548,8 +548,8 @@ namespace Godot
public readonly Vector2 Sign()
{
Vector2 v;
v.x = Mathf.Sign(x);
v.y = Mathf.Sign(y);
v.X = Mathf.Sign(X);
v.Y = Mathf.Sign(Y);
return v;
}
@ -597,7 +597,7 @@ namespace Godot
/// <returns>The snapped vector.</returns>
public readonly Vector2 Snapped(Vector2 step)
{
return new Vector2(Mathf.Snapped(x, step.x), Mathf.Snapped(y, step.y));
return new Vector2(Mathf.Snapped(X, step.X), Mathf.Snapped(Y, step.Y));
}
/// <summary>
@ -607,7 +607,7 @@ namespace Godot
/// <returns>The perpendicular vector.</returns>
public readonly Vector2 Orthogonal()
{
return new Vector2(y, -x);
return new Vector2(Y, -X);
}
// Constants
@ -664,8 +664,8 @@ namespace Godot
/// <param name="y">The vector's Y component.</param>
public Vector2(real_t x, real_t y)
{
this.x = x;
this.y = y;
X = x;
Y = y;
}
/// <summary>
@ -689,8 +689,8 @@ namespace Godot
/// <returns>The added vector.</returns>
public static Vector2 operator +(Vector2 left, Vector2 right)
{
left.x += right.x;
left.y += right.y;
left.X += right.X;
left.Y += right.Y;
return left;
}
@ -703,14 +703,14 @@ namespace Godot
/// <returns>The subtracted vector.</returns>
public static Vector2 operator -(Vector2 left, Vector2 right)
{
left.x -= right.x;
left.y -= right.y;
left.X -= right.X;
left.Y -= right.Y;
return left;
}
/// <summary>
/// Returns the negative value of the <see cref="Vector2"/>.
/// This is the same as writing <c>new Vector2(-v.x, -v.y)</c>.
/// This is the same as writing <c>new Vector2(-v.X, -v.Y)</c>.
/// This operation flips the direction of the vector while
/// keeping the same magnitude.
/// With floats, the number zero can be either positive or negative.
@ -719,8 +719,8 @@ namespace Godot
/// <returns>The negated/flipped vector.</returns>
public static Vector2 operator -(Vector2 vec)
{
vec.x = -vec.x;
vec.y = -vec.y;
vec.X = -vec.X;
vec.Y = -vec.Y;
return vec;
}
@ -733,8 +733,8 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector2 operator *(Vector2 vec, real_t scale)
{
vec.x *= scale;
vec.y *= scale;
vec.X *= scale;
vec.Y *= scale;
return vec;
}
@ -747,8 +747,8 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector2 operator *(real_t scale, Vector2 vec)
{
vec.x *= scale;
vec.y *= scale;
vec.X *= scale;
vec.Y *= scale;
return vec;
}
@ -761,8 +761,8 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector2 operator *(Vector2 left, Vector2 right)
{
left.x *= right.x;
left.y *= right.y;
left.X *= right.X;
left.Y *= right.Y;
return left;
}
@ -775,8 +775,8 @@ namespace Godot
/// <returns>The divided vector.</returns>
public static Vector2 operator /(Vector2 vec, real_t divisor)
{
vec.x /= divisor;
vec.y /= divisor;
vec.X /= divisor;
vec.Y /= divisor;
return vec;
}
@ -789,8 +789,8 @@ namespace Godot
/// <returns>The divided vector.</returns>
public static Vector2 operator /(Vector2 vec, Vector2 divisorv)
{
vec.x /= divisorv.x;
vec.y /= divisorv.y;
vec.X /= divisorv.X;
vec.Y /= divisorv.Y;
return vec;
}
@ -812,8 +812,8 @@ namespace Godot
/// <returns>The remainder vector.</returns>
public static Vector2 operator %(Vector2 vec, real_t divisor)
{
vec.x %= divisor;
vec.y %= divisor;
vec.X %= divisor;
vec.Y %= divisor;
return vec;
}
@ -835,8 +835,8 @@ namespace Godot
/// <returns>The remainder vector.</returns>
public static Vector2 operator %(Vector2 vec, Vector2 divisorv)
{
vec.x %= divisorv.x;
vec.y %= divisorv.y;
vec.X %= divisorv.X;
vec.Y %= divisorv.Y;
return vec;
}
@ -879,11 +879,11 @@ namespace Godot
/// <returns>Whether or not the left is less than the right.</returns>
public static bool operator <(Vector2 left, Vector2 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
@ -899,11 +899,11 @@ namespace Godot
/// <returns>Whether or not the left is greater than the right.</returns>
public static bool operator >(Vector2 left, Vector2 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
@ -919,11 +919,11 @@ namespace Godot
/// <returns>Whether or not the left is less than or equal to the right.</returns>
public static bool operator <=(Vector2 left, Vector2 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
return left.y <= right.y;
return left.Y <= right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
@ -939,11 +939,11 @@ namespace Godot
/// <returns>Whether or not the left is greater than or equal to the right.</returns>
public static bool operator >=(Vector2 left, Vector2 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
return left.y >= right.y;
return left.Y >= right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
@ -968,7 +968,7 @@ namespace Godot
/// <returns>Whether or not the vectors are exactly equal.</returns>
public readonly bool Equals(Vector2 other)
{
return x == other.x && y == other.y;
return X == other.X && Y == other.Y;
}
/// <summary>
@ -979,7 +979,7 @@ namespace Godot
/// <returns>Whether or not the vectors are approximately equal.</returns>
public readonly bool IsEqualApprox(Vector2 other)
{
return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y);
return Mathf.IsEqualApprox(X, other.X) && Mathf.IsEqualApprox(Y, other.Y);
}
/// <summary>
@ -991,7 +991,7 @@ namespace Godot
/// <returns>Whether or not the vector is approximately zero.</returns>
public readonly bool IsZeroApprox()
{
return Mathf.IsZeroApprox(x) && Mathf.IsZeroApprox(y);
return Mathf.IsZeroApprox(X) && Mathf.IsZeroApprox(Y);
}
/// <summary>
@ -1000,7 +1000,7 @@ namespace Godot
/// <returns>A hash code for this vector.</returns>
public override readonly int GetHashCode()
{
return y.GetHashCode() ^ x.GetHashCode();
return Y.GetHashCode() ^ X.GetHashCode();
}
/// <summary>
@ -1009,7 +1009,7 @@ namespace Godot
/// <returns>A string representation of this vector.</returns>
public override readonly string ToString()
{
return $"({x}, {y})";
return $"({X}, {Y})";
}
/// <summary>
@ -1018,7 +1018,7 @@ namespace Godot
/// <returns>A string representation of this vector.</returns>
public readonly string ToString(string format)
{
return $"({x.ToString(format)}, {y.ToString(format)})";
return $"({X.ToString(format)}, {Y.ToString(format)})";
}
}
}

278
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2i.cs → modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2I.cs
View File

@ -8,7 +8,7 @@ namespace Godot
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct Vector2i : IEquatable<Vector2i>
public struct Vector2I : IEquatable<Vector2I>
{
/// <summary>
/// Enumerated index values for the axes.
@ -29,12 +29,12 @@ namespace Godot
/// <summary>
/// The vector's X component. Also accessible by using the index position <c>[0]</c>.
/// </summary>
public int x;
public int X;
/// <summary>
/// The vector's Y component. Also accessible by using the index position <c>[1]</c>.
/// </summary>
public int y;
public int Y;
/// <summary>
/// Access vector components using their index.
@ -43,8 +43,8 @@ namespace Godot
/// <paramref name="index"/> is not 0 or 1.
/// </exception>
/// <value>
/// <c>[0]</c> is equivalent to <see cref="x"/>,
/// <c>[1]</c> is equivalent to <see cref="y"/>.
/// <c>[0]</c> is equivalent to <see cref="X"/>,
/// <c>[1]</c> is equivalent to <see cref="Y"/>.
/// </value>
public int this[int index]
{
@ -53,9 +53,9 @@ namespace Godot
switch (index)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
default:
throw new ArgumentOutOfRangeException(nameof(index));
}
@ -65,10 +65,10 @@ namespace Godot
switch (index)
{
case 0:
x = value;
X = value;
return;
case 1:
y = value;
Y = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(index));
@ -81,26 +81,26 @@ namespace Godot
/// </summary>
public readonly void Deconstruct(out int x, out int y)
{
x = this.x;
y = this.y;
x = X;
y = Y;
}
/// <summary>
/// Returns a new vector with all components in absolute values (i.e. positive).
/// </summary>
/// <returns>A vector with <see cref="Mathf.Abs(int)"/> called on each component.</returns>
public readonly Vector2i Abs()
public readonly Vector2I Abs()
{
return new Vector2i(Mathf.Abs(x), Mathf.Abs(y));
return new Vector2I(Mathf.Abs(X), Mathf.Abs(Y));
}
/// <summary>
/// Returns the aspect ratio of this vector, the ratio of <see cref="x"/> to <see cref="y"/>.
/// Returns the aspect ratio of this vector, the ratio of <see cref="X"/> to <see cref="Y"/>.
/// </summary>
/// <returns>The <see cref="x"/> component divided by the <see cref="y"/> component.</returns>
/// <returns>The <see cref="X"/> component divided by the <see cref="Y"/> component.</returns>
public readonly real_t Aspect()
{
return x / (real_t)y;
return X / (real_t)Y;
}
/// <summary>
@ -111,12 +111,12 @@ namespace Godot
/// <param name="min">The vector with minimum allowed values.</param>
/// <param name="max">The vector with maximum allowed values.</param>
/// <returns>The vector with all components clamped.</returns>
public readonly Vector2i Clamp(Vector2i min, Vector2i max)
public readonly Vector2I Clamp(Vector2I min, Vector2I max)
{
return new Vector2i
return new Vector2I
(
Mathf.Clamp(x, min.x, max.x),
Mathf.Clamp(y, min.y, max.y)
Mathf.Clamp(X, min.X, max.X),
Mathf.Clamp(Y, min.Y, max.Y)
);
}
@ -127,8 +127,8 @@ namespace Godot
/// <returns>The length of this vector.</returns>
public readonly real_t Length()
{
int x2 = x * x;
int y2 = y * y;
int x2 = X * X;
int y2 = Y * Y;
return Mathf.Sqrt(x2 + y2);
}
@ -141,8 +141,8 @@ namespace Godot
/// <returns>The squared length of this vector.</returns>
public readonly int LengthSquared()
{
int x2 = x * x;
int y2 = y * y;
int x2 = X * X;
int y2 = Y * Y;
return x2 + y2;
}
@ -154,7 +154,7 @@ namespace Godot
/// <returns>The index of the highest axis.</returns>
public readonly Axis MaxAxisIndex()
{
return x < y ? Axis.Y : Axis.X;
return X < Y ? Axis.Y : Axis.X;
}
/// <summary>
@ -164,7 +164,7 @@ namespace Godot
/// <returns>The index of the lowest axis.</returns>
public readonly Axis MinAxisIndex()
{
return x < y ? Axis.X : Axis.Y;
return X < Y ? Axis.X : Axis.Y;
}
/// <summary>
@ -173,181 +173,181 @@ namespace Godot
/// by calling <see cref="Mathf.Sign(int)"/> on each component.
/// </summary>
/// <returns>A vector with all components as either <c>1</c>, <c>-1</c>, or <c>0</c>.</returns>
public readonly Vector2i Sign()
public readonly Vector2I Sign()
{
Vector2i v = this;
v.x = Mathf.Sign(v.x);
v.y = Mathf.Sign(v.y);
Vector2I v = this;
v.X = Mathf.Sign(v.X);
v.Y = Mathf.Sign(v.Y);
return v;
}
// Constants
private static readonly Vector2i _zero = new Vector2i(0, 0);
private static readonly Vector2i _one = new Vector2i(1, 1);
private static readonly Vector2I _zero = new Vector2I(0, 0);
private static readonly Vector2I _one = new Vector2I(1, 1);
private static readonly Vector2i _up = new Vector2i(0, -1);
private static readonly Vector2i _down = new Vector2i(0, 1);
private static readonly Vector2i _right = new Vector2i(1, 0);
private static readonly Vector2i _left = new Vector2i(-1, 0);
private static readonly Vector2I _up = new Vector2I(0, -1);
private static readonly Vector2I _down = new Vector2I(0, 1);
private static readonly Vector2I _right = new Vector2I(1, 0);
private static readonly Vector2I _left = new Vector2I(-1, 0);
/// <summary>
/// Zero vector, a vector with all components set to <c>0</c>.
/// </summary>
/// <value>Equivalent to <c>new Vector2i(0, 0)</c>.</value>
public static Vector2i Zero { get { return _zero; } }
/// <value>Equivalent to <c>new Vector2I(0, 0)</c>.</value>
public static Vector2I Zero { get { return _zero; } }
/// <summary>
/// One vector, a vector with all components set to <c>1</c>.
/// </summary>
/// <value>Equivalent to <c>new Vector2i(1, 1)</c>.</value>
public static Vector2i One { get { return _one; } }
/// <value>Equivalent to <c>new Vector2I(1, 1)</c>.</value>
public static Vector2I One { get { return _one; } }
/// <summary>
/// Up unit vector. Y is down in 2D, so this vector points -Y.
/// </summary>
/// <value>Equivalent to <c>new Vector2i(0, -1)</c>.</value>
public static Vector2i Up { get { return _up; } }
/// <value>Equivalent to <c>new Vector2I(0, -1)</c>.</value>
public static Vector2I Up { get { return _up; } }
/// <summary>
/// Down unit vector. Y is down in 2D, so this vector points +Y.
/// </summary>
/// <value>Equivalent to <c>new Vector2i(0, 1)</c>.</value>
public static Vector2i Down { get { return _down; } }
/// <value>Equivalent to <c>new Vector2I(0, 1)</c>.</value>
public static Vector2I Down { get { return _down; } }
/// <summary>
/// Right unit vector. Represents the direction of right.
/// </summary>
/// <value>Equivalent to <c>new Vector2i(1, 0)</c>.</value>
public static Vector2i Right { get { return _right; } }
/// <value>Equivalent to <c>new Vector2I(1, 0)</c>.</value>
public static Vector2I Right { get { return _right; } }
/// <summary>
/// Left unit vector. Represents the direction of left.
/// </summary>
/// <value>Equivalent to <c>new Vector2i(-1, 0)</c>.</value>
public static Vector2i Left { get { return _left; } }
/// <value>Equivalent to <c>new Vector2I(-1, 0)</c>.</value>
public static Vector2I Left { get { return _left; } }
/// <summary>
/// Constructs a new <see cref="Vector2i"/> with the given components.
/// Constructs a new <see cref="Vector2I"/> with the given components.
/// </summary>
/// <param name="x">The vector's X component.</param>
/// <param name="y">The vector's Y component.</param>
public Vector2i(int x, int y)
public Vector2I(int x, int y)
{
this.x = x;
this.y = y;
X = x;
Y = y;
}
/// <summary>
/// Adds each component of the <see cref="Vector2i"/>
/// with the components of the given <see cref="Vector2i"/>.
/// Adds each component of the <see cref="Vector2I"/>
/// with the components of the given <see cref="Vector2I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The added vector.</returns>
public static Vector2i operator +(Vector2i left, Vector2i right)
public static Vector2I operator +(Vector2I left, Vector2I right)
{
left.x += right.x;
left.y += right.y;
left.X += right.X;
left.Y += right.Y;
return left;
}
/// <summary>
/// Subtracts each component of the <see cref="Vector2i"/>
/// by the components of the given <see cref="Vector2i"/>.
/// Subtracts each component of the <see cref="Vector2I"/>
/// by the components of the given <see cref="Vector2I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The subtracted vector.</returns>
public static Vector2i operator -(Vector2i left, Vector2i right)
public static Vector2I operator -(Vector2I left, Vector2I right)
{
left.x -= right.x;
left.y -= right.y;
left.X -= right.X;
left.Y -= right.Y;
return left;
}
/// <summary>
/// Returns the negative value of the <see cref="Vector2i"/>.
/// This is the same as writing <c>new Vector2i(-v.x, -v.y)</c>.
/// Returns the negative value of the <see cref="Vector2I"/>.
/// This is the same as writing <c>new Vector2I(-v.X, -v.Y)</c>.
/// This operation flips the direction of the vector while
/// keeping the same magnitude.
/// </summary>
/// <param name="vec">The vector to negate/flip.</param>
/// <returns>The negated/flipped vector.</returns>
public static Vector2i operator -(Vector2i vec)
public static Vector2I operator -(Vector2I vec)
{
vec.x = -vec.x;
vec.y = -vec.y;
vec.X = -vec.X;
vec.Y = -vec.Y;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector2i"/>
/// Multiplies each component of the <see cref="Vector2I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="vec">The vector to multiply.</param>
/// <param name="scale">The scale to multiply by.</param>
/// <returns>The multiplied vector.</returns>
public static Vector2i operator *(Vector2i vec, int scale)
public static Vector2I operator *(Vector2I vec, int scale)
{
vec.x *= scale;
vec.y *= scale;
vec.X *= scale;
vec.Y *= scale;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector2i"/>
/// Multiplies each component of the <see cref="Vector2I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="scale">The scale to multiply by.</param>
/// <param name="vec">The vector to multiply.</param>
/// <returns>The multiplied vector.</returns>
public static Vector2i operator *(int scale, Vector2i vec)
public static Vector2I operator *(int scale, Vector2I vec)
{
vec.x *= scale;
vec.y *= scale;
vec.X *= scale;
vec.Y *= scale;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector2i"/>
/// by the components of the given <see cref="Vector2i"/>.
/// Multiplies each component of the <see cref="Vector2I"/>
/// by the components of the given <see cref="Vector2I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The multiplied vector.</returns>
public static Vector2i operator *(Vector2i left, Vector2i right)
public static Vector2I operator *(Vector2I left, Vector2I right)
{
left.x *= right.x;
left.y *= right.y;
left.X *= right.X;
left.Y *= right.Y;
return left;
}
/// <summary>
/// Divides each component of the <see cref="Vector2i"/>
/// Divides each component of the <see cref="Vector2I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisor">The divisor value.</param>
/// <returns>The divided vector.</returns>
public static Vector2i operator /(Vector2i vec, int divisor)
public static Vector2I operator /(Vector2I vec, int divisor)
{
vec.x /= divisor;
vec.y /= divisor;
vec.X /= divisor;
vec.Y /= divisor;
return vec;
}
/// <summary>
/// Divides each component of the <see cref="Vector2i"/>
/// by the components of the given <see cref="Vector2i"/>.
/// Divides each component of the <see cref="Vector2I"/>
/// by the components of the given <see cref="Vector2I"/>.
/// </summary>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisorv">The divisor vector.</param>
/// <returns>The divided vector.</returns>
public static Vector2i operator /(Vector2i vec, Vector2i divisorv)
public static Vector2I operator /(Vector2I vec, Vector2I divisorv)
{
vec.x /= divisorv.x;
vec.y /= divisorv.y;
vec.X /= divisorv.X;
vec.Y /= divisorv.Y;
return vec;
}
/// <summary>
/// Gets the remainder of each component of the <see cref="Vector2i"/>
/// Gets the remainder of each component of the <see cref="Vector2I"/>
/// with the components of the given <see langword="int"/>.
/// This operation uses truncated division, which is often not desired
/// as it does not work well with negative numbers.
@ -356,22 +356,22 @@ namespace Godot
/// </summary>
/// <example>
/// <code>
/// GD.Print(new Vector2i(10, -20) % 7); // Prints "(3, -6)"
/// GD.Print(new Vector2I(10, -20) % 7); // Prints "(3, -6)"
/// </code>
/// </example>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisor">The divisor value.</param>
/// <returns>The remainder vector.</returns>
public static Vector2i operator %(Vector2i vec, int divisor)
public static Vector2I operator %(Vector2I vec, int divisor)
{
vec.x %= divisor;
vec.y %= divisor;
vec.X %= divisor;
vec.Y %= divisor;
return vec;
}
/// <summary>
/// Gets the remainder of each component of the <see cref="Vector2i"/>
/// with the components of the given <see cref="Vector2i"/>.
/// Gets the remainder of each component of the <see cref="Vector2I"/>
/// with the components of the given <see cref="Vector2I"/>.
/// This operation uses truncated division, which is often not desired
/// as it does not work well with negative numbers.
/// Consider using <see cref="Mathf.PosMod(int, int)"/> instead
@ -379,16 +379,16 @@ namespace Godot
/// </summary>
/// <example>
/// <code>
/// GD.Print(new Vector2i(10, -20) % new Vector2i(7, 8)); // Prints "(3, -4)"
/// GD.Print(new Vector2I(10, -20) % new Vector2I(7, 8)); // Prints "(3, -4)"
/// </code>
/// </example>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisorv">The divisor vector.</param>
/// <returns>The remainder vector.</returns>
public static Vector2i operator %(Vector2i vec, Vector2i divisorv)
public static Vector2I operator %(Vector2I vec, Vector2I divisorv)
{
vec.x %= divisorv.x;
vec.y %= divisorv.y;
vec.X %= divisorv.X;
vec.Y %= divisorv.Y;
return vec;
}
@ -398,7 +398,7 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the vectors are equal.</returns>
public static bool operator ==(Vector2i left, Vector2i right)
public static bool operator ==(Vector2I left, Vector2I right)
{
return left.Equals(right);
}
@ -409,13 +409,13 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the vectors are not equal.</returns>
public static bool operator !=(Vector2i left, Vector2i right)
public static bool operator !=(Vector2I left, Vector2I right)
{
return !left.Equals(right);
}
/// <summary>
/// Compares two <see cref="Vector2i"/> vectors by first checking if
/// Compares two <see cref="Vector2I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is less than
/// the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -425,17 +425,17 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is less than the right.</returns>
public static bool operator <(Vector2i left, Vector2i right)
public static bool operator <(Vector2I left, Vector2I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
/// Compares two <see cref="Vector2i"/> vectors by first checking if
/// Compares two <see cref="Vector2I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is greater than
/// the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -445,17 +445,17 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is greater than the right.</returns>
public static bool operator >(Vector2i left, Vector2i right)
public static bool operator >(Vector2I left, Vector2I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
/// Compares two <see cref="Vector2i"/> vectors by first checking if
/// Compares two <see cref="Vector2I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is less than
/// or equal to the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -465,17 +465,17 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is less than or equal to the right.</returns>
public static bool operator <=(Vector2i left, Vector2i right)
public static bool operator <=(Vector2I left, Vector2I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
return left.y <= right.y;
return left.Y <= right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
/// Compares two <see cref="Vector2i"/> vectors by first checking if
/// Compares two <see cref="Vector2I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is greater than
/// or equal to the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -485,33 +485,33 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is greater than or equal to the right.</returns>
public static bool operator >=(Vector2i left, Vector2i right)
public static bool operator >=(Vector2I left, Vector2I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
return left.y >= right.y;
return left.Y >= right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
/// Converts this <see cref="Vector2i"/> to a <see cref="Vector2"/>.
/// Converts this <see cref="Vector2I"/> to a <see cref="Vector2"/>.
/// </summary>
/// <param name="value">The vector to convert.</param>
public static implicit operator Vector2(Vector2i value)
public static implicit operator Vector2(Vector2I value)
{
return new Vector2(value.x, value.y);
return new Vector2(value.X, value.Y);
}
/// <summary>
/// Converts a <see cref="Vector2"/> to a <see cref="Vector2i"/>.
/// Converts a <see cref="Vector2"/> to a <see cref="Vector2I"/>.
/// </summary>
/// <param name="value">The vector to convert.</param>
public static explicit operator Vector2i(Vector2 value)
public static explicit operator Vector2I(Vector2 value)
{
return new Vector2i(
Mathf.RoundToInt(value.x),
Mathf.RoundToInt(value.y)
return new Vector2I(
Mathf.RoundToInt(value.X),
Mathf.RoundToInt(value.Y)
);
}
@ -523,7 +523,7 @@ namespace Godot
/// <returns>Whether or not the vector and the object are equal.</returns>
public override readonly bool Equals(object obj)
{
return obj is Vector2i other && Equals(other);
return obj is Vector2I other && Equals(other);
}
/// <summary>
@ -531,36 +531,36 @@ namespace Godot
/// </summary>
/// <param name="other">The other vector.</param>
/// <returns>Whether or not the vectors are equal.</returns>
public readonly bool Equals(Vector2i other)
public readonly bool Equals(Vector2I other)
{
return x == other.x && y == other.y;
return X == other.X && Y == other.Y;
}
/// <summary>
/// Serves as the hash function for <see cref="Vector2i"/>.
/// Serves as the hash function for <see cref="Vector2I"/>.
/// </summary>
/// <returns>A hash code for this vector.</returns>
public override readonly int GetHashCode()
{
return y.GetHashCode() ^ x.GetHashCode();
return Y.GetHashCode() ^ X.GetHashCode();
}
/// <summary>
/// Converts this <see cref="Vector2i"/> to a string.
/// Converts this <see cref="Vector2I"/> to a string.
/// </summary>
/// <returns>A string representation of this vector.</returns>
public override readonly string ToString()
{
return $"({x}, {y})";
return $"({X}, {Y})";
}
/// <summary>
/// Converts this <see cref="Vector2i"/> to a string with the given <paramref name="format"/>.
/// Converts this <see cref="Vector2I"/> to a string with the given <paramref name="format"/>.
/// </summary>
/// <returns>A string representation of this vector.</returns>
public readonly string ToString(string format)
{
return $"({x.ToString(format)}, {y.ToString(format)})";
return $"({X.ToString(format)}, {Y.ToString(format)})";
}
}
}

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

@ -33,17 +33,17 @@ namespace Godot
/// <summary>
/// The vector's X component. Also accessible by using the index position <c>[0]</c>.
/// </summary>
public real_t x;
public real_t X;
/// <summary>
/// The vector's Y component. Also accessible by using the index position <c>[1]</c>.
/// </summary>
public real_t y;
public real_t Y;
/// <summary>
/// The vector's Z component. Also accessible by using the index position <c>[2]</c>.
/// </summary>
public real_t z;
public real_t Z;
/// <summary>
/// Access vector components using their index.
@ -52,9 +52,9 @@ namespace Godot
/// <paramref name="index"/> is not 0, 1 or 2.
/// </exception>
/// <value>
/// <c>[0]</c> is equivalent to <see cref="x"/>,
/// <c>[1]</c> is equivalent to <see cref="y"/>,
/// <c>[2]</c> is equivalent to <see cref="z"/>.
/// <c>[0]</c> is equivalent to <see cref="X"/>,
/// <c>[1]</c> is equivalent to <see cref="Y"/>,
/// <c>[2]</c> is equivalent to <see cref="Z"/>.
/// </value>
public real_t this[int index]
{
@ -63,11 +63,11 @@ namespace Godot
switch (index)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
case 2:
return z;
return Z;
default:
throw new ArgumentOutOfRangeException(nameof(index));
}
@ -77,13 +77,13 @@ namespace Godot
switch (index)
{
case 0:
x = value;
X = value;
return;
case 1:
y = value;
Y = value;
return;
case 2:
z = value;
Z = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(index));
@ -96,9 +96,9 @@ namespace Godot
/// </summary>
public readonly void Deconstruct(out real_t x, out real_t y, out real_t z)
{
x = this.x;
y = this.y;
z = this.z;
x = X;
y = Y;
z = Z;
}
internal void Normalize()
@ -107,14 +107,14 @@ namespace Godot
if (lengthsq == 0)
{
x = y = z = 0f;
X = Y = Z = 0f;
}
else
{
real_t length = Mathf.Sqrt(lengthsq);
x /= length;
y /= length;
z /= length;
X /= length;
Y /= length;
Z /= length;
}
}
@ -124,7 +124,7 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Abs(real_t)"/> called on each component.</returns>
public readonly Vector3 Abs()
{
return new Vector3(Mathf.Abs(x), Mathf.Abs(y), Mathf.Abs(z));
return new Vector3(Mathf.Abs(X), Mathf.Abs(Y), Mathf.Abs(Z));
}
/// <summary>
@ -153,7 +153,7 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Ceil"/> called on each component.</returns>
public readonly Vector3 Ceil()
{
return new Vector3(Mathf.Ceil(x), Mathf.Ceil(y), Mathf.Ceil(z));
return new Vector3(Mathf.Ceil(X), Mathf.Ceil(Y), Mathf.Ceil(Z));
}
/// <summary>
@ -168,9 +168,9 @@ namespace Godot
{
return new Vector3
(
Mathf.Clamp(x, min.x, max.x),
Mathf.Clamp(y, min.y, max.y),
Mathf.Clamp(z, min.z, max.z)
Mathf.Clamp(X, min.X, max.X),
Mathf.Clamp(Y, min.Y, max.Y),
Mathf.Clamp(Z, min.Z, max.Z)
);
}
@ -183,9 +183,9 @@ namespace Godot
{
return new Vector3
(
(y * with.z) - (z * with.y),
(z * with.x) - (x * with.z),
(x * with.y) - (y * with.x)
(Y * with.Z) - (Z * with.Y),
(Z * with.X) - (X * with.Z),
(X * with.Y) - (Y * with.X)
);
}
@ -202,9 +202,9 @@ namespace Godot
{
return new Vector3
(
Mathf.CubicInterpolate(x, b.x, preA.x, postB.x, weight),
Mathf.CubicInterpolate(y, b.y, preA.y, postB.y, weight),
Mathf.CubicInterpolate(z, b.z, preA.z, postB.z, weight)
Mathf.CubicInterpolate(X, b.X, preA.X, postB.X, weight),
Mathf.CubicInterpolate(Y, b.Y, preA.Y, postB.Y, weight),
Mathf.CubicInterpolate(Z, b.Z, preA.Z, postB.Z, weight)
);
}
@ -226,9 +226,9 @@ namespace Godot
{
return new Vector3
(
Mathf.CubicInterpolateInTime(x, b.x, preA.x, postB.x, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(y, b.y, preA.y, postB.y, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(z, b.z, preA.z, postB.z, weight, t, preAT, postBT)
Mathf.CubicInterpolateInTime(X, b.X, preA.X, postB.X, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(Y, b.Y, preA.Y, postB.Y, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(Z, b.Z, preA.Z, postB.Z, weight, t, preAT, postBT)
);
}
@ -245,9 +245,9 @@ namespace Godot
{
return new Vector3
(
Mathf.BezierInterpolate(x, control1.x, control2.x, end.x, t),
Mathf.BezierInterpolate(y, control1.y, control2.y, end.y, t),
Mathf.BezierInterpolate(z, control1.z, control2.z, end.z, t)
Mathf.BezierInterpolate(X, control1.X, control2.X, end.X, t),
Mathf.BezierInterpolate(Y, control1.Y, control2.Y, end.Y, t),
Mathf.BezierInterpolate(Z, control1.Z, control2.Z, end.Z, t)
);
}
@ -263,9 +263,9 @@ namespace Godot
public readonly Vector3 BezierDerivative(Vector3 control1, Vector3 control2, Vector3 end, real_t t)
{
return new Vector3(
Mathf.BezierDerivative(x, control1.x, control2.x, end.x, t),
Mathf.BezierDerivative(y, control1.y, control2.y, end.y, t),
Mathf.BezierDerivative(z, control1.z, control2.z, end.y, t)
Mathf.BezierDerivative(X, control1.X, control2.X, end.X, t),
Mathf.BezierDerivative(Y, control1.Y, control2.Y, end.Y, t),
Mathf.BezierDerivative(Z, control1.Z, control2.Z, end.Y, t)
);
}
@ -276,7 +276,7 @@ namespace Godot
/// <returns>The direction from this vector to <paramref name="to"/>.</returns>
public readonly Vector3 DirectionTo(Vector3 to)
{
return new Vector3(to.x - x, to.y - y, to.z - z).Normalized();
return new Vector3(to.X - X, to.Y - Y, to.Z - Z).Normalized();
}
/// <summary>
@ -309,7 +309,7 @@ namespace Godot
/// <returns>The dot product of the two vectors.</returns>
public readonly real_t Dot(Vector3 with)
{
return (x * with.x) + (y * with.y) + (z * with.z);
return (X * with.X) + (Y * with.Y) + (Z * with.Z);
}
/// <summary>
@ -318,16 +318,16 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Floor"/> called on each component.</returns>
public readonly Vector3 Floor()
{
return new Vector3(Mathf.Floor(x), Mathf.Floor(y), Mathf.Floor(z));
return new Vector3(Mathf.Floor(X), Mathf.Floor(Y), Mathf.Floor(Z));
}
/// <summary>
/// Returns the inverse of this vector. This is the same as <c>new Vector3(1 / v.x, 1 / v.y, 1 / v.z)</c>.
/// Returns the inverse of this vector. This is the same as <c>new Vector3(1 / v.X, 1 / v.Y, 1 / v.Z)</c>.
/// </summary>
/// <returns>The inverse of this vector.</returns>
public readonly Vector3 Inverse()
{
return new Vector3(1 / x, 1 / y, 1 / z);
return new Vector3(1 / X, 1 / Y, 1 / Z);
}
/// <summary>
@ -337,7 +337,7 @@ namespace Godot
/// <returns>Whether this vector is finite or not.</returns>
public readonly bool IsFinite()
{
return Mathf.IsFinite(x) && Mathf.IsFinite(y) && Mathf.IsFinite(z);
return Mathf.IsFinite(X) && Mathf.IsFinite(Y) && Mathf.IsFinite(Z);
}
/// <summary>
@ -356,9 +356,9 @@ namespace Godot
/// <returns>The length of this vector.</returns>
public readonly real_t Length()
{
real_t x2 = x * x;
real_t y2 = y * y;
real_t z2 = z * z;
real_t x2 = X * X;
real_t y2 = Y * Y;
real_t z2 = Z * Z;
return Mathf.Sqrt(x2 + y2 + z2);
}
@ -371,9 +371,9 @@ namespace Godot
/// <returns>The squared length of this vector.</returns>
public readonly real_t LengthSquared()
{
real_t x2 = x * x;
real_t y2 = y * y;
real_t z2 = z * z;
real_t x2 = X * X;
real_t y2 = Y * Y;
real_t z2 = Z * Z;
return x2 + y2 + z2;
}
@ -389,9 +389,9 @@ namespace Godot
{
return new Vector3
(
Mathf.Lerp(x, to.x, weight),
Mathf.Lerp(y, to.y, weight),
Mathf.Lerp(z, to.z, weight)
Mathf.Lerp(X, to.X, weight),
Mathf.Lerp(Y, to.Y, weight),
Mathf.Lerp(Z, to.Z, weight)
);
}
@ -421,7 +421,7 @@ namespace Godot
/// <returns>The index of the highest axis.</returns>
public readonly Axis MaxAxisIndex()
{
return x < y ? (y < z ? Axis.Z : Axis.Y) : (x < z ? Axis.Z : Axis.X);
return X < Y ? (Y < Z ? Axis.Z : Axis.Y) : (X < Z ? Axis.Z : Axis.X);
}
/// <summary>
@ -431,7 +431,7 @@ namespace Godot
/// <returns>The index of the lowest axis.</returns>
public readonly Axis MinAxisIndex()
{
return x < y ? (x < z ? Axis.X : Axis.Z) : (y < z ? Axis.Y : Axis.Z);
return X < Y ? (X < Z ? Axis.X : Axis.Z) : (Y < Z ? Axis.Y : Axis.Z);
}
/// <summary>
@ -470,9 +470,9 @@ namespace Godot
public readonly Basis Outer(Vector3 with)
{
return new Basis(
x * with.x, x * with.y, x * with.z,
y * with.x, y * with.y, y * with.z,
z * with.x, z * with.y, z * with.z
X * with.X, X * with.Y, X * with.Z,
Y * with.X, Y * with.Y, Y * with.Z,
Z * with.X, Z * with.Y, Z * with.Z
);
}
@ -487,9 +487,9 @@ namespace Godot
public readonly Vector3 PosMod(real_t mod)
{
Vector3 v;
v.x = Mathf.PosMod(x, mod);
v.y = Mathf.PosMod(y, mod);
v.z = Mathf.PosMod(z, mod);
v.X = Mathf.PosMod(X, mod);
v.Y = Mathf.PosMod(Y, mod);
v.Z = Mathf.PosMod(Z, mod);
return v;
}
@ -504,9 +504,9 @@ namespace Godot
public readonly Vector3 PosMod(Vector3 modv)
{
Vector3 v;
v.x = Mathf.PosMod(x, modv.x);
v.y = Mathf.PosMod(y, modv.y);
v.z = Mathf.PosMod(z, modv.z);
v.X = Mathf.PosMod(X, modv.X);
v.Y = Mathf.PosMod(Y, modv.Y);
v.Z = Mathf.PosMod(Z, modv.Z);
return v;
}
@ -561,7 +561,7 @@ namespace Godot
/// <returns>The rounded vector.</returns>
public readonly Vector3 Round()
{
return new Vector3(Mathf.Round(x), Mathf.Round(y), Mathf.Round(z));
return new Vector3(Mathf.Round(X), Mathf.Round(Y), Mathf.Round(Z));
}
/// <summary>
@ -573,9 +573,9 @@ namespace Godot
public readonly Vector3 Sign()
{
Vector3 v;
v.x = Mathf.Sign(x);
v.y = Mathf.Sign(y);
v.z = Mathf.Sign(z);
v.X = Mathf.Sign(X);
v.Y = Mathf.Sign(Y);
v.Z = Mathf.Sign(Z);
return v;
}
@ -642,9 +642,9 @@ namespace Godot
{
return new Vector3
(
Mathf.Snapped(x, step.x),
Mathf.Snapped(y, step.y),
Mathf.Snapped(z, step.z)
Mathf.Snapped(X, step.X),
Mathf.Snapped(Y, step.Y),
Mathf.Snapped(Z, step.Z)
);
}
@ -719,9 +719,9 @@ namespace Godot
/// <param name="z">The vector's Z component.</param>
public Vector3(real_t x, real_t y, real_t z)
{
this.x = x;
this.y = y;
this.z = z;
X = x;
Y = y;
Z = z;
}
/// <summary>
@ -733,9 +733,9 @@ namespace Godot
/// <returns>The added vector.</returns>
public static Vector3 operator +(Vector3 left, Vector3 right)
{
left.x += right.x;
left.y += right.y;
left.z += right.z;
left.X += right.X;
left.Y += right.Y;
left.Z += right.Z;
return left;
}
@ -748,15 +748,15 @@ namespace Godot
/// <returns>The subtracted vector.</returns>
public static Vector3 operator -(Vector3 left, Vector3 right)
{
left.x -= right.x;
left.y -= right.y;
left.z -= right.z;
left.X -= right.X;
left.Y -= right.Y;
left.Z -= right.Z;
return left;
}
/// <summary>
/// Returns the negative value of the <see cref="Vector3"/>.
/// This is the same as writing <c>new Vector3(-v.x, -v.y, -v.z)</c>.
/// This is the same as writing <c>new Vector3(-v.X, -v.Y, -v.Z)</c>.
/// This operation flips the direction of the vector while
/// keeping the same magnitude.
/// With floats, the number zero can be either positive or negative.
@ -765,9 +765,9 @@ namespace Godot
/// <returns>The negated/flipped vector.</returns>
public static Vector3 operator -(Vector3 vec)
{
vec.x = -vec.x;
vec.y = -vec.y;
vec.z = -vec.z;
vec.X = -vec.X;
vec.Y = -vec.Y;
vec.Z = -vec.Z;
return vec;
}
@ -780,9 +780,9 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector3 operator *(Vector3 vec, real_t scale)
{
vec.x *= scale;
vec.y *= scale;
vec.z *= scale;
vec.X *= scale;
vec.Y *= scale;
vec.Z *= scale;
return vec;
}
@ -795,9 +795,9 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector3 operator *(real_t scale, Vector3 vec)
{
vec.x *= scale;
vec.y *= scale;
vec.z *= scale;
vec.X *= scale;
vec.Y *= scale;
vec.Z *= scale;
return vec;
}
@ -810,9 +810,9 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector3 operator *(Vector3 left, Vector3 right)
{
left.x *= right.x;
left.y *= right.y;
left.z *= right.z;
left.X *= right.X;
left.Y *= right.Y;
left.Z *= right.Z;
return left;
}
@ -825,9 +825,9 @@ namespace Godot
/// <returns>The divided vector.</returns>
public static Vector3 operator /(Vector3 vec, real_t divisor)
{
vec.x /= divisor;
vec.y /= divisor;
vec.z /= divisor;
vec.X /= divisor;
vec.Y /= divisor;
vec.Z /= divisor;
return vec;
}
@ -840,9 +840,9 @@ namespace Godot
/// <returns>The divided vector.</returns>
public static Vector3 operator /(Vector3 vec, Vector3 divisorv)
{
vec.x /= divisorv.x;
vec.y /= divisorv.y;
vec.z /= divisorv.z;
vec.X /= divisorv.X;
vec.Y /= divisorv.Y;
vec.Z /= divisorv.Z;
return vec;
}
@ -864,9 +864,9 @@ namespace Godot
/// <returns>The remainder vector.</returns>
public static Vector3 operator %(Vector3 vec, real_t divisor)
{
vec.x %= divisor;
vec.y %= divisor;
vec.z %= divisor;
vec.X %= divisor;
vec.Y %= divisor;
vec.Z %= divisor;
return vec;
}
@ -888,9 +888,9 @@ namespace Godot
/// <returns>The remainder vector.</returns>
public static Vector3 operator %(Vector3 vec, Vector3 divisorv)
{
vec.x %= divisorv.x;
vec.y %= divisorv.y;
vec.z %= divisorv.z;
vec.X %= divisorv.X;
vec.Y %= divisorv.Y;
vec.Z %= divisorv.Z;
return vec;
}
@ -933,15 +933,15 @@ namespace Godot
/// <returns>Whether or not the left is less than the right.</returns>
public static bool operator <(Vector3 left, Vector3 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
return left.z < right.z;
return left.Z < right.Z;
}
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
@ -957,15 +957,15 @@ namespace Godot
/// <returns>Whether or not the left is greater than the right.</returns>
public static bool operator >(Vector3 left, Vector3 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
return left.z > right.z;
return left.Z > right.Z;
}
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
@ -981,15 +981,15 @@ namespace Godot
/// <returns>Whether or not the left is less than or equal to the right.</returns>
public static bool operator <=(Vector3 left, Vector3 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
return left.z <= right.z;
return left.Z <= right.Z;
}
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
@ -1005,15 +1005,15 @@ namespace Godot
/// <returns>Whether or not the left is greater than or equal to the right.</returns>
public static bool operator >=(Vector3 left, Vector3 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
return left.z >= right.z;
return left.Z >= right.Z;
}
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
@ -1038,7 +1038,7 @@ namespace Godot
/// <returns>Whether or not the vectors are exactly equal.</returns>
public readonly bool Equals(Vector3 other)
{
return x == other.x && y == other.y && z == other.z;
return X == other.X && Y == other.Y && Z == other.Z;
}
/// <summary>
@ -1049,7 +1049,7 @@ namespace Godot
/// <returns>Whether or not the vectors are approximately equal.</returns>
public readonly bool IsEqualApprox(Vector3 other)
{
return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y) && Mathf.IsEqualApprox(z, other.z);
return Mathf.IsEqualApprox(X, other.X) && Mathf.IsEqualApprox(Y, other.Y) && Mathf.IsEqualApprox(Z, other.Z);
}
/// <summary>
@ -1061,7 +1061,7 @@ namespace Godot
/// <returns>Whether or not the vector is approximately zero.</returns>
public readonly bool IsZeroApprox()
{
return Mathf.IsZeroApprox(x) && Mathf.IsZeroApprox(y) && Mathf.IsZeroApprox(z);
return Mathf.IsZeroApprox(X) && Mathf.IsZeroApprox(Y) && Mathf.IsZeroApprox(Z);
}
/// <summary>
@ -1070,7 +1070,7 @@ namespace Godot
/// <returns>A hash code for this vector.</returns>
public override readonly int GetHashCode()
{
return y.GetHashCode() ^ x.GetHashCode() ^ z.GetHashCode();
return Y.GetHashCode() ^ X.GetHashCode() ^ Z.GetHashCode();
}
/// <summary>
@ -1079,7 +1079,7 @@ namespace Godot
/// <returns>A string representation of this vector.</returns>
public override readonly string ToString()
{
return $"({x}, {y}, {z})";
return $"({X}, {Y}, {Z})";
}
/// <summary>
@ -1088,7 +1088,7 @@ namespace Godot
/// <returns>A string representation of this vector.</returns>
public readonly string ToString(string format)
{
return $"({x.ToString(format)}, {y.ToString(format)}, {z.ToString(format)})";
return $"({X.ToString(format)}, {Y.ToString(format)}, {Z.ToString(format)})";
}
}
}

342
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3i.cs → modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3I.cs
View File

@ -8,7 +8,7 @@ namespace Godot
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct Vector3i : IEquatable<Vector3i>
public struct Vector3I : IEquatable<Vector3I>
{
/// <summary>
/// Enumerated index values for the axes.
@ -33,17 +33,17 @@ namespace Godot
/// <summary>
/// The vector's X component. Also accessible by using the index position <c>[0]</c>.
/// </summary>
public int x;
public int X;
/// <summary>
/// The vector's Y component. Also accessible by using the index position <c>[1]</c>.
/// </summary>
public int y;
public int Y;
/// <summary>
/// The vector's Z component. Also accessible by using the index position <c>[2]</c>.
/// </summary>
public int z;
public int Z;
/// <summary>
/// Access vector components using their <paramref name="index"/>.
@ -52,9 +52,9 @@ namespace Godot
/// <paramref name="index"/> is not 0, 1 or 2.
/// </exception>
/// <value>
/// <c>[0]</c> is equivalent to <see cref="x"/>,
/// <c>[1]</c> is equivalent to <see cref="y"/>,
/// <c>[2]</c> is equivalent to <see cref="z"/>.
/// <c>[0]</c> is equivalent to <see cref="X"/>,
/// <c>[1]</c> is equivalent to <see cref="Y"/>,
/// <c>[2]</c> is equivalent to <see cref="Z"/>.
/// </value>
public int this[int index]
{
@ -63,11 +63,11 @@ namespace Godot
switch (index)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
case 2:
return z;
return Z;
default:
throw new ArgumentOutOfRangeException(nameof(index));
}
@ -77,13 +77,13 @@ namespace Godot
switch (index)
{
case 0:
x = value;
X = value;
return;
case 1:
y = value;
Y = value;
return;
case 2:
z = value;
Z = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(index));
@ -96,18 +96,18 @@ namespace Godot
/// </summary>
public readonly void Deconstruct(out int x, out int y, out int z)
{
x = this.x;
y = this.y;
z = this.z;
x = X;
y = Y;
z = Z;
}
/// <summary>
/// Returns a new vector with all components in absolute values (i.e. positive).
/// </summary>
/// <returns>A vector with <see cref="Mathf.Abs(int)"/> called on each component.</returns>
public readonly Vector3i Abs()
public readonly Vector3I Abs()
{
return new Vector3i(Mathf.Abs(x), Mathf.Abs(y), Mathf.Abs(z));
return new Vector3I(Mathf.Abs(X), Mathf.Abs(Y), Mathf.Abs(Z));
}
/// <summary>
@ -118,13 +118,13 @@ namespace Godot
/// <param name="min">The vector with minimum allowed values.</param>
/// <param name="max">The vector with maximum allowed values.</param>
/// <returns>The vector with all components clamped.</returns>
public readonly Vector3i Clamp(Vector3i min, Vector3i max)
public readonly Vector3I Clamp(Vector3I min, Vector3I max)
{
return new Vector3i
return new Vector3I
(
Mathf.Clamp(x, min.x, max.x),
Mathf.Clamp(y, min.y, max.y),
Mathf.Clamp(z, min.z, max.z)
Mathf.Clamp(X, min.X, max.X),
Mathf.Clamp(Y, min.Y, max.Y),
Mathf.Clamp(Z, min.Z, max.Z)
);
}
@ -135,9 +135,9 @@ namespace Godot
/// <returns>The length of this vector.</returns>
public readonly real_t Length()
{
int x2 = x * x;
int y2 = y * y;
int z2 = z * z;
int x2 = X * X;
int y2 = Y * Y;
int z2 = Z * Z;
return Mathf.Sqrt(x2 + y2 + z2);
}
@ -150,9 +150,9 @@ namespace Godot
/// <returns>The squared length of this vector.</returns>
public readonly int LengthSquared()
{
int x2 = x * x;
int y2 = y * y;
int z2 = z * z;
int x2 = X * X;
int y2 = Y * Y;
int z2 = Z * Z;
return x2 + y2 + z2;
}
@ -164,7 +164,7 @@ namespace Godot
/// <returns>The index of the highest axis.</returns>
public readonly Axis MaxAxisIndex()
{
return x < y ? (y < z ? Axis.Z : Axis.Y) : (x < z ? Axis.Z : Axis.X);
return X < Y ? (Y < Z ? Axis.Z : Axis.Y) : (X < Z ? Axis.Z : Axis.X);
}
/// <summary>
@ -174,7 +174,7 @@ namespace Godot
/// <returns>The index of the lowest axis.</returns>
public readonly Axis MinAxisIndex()
{
return x < y ? (x < z ? Axis.X : Axis.Z) : (y < z ? Axis.Y : Axis.Z);
return X < Y ? (X < Z ? Axis.X : Axis.Z) : (Y < Z ? Axis.Y : Axis.Z);
}
/// <summary>
@ -183,208 +183,208 @@ namespace Godot
/// by calling <see cref="Mathf.Sign(int)"/> on each component.
/// </summary>
/// <returns>A vector with all components as either <c>1</c>, <c>-1</c>, or <c>0</c>.</returns>
public readonly Vector3i Sign()
public readonly Vector3I Sign()
{
Vector3i v = this;
v.x = Mathf.Sign(v.x);
v.y = Mathf.Sign(v.y);
v.z = Mathf.Sign(v.z);
Vector3I v = this;
v.X = Mathf.Sign(v.X);
v.Y = Mathf.Sign(v.Y);
v.Z = Mathf.Sign(v.Z);
return v;
}
// Constants
private static readonly Vector3i _zero = new Vector3i(0, 0, 0);
private static readonly Vector3i _one = new Vector3i(1, 1, 1);
private static readonly Vector3I _zero = new Vector3I(0, 0, 0);
private static readonly Vector3I _one = new Vector3I(1, 1, 1);
private static readonly Vector3i _up = new Vector3i(0, 1, 0);
private static readonly Vector3i _down = new Vector3i(0, -1, 0);
private static readonly Vector3i _right = new Vector3i(1, 0, 0);
private static readonly Vector3i _left = new Vector3i(-1, 0, 0);
private static readonly Vector3i _forward = new Vector3i(0, 0, -1);
private static readonly Vector3i _back = new Vector3i(0, 0, 1);
private static readonly Vector3I _up = new Vector3I(0, 1, 0);
private static readonly Vector3I _down = new Vector3I(0, -1, 0);
private static readonly Vector3I _right = new Vector3I(1, 0, 0);
private static readonly Vector3I _left = new Vector3I(-1, 0, 0);
private static readonly Vector3I _forward = new Vector3I(0, 0, -1);
private static readonly Vector3I _back = new Vector3I(0, 0, 1);
/// <summary>
/// Zero vector, a vector with all components set to <c>0</c>.
/// </summary>
/// <value>Equivalent to <c>new Vector3i(0, 0, 0)</c>.</value>
public static Vector3i Zero { get { return _zero; } }
/// <value>Equivalent to <c>new Vector3I(0, 0, 0)</c>.</value>
public static Vector3I Zero { get { return _zero; } }
/// <summary>
/// One vector, a vector with all components set to <c>1</c>.
/// </summary>
/// <value>Equivalent to <c>new Vector3i(1, 1, 1)</c>.</value>
public static Vector3i One { get { return _one; } }
/// <value>Equivalent to <c>new Vector3I(1, 1, 1)</c>.</value>
public static Vector3I One { get { return _one; } }
/// <summary>
/// Up unit vector.
/// </summary>
/// <value>Equivalent to <c>new Vector3i(0, 1, 0)</c>.</value>
public static Vector3i Up { get { return _up; } }
/// <value>Equivalent to <c>new Vector3I(0, 1, 0)</c>.</value>
public static Vector3I Up { get { return _up; } }
/// <summary>
/// Down unit vector.
/// </summary>
/// <value>Equivalent to <c>new Vector3i(0, -1, 0)</c>.</value>
public static Vector3i Down { get { return _down; } }
/// <value>Equivalent to <c>new Vector3I(0, -1, 0)</c>.</value>
public static Vector3I Down { get { return _down; } }
/// <summary>
/// Right unit vector. Represents the local direction of right,
/// and the global direction of east.
/// </summary>
/// <value>Equivalent to <c>new Vector3i(1, 0, 0)</c>.</value>
public static Vector3i Right { get { return _right; } }
/// <value>Equivalent to <c>new Vector3I(1, 0, 0)</c>.</value>
public static Vector3I Right { get { return _right; } }
/// <summary>
/// Left unit vector. Represents the local direction of left,
/// and the global direction of west.
/// </summary>
/// <value>Equivalent to <c>new Vector3i(-1, 0, 0)</c>.</value>
public static Vector3i Left { get { return _left; } }
/// <value>Equivalent to <c>new Vector3I(-1, 0, 0)</c>.</value>
public static Vector3I Left { get { return _left; } }
/// <summary>
/// Forward unit vector. Represents the local direction of forward,
/// and the global direction of north.
/// </summary>
/// <value>Equivalent to <c>new Vector3i(0, 0, -1)</c>.</value>
public static Vector3i Forward { get { return _forward; } }
/// <value>Equivalent to <c>new Vector3I(0, 0, -1)</c>.</value>
public static Vector3I Forward { get { return _forward; } }
/// <summary>
/// Back unit vector. Represents the local direction of back,
/// and the global direction of south.
/// </summary>
/// <value>Equivalent to <c>new Vector3i(0, 0, 1)</c>.</value>
public static Vector3i Back { get { return _back; } }
/// <value>Equivalent to <c>new Vector3I(0, 0, 1)</c>.</value>
public static Vector3I Back { get { return _back; } }
/// <summary>
/// Constructs a new <see cref="Vector3i"/> with the given components.
/// Constructs a new <see cref="Vector3I"/> with the given components.
/// </summary>
/// <param name="x">The vector's X component.</param>
/// <param name="y">The vector's Y component.</param>
/// <param name="z">The vector's Z component.</param>
public Vector3i(int x, int y, int z)
public Vector3I(int x, int y, int z)
{
this.x = x;
this.y = y;
this.z = z;
X = x;
Y = y;
Z = z;
}
/// <summary>
/// Adds each component of the <see cref="Vector3i"/>
/// with the components of the given <see cref="Vector3i"/>.
/// Adds each component of the <see cref="Vector3I"/>
/// with the components of the given <see cref="Vector3I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The added vector.</returns>
public static Vector3i operator +(Vector3i left, Vector3i right)
public static Vector3I operator +(Vector3I left, Vector3I right)
{
left.x += right.x;
left.y += right.y;
left.z += right.z;
left.X += right.X;
left.Y += right.Y;
left.Z += right.Z;
return left;
}
/// <summary>
/// Subtracts each component of the <see cref="Vector3i"/>
/// by the components of the given <see cref="Vector3i"/>.
/// Subtracts each component of the <see cref="Vector3I"/>
/// by the components of the given <see cref="Vector3I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The subtracted vector.</returns>
public static Vector3i operator -(Vector3i left, Vector3i right)
public static Vector3I operator -(Vector3I left, Vector3I right)
{
left.x -= right.x;
left.y -= right.y;
left.z -= right.z;
left.X -= right.X;
left.Y -= right.Y;
left.Z -= right.Z;
return left;
}
/// <summary>
/// Returns the negative value of the <see cref="Vector3i"/>.
/// This is the same as writing <c>new Vector3i(-v.x, -v.y, -v.z)</c>.
/// Returns the negative value of the <see cref="Vector3I"/>.
/// This is the same as writing <c>new Vector3I(-v.X, -v.Y, -v.Z)</c>.
/// This operation flips the direction of the vector while
/// keeping the same magnitude.
/// </summary>
/// <param name="vec">The vector to negate/flip.</param>
/// <returns>The negated/flipped vector.</returns>
public static Vector3i operator -(Vector3i vec)
public static Vector3I operator -(Vector3I vec)
{
vec.x = -vec.x;
vec.y = -vec.y;
vec.z = -vec.z;
vec.X = -vec.X;
vec.Y = -vec.Y;
vec.Z = -vec.Z;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector3i"/>
/// Multiplies each component of the <see cref="Vector3I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="vec">The vector to multiply.</param>
/// <param name="scale">The scale to multiply by.</param>
/// <returns>The multiplied vector.</returns>
public static Vector3i operator *(Vector3i vec, int scale)
public static Vector3I operator *(Vector3I vec, int scale)
{
vec.x *= scale;
vec.y *= scale;
vec.z *= scale;
vec.X *= scale;
vec.Y *= scale;
vec.Z *= scale;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector3i"/>
/// Multiplies each component of the <see cref="Vector3I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="scale">The scale to multiply by.</param>
/// <param name="vec">The vector to multiply.</param>
/// <returns>The multiplied vector.</returns>
public static Vector3i operator *(int scale, Vector3i vec)
public static Vector3I operator *(int scale, Vector3I vec)
{
vec.x *= scale;
vec.y *= scale;
vec.z *= scale;
vec.X *= scale;
vec.Y *= scale;
vec.Z *= scale;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector3i"/>
/// by the components of the given <see cref="Vector3i"/>.
/// Multiplies each component of the <see cref="Vector3I"/>
/// by the components of the given <see cref="Vector3I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The multiplied vector.</returns>
public static Vector3i operator *(Vector3i left, Vector3i right)
public static Vector3I operator *(Vector3I left, Vector3I right)
{
left.x *= right.x;
left.y *= right.y;
left.z *= right.z;
left.X *= right.X;
left.Y *= right.Y;
left.Z *= right.Z;
return left;
}
/// <summary>
/// Divides each component of the <see cref="Vector3i"/>
/// Divides each component of the <see cref="Vector3I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisor">The divisor value.</param>
/// <returns>The divided vector.</returns>
public static Vector3i operator /(Vector3i vec, int divisor)
public static Vector3I operator /(Vector3I vec, int divisor)
{
vec.x /= divisor;
vec.y /= divisor;
vec.z /= divisor;
vec.X /= divisor;
vec.Y /= divisor;
vec.Z /= divisor;
return vec;
}
/// <summary>
/// Divides each component of the <see cref="Vector3i"/>
/// by the components of the given <see cref="Vector3i"/>.
/// Divides each component of the <see cref="Vector3I"/>
/// by the components of the given <see cref="Vector3I"/>.
/// </summary>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisorv">The divisor vector.</param>
/// <returns>The divided vector.</returns>
public static Vector3i operator /(Vector3i vec, Vector3i divisorv)
public static Vector3I operator /(Vector3I vec, Vector3I divisorv)
{
vec.x /= divisorv.x;
vec.y /= divisorv.y;
vec.z /= divisorv.z;
vec.X /= divisorv.X;
vec.Y /= divisorv.Y;
vec.Z /= divisorv.Z;
return vec;
}
/// <summary>
/// Gets the remainder of each component of the <see cref="Vector3i"/>
/// Gets the remainder of each component of the <see cref="Vector3I"/>
/// with the components of the given <see langword="int"/>.
/// This operation uses truncated division, which is often not desired
/// as it does not work well with negative numbers.
@ -393,23 +393,23 @@ namespace Godot
/// </summary>
/// <example>
/// <code>
/// GD.Print(new Vector3i(10, -20, 30) % 7); // Prints "(3, -6, 2)"
/// GD.Print(new Vector3I(10, -20, 30) % 7); // Prints "(3, -6, 2)"
/// </code>
/// </example>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisor">The divisor value.</param>
/// <returns>The remainder vector.</returns>
public static Vector3i operator %(Vector3i vec, int divisor)
public static Vector3I operator %(Vector3I vec, int divisor)
{
vec.x %= divisor;
vec.y %= divisor;
vec.z %= divisor;
vec.X %= divisor;
vec.Y %= divisor;
vec.Z %= divisor;
return vec;
}
/// <summary>
/// Gets the remainder of each component of the <see cref="Vector3i"/>
/// with the components of the given <see cref="Vector3i"/>.
/// Gets the remainder of each component of the <see cref="Vector3I"/>
/// with the components of the given <see cref="Vector3I"/>.
/// This operation uses truncated division, which is often not desired
/// as it does not work well with negative numbers.
/// Consider using <see cref="Mathf.PosMod(int, int)"/> instead
@ -417,17 +417,17 @@ namespace Godot
/// </summary>
/// <example>
/// <code>
/// GD.Print(new Vector3i(10, -20, 30) % new Vector3i(7, 8, 9)); // Prints "(3, -4, 3)"
/// GD.Print(new Vector3I(10, -20, 30) % new Vector3I(7, 8, 9)); // Prints "(3, -4, 3)"
/// </code>
/// </example>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisorv">The divisor vector.</param>
/// <returns>The remainder vector.</returns>
public static Vector3i operator %(Vector3i vec, Vector3i divisorv)
public static Vector3I operator %(Vector3I vec, Vector3I divisorv)
{
vec.x %= divisorv.x;
vec.y %= divisorv.y;
vec.z %= divisorv.z;
vec.X %= divisorv.X;
vec.Y %= divisorv.Y;
vec.Z %= divisorv.Z;
return vec;
}
@ -437,7 +437,7 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the vectors are equal.</returns>
public static bool operator ==(Vector3i left, Vector3i right)
public static bool operator ==(Vector3I left, Vector3I right)
{
return left.Equals(right);
}
@ -448,13 +448,13 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the vectors are not equal.</returns>
public static bool operator !=(Vector3i left, Vector3i right)
public static bool operator !=(Vector3I left, Vector3I right)
{
return !left.Equals(right);
}
/// <summary>
/// Compares two <see cref="Vector3i"/> vectors by first checking if
/// Compares two <see cref="Vector3I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is less than
/// the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -464,21 +464,21 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is less than the right.</returns>
public static bool operator <(Vector3i left, Vector3i right)
public static bool operator <(Vector3I left, Vector3I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
return left.z < right.z;
return left.Z < right.Z;
}
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
/// Compares two <see cref="Vector3i"/> vectors by first checking if
/// Compares two <see cref="Vector3I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is greater than
/// the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -488,21 +488,21 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is greater than the right.</returns>
public static bool operator >(Vector3i left, Vector3i right)
public static bool operator >(Vector3I left, Vector3I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
return left.z > right.z;
return left.Z > right.Z;
}
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
/// Compares two <see cref="Vector3i"/> vectors by first checking if
/// Compares two <see cref="Vector3I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is less than
/// or equal to the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -512,21 +512,21 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is less than or equal to the right.</returns>
public static bool operator <=(Vector3i left, Vector3i right)
public static bool operator <=(Vector3I left, Vector3I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
return left.z <= right.z;
return left.Z <= right.Z;
}
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
/// Compares two <see cref="Vector3i"/> vectors by first checking if
/// Compares two <see cref="Vector3I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is greater than
/// or equal to the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -536,38 +536,38 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is greater than or equal to the right.</returns>
public static bool operator >=(Vector3i left, Vector3i right)
public static bool operator >=(Vector3I left, Vector3I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
return left.z >= right.z;
return left.Z >= right.Z;
}
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
/// Converts this <see cref="Vector3i"/> to a <see cref="Vector3"/>.
/// Converts this <see cref="Vector3I"/> to a <see cref="Vector3"/>.
/// </summary>
/// <param name="value">The vector to convert.</param>
public static implicit operator Vector3(Vector3i value)
public static implicit operator Vector3(Vector3I value)
{
return new Vector3(value.x, value.y, value.z);
return new Vector3(value.X, value.Y, value.Z);
}
/// <summary>
/// Converts a <see cref="Vector3"/> to a <see cref="Vector3i"/>.
/// Converts a <see cref="Vector3"/> to a <see cref="Vector3I"/>.
/// </summary>
/// <param name="value">The vector to convert.</param>
public static explicit operator Vector3i(Vector3 value)
public static explicit operator Vector3I(Vector3 value)
{
return new Vector3i(
Mathf.RoundToInt(value.x),
Mathf.RoundToInt(value.y),
Mathf.RoundToInt(value.z)
return new Vector3I(
Mathf.RoundToInt(value.X),
Mathf.RoundToInt(value.Y),
Mathf.RoundToInt(value.Z)
);
}
@ -579,7 +579,7 @@ namespace Godot
/// <returns>Whether or not the vector and the object are equal.</returns>
public override readonly bool Equals(object obj)
{
return obj is Vector3i other && Equals(other);
return obj is Vector3I other && Equals(other);
}
/// <summary>
@ -587,36 +587,36 @@ namespace Godot
/// </summary>
/// <param name="other">The other vector.</param>
/// <returns>Whether or not the vectors are equal.</returns>
public readonly bool Equals(Vector3i other)
public readonly bool Equals(Vector3I other)
{
return x == other.x && y == other.y && z == other.z;
return X == other.X && Y == other.Y && Z == other.Z;
}
/// <summary>
/// Serves as the hash function for <see cref="Vector3i"/>.
/// Serves as the hash function for <see cref="Vector3I"/>.
/// </summary>
/// <returns>A hash code for this vector.</returns>
public override readonly int GetHashCode()
{
return y.GetHashCode() ^ x.GetHashCode() ^ z.GetHashCode();
return Y.GetHashCode() ^ X.GetHashCode() ^ Z.GetHashCode();
}
/// <summary>
/// Converts this <see cref="Vector3i"/> to a string.
/// Converts this <see cref="Vector3I"/> to a string.
/// </summary>
/// <returns>A string representation of this vector.</returns>
public override readonly string ToString()
{
return $"({x}, {y}, {z})";
return $"({X}, {Y}, {Z})";
}
/// <summary>
/// Converts this <see cref="Vector3i"/> to a string with the given <paramref name="format"/>.
/// Converts this <see cref="Vector3I"/> to a string with the given <paramref name="format"/>.
/// </summary>
/// <returns>A string representation of this vector.</returns>
public readonly string ToString(string format)
{
return $"({x.ToString(format)}, {y.ToString(format)}, {z.ToString(format)})";
return $"({X.ToString(format)}, {Y.ToString(format)}, {Z.ToString(format)})";
}
}
}

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

@ -37,22 +37,22 @@ namespace Godot
/// <summary>
/// The vector's X component. Also accessible by using the index position <c>[0]</c>.
/// </summary>
public real_t x;
public real_t X;
/// <summary>
/// The vector's Y component. Also accessible by using the index position <c>[1]</c>.
/// </summary>
public real_t y;
public real_t Y;
/// <summary>
/// The vector's Z component. Also accessible by using the index position <c>[2]</c>.
/// </summary>
public real_t z;
public real_t Z;
/// <summary>
/// The vector's W component. Also accessible by using the index position <c>[3]</c>.
/// </summary>
public real_t w;
public real_t W;
/// <summary>
/// Access vector components using their index.
@ -61,10 +61,10 @@ namespace Godot
/// <paramref name="index"/> is not 0, 1, 2 or 3.
/// </exception>
/// <value>
/// <c>[0]</c> is equivalent to <see cref="x"/>,
/// <c>[1]</c> is equivalent to <see cref="y"/>,
/// <c>[2]</c> is equivalent to <see cref="z"/>.
/// <c>[3]</c> is equivalent to <see cref="w"/>.
/// <c>[0]</c> is equivalent to <see cref="X"/>,
/// <c>[1]</c> is equivalent to <see cref="Y"/>,
/// <c>[2]</c> is equivalent to <see cref="Z"/>.
/// <c>[3]</c> is equivalent to <see cref="W"/>.
/// </value>
public real_t this[int index]
{
@ -73,13 +73,13 @@ namespace Godot
switch (index)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
case 2:
return z;
return Z;
case 3:
return w;
return W;
default:
throw new ArgumentOutOfRangeException(nameof(index));
}
@ -89,16 +89,16 @@ namespace Godot
switch (index)
{
case 0:
x = value;
X = value;
return;
case 1:
y = value;
Y = value;
return;
case 2:
z = value;
Z = value;
return;
case 3:
w = value;
W = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(index));
@ -111,10 +111,10 @@ namespace Godot
/// </summary>
public readonly void Deconstruct(out real_t x, out real_t y, out real_t z, out real_t w)
{
x = this.x;
y = this.y;
z = this.z;
w = this.w;
x = X;
y = Y;
z = Z;
w = W;
}
internal void Normalize()
@ -123,15 +123,15 @@ namespace Godot
if (lengthsq == 0)
{
x = y = z = w = 0f;
X = Y = Z = W = 0f;
}
else
{
real_t length = Mathf.Sqrt(lengthsq);
x /= length;
y /= length;
z /= length;
w /= length;
X /= length;
Y /= length;
Z /= length;
W /= length;
}
}
@ -141,7 +141,7 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Abs(real_t)"/> called on each component.</returns>
public readonly Vector4 Abs()
{
return new Vector4(Mathf.Abs(x), Mathf.Abs(y), Mathf.Abs(z), Mathf.Abs(w));
return new Vector4(Mathf.Abs(X), Mathf.Abs(Y), Mathf.Abs(Z), Mathf.Abs(W));
}
/// <summary>
@ -150,7 +150,7 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Ceil"/> called on each component.</returns>
public readonly Vector4 Ceil()
{
return new Vector4(Mathf.Ceil(x), Mathf.Ceil(y), Mathf.Ceil(z), Mathf.Ceil(w));
return new Vector4(Mathf.Ceil(X), Mathf.Ceil(Y), Mathf.Ceil(Z), Mathf.Ceil(W));
}
/// <summary>
@ -165,10 +165,10 @@ namespace Godot
{
return new Vector4
(
Mathf.Clamp(x, min.x, max.x),
Mathf.Clamp(y, min.y, max.y),
Mathf.Clamp(z, min.z, max.z),
Mathf.Clamp(w, min.w, max.w)
Mathf.Clamp(X, min.X, max.X),
Mathf.Clamp(Y, min.Y, max.Y),
Mathf.Clamp(Z, min.Z, max.Z),
Mathf.Clamp(W, min.W, max.W)
);
}
@ -185,10 +185,10 @@ namespace Godot
{
return new Vector4
(
Mathf.CubicInterpolate(x, b.x, preA.x, postB.x, weight),
Mathf.CubicInterpolate(y, b.y, preA.y, postB.y, weight),
Mathf.CubicInterpolate(z, b.z, preA.z, postB.z, weight),
Mathf.CubicInterpolate(w, b.w, preA.w, postB.w, weight)
Mathf.CubicInterpolate(X, b.X, preA.X, postB.X, weight),
Mathf.CubicInterpolate(Y, b.Y, preA.Y, postB.Y, weight),
Mathf.CubicInterpolate(Z, b.Z, preA.Z, postB.Z, weight),
Mathf.CubicInterpolate(W, b.W, preA.W, postB.W, weight)
);
}
@ -210,10 +210,10 @@ namespace Godot
{
return new Vector4
(
Mathf.CubicInterpolateInTime(x, b.x, preA.x, postB.x, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(y, b.y, preA.y, postB.y, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(z, b.z, preA.z, postB.z, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(w, b.w, preA.w, postB.w, weight, t, preAT, postBT)
Mathf.CubicInterpolateInTime(X, b.X, preA.X, postB.X, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(Y, b.Y, preA.Y, postB.Y, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(Z, b.Z, preA.Z, postB.Z, weight, t, preAT, postBT),
Mathf.CubicInterpolateInTime(W, b.W, preA.W, postB.W, weight, t, preAT, postBT)
);
}
@ -224,7 +224,7 @@ namespace Godot
/// <returns>The direction from this vector to <paramref name="to"/>.</returns>
public readonly Vector4 DirectionTo(Vector4 to)
{
Vector4 ret = new Vector4(to.x - x, to.y - y, to.z - z, to.w - w);
Vector4 ret = new Vector4(to.X - X, to.Y - Y, to.Z - Z, to.W - W);
ret.Normalize();
return ret;
}
@ -258,7 +258,7 @@ namespace Godot
/// <returns>The dot product of the two vectors.</returns>
public readonly real_t Dot(Vector4 with)
{
return (x * with.x) + (y * with.y) + (z * with.z) + (w * with.w);
return (X * with.X) + (Y * with.Y) + (Z * with.Z) + (W * with.W);
}
/// <summary>
@ -267,16 +267,16 @@ namespace Godot
/// <returns>A vector with <see cref="Mathf.Floor"/> called on each component.</returns>
public readonly Vector4 Floor()
{
return new Vector4(Mathf.Floor(x), Mathf.Floor(y), Mathf.Floor(z), Mathf.Floor(w));
return new Vector4(Mathf.Floor(X), Mathf.Floor(Y), Mathf.Floor(Z), Mathf.Floor(W));
}
/// <summary>
/// Returns the inverse of this vector. This is the same as <c>new Vector4(1 / v.x, 1 / v.y, 1 / v.z, 1 / v.w)</c>.
/// Returns the inverse of this vector. This is the same as <c>new Vector4(1 / v.X, 1 / v.Y, 1 / v.Z, 1 / v.W)</c>.
/// </summary>
/// <returns>The inverse of this vector.</returns>
public readonly Vector4 Inverse()
{
return new Vector4(1 / x, 1 / y, 1 / z, 1 / w);
return new Vector4(1 / X, 1 / Y, 1 / Z, 1 / W);
}
/// <summary>
@ -286,7 +286,7 @@ namespace Godot
/// <returns>Whether this vector is finite or not.</returns>
public readonly bool IsFinite()
{
return Mathf.IsFinite(x) && Mathf.IsFinite(y) && Mathf.IsFinite(z) && Mathf.IsFinite(w);
return Mathf.IsFinite(X) && Mathf.IsFinite(Y) && Mathf.IsFinite(Z) && Mathf.IsFinite(W);
}
/// <summary>
@ -305,10 +305,10 @@ namespace Godot
/// <returns>The length of this vector.</returns>
public readonly real_t Length()
{
real_t x2 = x * x;
real_t y2 = y * y;
real_t z2 = z * z;
real_t w2 = w * w;
real_t x2 = X * X;
real_t y2 = Y * Y;
real_t z2 = Z * Z;
real_t w2 = W * W;
return Mathf.Sqrt(x2 + y2 + z2 + w2);
}
@ -321,10 +321,10 @@ namespace Godot
/// <returns>The squared length of this vector.</returns>
public readonly real_t LengthSquared()
{
real_t x2 = x * x;
real_t y2 = y * y;
real_t z2 = z * z;
real_t w2 = w * w;
real_t x2 = X * X;
real_t y2 = Y * Y;
real_t z2 = Z * Z;
real_t w2 = W * W;
return x2 + y2 + z2 + w2;
}
@ -340,10 +340,10 @@ namespace Godot
{
return new Vector4
(
Mathf.Lerp(x, to.x, weight),
Mathf.Lerp(y, to.y, weight),
Mathf.Lerp(z, to.z, weight),
Mathf.Lerp(w, to.w, weight)
Mathf.Lerp(X, to.X, weight),
Mathf.Lerp(Y, to.Y, weight),
Mathf.Lerp(Z, to.Z, weight),
Mathf.Lerp(W, to.W, weight)
);
}
@ -355,7 +355,7 @@ namespace Godot
public readonly Axis MaxAxisIndex()
{
int max_index = 0;
real_t max_value = x;
real_t max_value = X;
for (int i = 1; i < 4; i++)
{
if (this[i] > max_value)
@ -375,7 +375,7 @@ namespace Godot
public readonly Axis MinAxisIndex()
{
int min_index = 0;
real_t min_value = x;
real_t min_value = X;
for (int i = 1; i < 4; i++)
{
if (this[i] <= min_value)
@ -409,10 +409,10 @@ namespace Godot
public readonly Vector4 PosMod(real_t mod)
{
return new Vector4(
Mathf.PosMod(x, mod),
Mathf.PosMod(y, mod),
Mathf.PosMod(z, mod),
Mathf.PosMod(w, mod)
Mathf.PosMod(X, mod),
Mathf.PosMod(Y, mod),
Mathf.PosMod(Z, mod),
Mathf.PosMod(W, mod)
);
}
@ -427,10 +427,10 @@ namespace Godot
public readonly Vector4 PosMod(Vector4 modv)
{
return new Vector4(
Mathf.PosMod(x, modv.x),
Mathf.PosMod(y, modv.y),
Mathf.PosMod(z, modv.z),
Mathf.PosMod(w, modv.w)
Mathf.PosMod(X, modv.X),
Mathf.PosMod(Y, modv.Y),
Mathf.PosMod(Z, modv.Z),
Mathf.PosMod(W, modv.W)
);
}
@ -441,7 +441,7 @@ namespace Godot
/// <returns>The rounded vector.</returns>
public readonly Vector4 Round()
{
return new Vector4(Mathf.Round(x), Mathf.Round(y), Mathf.Round(z), Mathf.Round(w));
return new Vector4(Mathf.Round(X), Mathf.Round(Y), Mathf.Round(Z), Mathf.Round(W));
}
/// <summary>
@ -453,10 +453,10 @@ namespace Godot
public readonly Vector4 Sign()
{
Vector4 v;
v.x = Mathf.Sign(x);
v.y = Mathf.Sign(y);
v.z = Mathf.Sign(z);
v.w = Mathf.Sign(w);
v.X = Mathf.Sign(X);
v.Y = Mathf.Sign(Y);
v.Z = Mathf.Sign(Z);
v.W = Mathf.Sign(W);
return v;
}
@ -469,10 +469,10 @@ namespace Godot
public readonly Vector4 Snapped(Vector4 step)
{
return new Vector4(
Mathf.Snapped(x, step.x),
Mathf.Snapped(y, step.y),
Mathf.Snapped(z, step.z),
Mathf.Snapped(w, step.w)
Mathf.Snapped(X, step.X),
Mathf.Snapped(Y, step.Y),
Mathf.Snapped(Z, step.Z),
Mathf.Snapped(W, step.W)
);
}
@ -506,10 +506,10 @@ namespace Godot
/// <param name="w">The vector's W component.</param>
public Vector4(real_t x, real_t y, real_t z, real_t w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
X = x;
Y = y;
Z = z;
W = w;
}
/// <summary>
@ -521,10 +521,10 @@ namespace Godot
/// <returns>The added vector.</returns>
public static Vector4 operator +(Vector4 left, Vector4 right)
{
left.x += right.x;
left.y += right.y;
left.z += right.z;
left.w += right.w;
left.X += right.X;
left.Y += right.Y;
left.Z += right.Z;
left.W += right.W;
return left;
}
@ -537,16 +537,16 @@ namespace Godot
/// <returns>The subtracted vector.</returns>
public static Vector4 operator -(Vector4 left, Vector4 right)
{
left.x -= right.x;
left.y -= right.y;
left.z -= right.z;
left.w -= right.w;
left.X -= right.X;
left.Y -= right.Y;
left.Z -= right.Z;
left.W -= right.W;
return left;
}
/// <summary>
/// Returns the negative value of the <see cref="Vector4"/>.
/// This is the same as writing <c>new Vector4(-v.x, -v.y, -v.z, -v.w)</c>.
/// This is the same as writing <c>new Vector4(-v.X, -v.Y, -v.Z, -v.W)</c>.
/// This operation flips the direction of the vector while
/// keeping the same magnitude.
/// With floats, the number zero can be either positive or negative.
@ -555,10 +555,10 @@ namespace Godot
/// <returns>The negated/flipped vector.</returns>
public static Vector4 operator -(Vector4 vec)
{
vec.x = -vec.x;
vec.y = -vec.y;
vec.z = -vec.z;
vec.w = -vec.w;
vec.X = -vec.X;
vec.Y = -vec.Y;
vec.Z = -vec.Z;
vec.W = -vec.W;
return vec;
}
@ -571,10 +571,10 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector4 operator *(Vector4 vec, real_t scale)
{
vec.x *= scale;
vec.y *= scale;
vec.z *= scale;
vec.w *= scale;
vec.X *= scale;
vec.Y *= scale;
vec.Z *= scale;
vec.W *= scale;
return vec;
}
@ -587,10 +587,10 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector4 operator *(real_t scale, Vector4 vec)
{
vec.x *= scale;
vec.y *= scale;
vec.z *= scale;
vec.w *= scale;
vec.X *= scale;
vec.Y *= scale;
vec.Z *= scale;
vec.W *= scale;
return vec;
}
@ -603,10 +603,10 @@ namespace Godot
/// <returns>The multiplied vector.</returns>
public static Vector4 operator *(Vector4 left, Vector4 right)
{
left.x *= right.x;
left.y *= right.y;
left.z *= right.z;
left.w *= right.w;
left.X *= right.X;
left.Y *= right.Y;
left.Z *= right.Z;
left.W *= right.W;
return left;
}
@ -619,10 +619,10 @@ namespace Godot
/// <returns>The divided vector.</returns>
public static Vector4 operator /(Vector4 vec, real_t divisor)
{
vec.x /= divisor;
vec.y /= divisor;
vec.z /= divisor;
vec.w /= divisor;
vec.X /= divisor;
vec.Y /= divisor;
vec.Z /= divisor;
vec.W /= divisor;
return vec;
}
@ -635,10 +635,10 @@ namespace Godot
/// <returns>The divided vector.</returns>
public static Vector4 operator /(Vector4 vec, Vector4 divisorv)
{
vec.x /= divisorv.x;
vec.y /= divisorv.y;
vec.z /= divisorv.z;
vec.w /= divisorv.w;
vec.X /= divisorv.X;
vec.Y /= divisorv.Y;
vec.Z /= divisorv.Z;
vec.W /= divisorv.W;
return vec;
}
@ -660,10 +660,10 @@ namespace Godot
/// <returns>The remainder vector.</returns>
public static Vector4 operator %(Vector4 vec, real_t divisor)
{
vec.x %= divisor;
vec.y %= divisor;
vec.z %= divisor;
vec.w %= divisor;
vec.X %= divisor;
vec.Y %= divisor;
vec.Z %= divisor;
vec.W %= divisor;
return vec;
}
@ -685,10 +685,10 @@ namespace Godot
/// <returns>The remainder vector.</returns>
public static Vector4 operator %(Vector4 vec, Vector4 divisorv)
{
vec.x %= divisorv.x;
vec.y %= divisorv.y;
vec.z %= divisorv.z;
vec.w %= divisorv.w;
vec.X %= divisorv.X;
vec.Y %= divisorv.Y;
vec.Z %= divisorv.Z;
vec.W %= divisorv.W;
return vec;
}
@ -731,19 +731,19 @@ namespace Godot
/// <returns>Whether or not the left is less than the right.</returns>
public static bool operator <(Vector4 left, Vector4 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
if (left.z == right.z)
if (left.Z == right.Z)
{
return left.w < right.w;
return left.W < right.W;
}
return left.z < right.z;
return left.Z < right.Z;
}
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
@ -759,19 +759,19 @@ namespace Godot
/// <returns>Whether or not the left is greater than the right.</returns>
public static bool operator >(Vector4 left, Vector4 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
if (left.z == right.z)
if (left.Z == right.Z)
{
return left.w > right.w;
return left.W > right.W;
}
return left.z > right.z;
return left.Z > right.Z;
}
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
@ -787,19 +787,19 @@ namespace Godot
/// <returns>Whether or not the left is less than or equal to the right.</returns>
public static bool operator <=(Vector4 left, Vector4 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
if (left.z == right.z)
if (left.Z == right.Z)
{
return left.w <= right.w;
return left.W <= right.W;
}
return left.z < right.z;
return left.Z < right.Z;
}
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
@ -815,19 +815,19 @@ namespace Godot
/// <returns>Whether or not the left is greater than or equal to the right.</returns>
public static bool operator >=(Vector4 left, Vector4 right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
if (left.z == right.z)
if (left.Z == right.Z)
{
return left.w >= right.w;
return left.W >= right.W;
}
return left.z > right.z;
return left.Z > right.Z;
}
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
@ -852,7 +852,7 @@ namespace Godot
/// <returns>Whether or not the vectors are exactly equal.</returns>
public readonly bool Equals(Vector4 other)
{
return x == other.x && y == other.y && z == other.z && w == other.w;
return X == other.X && Y == other.Y && Z == other.Z && W == other.W;
}
/// <summary>
@ -863,7 +863,7 @@ namespace Godot
/// <returns>Whether or not the vectors are approximately equal.</returns>
public readonly bool IsEqualApprox(Vector4 other)
{
return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y) && Mathf.IsEqualApprox(z, other.z) && Mathf.IsEqualApprox(w, other.w);
return Mathf.IsEqualApprox(X, other.X) && Mathf.IsEqualApprox(Y, other.Y) && Mathf.IsEqualApprox(Z, other.Z) && Mathf.IsEqualApprox(W, other.W);
}
/// <summary>
@ -875,7 +875,7 @@ namespace Godot
/// <returns>Whether or not the vector is approximately zero.</returns>
public readonly bool IsZeroApprox()
{
return Mathf.IsZeroApprox(x) && Mathf.IsZeroApprox(y) && Mathf.IsZeroApprox(z) && Mathf.IsZeroApprox(w);
return Mathf.IsZeroApprox(X) && Mathf.IsZeroApprox(Y) && Mathf.IsZeroApprox(Z) && Mathf.IsZeroApprox(W);
}
/// <summary>
@ -884,7 +884,7 @@ namespace Godot
/// <returns>A hash code for this vector.</returns>
public override readonly int GetHashCode()
{
return y.GetHashCode() ^ x.GetHashCode() ^ z.GetHashCode() ^ w.GetHashCode();
return Y.GetHashCode() ^ X.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
}
/// <summary>
@ -893,7 +893,7 @@ namespace Godot
/// <returns>A string representation of this vector.</returns>
public override string ToString()
{
return $"({x}, {y}, {z}, {w})";
return $"({X}, {Y}, {Z}, {W})";
}
/// <summary>
@ -902,7 +902,7 @@ namespace Godot
/// <returns>A string representation of this vector.</returns>
public readonly string ToString(string format)
{
return $"({x.ToString(format)}, {y.ToString(format)}, {z.ToString(format)}, {w.ToString(format)})";
return $"({X.ToString(format)}, {Y.ToString(format)}, {Z.ToString(format)}, {W.ToString(format)})";
}
}
}

360
modules/mono/glue/GodotSharp/GodotSharp/Core/Vector4i.cs → modules/mono/glue/GodotSharp/GodotSharp/Core/Vector4I.cs
View File

@ -8,7 +8,7 @@ namespace Godot
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct Vector4i : IEquatable<Vector4i>
public struct Vector4I : IEquatable<Vector4I>
{
/// <summary>
/// Enumerated index values for the axes.
@ -37,22 +37,22 @@ namespace Godot
/// <summary>
/// The vector's X component. Also accessible by using the index position <c>[0]</c>.
/// </summary>
public int x;
public int X;
/// <summary>
/// The vector's Y component. Also accessible by using the index position <c>[1]</c>.
/// </summary>
public int y;
public int Y;
/// <summary>
/// The vector's Z component. Also accessible by using the index position <c>[2]</c>.
/// </summary>
public int z;
public int Z;
/// <summary>
/// The vector's W component. Also accessible by using the index position <c>[3]</c>.
/// </summary>
public int w;
public int W;
/// <summary>
/// Access vector components using their <paramref name="index"/>.
@ -61,10 +61,10 @@ namespace Godot
/// <paramref name="index"/> is not 0, 1, 2 or 3.
/// </exception>
/// <value>
/// <c>[0]</c> is equivalent to <see cref="x"/>,
/// <c>[1]</c> is equivalent to <see cref="y"/>,
/// <c>[2]</c> is equivalent to <see cref="z"/>.
/// <c>[3]</c> is equivalent to <see cref="w"/>.
/// <c>[0]</c> is equivalent to <see cref="X"/>,
/// <c>[1]</c> is equivalent to <see cref="Y"/>,
/// <c>[2]</c> is equivalent to <see cref="Z"/>.
/// <c>[3]</c> is equivalent to <see cref="W"/>.
/// </value>
public int this[int index]
{
@ -73,13 +73,13 @@ namespace Godot
switch (index)
{
case 0:
return x;
return X;
case 1:
return y;
return Y;
case 2:
return z;
return Z;
case 3:
return w;
return W;
default:
throw new ArgumentOutOfRangeException(nameof(index));
}
@ -89,16 +89,16 @@ namespace Godot
switch (index)
{
case 0:
x = value;
X = value;
return;
case 1:
y = value;
Y = value;
return;
case 2:
z = value;
Z = value;
return;
case 3:
w = value;
W = value;
return;
default:
throw new ArgumentOutOfRangeException(nameof(index));
@ -111,19 +111,19 @@ namespace Godot
/// </summary>
public readonly void Deconstruct(out int x, out int y, out int z, out int w)
{
x = this.x;
y = this.y;
z = this.z;
w = this.w;
x = X;
y = Y;
z = Z;
w = W;
}
/// <summary>
/// Returns a new vector with all components in absolute values (i.e. positive).
/// </summary>
/// <returns>A vector with <see cref="Mathf.Abs(int)"/> called on each component.</returns>
public readonly Vector4i Abs()
public readonly Vector4I Abs()
{
return new Vector4i(Mathf.Abs(x), Mathf.Abs(y), Mathf.Abs(z), Mathf.Abs(w));
return new Vector4I(Mathf.Abs(X), Mathf.Abs(Y), Mathf.Abs(Z), Mathf.Abs(W));
}
/// <summary>
@ -134,14 +134,14 @@ namespace Godot
/// <param name="min">The vector with minimum allowed values.</param>
/// <param name="max">The vector with maximum allowed values.</param>
/// <returns>The vector with all components clamped.</returns>
public readonly Vector4i Clamp(Vector4i min, Vector4i max)
public readonly Vector4I Clamp(Vector4I min, Vector4I max)
{
return new Vector4i
return new Vector4I
(
Mathf.Clamp(x, min.x, max.x),
Mathf.Clamp(y, min.y, max.y),
Mathf.Clamp(z, min.z, max.z),
Mathf.Clamp(w, min.w, max.w)
Mathf.Clamp(X, min.X, max.X),
Mathf.Clamp(Y, min.Y, max.Y),
Mathf.Clamp(Z, min.Z, max.Z),
Mathf.Clamp(W, min.W, max.W)
);
}
@ -152,10 +152,10 @@ namespace Godot
/// <returns>The length of this vector.</returns>
public readonly real_t Length()
{
int x2 = x * x;
int y2 = y * y;
int z2 = z * z;
int w2 = w * w;
int x2 = X * X;
int y2 = Y * Y;
int z2 = Z * Z;
int w2 = W * W;
return Mathf.Sqrt(x2 + y2 + z2 + w2);
}
@ -168,10 +168,10 @@ namespace Godot
/// <returns>The squared length of this vector.</returns>
public readonly int LengthSquared()
{
int x2 = x * x;
int y2 = y * y;
int z2 = z * z;
int w2 = w * w;
int x2 = X * X;
int y2 = Y * Y;
int z2 = Z * Z;
int w2 = W * W;
return x2 + y2 + z2 + w2;
}
@ -184,7 +184,7 @@ namespace Godot
public readonly Axis MaxAxisIndex()
{
int max_index = 0;
int max_value = x;
int max_value = X;
for (int i = 1; i < 4; i++)
{
if (this[i] > max_value)
@ -204,7 +204,7 @@ namespace Godot
public readonly Axis MinAxisIndex()
{
int min_index = 0;
int min_value = x;
int min_value = X;
for (int i = 1; i < 4; i++)
{
if (this[i] <= min_value)
@ -222,213 +222,217 @@ namespace Godot
/// by calling <see cref="Mathf.Sign(int)"/> on each component.
/// </summary>
/// <returns>A vector with all components as either <c>1</c>, <c>-1</c>, or <c>0</c>.</returns>
public readonly Vector4i Sign()
public readonly Vector4I Sign()
{
return new Vector4i(Mathf.Sign(x), Mathf.Sign(y), Mathf.Sign(z), Mathf.Sign(w));
return new Vector4I(Mathf.Sign(X), Mathf.Sign(Y), Mathf.Sign(Z), Mathf.Sign(W));
}
// Constants
private static readonly Vector4i _zero = new Vector4i(0, 0, 0, 0);
private static readonly Vector4i _one = new Vector4i(1, 1, 1, 1);
private static readonly Vector4I _zero = new Vector4I(0, 0, 0, 0);
private static readonly Vector4I _one = new Vector4I(1, 1, 1, 1);
/// <summary>
/// Zero vector, a vector with all components set to <c>0</c>.
/// </summary>
/// <value>Equivalent to <c>new Vector4i(0, 0, 0, 0)</c>.</value>
public static Vector4i Zero { get { return _zero; } }
/// <value>Equivalent to <c>new Vector4I(0, 0, 0, 0)</c>.</value>
public static Vector4I Zero { get { return _zero; } }
/// <summary>
/// One vector, a vector with all components set to <c>1</c>.
/// </summary>
/// <value>Equivalent to <c>new Vector4i(1, 1, 1, 1)</c>.</value>
public static Vector4i One { get { return _one; } }
/// <value>Equivalent to <c>new Vector4I(1, 1, 1, 1)</c>.</value>
public static Vector4I One { get { return _one; } }
/// <summary>
/// Constructs a new <see cref="Vector4i"/> with the given components.
/// Constructs a new <see cref="Vector4I"/> with the given components.
/// </summary>
/// <param name="x">The vector's X component.</param>
/// <param name="y">The vector's Y component.</param>
/// <param name="z">The vector's Z component.</param>
/// <param name="w">The vector's W component.</param>
public Vector4i(int x, int y, int z, int w)
public Vector4I(int x, int y, int z, int w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
X = x;
Y = y;
Z = z;
W = w;
}
/// <summary>
/// Adds each component of the <see cref="Vector4i"/>
/// with the components of the given <see cref="Vector4i"/>.
/// Adds each component of the <see cref="Vector4I"/>
/// with the components of the given <see cref="Vector4I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The added vector.</returns>
public static Vector4i operator +(Vector4i left, Vector4i right)
public static Vector4I operator +(Vector4I left, Vector4I right)
{
left.x += right.x;
left.y += right.y;
left.z += right.z;
left.w += right.w;
left.X += right.X;
left.Y += right.Y;
left.Z += right.Z;
left.W += right.W;
return left;
}
/// <summary>
/// Subtracts each component of the <see cref="Vector4i"/>
/// by the components of the given <see cref="Vector4i"/>.
/// Subtracts each component of the <see cref="Vector4I"/>
/// by the components of the given <see cref="Vector4I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The subtracted vector.</returns>
public static Vector4i operator -(Vector4i left, Vector4i right)
public static Vector4I operator -(Vector4I left, Vector4I right)
{
left.x -= right.x;
left.y -= right.y;
left.z -= right.z;
left.w -= right.w;
left.X -= right.X;
left.Y -= right.Y;
left.Z -= right.Z;
left.W -= right.W;
return left;
}
/// <summary>
/// Returns the negative value of the <see cref="Vector4i"/>.
/// This is the same as writing <c>new Vector4i(-v.x, -v.y, -v.z, -v.w)</c>.
/// Returns the negative value of the <see cref="Vector4I"/>.
/// This is the same as writing <c>new Vector4I(-v.X, -v.Y, -v.Z, -v.W)</c>.
/// This operation flips the direction of the vector while
/// keeping the same magnitude.
/// </summary>
/// <param name="vec">The vector to negate/flip.</param>
/// <returns>The negated/flipped vector.</returns>
public static Vector4i operator -(Vector4i vec)
public static Vector4I operator -(Vector4I vec)
{
vec.x = -vec.x;
vec.y = -vec.y;
vec.z = -vec.z;
vec.w = -vec.w;
vec.X = -vec.X;
vec.Y = -vec.Y;
vec.Z = -vec.Z;
vec.W = -vec.W;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector4i"/>
/// Multiplies each component of the <see cref="Vector4I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="vec">The vector to multiply.</param>
/// <param name="scale">The scale to multiply by.</param>
/// <returns>The multiplied vector.</returns>
public static Vector4i operator *(Vector4i vec, int scale)
public static Vector4I operator *(Vector4I vec, int scale)
{
vec.x *= scale;
vec.y *= scale;
vec.z *= scale;
vec.w *= scale;
vec.X *= scale;
vec.Y *= scale;
vec.Z *= scale;
vec.W *= scale;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector4i"/>
/// Multiplies each component of the <see cref="Vector4I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="scale">The scale to multiply by.</param>
/// <param name="vec">The vector to multiply.</param>
/// <returns>The multiplied vector.</returns>
public static Vector4i operator *(int scale, Vector4i vec)
public static Vector4I operator *(int scale, Vector4I vec)
{
vec.x *= scale;
vec.y *= scale;
vec.z *= scale;
vec.w *= scale;
vec.X *= scale;
vec.Y *= scale;
vec.Z *= scale;
vec.W *= scale;
return vec;
}
/// <summary>
/// Multiplies each component of the <see cref="Vector4i"/>
/// by the components of the given <see cref="Vector4i"/>.
/// Multiplies each component of the <see cref="Vector4I"/>
/// by the components of the given <see cref="Vector4I"/>.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>The multiplied vector.</returns>
public static Vector4i operator *(Vector4i left, Vector4i right)
public static Vector4I operator *(Vector4I left, Vector4I right)
{
left.x *= right.x;
left.y *= right.y;
left.z *= right.z;
left.w *= right.w;
left.X *= right.X;
left.Y *= right.Y;
left.Z *= right.Z;
left.W *= right.W;
return left;
}
/// <summary>
/// Divides each component of the <see cref="Vector4i"/>
/// Divides each component of the <see cref="Vector4I"/>
/// by the given <see langword="int"/>.
/// </summary>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisor">The divisor value.</param>
/// <returns>The divided vector.</returns>
public static Vector4i operator /(Vector4i vec, int divisor)
public static Vector4I operator /(Vector4I vec, int divisor)
{
vec.x /= divisor;
vec.y /= divisor;
vec.z /= divisor;
vec.w /= divisor;
vec.X /= divisor;
vec.Y /= divisor;
vec.Z /= divisor;
vec.W /= divisor;
return vec;
}
/// <summary>
/// Divides each component of the <see cref="Vector4i"/>
/// by the components of the given <see cref="Vector4i"/>.
/// Divides each component of the <see cref="Vector4I"/>
/// by the components of the given <see cref="Vector4I"/>.
/// </summary>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisorv">The divisor vector.</param>
/// <returns>The divided vector.</returns>
public static Vector4i operator /(Vector4i vec, Vector4i divisorv)
public static Vector4I operator /(Vector4I vec, Vector4I divisorv)
{
vec.x /= divisorv.x;
vec.y /= divisorv.y;
vec.z /= divisorv.z;
vec.w /= divisorv.w;
vec.X /= divisorv.X;
vec.Y /= divisorv.Y;
vec.Z /= divisorv.Z;
vec.W /= divisorv.W;
return vec;
}
/// <summary>
/// Gets the remainder of each component of the <see cref="Vector4i"/>
/// Gets the remainder of each component of the <see cref="Vector4I"/>
/// with the components of the given <see langword="int"/>.
/// This operation uses truncated division, which is often not desired
/// as it does not work well with negative numbers.
/// Consider using <see cref="Mathf.PosMod(int, int)"/> instead
/// if you want to handle negative numbers.
/// </summary>
/// <example>
/// <code>
/// GD.Print(new Vecto43i(10, -20, 30, -40) % 7); // Prints "(3, -6, 2, -5)"
/// GD.Print(new Vector4I(10, -20, 30, -40) % 7); // Prints "(3, -6, 2, -5)"
/// </code>
/// </example>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisor">The divisor value.</param>
/// <returns>The remainder vector.</returns>
public static Vector4i operator %(Vector4i vec, int divisor)
public static Vector4I operator %(Vector4I vec, int divisor)
{
vec.x %= divisor;
vec.y %= divisor;
vec.z %= divisor;
vec.w %= divisor;
vec.X %= divisor;
vec.Y %= divisor;
vec.Z %= divisor;
vec.W %= divisor;
return vec;
}
/// <summary>
/// Gets the remainder of each component of the <see cref="Vector4i"/>
/// with the components of the given <see cref="Vector4i"/>.
/// Gets the remainder of each component of the <see cref="Vector4I"/>
/// with the components of the given <see cref="Vector4I"/>.
/// This operation uses truncated division, which is often not desired
/// as it does not work well with negative numbers.
/// Consider using <see cref="Mathf.PosMod(int, int)"/> instead
/// if you want to handle negative numbers.
/// </summary>
/// <example>
/// <code>
/// GD.Print(new Vector4i(10, -20, 30, -40) % new Vector4i(6, 7, 8, 9)); // Prints "(4, -6, 6, -4)"
/// GD.Print(new Vector4I(10, -20, 30, -40) % new Vector4I(6, 7, 8, 9)); // Prints "(4, -6, 6, -4)"
/// </code>
/// </example>
/// <param name="vec">The dividend vector.</param>
/// <param name="divisorv">The divisor vector.</param>
/// <returns>The remainder vector.</returns>
public static Vector4i operator %(Vector4i vec, Vector4i divisorv)
public static Vector4I operator %(Vector4I vec, Vector4I divisorv)
{
vec.x %= divisorv.x;
vec.y %= divisorv.y;
vec.z %= divisorv.z;
vec.w %= divisorv.w;
vec.X %= divisorv.X;
vec.Y %= divisorv.Y;
vec.Z %= divisorv.Z;
vec.W %= divisorv.W;
return vec;
}
@ -438,7 +442,7 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the vectors are equal.</returns>
public static bool operator ==(Vector4i left, Vector4i right)
public static bool operator ==(Vector4I left, Vector4I right)
{
return left.Equals(right);
}
@ -449,13 +453,13 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the vectors are not equal.</returns>
public static bool operator !=(Vector4i left, Vector4i right)
public static bool operator !=(Vector4I left, Vector4I right)
{
return !left.Equals(right);
}
/// <summary>
/// Compares two <see cref="Vector4i"/> vectors by first checking if
/// Compares two <see cref="Vector4I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is less than
/// the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -465,25 +469,25 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is less than the right.</returns>
public static bool operator <(Vector4i left, Vector4i right)
public static bool operator <(Vector4I left, Vector4I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
if (left.z == right.z)
if (left.Z == right.Z)
{
return left.w < right.w;
return left.W < right.W;
}
return left.z < right.z;
return left.Z < right.Z;
}
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
/// Compares two <see cref="Vector4i"/> vectors by first checking if
/// Compares two <see cref="Vector4I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is greater than
/// the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -493,25 +497,25 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is greater than the right.</returns>
public static bool operator >(Vector4i left, Vector4i right)
public static bool operator >(Vector4I left, Vector4I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
if (left.z == right.z)
if (left.Z == right.Z)
{
return left.w > right.w;
return left.W > right.W;
}
return left.z > right.z;
return left.Z > right.Z;
}
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
/// Compares two <see cref="Vector4i"/> vectors by first checking if
/// Compares two <see cref="Vector4I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is less than
/// or equal to the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -521,25 +525,25 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is less than or equal to the right.</returns>
public static bool operator <=(Vector4i left, Vector4i right)
public static bool operator <=(Vector4I left, Vector4I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
if (left.z == right.z)
if (left.Z == right.Z)
{
return left.w <= right.w;
return left.W <= right.W;
}
return left.z < right.z;
return left.Z < right.Z;
}
return left.y < right.y;
return left.Y < right.Y;
}
return left.x < right.x;
return left.X < right.X;
}
/// <summary>
/// Compares two <see cref="Vector4i"/> vectors by first checking if
/// Compares two <see cref="Vector4I"/> vectors by first checking if
/// the X value of the <paramref name="left"/> vector is greater than
/// or equal to the X value of the <paramref name="right"/> vector.
/// If the X values are exactly equal, then it repeats this check
@ -549,43 +553,43 @@ namespace Godot
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <returns>Whether or not the left is greater than or equal to the right.</returns>
public static bool operator >=(Vector4i left, Vector4i right)
public static bool operator >=(Vector4I left, Vector4I right)
{
if (left.x == right.x)
if (left.X == right.X)
{
if (left.y == right.y)
if (left.Y == right.Y)
{
if (left.z == right.z)
if (left.Z == right.Z)
{
return left.w >= right.w;
return left.W >= right.W;
}
return left.z > right.z;
return left.Z > right.Z;
}
return left.y > right.y;
return left.Y > right.Y;
}
return left.x > right.x;
return left.X > right.X;
}
/// <summary>
/// Converts this <see cref="Vector4i"/> to a <see cref="Vector4"/>.
/// Converts this <see cref="Vector4I"/> to a <see cref="Vector4"/>.
/// </summary>
/// <param name="value">The vector to convert.</param>
public static implicit operator Vector4(Vector4i value)
public static implicit operator Vector4(Vector4I value)
{
return new Vector4(value.x, value.y, value.z, value.w);
return new Vector4(value.X, value.Y, value.Z, value.W);
}
/// <summary>
/// Converts a <see cref="Vector4"/> to a <see cref="Vector4i"/>.
/// Converts a <see cref="Vector4"/> to a <see cref="Vector4I"/>.
/// </summary>
/// <param name="value">The vector to convert.</param>
public static explicit operator Vector4i(Vector4 value)
public static explicit operator Vector4I(Vector4 value)
{
return new Vector4i(
Mathf.RoundToInt(value.x),
Mathf.RoundToInt(value.y),
Mathf.RoundToInt(value.z),
Mathf.RoundToInt(value.w)
return new Vector4I(
Mathf.RoundToInt(value.X),
Mathf.RoundToInt(value.Y),
Mathf.RoundToInt(value.Z),
Mathf.RoundToInt(value.W)
);
}
@ -597,7 +601,7 @@ namespace Godot
/// <returns>Whether or not the vector and the object are equal.</returns>
public override readonly bool Equals(object obj)
{
return obj is Vector4i other && Equals(other);
return obj is Vector4I other && Equals(other);
}
/// <summary>
@ -605,36 +609,36 @@ namespace Godot
/// </summary>
/// <param name="other">The other vector.</param>
/// <returns>Whether or not the vectors are equal.</returns>
public readonly bool Equals(Vector4i other)
public readonly bool Equals(Vector4I other)
{
return x == other.x && y == other.y && z == other.z && w == other.w;
return X == other.X && Y == other.Y && Z == other.Z && W == other.W;
}
/// <summary>
/// Serves as the hash function for <see cref="Vector4i"/>.
/// Serves as the hash function for <see cref="Vector4I"/>.
/// </summary>
/// <returns>A hash code for this vector.</returns>
public override readonly int GetHashCode()
{
return y.GetHashCode() ^ x.GetHashCode() ^ z.GetHashCode() ^ w.GetHashCode();
return Y.GetHashCode() ^ X.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
}
/// <summary>
/// Converts this <see cref="Vector4i"/> to a string.
/// Converts this <see cref="Vector4I"/> to a string.
/// </summary>
/// <returns>A string representation of this vector.</returns>
public override readonly string ToString()
{
return $"({x}, {y}, {z}, {w})";
return $"({X}, {Y}, {Z}, {W})";
}
/// <summary>
/// Converts this <see cref="Vector4i"/> to a string with the given <paramref name="format"/>.
/// Converts this <see cref="Vector4I"/> to a string with the given <paramref name="format"/>.
/// </summary>
/// <returns>A string representation of this vector.</returns>
public readonly string ToString(string format)
{
return $"({x.ToString(format)}, {y.ToString(format)}, {z.ToString(format)}), {w.ToString(format)})";
return $"({X.ToString(format)}, {Y.ToString(format)}, {Z.ToString(format)}), {W.ToString(format)})";
}
}
}

15
modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj
View File

@ -49,7 +49,7 @@
</ItemGroup>
<!-- Sources -->
<ItemGroup>
<Compile Include="Core\AABB.cs" />
<Compile Include="Core\Aabb.cs" />
<Compile Include="Core\Bridge\GodotSerializationInfo.cs" />
<Compile Include="Core\Bridge\MethodInfo.cs" />
<Compile Include="Core\Callable.generics.cs" />
@ -60,8 +60,9 @@
<Compile Include="Core\Attributes\ExportCategoryAttribute.cs" />
<Compile Include="Core\Attributes\ExportGroupAttribute.cs" />
<Compile Include="Core\Attributes\ExportSubgroupAttribute.cs" />
<Compile Include="Core\Attributes\GodotClassNameAttribute.cs" />
<Compile Include="Core\Attributes\MustBeVariantAttribute.cs" />
<Compile Include="Core\Attributes\RPCAttribute.cs" />
<Compile Include="Core\Attributes\RpcAttribute.cs" />
<Compile Include="Core\Attributes\ScriptPathAttribute.cs" />
<Compile Include="Core\Attributes\SignalAttribute.cs" />
<Compile Include="Core\Attributes\ToolAttribute.cs" />
@ -110,9 +111,9 @@
<Compile Include="Core\Projection.cs" />
<Compile Include="Core\Quaternion.cs" />
<Compile Include="Core\Rect2.cs" />
<Compile Include="Core\Rect2i.cs" />
<Compile Include="Core\Rect2I.cs" />
<Compile Include="Core\ReflectionUtils.cs" />
<Compile Include="Core\RID.cs" />
<Compile Include="Core\Rid.cs" />
<Compile Include="Core\NativeInterop\NativeFuncs.cs" />
<Compile Include="Core\NativeInterop\InteropStructs.cs" />
<Compile Include="Core\NativeInterop\Marshaling.cs" />
@ -124,11 +125,11 @@
<Compile Include="Core\Transform3D.cs" />
<Compile Include="Core\Variant.cs" />
<Compile Include="Core\Vector2.cs" />
<Compile Include="Core\Vector2i.cs" />
<Compile Include="Core\Vector2I.cs" />
<Compile Include="Core\Vector3.cs" />
<Compile Include="Core\Vector3i.cs" />
<Compile Include="Core\Vector3I.cs" />
<Compile Include="Core\Vector4.cs" />
<Compile Include="Core\Vector4i.cs" />
<Compile Include="Core\Vector4I.cs" />
<Compile Include="GlobalUsings.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>

292
modules/mono/utils/naming_utils.cpp Normal file
View File

@ -0,0 +1,292 @@
/**************************************************************************/
/* naming_utils.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "naming_utils.h"
#include "core/string/ucaps.h"
#include "core/templates/hash_map.h"
HashMap<String, String> _create_hashmap_from_vector(Vector<Pair<String, String>> vector) {
HashMap<String, String> hashmap = HashMap<String, String>(vector.size());
for (const Pair<String, String> &pair : vector) {
hashmap.insert(pair.first, pair.second);
}
return hashmap;
}
// Hardcoded collection of PascalCase name conversions.
const HashMap<String, String> pascal_case_name_overrides = _create_hashmap_from_vector({
{ "BitMap", "Bitmap" },
{ "JSONRPC", "JsonRpc" },
{ "OpenXRIPBinding", "OpenXRIPBinding" },
{ "SkeletonModification2DCCDIK", "SkeletonModification2DCcdik" },
{ "SkeletonModification2DFABRIK", "SkeletonModification2DFabrik" },
{ "SkeletonModification3DCCDIK", "SkeletonModification3DCcdik" },
{ "SkeletonModification3DFABRIK", "SkeletonModification3DFabrik" },
{ "System", "System_" },
{ "Thread", "GodotThread" },
});
// Hardcoded collection of PascalCase part conversions.
const HashMap<String, String> pascal_case_part_overrides = _create_hashmap_from_vector({
{ "AA", "AA" }, // Anti Aliasing
{ "AO", "AO" }, // Ambient Occlusion
{ "FILENAME", "FileName" },
{ "FADEIN", "FadeIn" },
{ "FADEOUT", "FadeOut" },
{ "FX", "FX" },
{ "GI", "GI" }, // Global Illumination
{ "GZIP", "GZip" },
{ "HBOX", "HBox" }, // Horizontal Box
{ "ID", "Id" },
{ "IO", "IO" }, // Input/Output
{ "IP", "IP" }, // Internet Protocol
{ "IV", "IV" }, // Initialization Vector
{ "MACOS", "MacOS" },
{ "NODEPATH", "NodePath" },
{ "SPIRV", "SpirV" },
{ "STDIN", "StdIn" },
{ "STDOUT", "StdOut" },
{ "USERNAME", "UserName" },
{ "UV", "UV" },
{ "UV2", "UV2" },
{ "VBOX", "VBox" }, // Vertical Box
{ "WHITESPACE", "WhiteSpace" },
{ "WM", "WM" },
{ "XR", "XR" },
{ "XRAPI", "XRApi" },
});
String _get_pascal_case_part_override(String p_part, bool p_input_is_upper = true) {
if (!p_input_is_upper) {
for (int i = 0; i < p_part.length(); i++) {
p_part[i] = _find_upper(p_part[i]);
}
}
if (pascal_case_part_overrides.has(p_part)) {
return pascal_case_part_overrides.get(p_part);
}
return String();
}
Vector<String> _split_pascal_case(const String &p_identifier) {
Vector<String> parts;
int current_part_start = 0;
bool prev_was_upper = is_ascii_upper_case(p_identifier[0]);
for (int i = 1; i < p_identifier.length(); i++) {
if (prev_was_upper) {
if (is_digit(p_identifier[i]) || is_ascii_lower_case(p_identifier[i])) {
if (!is_digit(p_identifier[i])) {
// These conditions only apply when the separator is not a digit.
if (i - current_part_start == 1) {
// Upper character was only the beggining of a word.
prev_was_upper = false;
continue;
}
if (i != p_identifier.length()) {
// If this is not the last character, the last uppercase
// character is the start of the next word.
i--;
}
}
if (i - current_part_start > 0) {
parts.append(p_identifier.substr(current_part_start, i - current_part_start));
current_part_start = i;
prev_was_upper = false;
}
}
} else {
if (is_digit(p_identifier[i]) || is_ascii_upper_case(p_identifier[i])) {
parts.append(p_identifier.substr(current_part_start, i - current_part_start));
current_part_start = i;
prev_was_upper = true;
}
}
}
// Add the rest of the identifier as the last part.
if (current_part_start != p_identifier.length()) {
parts.append(p_identifier.substr(current_part_start));
}
return parts;
}
String pascal_to_pascal_case(const String &p_identifier) {
if (p_identifier.length() == 0) {
return p_identifier;
}
if (p_identifier.length() <= 2) {
return p_identifier.to_upper();
}
if (pascal_case_name_overrides.has(p_identifier)) {
// Use hardcoded value for the identifier.
return pascal_case_name_overrides.get(p_identifier);
}
Vector<String> parts = _split_pascal_case(p_identifier);
String ret;
for (String &part : parts) {
String part_override = _get_pascal_case_part_override(part);
if (!part_override.is_empty()) {
// Use hardcoded value for part.
ret += part_override;
continue;
}
if (part.length() <= 2 && part.to_upper() == part) {
// Acronym of length 1 or 2.
for (int j = 0; j < part.length(); j++) {
part[j] = _find_upper(part[j]);
}
ret += part;
continue;
}
part[0] = _find_upper(part[0]);
for (int i = 1; i < part.length(); i++) {
if (is_digit(part[i - 1])) {
// Use uppercase after digits.
part[i] = _find_upper(part[i]);
continue;
}
part[i] = _find_lower(part[i]);
}
ret += part;
}
return ret;
}
String snake_to_pascal_case(const String &p_identifier, bool p_input_is_upper) {
String ret;
Vector<String> parts = p_identifier.split("_", true);
for (int i = 0; i < parts.size(); i++) {
String part = parts[i];
String part_override = _get_pascal_case_part_override(part, p_input_is_upper);
if (!part_override.is_empty()) {
// Use hardcoded value for part.
ret += part_override;
continue;
}
if (!part.is_empty()) {
part[0] = _find_upper(part[0]);
for (int j = 1; j < part.length(); j++) {
if (is_digit(part[j - 1])) {
// Use uppercase after digits.
part[j] = _find_upper(part[j]);
continue;
}
if (p_input_is_upper) {
part[j] = _find_lower(part[j]);
}
}
ret += part;
} else {
if (i == 0 || i == (parts.size() - 1)) {
// Preserve underscores at the beginning and end
ret += "_";
} else {
// Preserve contiguous underscores
if (parts[i - 1].length()) {
ret += "__";
} else {
ret += "_";
}
}
}
}
return ret;
}
String snake_to_camel_case(const String &p_identifier, bool p_input_is_upper) {
String ret;
Vector<String> parts = p_identifier.split("_", true);
for (int i = 0; i < parts.size(); i++) {
String part = parts[i];
String part_override = _get_pascal_case_part_override(part, p_input_is_upper);
if (!part_override.is_empty()) {
// Use hardcoded value for part.
if (i == 0) {
part_override[0] = _find_lower(part_override[0]);
}
ret += part_override;
continue;
}
if (!part.is_empty()) {
if (i == 0) {
part[0] = _find_lower(part[0]);
} else {
part[0] = _find_upper(part[0]);
}
for (int j = 1; j < part.length(); j++) {
if (is_digit(part[j - 1])) {
// Use uppercase after digits.
part[j] = _find_upper(part[j]);
continue;
}
if (p_input_is_upper) {
part[j] = _find_lower(part[j]);
}
}
ret += part;
} else {
if (i == 0 || i == (parts.size() - 1)) {
// Preserve underscores at the beginning and end
ret += "_";
} else {
// Preserve contiguous underscores
if (parts[i - 1].length()) {
ret += "__";
} else {
ret += "_";
}
}
}
}
return ret;
}

42
modules/mono/utils/naming_utils.h Normal file
View File

@ -0,0 +1,42 @@
/**************************************************************************/
/* naming_utils.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef MONO_NAMING_UTILS_H
#define MONO_NAMING_UTILS_H
#include "core/string/ustring.h"
String pascal_to_pascal_case(const String &p_identifier);
String snake_to_pascal_case(const String &p_identifier, bool p_input_is_upper = false);
String snake_to_camel_case(const String &p_identifier, bool p_input_is_upper = false);
#endif // MONO_NAMING_UTILS_H