godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #17134 from aaronfranke/master 

[Mono] Replace float with real_t, other misc C# improvements
This commit is contained in:
Ignacio Etcheverry 2018-03-24 21:10:41 +01:00 committed by GitHub
parent ee6a2c5fbf ff97c97c93
commit a8d8c06753
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 472 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
modules/mono/glue/cs_files/AABB.cs
View File

@ -7,6 +7,12 @@ using System;
// file: core/variant_call.cpp
// commit: 5ad9be4c24e9d7dc5672fdc42cea896622fe5685
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
public struct AABB : IEquatable<AABB>
@ -75,7 +81,7 @@ namespace Godot
return new AABB(begin, end - begin);
}
public float GetArea()
public real_t GetArea()
{
return size.x * size.y * size.z;
}
@ -108,7 +114,7 @@ namespace Godot
public Vector3 GetLongestAxis()
{
Vector3 axis = new Vector3(1f, 0f, 0f);
float max_size = size.x;
real_t max_size = size.x;
if (size.y > max_size)
{
@ -128,7 +134,7 @@ namespace Godot
public Vector3.Axis GetLongestAxisIndex()
{
Vector3.Axis axis = Vector3.Axis.X;
float max_size = size.x;
real_t max_size = size.x;
if (size.y > max_size)
{
@ -145,9 +151,9 @@ namespace Godot
return axis;
}
public float GetLongestAxisSize()
public real_t GetLongestAxisSize()
{
float max_size = size.x;
real_t max_size = size.x;
if (size.y > max_size)
max_size = size.y;
@ -161,7 +167,7 @@ namespace Godot
public Vector3 GetShortestAxis()
{
Vector3 axis = new Vector3(1f, 0f, 0f);
float max_size = size.x;
real_t max_size = size.x;
if (size.y < max_size)
{
@ -181,7 +187,7 @@ namespace Godot
public Vector3.Axis GetShortestAxisIndex()
{
Vector3.Axis axis = Vector3.Axis.X;
float max_size = size.x;
real_t max_size = size.x;
if (size.y < max_size)
{
@ -198,9 +204,9 @@ namespace Godot
return axis;
}
public float GetShortestAxisSize()
public real_t GetShortestAxisSize()
{
float max_size = size.x;
real_t max_size = size.x;
if (size.y < max_size)
max_size = size.y;
@ -222,7 +228,7 @@ namespace Godot
(dir.z > 0f) ? -half_extents.z : half_extents.z);
}
public AABB Grow(float by)
public AABB Grow(real_t by)
{
AABB res = this;
@ -354,23 +360,23 @@ namespace Godot
public bool IntersectsSegment(Vector3 from, Vector3 to)
{
float min = 0f;
float max = 1f;
real_t min = 0f;
real_t max = 1f;
for (int i = 0; i < 3; i++)
{
float seg_from = from[i];
float seg_to = to[i];
float box_begin = position[i];
float box_end = box_begin + size[i];
float cmin, cmax;
real_t seg_from = from[i];
real_t seg_to = to[i];
real_t box_begin = position[i];
real_t box_end = box_begin + size[i];
real_t cmin, cmax;
if (seg_from < seg_to)
{
if (seg_from > box_end || seg_to < box_begin)
return false;
float length = seg_to - seg_from;
real_t length = seg_to - seg_from;
cmin = seg_from < box_begin ? (box_begin - seg_from) / length : 0f;
cmax = seg_to > box_end ? (box_end - seg_from) / length : 1f;
}
@ -379,7 +385,7 @@ namespace Godot
if (seg_to > box_end || seg_from < box_begin)
return false;
float length = seg_to - seg_from;
real_t length = seg_to - seg_from;
cmin = seg_from > box_end ? (box_end - seg_from) / length : 0f;
cmax = seg_to < box_begin ? (box_begin - seg_from) / length : 1f;
}
@ -420,6 +426,7 @@ namespace Godot
return new AABB(min, max - min);
}
// Constructors
public AABB(Vector3 position, Vector3 size)
{
this.position = position;

151
modules/mono/glue/cs_files/Basis.cs
View File

@ -1,6 +1,12 @@
using System;
using System.Runtime.InteropServices;
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
[StructLayout(LayoutKind.Sequential)]
@ -98,7 +104,7 @@ namespace Godot
}
}
public float this[int index, int axis]
public real_t this[int index, int axis]
{
get
{
@ -143,7 +149,7 @@ namespace Godot
);
}
public float Determinant()
public real_t Determinant()
{
return this[0, 0] * (this[1, 1] * this[2, 2] - this[2, 1] * this[1, 2]) -
this[1, 0] * (this[0, 1] * this[2, 2] - this[2, 1] * this[0, 2]) +
@ -162,7 +168,7 @@ namespace Godot
Vector3 euler;
euler.z = 0.0f;
float mxy = m.y[2];
real_t mxy = m.y[2];
if (mxy < 1.0f)
@ -196,7 +202,7 @@ namespace Godot
{
for (int j = 0; j < 3; j++)
{
float v = orth[i, j];
real_t v = orth[i, j];
if (v > 0.5f)
v = 1.0f;
@ -222,26 +228,26 @@ namespace Godot
{
Basis inv = this;
float[] co = new float[3]
real_t[] co = new real_t[3]
{
inv[1, 1] * inv[2, 2] - inv[1, 2] * inv[2, 1],
inv[1, 2] * inv[2, 0] - inv[1, 0] * inv[2, 2],
inv[1, 0] * inv[2, 1] - inv[1, 1] * inv[2, 0]
};
float det = inv[0, 0] * co[0] + inv[0, 1] * co[1] + inv[0, 2] * co[2];
real_t det = inv[0, 0] * co[0] + inv[0, 1] * co[1] + inv[0, 2] * co[2];
if (det == 0)
{
return new Basis
(
float.NaN, float.NaN, float.NaN,
float.NaN, float.NaN, float.NaN,
float.NaN, float.NaN, float.NaN
real_t.NaN, real_t.NaN, real_t.NaN,
real_t.NaN, real_t.NaN, real_t.NaN,
real_t.NaN, real_t.NaN, real_t.NaN
);
}
float s = 1.0f / det;
real_t s = 1.0f / det;
inv = new Basis
(
@ -274,7 +280,7 @@ namespace Godot
return Basis.CreateFromAxes(xAxis, yAxis, zAxis);
}
public Basis Rotated(Vector3 axis, float phi)
public Basis Rotated(Vector3 axis, real_t phi)
{
return new Basis(axis, phi) * this;
}
@ -296,17 +302,17 @@ namespace Godot
return m;
}
public float Tdotx(Vector3 with)
public real_t Tdotx(Vector3 with)
{
return this[0, 0] * with[0] + this[1, 0] * with[1] + this[2, 0] * with[2];
}
public float Tdoty(Vector3 with)
public real_t Tdoty(Vector3 with)
{
return this[0, 1] * with[0] + this[1, 1] * with[1] + this[2, 1] * with[2];
}
public float Tdotz(Vector3 with)
public real_t Tdotz(Vector3 with)
{
return this[0, 2] * with[0] + this[1, 2] * with[1] + this[2, 2] * with[2];
}
@ -315,7 +321,7 @@ namespace Godot
{
Basis tr = this;
float temp = this[0, 1];
real_t temp = this[0, 1];
this[0, 1] = this[1, 0];
this[1, 0] = temp;
@ -350,76 +356,77 @@ namespace Godot
);
}
public Quat Quat() {
float trace = x[0] + y[1] + z[2];
public Quat Quat() {
real_t trace = x[0] + y[1] + z[2];
if (trace > 0.0f) {
float s = Mathf.Sqrt(trace + 1.0f) * 2f;
float inv_s = 1f / s;
return new Quat(
(z[1] - y[2]) * inv_s,
(x[2] - z[0]) * inv_s,
(y[0] - x[1]) * inv_s,
s * 0.25f
);
} else if (x[0] > y[1] && x[0] > z[2]) {
float s = Mathf.Sqrt(x[0] - y[1] - z[2] + 1.0f) * 2f;
float inv_s = 1f / s;
return new Quat(
s * 0.25f,
(x[1] + y[0]) * inv_s,
(x[2] + z[0]) * inv_s,
(z[1] - y[2]) * inv_s
);
} else if (y[1] > z[2]) {
float s = Mathf.Sqrt(-x[0] + y[1] - z[2] + 1.0f) * 2f;
float inv_s = 1f / s;
return new Quat(
(x[1] + y[0]) * inv_s,
s * 0.25f,
(y[2] + z[1]) * inv_s,
(x[2] - z[0]) * inv_s
);
} else {
float s = Mathf.Sqrt(-x[0] - y[1] + z[2] + 1.0f) * 2f;
float inv_s = 1f / s;
return new Quat(
(x[2] + z[0]) * inv_s,
(y[2] + z[1]) * inv_s,
s * 0.25f,
(y[0] - x[1]) * inv_s
);
}
}
if (trace > 0.0f) {
real_t s = Mathf.Sqrt(trace + 1.0f) * 2f;
real_t inv_s = 1f / s;
return new Quat(
(z[1] - y[2]) * inv_s,
(x[2] - z[0]) * inv_s,
(y[0] - x[1]) * inv_s,
s * 0.25f
);
} else if (x[0] > y[1] && x[0] > z[2]) {
real_t s = Mathf.Sqrt(x[0] - y[1] - z[2] + 1.0f) * 2f;
real_t inv_s = 1f / s;
return new Quat(
s * 0.25f,
(x[1] + y[0]) * inv_s,
(x[2] + z[0]) * inv_s,
(z[1] - y[2]) * inv_s
);
} else if (y[1] > z[2]) {
real_t s = Mathf.Sqrt(-x[0] + y[1] - z[2] + 1.0f) * 2f;
real_t inv_s = 1f / s;
return new Quat(
(x[1] + y[0]) * inv_s,
s * 0.25f,
(y[2] + z[1]) * inv_s,
(x[2] - z[0]) * inv_s
);
} else {
real_t s = Mathf.Sqrt(-x[0] - y[1] + z[2] + 1.0f) * 2f;
real_t inv_s = 1f / s;
return new Quat(
(x[2] + z[0]) * inv_s,
(y[2] + z[1]) * inv_s,
s * 0.25f,
(y[0] - x[1]) * inv_s
);
}
}
// Constructors
public Basis(Quat quat)
{
float s = 2.0f / quat.LengthSquared();
real_t s = 2.0f / quat.LengthSquared();
float xs = quat.x * s;
float ys = quat.y * s;
float zs = quat.z * s;
float wx = quat.w * xs;
float wy = quat.w * ys;
float wz = quat.w * zs;
float xx = quat.x * xs;
float xy = quat.x * ys;
float xz = quat.x * zs;
float yy = quat.y * ys;
float yz = quat.y * zs;
float zz = quat.z * zs;
real_t xs = quat.x * s;
real_t ys = quat.y * s;
real_t zs = quat.z * s;
real_t wx = quat.w * xs;
real_t wy = quat.w * ys;
real_t wz = quat.w * zs;
real_t xx = quat.x * xs;
real_t xy = quat.x * ys;
real_t xz = quat.x * zs;
real_t yy = quat.y * ys;
real_t yz = quat.y * zs;
real_t zz = quat.z * zs;
this.x = new Vector3(1.0f - (yy + zz), xy - wz, xz + wy);
this.y = new Vector3(xy + wz, 1.0f - (xx + zz), yz - wx);
this.z = new Vector3(xz - wy, yz + wx, 1.0f - (xx + yy));
}
public Basis(Vector3 axis, float phi)
public Basis(Vector3 axis, real_t phi)
{
Vector3 axis_sq = new Vector3(axis.x * axis.x, axis.y * axis.y, axis.z * axis.z);
float cosine = Mathf.Cos(phi);
float sine = Mathf.Sin(phi);
real_t cosine = Mathf.Cos( (real_t)phi);
real_t sine = Mathf.Sin( (real_t)phi);
this.x = new Vector3
(
@ -450,7 +457,7 @@ namespace Godot
this.z = zAxis;
}
public Basis(float xx, float xy, float xz, float yx, float yy, float yz, float zx, float zy, float zz)
public Basis(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz)
{
this.x = new Vector3(xx, yx, zx);
this.y = new Vector3(xy, yy, zy);

13
modules/mono/glue/cs_files/Color.cs
View File

@ -45,8 +45,8 @@ namespace Godot
{
get
{
float max = Mathf.Max(r, Mathf.Max(g, b));
float min = Mathf.Min(r, Mathf.Min(g, b));
float max = (float) Mathf.Max(r, (float) Mathf.Max(g, b));
float min = (float) Mathf.Min(r, (float) Mathf.Min(g, b));
float delta = max - min;
@ -79,8 +79,8 @@ namespace Godot
{
get
{
float max = Mathf.Max(r, Mathf.Max(g, b));
float min = Mathf.Min(r, Mathf.Min(g, b));
float max = (float) Mathf.Max(r, (float) Mathf.Max(g, b));
float min = (float) Mathf.Min(r, (float) Mathf.Min(g, b));
float delta = max - min;
@ -96,7 +96,7 @@ namespace Godot
{
get
{
return Mathf.Max(r, Mathf.Max(g, b));
return (float) Mathf.Max(r, (float) Mathf.Max(g, b));
}
set
{
@ -317,6 +317,7 @@ namespace Godot
return txt;
}
// Constructors
public Color(float r, float g, float b, float a = 1.0f)
{
this.r = r;
@ -375,7 +376,7 @@ namespace Godot
private String _to_hex(float val)
{
int v = (int)Mathf.Clamp(val * 255.0f, 0, 255);
int v = (int) Mathf.Clamp(val * 255.0f, 0, 255);
string ret = string.Empty;

2
modules/mono/glue/cs_files/GD.cs
View File

@ -1,5 +1,7 @@
using System;
// TODO: Add comments describing what this class does. It is not obvious.
namespace Godot
{
public static partial class GD

137
modules/mono/glue/cs_files/Mathf.cs
View File

@ -1,51 +1,63 @@
using System;
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
public static class Mathf
{
public const float PI = 3.14159274f;
public const float Epsilon = 1e-06f;
// Define constants with Decimal precision and cast down to double or float.
public const real_t PI = (real_t) 3.1415926535897932384626433833M; // 3.1415927f and 3.14159265358979
private const float Deg2RadConst = 0.0174532924f;
private const float Rad2DegConst = 57.29578f;
#if REAL_T_IS_DOUBLE
public const real_t Epsilon = 1e-14; // Epsilon size should depend on the precision used.
#else
public const real_t Epsilon = 1e-06f;
#endif
public static float Abs(float s)
private const real_t Deg2RadConst = (real_t) 0.0174532925199432957692369077M; // 0.0174532924f and 0.0174532925199433
private const real_t Rad2DegConst = (real_t) 57.295779513082320876798154814M; // 57.29578f and 57.2957795130823
public static real_t Abs(real_t s)
{
return Math.Abs(s);
}
public static float Acos(float s)
public static real_t Acos(real_t s)
{
return (float)Math.Acos(s);
return (real_t)Math.Acos(s);
}
public static float Asin(float s)
public static real_t Asin(real_t s)
{
return (float)Math.Asin(s);
return (real_t)Math.Asin(s);
}
public static float Atan(float s)
public static real_t Atan(real_t s)
{
return (float)Math.Atan(s);
return (real_t)Math.Atan(s);
}
public static float Atan2(float x, float y)
public static real_t Atan2(real_t x, real_t y)
{
return (float)Math.Atan2(x, y);
return (real_t)Math.Atan2(x, y);
}
public static Vector2 Cartesian2Polar(float x, float y)
{
return new Vector2(Sqrt(x * x + y * y), Atan2(y, x));
}
public static float Ceil(float s)
public static Vector2 Cartesian2Polar(real_t x, real_t y)
{
return (float)Math.Ceiling(s);
return new Vector2(Sqrt(x * x + y * y), Atan2(y, x));
}
public static float Clamp(float val, float min, float max)
public static real_t Ceil(real_t s)
{
return (real_t)Math.Ceiling(s);
}
public static real_t Clamp(real_t val, real_t min, real_t max)
{
if (val < min)
{
@ -59,17 +71,17 @@ namespace Godot
return val;
}
public static float Cos(float s)
public static real_t Cos(real_t s)
{
return (float)Math.Cos(s);
return (real_t)Math.Cos(s);
}
public static float Cosh(float s)
public static real_t Cosh(real_t s)
{
return (float)Math.Cosh(s);
return (real_t)Math.Cosh(s);
}
public static int Decimals(float step)
public static int Decimals(real_t step)
{
return Decimals((decimal)step);
}
@ -79,12 +91,12 @@ namespace Godot
return BitConverter.GetBytes(decimal.GetBits(step)[3])[2];
}
public static float Deg2Rad(float deg)
public static real_t Deg2Rad(real_t deg)
{
return deg * Deg2RadConst;
}
public static float Ease(float s, float curve)
public static real_t Ease(real_t s, real_t curve)
{
if (s < 0f)
{
@ -117,17 +129,17 @@ namespace Godot
return 0f;
}
public static float Exp(float s)
public static real_t Exp(real_t s)
{
return (float)Math.Exp(s);
return (real_t)Math.Exp(s);
}
public static float Floor(float s)
public static real_t Floor(real_t s)
{
return (float)Math.Floor(s);
return (real_t)Math.Floor(s);
}
public static float Fposmod(float x, float y)
public static real_t Fposmod(real_t x, real_t y)
{
if (x >= 0f)
{
@ -139,14 +151,14 @@ namespace Godot
}
}
public static float Lerp(float from, float to, float weight)
public static real_t Lerp(real_t from, real_t to, real_t weight)
{
return from + (to - from) * Clamp(weight, 0f, 1f);
}
public static float Log(float s)
public static real_t Log(real_t s)
{
return (float)Math.Log(s);
return (real_t)Math.Log(s);
}
public static int Max(int a, int b)
@ -154,7 +166,7 @@ namespace Godot
return (a > b) ? a : b;
}
public static float Max(float a, float b)
public static real_t Max(real_t a, real_t b)
{
return (a > b) ? a : b;
}
@ -164,7 +176,7 @@ namespace Godot
return (a < b) ? a : b;
}
public static float Min(float a, float b)
public static real_t Min(real_t a, real_t b)
{
return (a < b) ? a : b;
}
@ -181,47 +193,52 @@ namespace Godot
return val;
}
public static Vector2 Polar2Cartesian(float r, float th)
{
return new Vector2(r * Cos(th), r * Sin(th));
}
public static float Pow(float x, float y)
public static Vector2 Polar2Cartesian(real_t r, real_t th)
{
return (float)Math.Pow(x, y);
return new Vector2(r * Cos(th), r * Sin(th));
}
public static float Rad2Deg(float rad)
public static real_t Pow(real_t x, real_t y)
{
return (real_t)Math.Pow(x, y);
}
public static real_t Rad2Deg(real_t rad)
{
return rad * Rad2DegConst;
}
public static float Round(float s)
public static real_t Round(real_t s)
{
return (float)Math.Round(s);
return (real_t)Math.Round(s);
}
public static float Sign(float s)
public static int RoundToInt(real_t s)
{
return (int)Math.Round(s);
}
public static real_t Sign(real_t s)
{
return (s < 0f) ? -1f : 1f;
}
public static float Sin(float s)
public static real_t Sin(real_t s)
{
return (float)Math.Sin(s);
return (real_t)Math.Sin(s);
}
public static float Sinh(float s)
public static real_t Sinh(real_t s)
{
return (float)Math.Sinh(s);
return (real_t)Math.Sinh(s);
}
public static float Sqrt(float s)
public static real_t Sqrt(real_t s)
{
return (float)Math.Sqrt(s);
return (real_t)Math.Sqrt(s);
}
public static float Stepify(float s, float step)
public static real_t Stepify(real_t s, real_t step)
{
if (step != 0f)
{
@ -231,14 +248,14 @@ namespace Godot
return s;
}
public static float Tan(float s)
public static real_t Tan(real_t s)
{
return (float)Math.Tan(s);
return (real_t)Math.Tan(s);
}
public static float Tanh(float s)
public static real_t Tanh(real_t s)
{
return (float)Math.Tanh(s);
return (real_t)Math.Tanh(s);
}
}
}

38
modules/mono/glue/cs_files/Plane.cs
View File

@ -1,12 +1,18 @@
using System;
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
public struct Plane : IEquatable<Plane>
{
Vector3 normal;
public float x
public real_t x
{
get
{
@ -18,7 +24,7 @@ namespace Godot
}
}
public float y
public real_t y
{
get
{
@ -30,7 +36,7 @@ namespace Godot
}
}
public float z
public real_t z
{
get
{
@ -42,7 +48,7 @@ namespace Godot
}
}
float d;
real_t d;
public Vector3 Center
{
@ -52,7 +58,7 @@ namespace Godot
}
}
public float DistanceTo(Vector3 point)
public real_t DistanceTo(Vector3 point)
{
return normal.Dot(point) - d;
}
@ -62,15 +68,15 @@ namespace Godot
return normal * d;
}
public bool HasPoint(Vector3 point, float epsilon = Mathf.Epsilon)
public bool HasPoint(Vector3 point, real_t epsilon = Mathf.Epsilon)
{
float dist = normal.Dot(point) - d;
real_t dist = normal.Dot(point) - d;
return Mathf.Abs(dist) <= epsilon;
}
public Vector3 Intersect3(Plane b, Plane c)
{
float denom = normal.Cross(b.normal).Dot(c.normal);
real_t denom = normal.Cross(b.normal).Dot(c.normal);
if (Mathf.Abs(denom) <= Mathf.Epsilon)
return new Vector3();
@ -84,12 +90,12 @@ namespace Godot
public Vector3 IntersectRay(Vector3 from, Vector3 dir)
{
float den = normal.Dot(dir);
real_t den = normal.Dot(dir);
if (Mathf.Abs(den) <= Mathf.Epsilon)
return new Vector3();
float 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)
@ -101,12 +107,12 @@ namespace Godot
public Vector3 IntersectSegment(Vector3 begin, Vector3 end)
{
Vector3 segment = begin - end;
float den = normal.Dot(segment);
real_t den = normal.Dot(segment);
if (Mathf.Abs(den) <= Mathf.Epsilon)
return new Vector3();
float dist = (normal.Dot(begin) - d) / den;
real_t dist = (normal.Dot(begin) - d) / den;
if (dist < -Mathf.Epsilon || dist > (1.0f + Mathf.Epsilon))
return new Vector3();
@ -121,7 +127,7 @@ namespace Godot
public Plane Normalized()
{
float len = normal.Length();
real_t len = normal.Length();
if (len == 0)
return new Plane(0, 0, 0, 0);
@ -134,13 +140,13 @@ namespace Godot
return point - normal * DistanceTo(point);
}
public Plane(float a, float b, float c, float d)
// Constructors
public Plane(real_t a, real_t b, real_t c, real_t d)
{
normal = new Vector3(a, b, c);
this.d = d;
}
public Plane(Vector3 normal, float d)
public Plane(Vector3 normal, real_t d)
{
this.normal = normal;
this.d = d;

84
modules/mono/glue/cs_files/Quat.cs
View File

@ -1,6 +1,12 @@
using System;
using System.Runtime.InteropServices;
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
[StructLayout(LayoutKind.Sequential)]
@ -8,17 +14,17 @@ namespace Godot
{
private static readonly Quat identity = new Quat(0f, 0f, 0f, 1f);
public float x;
public float y;
public float z;
public float w;
public real_t x;
public real_t y;
public real_t z;
public real_t w;
public static Quat Identity
{
get { return identity; }
}
public float this[int index]
public real_t this[int index]
{
get
{
@ -58,15 +64,15 @@ namespace Godot
}
}
public Quat CubicSlerp(Quat b, Quat preA, Quat postB, float t)
public Quat CubicSlerp(Quat b, Quat preA, Quat postB, real_t t)
{
float t2 = (1.0f - t) * t * 2f;
real_t t2 = (1.0f - t) * t * 2f;
Quat sp = Slerp(b, t);
Quat sq = preA.Slerpni(postB, t);
return sp.Slerpni(sq, t2);
}
public float Dot(Quat b)
public real_t Dot(Quat b)
{
return x * b.x + y * b.y + z * b.z + w * b.w;
}
@ -76,12 +82,12 @@ namespace Godot
return new Quat(-x, -y, -z, w);
}
public float Length()
public real_t Length()
{
return Mathf.Sqrt(LengthSquared());
}
public float LengthSquared()
public real_t LengthSquared()
{
return Dot(this);
}
@ -91,20 +97,27 @@ namespace Godot
return this / Length();
}
public void Set(float x, float y, float z, float w)
public void Set(real_t x, real_t y, real_t z, real_t w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
public void Set(Quat q)
{
this.x = q.x;
this.y = q.y;
this.z = q.z;
this.w = q.w;
}
public Quat Slerp(Quat b, float t)
public Quat Slerp(Quat b, real_t t)
{
// Calculate cosine
float cosom = x * b.x + y * b.y + z * b.z + w * b.w;
real_t cosom = x * b.x + y * b.y + z * b.z + w * b.w;
float[] to1 = new float[4];
real_t[] to1 = new real_t[4];
// Adjust signs if necessary
if (cosom < 0.0)
@ -122,13 +135,13 @@ namespace Godot
to1[3] = b.w;
}
float sinom, scale0, scale1;
real_t sinom, scale0, scale1;
// Calculate coefficients
if ((1.0 - cosom) > Mathf.Epsilon)
{
// Standard case (Slerp)
float omega = Mathf.Acos(cosom);
real_t omega = Mathf.Acos(cosom);
sinom = Mathf.Sin(omega);
scale0 = Mathf.Sin((1.0f - t) * omega) / sinom;
scale1 = Mathf.Sin(t * omega) / sinom;
@ -150,19 +163,19 @@ namespace Godot
);
}
public Quat Slerpni(Quat b, float t)
public Quat Slerpni(Quat b, real_t t)
{
float dot = this.Dot(b);
real_t dot = this.Dot(b);
if (Mathf.Abs(dot) > 0.9999f)
{
return this;
}
float theta = Mathf.Acos(dot);
float sinT = 1.0f / Mathf.Sin(theta);
float newFactor = Mathf.Sin(t * theta) * sinT;
float invFactor = Mathf.Sin((1.0f - t) * theta) * sinT;
real_t theta = Mathf.Acos(dot);
real_t sinT = 1.0f / Mathf.Sin(theta);
real_t newFactor = Mathf.Sin(t * theta) * sinT;
real_t invFactor = Mathf.Sin((1.0f - t) * theta) * sinT;
return new Quat
(
@ -180,17 +193,26 @@ namespace Godot
return new Vector3(q.x, q.y, q.z);
}
public Quat(float x, float y, float z, float w)
// Constructors
public Quat(real_t x, real_t y, real_t z, real_t w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
public Quat(Vector3 axis, float angle)
public Quat(Quat q)
{
float d = axis.Length();
this.x = q.x;
this.y = q.y;
this.z = q.z;
this.w = q.w;
}
public Quat(Vector3 axis, real_t angle)
{
real_t d = axis.Length();
real_t angle_t = angle;
if (d == 0f)
{
@ -201,12 +223,12 @@ namespace Godot
}
else
{
float s = Mathf.Sin(angle * 0.5f) / d;
real_t s = Mathf.Sin(angle_t * 0.5f) / d;
x = axis.x * s;
y = axis.y * s;
z = axis.z * s;
w = Mathf.Cos(angle * 0.5f);
w = Mathf.Cos(angle_t * 0.5f);
}
}
@ -258,17 +280,17 @@ namespace Godot
);
}
public static Quat operator *(Quat left, float right)
public static Quat operator *(Quat left, real_t right)
{
return new Quat(left.x * right, left.y * right, left.z * right, left.w * right);
}
public static Quat operator *(float left, Quat right)
public static Quat operator *(real_t left, Quat right)
{
return new Quat(right.x * left, right.y * left, right.z * left, right.w * left);
}
public static Quat operator /(Quat left, float right)
public static Quat operator /(Quat left, real_t right)
{
return left * (1.0f / right);
}

30
modules/mono/glue/cs_files/Rect2.cs
View File

@ -1,6 +1,12 @@
using System;
using System.Runtime.InteropServices;
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
[StructLayout(LayoutKind.Sequential)]
@ -26,7 +32,7 @@ namespace Godot
get { return position + size; }
}
public float Area
public real_t Area
{
get { return GetArea(); }
}
@ -80,12 +86,12 @@ namespace Godot
return expanded;
}
public float GetArea()
public real_t GetArea()
{
return size.x * size.y;
}
public Rect2 Grow(float by)
public Rect2 Grow(real_t by)
{
Rect2 g = this;
@ -97,7 +103,7 @@ namespace Godot
return g;
}
public Rect2 GrowIndividual(float left, float top, float right, float bottom)
public Rect2 GrowIndividual(real_t left, real_t top, real_t right, real_t bottom)
{
Rect2 g = this;
@ -109,7 +115,7 @@ namespace Godot
return g;
}
public Rect2 GrowMargin(Margin margin, float by)
public Rect2 GrowMargin(Margin margin, real_t by)
{
Rect2 g = this;
@ -170,13 +176,23 @@ namespace Godot
return newRect;
}
// Constructors
public Rect2(Vector2 position, Vector2 size)
{
this.position = position;
this.size = size;
}
public Rect2(float x, float y, float width, float height)
public Rect2(Vector2 position, real_t width, real_t height)
{
this.position = position;
this.size = new Vector2(width, height);
}
public Rect2(real_t x, real_t y, Vector2 size)
{
this.position = new Vector2(x, y);
this.size = size;
}
public Rect2(real_t x, real_t y, real_t width, real_t height)
{
this.position = new Vector2(x, y);
this.size = new Vector2(width, height);

9
modules/mono/glue/cs_files/Transform.cs
View File

@ -1,6 +1,12 @@
using System;
using System.Runtime.InteropServices;
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
[StructLayout(LayoutKind.Sequential)]
@ -33,7 +39,7 @@ namespace Godot
return new Transform(basis.Orthonormalized(), origin);
}
public Transform Rotated(Vector3 axis, float phi)
public Transform Rotated(Vector3 axis, real_t phi)
{
return new Transform(new Basis(axis, phi), new Vector3()) * this;
}
@ -98,6 +104,7 @@ namespace Godot
);
}
// Constructors
public Transform(Vector3 xAxis, Vector3 yAxis, Vector3 zAxis, Vector3 origin)
{
this.basis = Basis.CreateFromAxes(xAxis, yAxis, zAxis);

46
modules/mono/glue/cs_files/Transform2D.cs
View File

@ -1,6 +1,12 @@
using System;
using System.Runtime.InteropServices;
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
[StructLayout(LayoutKind.Sequential)]
@ -27,7 +33,7 @@ namespace Godot
get { return o; }
}
public float Rotation
public real_t Rotation
{
get { return Mathf.Atan2(y.x, o.y); }
}
@ -73,7 +79,7 @@ namespace Godot
}
public float this[int index, int axis]
public real_t this[int index, int axis]
{
get
{
@ -107,7 +113,7 @@ namespace Godot
{
Transform2D inv = this;
float det = this[0, 0] * this[1, 1] - this[1, 0] * this[0, 1];
real_t det = this[0, 0] * this[1, 1] - this[1, 0] * this[0, 1];
if (det == 0)
{
@ -119,9 +125,9 @@ namespace Godot
);
}
float idet = 1.0f / det;
real_t idet = 1.0f / det;
float temp = this[0, 0];
real_t temp = this[0, 0];
this[0, 0] = this[1, 1];
this[1, 1] = temp;
@ -143,10 +149,10 @@ namespace Godot
return new Vector2(x.Dot(v), y.Dot(v));
}
public Transform2D InterpolateWith(Transform2D m, float c)
public Transform2D InterpolateWith(Transform2D m, real_t c)
{
float r1 = Rotation;
float r2 = m.Rotation;
real_t r1 = Rotation;
real_t r2 = m.Rotation;
Vector2 s1 = Scale;
Vector2 s2 = m.Scale;
@ -155,7 +161,7 @@ namespace Godot
Vector2 v1 = new Vector2(Mathf.Cos(r1), Mathf.Sin(r1));
Vector2 v2 = new Vector2(Mathf.Cos(r2), Mathf.Sin(r2));
float dot = v1.Dot(v2);
real_t dot = v1.Dot(v2);
// Clamp dot to [-1, 1]
dot = (dot < -1.0f) ? -1.0f : ((dot > 1.0f) ? 1.0f : dot);
@ -169,7 +175,7 @@ namespace Godot
}
else
{
float angle = c * Mathf.Acos(dot);
real_t angle = c * Mathf.Acos(dot);
Vector2 v3 = (v2 - v1 * dot).Normalized();
v = v1 * Mathf.Cos(angle) + v3 * Mathf.Sin(angle);
}
@ -192,7 +198,7 @@ namespace Godot
Transform2D inv = this;
// Swap
float temp = inv.x.y;
real_t temp = inv.x.y;
inv.x.y = inv.y.x;
inv.y.x = temp;
@ -218,7 +224,7 @@ namespace Godot
return on;
}
public Transform2D Rotated(float phi)
public Transform2D Rotated(real_t phi)
{
return this * new Transform2D(phi, new Vector2());
}
@ -232,12 +238,12 @@ namespace Godot
return copy;
}
private float Tdotx(Vector2 with)
private real_t Tdotx(Vector2 with)
{
return this[0, 0] * with[0] + this[1, 0] * with[1];
}
private float Tdoty(Vector2 with)
private real_t Tdoty(Vector2 with)
{
return this[0, 1] * with[0] + this[1, 1] * with[1];
}
@ -260,23 +266,25 @@ namespace Godot
return new Vector2(x.Dot(vInv), y.Dot(vInv));
}
// Constructors
public Transform2D(Vector2 xAxis, Vector2 yAxis, Vector2 origin)
{
this.x = xAxis;
this.y = yAxis;
this.o = origin;
}
public Transform2D(float xx, float xy, float yx, float yy, float ox, float oy)
public Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy)
{
this.x = new Vector2(xx, xy);
this.y = new Vector2(yx, yy);
this.o = new Vector2(ox, oy);
}
public Transform2D(float rot, Vector2 pos)
public Transform2D(real_t rot, Vector2 pos)
{
float cr = Mathf.Cos(rot);
float sr = Mathf.Sin(rot);
real_t cr = Mathf.Cos( (real_t)rot);
real_t sr = Mathf.Sin( (real_t)rot);
x.x = cr;
y.y = cr;
x.y = -sr;
@ -288,7 +296,7 @@ namespace Godot
{
left.o = left.Xform(right.o);
float x0, x1, y0, y1;
real_t x0, x1, y0, y1;
x0 = left.Tdotx(right.x);
x1 = left.Tdoty(right.x);

93
modules/mono/glue/cs_files/Vector2.cs
View File

@ -8,15 +8,21 @@ using System.Runtime.InteropServices;
// file: core/variant_call.cpp
// commit: 5ad9be4c24e9d7dc5672fdc42cea896622fe5685
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
[StructLayout(LayoutKind.Sequential)]
public struct Vector2 : IEquatable<Vector2>
{
public float x;
public float y;
public real_t x;
public real_t y;
public float this[int index]
public real_t this[int index]
{
get
{
@ -48,7 +54,7 @@ namespace Godot
internal void Normalize()
{
float length = x * x + y * y;
real_t length = x * x + y * y;
if (length != 0f)
{
@ -58,7 +64,7 @@ namespace Godot
}
}
private float Cross(Vector2 b)
private real_t Cross(Vector2 b)
{
return x * b.y - y * b.x;
}
@ -68,22 +74,22 @@ namespace Godot
return new Vector2(Mathf.Abs(x), Mathf.Abs(y));
}
public float Angle()
public real_t Angle()
{
return Mathf.Atan2(y, x);
}
public float AngleTo(Vector2 to)
public real_t AngleTo(Vector2 to)
{
return Mathf.Atan2(Cross(to), Dot(to));
}
public float AngleToPoint(Vector2 to)
public real_t AngleToPoint(Vector2 to)
{
return Mathf.Atan2(x - to.x, y - to.y);
}
public float Aspect()
public real_t Aspect()
{
return x / y;
}
@ -93,10 +99,10 @@ namespace Godot
return -Reflect(n);
}
public Vector2 Clamped(float length)
public Vector2 Clamped(real_t length)
{
Vector2 v = this;
float l = this.Length();
real_t l = this.Length();
if (l > 0 && length < l)
{
@ -107,15 +113,15 @@ namespace Godot
return v;
}
public Vector2 CubicInterpolate(Vector2 b, Vector2 preA, Vector2 postB, float t)
public Vector2 CubicInterpolate(Vector2 b, Vector2 preA, Vector2 postB, real_t t)
{
Vector2 p0 = preA;
Vector2 p1 = this;
Vector2 p2 = b;
Vector2 p3 = postB;
float t2 = t * t;
float t3 = t2 * t;
real_t t2 = t * t;
real_t t3 = t2 * t;
return 0.5f * ((p1 * 2.0f) +
(-p0 + p2) * t +
@ -123,17 +129,17 @@ namespace Godot
(-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3);
}
public float DistanceSquaredTo(Vector2 to)
public real_t DistanceSquaredTo(Vector2 to)
{
return (x - to.x) * (x - to.x) + (y - to.y) * (y - to.y);
}
public float DistanceTo(Vector2 to)
public real_t DistanceTo(Vector2 to)
{
return Mathf.Sqrt((x - to.x) * (x - to.x) + (y - to.y) * (y - to.y));
}
public float Dot(Vector2 with)
public real_t Dot(Vector2 with)
{
return x * with.x + y * with.y;
}
@ -148,17 +154,17 @@ namespace Godot
return Mathf.Abs(LengthSquared() - 1.0f) < Mathf.Epsilon;
}
public float Length()
public real_t Length()
{
return Mathf.Sqrt(x * x + y * y);
}
public float LengthSquared()
public real_t LengthSquared()
{
return x * x + y * y;
}
public Vector2 LinearInterpolate(Vector2 b, float t)
public Vector2 LinearInterpolate(Vector2 b, real_t t)
{
Vector2 res = this;
@ -180,12 +186,23 @@ namespace Godot
return 2.0f * n * Dot(n) - this;
}
public Vector2 Rotated(float phi)
public Vector2 Rotated(real_t phi)
{
float rads = Angle() + phi;
real_t rads = Angle() + phi;
return new Vector2(Mathf.Cos(rads), Mathf.Sin(rads)) * Length();
}
public void Set(real_t x, real_t y)
{
this.x = x;
this.y = y;
}
public void Set(Vector2 v)
{
this.x = v.x;
this.y = v.y;
}
public Vector2 Slide(Vector2 n)
{
return this - n * Dot(n);
@ -201,11 +218,35 @@ namespace Godot
return new Vector2(y, -x);
}
public Vector2(float x, float y)
private static readonly Vector2 zero = new Vector2 (0, 0);
private static readonly Vector2 one = new Vector2 (1, 1);
private static readonly Vector2 negOne = new Vector2 (-1, -1);
private static readonly Vector2 up = new Vector2 (0, 1);
private static readonly Vector2 down = new Vector2 (0, -1);
private static readonly Vector2 right = new Vector2 (1, 0);
private static readonly Vector2 left = new Vector2 (-1, 0);
public static Vector2 Zero { get { return zero; } }
public static Vector2 One { get { return one; } }
public static Vector2 NegOne { get { return negOne; } }
public static Vector2 Up { get { return up; } }
public static Vector2 Down { get { return down; } }
public static Vector2 Right { get { return right; } }
public static Vector2 Left { get { return left; } }
// Constructors
public Vector2(real_t x, real_t y)
{
this.x = x;
this.y = y;
}
public Vector2(Vector2 v)
{
this.x = v.x;
this.y = v.y;
}
public static Vector2 operator +(Vector2 left, Vector2 right)
{
@ -228,14 +269,14 @@ namespace Godot
return vec;
}
public static Vector2 operator *(Vector2 vec, float scale)
public static Vector2 operator *(Vector2 vec, real_t scale)
{
vec.x *= scale;
vec.y *= scale;
return vec;
}
public static Vector2 operator *(float scale, Vector2 vec)
public static Vector2 operator *(real_t scale, Vector2 vec)
{
vec.x *= scale;
vec.y *= scale;
@ -249,7 +290,7 @@ namespace Godot
return left;
}
public static Vector2 operator /(Vector2 vec, float scale)
public static Vector2 operator /(Vector2 vec, real_t scale)
{
vec.x /= scale;
vec.y /= scale;

100
modules/mono/glue/cs_files/Vector3.cs
View File

@ -8,6 +8,12 @@ using System.Runtime.InteropServices;
// file: core/variant_call.cpp
// commit: 5ad9be4c24e9d7dc5672fdc42cea896622fe5685
#if REAL_T_IS_DOUBLE
using real_t = System.Double;
#else
using real_t = System.Single;
#endif
namespace Godot
{
[StructLayout(LayoutKind.Sequential)]
@ -20,11 +26,11 @@ namespace Godot
Z
}
public float x;
public float y;
public float z;
public real_t x;
public real_t y;
public real_t z;
public float this[int index]
public real_t this[int index]
{
get
{
@ -61,7 +67,7 @@ namespace Godot
internal void Normalize()
{
float length = this.Length();
real_t length = this.Length();
if (length == 0f)
{
@ -80,7 +86,7 @@ namespace Godot
return new Vector3(Mathf.Abs(x), Mathf.Abs(y), Mathf.Abs(z));
}
public float AngleTo(Vector3 to)
public real_t AngleTo(Vector3 to)
{
return Mathf.Atan2(Cross(to).Length(), Dot(to));
}
@ -105,15 +111,15 @@ namespace Godot
);
}
public Vector3 CubicInterpolate(Vector3 b, Vector3 preA, Vector3 postB, float t)
public Vector3 CubicInterpolate(Vector3 b, Vector3 preA, Vector3 postB, real_t t)
{
Vector3 p0 = preA;
Vector3 p1 = this;
Vector3 p2 = b;
Vector3 p3 = postB;
float t2 = t * t;
float t3 = t2 * t;
real_t t2 = t * t;
real_t t3 = t2 * t;
return 0.5f * (
(p1 * 2.0f) + (-p0 + p2) * t +
@ -122,17 +128,17 @@ namespace Godot
);
}
public float DistanceSquaredTo(Vector3 b)
public real_t DistanceSquaredTo(Vector3 b)
{
return (b - this).LengthSquared();
}
public float DistanceTo(Vector3 b)
public real_t DistanceTo(Vector3 b)
{
return (b - this).Length();
}
public float Dot(Vector3 b)
public real_t Dot(Vector3 b)
{
return x * b.x + y * b.y + z * b.z;
}
@ -152,25 +158,25 @@ namespace Godot
return Mathf.Abs(LengthSquared() - 1.0f) < Mathf.Epsilon;
}
public float Length()
public real_t Length()
{
float x2 = x * x;
float y2 = y * y;
float z2 = z * z;
real_t x2 = x * x;
real_t y2 = y * y;
real_t z2 = z * z;
return Mathf.Sqrt(x2 + y2 + z2);
}
public float LengthSquared()
public real_t LengthSquared()
{
float x2 = x * x;
float y2 = y * y;
float z2 = z * z;
real_t x2 = x * x;
real_t y2 = y * y;
real_t z2 = z * z;
return x2 + y2 + z2;
}
public Vector3 LinearInterpolate(Vector3 b, float t)
public Vector3 LinearInterpolate(Vector3 b, real_t t)
{
return new Vector3
(
@ -215,11 +221,24 @@ namespace Godot
return 2.0f * n * Dot(n) - this;
}
public Vector3 Rotated(Vector3 axis, float phi)
public Vector3 Rotated(Vector3 axis, real_t phi)
{
return new Basis(axis, phi).Xform(this);
}
public void Set(real_t x, real_t y, real_t z)
{
this.x = x;
this.y = y;
this.z = z;
}
public void Set(Vector3 v)
{
this.x = v.x;
this.y = v.y;
this.z = v.z;
}
public Vector3 Slide(Vector3 n)
{
return this - n * Dot(n);
@ -244,12 +263,41 @@ namespace Godot
);
}
public Vector3(float x, float y, float z)
private static readonly Vector3 zero = new Vector3 (0, 0, 0);
private static readonly Vector3 one = new Vector3 (1, 1, 1);
private static readonly Vector3 negOne = new Vector3 (-1, -1, -1);
private static readonly Vector3 up = new Vector3 (0, 1, 0);
private static readonly Vector3 down = new Vector3 (0, -1, 0);
private static readonly Vector3 right = new Vector3 (1, 0, 0);
private static readonly Vector3 left = new Vector3 (-1, 0, 0);
private static readonly Vector3 forward = new Vector3 (0, 0, -1);
private static readonly Vector3 back = new Vector3 (0, 0, 1);
public static Vector3 Zero { get { return zero; } }
public static Vector3 One { get { return one; } }
public static Vector3 NegOne { get { return negOne; } }
public static Vector3 Up { get { return up; } }
public static Vector3 Down { get { return down; } }
public static Vector3 Right { get { return right; } }
public static Vector3 Left { get { return left; } }
public static Vector3 Forward { get { return forward; } }
public static Vector3 Back { get { return back; } }
// Constructors
public Vector3(real_t x, real_t y, real_t z)
{
this.x = x;
this.y = y;
this.z = z;
}
public Vector3(Vector3 v)
{
this.x = v.x;
this.y = v.y;
this.z = v.z;
}
public static Vector3 operator +(Vector3 left, Vector3 right)
{
@ -275,7 +323,7 @@ namespace Godot
return vec;
}
public static Vector3 operator *(Vector3 vec, float scale)
public static Vector3 operator *(Vector3 vec, real_t scale)
{
vec.x *= scale;
vec.y *= scale;
@ -283,7 +331,7 @@ namespace Godot
return vec;
}
public static Vector3 operator *(float scale, Vector3 vec)
public static Vector3 operator *(real_t scale, Vector3 vec)
{
vec.x *= scale;
vec.y *= scale;
@ -299,7 +347,7 @@ namespace Godot
return left;
}
public static Vector3 operator /(Vector3 vec, float scale)
public static Vector3 operator /(Vector3 vec, real_t scale)
{
vec.x /= scale;
vec.y /= scale;