Replace float with real_t, default Vectors, other misc C# improvements

Replace float with real_t in most files, defined at the top of each file via using. Objects such as Vector3 now accept doubles as inputs, and convert to real_t internally. I've added default Vectors such as Vector3.Zero. Other misc C# improvements such as Mathf.RoundToInt(). Color continues to use float only because high precision is not needed for 8-bit color math and to keep things simple. Everything seems to compile and work fine, but testing is requested, as this is the first time I've ever contributed to Godot.
This commit is contained in:
Aaron Franke 2018-03-01 01:51:35 -06:00
parent c094e90b25
commit ff97c97c93
13 changed files with 473 additions and 291 deletions

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;
}
@ -419,7 +425,8 @@ namespace Godot
return new AABB(min, max - min);
}
// Constructors
public AABB(Vector3 position, Vector3 size)
{
this.position = position;

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];
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
);
}
}
public Quat Quat() {
real_t trace = x[0] + y[1] + z[2];
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);

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
{
@ -316,7 +316,8 @@ 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;

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

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);
}
}
}

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);
@ -133,14 +139,14 @@ 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;

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(Quat q)
{
this.x = q.x;
this.y = q.y;
this.z = q.z;
this.w = q.w;
}
public Quat(Vector3 axis, float angle)
public Quat(Vector3 axis, real_t angle)
{
float d = axis.Length();
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);
}

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;
@ -169,14 +175,24 @@ 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);

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;
}
@ -97,7 +103,8 @@ namespace Godot
(basis[0, 2] * vInv.x) + (basis[1, 2] * vInv.y) + (basis[2, 2] * vInv.z)
);
}
// Constructors
public Transform(Vector3 xAxis, Vector3 yAxis, Vector3 zAxis, Vector3 origin)
{
this.basis = Basis.CreateFromAxes(xAxis, yAxis, zAxis);

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];
}
@ -259,24 +265,26 @@ namespace Godot
Vector2 vInv = v - o;
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);

View file

@ -1 +1 @@
1
2

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);
@ -200,12 +217,36 @@ namespace Godot
{
return new Vector2(y, -x);
}
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 Vector2(float x, float y)
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;

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);
@ -243,13 +262,42 @@ namespace Godot
0f, 0f, 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 Vector3(float x, float y, float z)
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;