Gottfried/glitchy-engine-beef
1
0
Fork 0
mirror of https://github.com/aharabada/glitchy-engine-beef.git synced 2026-09-05 13:01:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Shader like vectors for C# Scripting

Browse Source
This commit is contained in:
Simon Lübeß
2023-07-20 17:48:28 +02:00
parent f0de874572
commit 3e55a1614a
24 changed files with 1572 additions and 486 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ScriptCore/Components/RigidBody2D.cs
+2 -2
View File
@@ -12,7 +12,7 @@ public class RigidBody2D : Component
/// <param name="force">The world force vector, usually in Newtons (N).</param>
/// <param name="point">The world position of the point of application.</param>
/// <param name="wakeUp">Wake up the body</param>
public void ApplyForce(Vector2 force, Vector2 point, bool wakeUp = true)
public void ApplyForce(float2 force, float2 point, bool wakeUp = true)
{
ScriptGlue.RigidBody2D_ApplyForce(Entity._uuid, force, point, wakeUp);
}
@@ -23,7 +23,7 @@ public class RigidBody2D : Component
/// </summary>
/// <param name="force">The world force vector, usually in Newtons (N).</param>
/// <param name="wakeUp">Wake up the body</param>
public void ApplyForceToCenter(Vector2 force, bool wakeUp = true)
public void ApplyForceToCenter(float2 force, bool wakeUp = true)
{
ScriptGlue.RigidBody2D_ApplyForceToCenter(Entity._uuid, force, wakeUp);
}
ScriptCore/Components/Transform.cs
+2 -2
View File
@@ -5,11 +5,11 @@ namespace GlitchyEngine;
public class Transform : Component
{
public Vector3 Translation
public float3 Translation
{
get
{
ScriptGlue.Transform_GetTranslation(Entity.UUID, out Vector3 translation);
ScriptGlue.Transform_GetTranslation(Entity.UUID, out float3 translation);
return translation;
}
set
ScriptCore/Entity.cs
+1 -3
View File
@@ -143,9 +143,7 @@ public class Entity : EngineObject
public static Entity FindEntityWithName(string name)
{
ScriptGlue.Entity_FindEntityWithName(name, out UUID entityId);
Log.Error($"Found EntityID {entityId}");
if (entityId == UUID.Zero)
return null;
ScriptCore/Math/Attributes/VectorAttribute.cs
+18 -3
View File
@@ -2,8 +2,9 @@
using System.Collections.Generic;
using System.Text;
namespace ScriptCore.Math.Attributes;
namespace GlitchyEngine.Math.Attributes;
[AttributeUsage(AttributeTargets.Struct)]
public class VectorAttribute : Attribute
{
public Type Type { get; set; }
@@ -19,9 +20,23 @@ public class VectorAttribute : Attribute
}
}
public class SwizzleVectorAttribute : Attribute
[AttributeUsage(AttributeTargets.Struct)]
public class ComparableVectorAttribute : Attribute { }
[AttributeUsage(AttributeTargets.Struct)]
public class VectorMathAttribute : Attribute { }
[AttributeUsage(AttributeTargets.Struct)]
public class VectorLogicAttribute : Attribute { }
[AttributeUsage(AttributeTargets.Struct, AllowMultiple = true)]
public class VectorCastAttribute : Attribute
{
public SwizzleVectorAttribute()
public Type TargetType { get; set; }
public bool IsExplicit { get; set; }
public VectorCastAttribute(Type targetType, bool isExplicit)
{
TargetType = targetType;
IsExplicit = isExplicit;
}
}
ScriptCore/Math/BoolVectors.cs
+35
View File
@@ -0,0 +1,35 @@
using System;
using GlitchyEngine.Math;
using GlitchyEngine.Math.Attributes;
namespace GlitchyEngine.Math;
[Vector(typeof(bool), 2, "bool")]
[VectorLogic]
public partial struct bool2
{
public static bool2 operator !(bool2 value)
{
return new bool2(!value.X, !value.Y);
}
}
[Vector(typeof(bool), 3, "bool")]
[VectorLogic]
public partial struct bool3
{
public static bool3 operator !(bool3 value)
{
return new bool3(!value.X, !value.Y, !value.Z);
}
}
[Vector(typeof(bool), 4, "bool")]
[VectorLogic]
public partial struct bool4
{
public static bool4 operator !(bool4 value)
{
return new bool4(!value.X, !value.Y, !value.Z, !value.W);
}
}
ScriptCore/Math/DoubleVectors.cs
+29
View File
@@ -0,0 +1,29 @@
using System;
using GlitchyEngine.Math;
using GlitchyEngine.Math.Attributes;
namespace GlitchyEngine.Math;
[Vector(typeof(double), 2, "double")]
[VectorMath]
[ComparableVector]
[VectorCast(typeof(float2), true)]
public partial struct double2
{
}
[Vector(typeof(double), 3, "double")]
[VectorMath]
[ComparableVector]
[VectorCast(typeof(float3), true)]
public partial struct double3
{
}
[Vector(typeof(double), 4, "double")]
[VectorMath]
[ComparableVector]
[VectorCast(typeof(float4), true)]
public partial struct double4
{
}
ScriptCore/Math/FloatVectors.cs
+60
View File
@@ -0,0 +1,60 @@
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using GlitchyEngine.Math;
using GlitchyEngine.Math.Attributes;
namespace GlitchyEngine.Math;
[Vector(typeof(float), 2, "float")]
[ComparableVector]
[VectorMath]
[VectorCast(typeof(int2), true)]
[VectorCast(typeof(double2), true)]
[VectorCast(typeof(half2), true)]
public partial struct float2
{
public static readonly float2 Zero = new(0.0f, 0.0f);
public static readonly float2 UnitX = new(1.0f, 0.0f);
public static readonly float2 UnitY = new(0.0f, 1.0f);
public static readonly float2 One = new(0.0f, 0.0f);
}
[Vector(typeof(float), 3, "float")]
[ComparableVector]
[VectorMath]
[VectorCast(typeof(int3), true)]
[VectorCast(typeof(double3), true)]
[VectorCast(typeof(half3), true)]
public partial struct float3
{
public static readonly float3 Zero = new(0.0f, 0.0f, 0.0f);
public static readonly float3 UnitX = new(1.0f, 0.0f, 0.0f);
public static readonly float3 UnitY = new(0.0f, 1.0f, 0.0f);
public static readonly float3 UnitZ = new(0.0f, 0.0f, 1.0f);
public static readonly float3 One = new(0.0f, 0.0f, 0.0f);
public static readonly float3 Forward = new(0.0f, 0.0f, 1.0f);
public static readonly float3 Backward = new(0.0f, 0.0f, -1.0f);
public static readonly float3 Left = new(-1.0f, 0.0f, 0.0f);
public static readonly float3 Right = new(1.0f, 0.0f, 0.0f);
public static readonly float3 Up = new(0.0f, 1.0f, 0.0f);
public static readonly float3 Down = new(0.0f, -1.0f, 0.0f);
}
[Vector(typeof(float), 4, "float")]
[ComparableVector]
[VectorMath]
[VectorCast(typeof(int4), true)]
[VectorCast(typeof(double4), true)]
[VectorCast(typeof(half4), true)]
public partial struct float4
{
public static readonly float4 Zero = new(0f, 0f, 0f, 0f);
public static readonly float4 UnitX = new(1f, 0f, 0f, 0f);
public static readonly float4 UnitY = new(0f, 1f, 0f, 0f);
public static readonly float4 UnitZ = new(0f, 0f, 1f, 0f);
public static readonly float4 UnitW = new(0f, 0f, 0f, 1f);
public static readonly float4 One = new(1f, 1f, 1f, 1f);
}
ScriptCore/Math/HalfVectors.cs
+23
View File
@@ -0,0 +1,23 @@
using System;
using GlitchyEngine.Math;
using GlitchyEngine.Math.Attributes;
namespace GlitchyEngine.Math;
[Vector(typeof(Half), 2, "half")]
[VectorCast(typeof(float2), true)]
public partial struct half2
{
}
[Vector(typeof(Half), 3, "half")]
[VectorCast(typeof(float3), true)]
public partial struct half3
{
}
[Vector(typeof(Half), 4, "half")]
[VectorCast(typeof(float4), true)]
public partial struct half4
{
}
ScriptCore/Math/IntVectors.cs
+47
View File
@@ -0,0 +1,47 @@
using System;
using GlitchyEngine.Math;
using GlitchyEngine.Math.Attributes;
namespace GlitchyEngine.Math;
[Vector(typeof(int), 2, "int")]
[VectorMath]
[VectorLogic]
[ComparableVector]
[VectorCast(typeof(float2), true)]
[VectorCast(typeof(uint2), true)]
public partial struct int2
{
public static int2 operator ~(int2 value)
{
return new int2(~value.X, ~value.Y);
}
}
[Vector(typeof(int), 3, "int")]
[VectorMath]
[VectorLogic]
[ComparableVector]
[VectorCast(typeof(float3), true)]
[VectorCast(typeof(uint3), true)]
public partial struct int3
{
public static int3 operator ~(int3 value)
{
return new int3(~value.X, ~value.Y, ~value.Z);
}
}
[Vector(typeof(int), 4, "int")]
[VectorMath]
[VectorLogic]
[ComparableVector]
[VectorCast(typeof(float4), true)]
[VectorCast(typeof(uint4), true)]
public partial struct int4
{
public static int4 operator ~(int4 value)
{
return new int4(~value.X, ~value.Y, ~value.Z, ~value.W);
}
}
ScriptCore/Math/Math.cs
+841
View File
@@ -0,0 +1,841 @@
using System;
using System.Runtime.CompilerServices;
namespace GlitchyEngine.Math;
public static class Math
{
/// An optimal representation of π.
public const float Pi = 3.141592654f;
/// An optimal representation of 2*π.
public const float TwoPi = 6.283185307f;
/// An optimal representation of 1/π.
public const float OneOverPi = 0.318309886f;
/// An optimal representation of 2/π.
public const float OneOverTwoPi = 0.159154943f;
/// An optimal representation of π/2.
public const float PiOverTwo = 1.570796327f;
/// An optimal representation of π/4.
public const float PiOverFour = 0.785398163f;
/// Converts radians to degrees
public const float RadToDeg = 180.0f / Pi;
/// Converts radians to degrees
public const float DegToRad = Pi / 180.0f;
/// Returns true if at least one of the components is true.
public static bool any(bool value) => value;
/// Returns true if at least one of the components is true.
public static bool any(bool2 value) => value.X || value.Y;
/// Returns true if at least one of the components is true.
public static bool any(bool3 value) => value.X || value.Y || value.Z;
/// Returns true if at least one of the components is true.
public static bool any(bool4 value) => value.X || value.Y || value.Z || value.W;
/// Returns true if all of the components are true.
public static bool all(bool value) => value;
/// Returns true if all of the components are true.
public static bool all(bool2 value) => value.X && value.Y;
/// Returns true if all of the components are true.
public static bool all(bool3 value) => value.X && value.Y && value.Z;
/// Returns true if all of the components are true.
public static bool all(bool4 value) => value.X && value.Y && value.Z && value.W;
#region abs
public static float abs(float value)
{
return System.Math.Abs(value);
}
public static float2 abs(float2 value)
{
return new float2(System.Math.Abs(value.X), System.Math.Abs(value.Y));
}
public static float3 abs(float3 value)
{
return new float3(System.Math.Abs(value.X), System.Math.Abs(value.Y), System.Math.Abs(value.Z));
}
public static float4 abs(float4 value)
{
return new float4(System.Math.Abs(value.X), System.Math.Abs(value.Y), System.Math.Abs(value.Z), System.Math.Abs(value.W));
}
public static int abs(int value)
{
return System.Math.Abs(value);
}
public static int2 abs(int2 value)
{
return new int2(System.Math.Abs(value.X), System.Math.Abs(value.Y));
}
public static int3 abs(int3 value)
{
return new int3(System.Math.Abs(value.X), System.Math.Abs(value.Y), System.Math.Abs(value.Z));
}
public static int4 abs(int4 value)
{
return new int4(System.Math.Abs(value.X), System.Math.Abs(value.Y), System.Math.Abs(value.Z), System.Math.Abs(value.W));
}
#endregion
#region modf / frac / trunc
// Splits the value x into fractional and integer parts, each of which has the same sign as x.
public static float modf(float x, out float integerPart) => ScriptGlue.modf_float(x, out integerPart);
// Splits the value x into fractional and integer parts, each of which has the same sign as x.
public static float2 modf(float2 x, out float2 integerPart) => ScriptGlue.modf_float2(x, out integerPart);
// Splits the value x into fractional and integer parts, each of which has the same sign as x.
public static float3 modf(float3 x, out float3 integerPart) => ScriptGlue.modf_float3(x, out integerPart);
// Splits the value x into fractional and integer parts, each of which has the same sign as x.
public static float4 modf(float4 x, out float4 integerPart) => ScriptGlue.modf_float4(x, out integerPart);
// Returns the fractional (or decimal) part of x; which is greater than or equal to 0 and less than 1.
public static float frac(float x) => modf(x, out _);
// Returns the fractional (or decimal) part of x; which is greater than or equal to 0 and less than 1.
public static float2 frac(float2 x) => modf(x, out _);
// Returns the fractional (or decimal) part of x; which is greater than or equal to 0 and less than 1.
public static float3 frac(float3 x) => modf(x, out _);
// Returns the fractional (or decimal) part of x; which is greater than or equal to 0 and less than 1.
public static float4 frac(float4 x) => modf(x, out _);
/// <summary>
/// Truncates a floating-point value to the integer component.
/// </summary>
public static float trunc(float x)
{
return (float)System.Math.Truncate(x);
}
/// <summary>
/// Truncates a floating-point value to the integer component.
/// </summary>
public static float2 trunc(float2 x)
{
return new float2((float)System.Math.Truncate(x.X), (float)System.Math.Truncate(x.Y));
}
/// <summary>
/// Truncates a floating-point value to the integer component.
/// </summary>
public static float3 trunc(float3 x)
{
return new float3((float)System.Math.Truncate(x.X), (float)System.Math.Truncate(x.Y), (float)System.Math.Truncate(x.Z));
}
/// <summary>
/// Truncates a floating-point value to the integer component.
/// </summary>
public static float4 trunc(float4 x)
{
return new float4((float)System.Math.Truncate(x.X), (float)System.Math.Truncate(x.Y), (float)System.Math.Truncate(x.Z), (float)System.Math.Truncate(x.W));
}
#endregion
#region infinity and nan check
/// Determines if the specified floating-point value is finite.
public static bool2 isfinite(float2 value)
{
return new bool2(!float.IsInfinity(value.X), !float.IsInfinity(value.Y));
}
/// Determines if the specified floating-point value is finite.
public static bool3 isfinite(float3 value)
{
return new bool3(!float.IsInfinity(value.X), !float.IsInfinity(value.Y), !float.IsInfinity(value.Z));
}
/// Determines if the specified floating-point value is finite.
public static bool4 isfinite(float4 value)
{
return new bool4(!float.IsInfinity(value.X), !float.IsInfinity(value.Y), !float.IsInfinity(value.Z), !float.IsInfinity(value.W));
}
/// Determines if the specified value is infinite.
public static bool2 isinf(float2 value)
{
return new bool2(float.IsInfinity(value.X), float.IsInfinity(value.Y));
}
/// Determines if the specified value is infinite.
public static bool3 isinf(float3 value)
{
return new bool3(float.IsInfinity(value.X), float.IsInfinity(value.Y), float.IsInfinity(value.Z));
}
/// Determines if the specified value is infinite.
public static bool4 isinf(float4 value)
{
return new bool4(float.IsInfinity(value.X), float.IsInfinity(value.Y), float.IsInfinity(value.Z), float.IsInfinity(value.W));
}
/// Determines if the specified value is infinite.
public static bool2 isnan(float2 value)
{
return new bool2(float.IsNaN(value.X), float.IsNaN(value.Y));
}
/// Determines if the specified value is infinite.
public static bool3 isnan(float3 value)
{
return new bool3(float.IsNaN(value.X), float.IsNaN(value.Y), float.IsNaN(value.Z));
}
/// Determines if the specified value is infinite.
public static bool4 isnan(float4 value)
{
return new bool4(float.IsNaN(value.X), float.IsNaN(value.Y), float.IsNaN(value.Z), float.IsNaN(value.W));
}
#endregion
#region Sign
/// Returns the sign of x.
public static int sign(float x)
{
return System.Math.Sign(x);
}
/// Returns the sign of x.
public static int2 sign(float2 x)
{
return new int2(System.Math.Sign(x.X), System.Math.Sign(x.Y));
}
/// Returns the sign of x.
public static int3 sign(float3 x)
{
return new int3(System.Math.Sign(x.X), System.Math.Sign(x.Y), System.Math.Sign(x.Z));
}
/// Returns the sign of x.
public static int4 sign(float4 x)
{
return new int4(System.Math.Sign(x.X), System.Math.Sign(x.Y), System.Math.Sign(x.Z), System.Math.Sign(x.W));
}
/// Returns the sign of x.
public static int sign(int x)
{
return System.Math.Sign(x);
}
/// Returns the sign of x.
public static int2 sign(int2 x)
{
return new int2(System.Math.Sign(x.X), System.Math.Sign(x.Y));
}
/// Returns the sign of x.
public static int3 sign(int3 x)
{
return new int3(System.Math.Sign(x.X), System.Math.Sign(x.Y), System.Math.Sign(x.Z));
}
/// Returns the sign of x.
public static int4 sign(int4 x)
{
return new int4(System.Math.Sign(x.X), System.Math.Sign(x.Y), System.Math.Sign(x.Z), System.Math.Sign(x.W));
}
#endregion
#region ceil / floor / round
public static float ceil(float value)
{
return (float)System.Math.Ceiling(value);
}
public static float2 ceil(float2 value)
{
return new float2((float)System.Math.Ceiling(value.X), (float)System.Math.Ceiling(value.Y));
}
public static float3 ceil(float3 value)
{
return new float3((float)System.Math.Ceiling(value.X), (float)System.Math.Ceiling(value.Y), (float)System.Math.Ceiling(value.Z));
}
public static float4 ceil(float4 value)
{
return new float4((float)System.Math.Ceiling(value.X), (float)System.Math.Ceiling(value.Y), (float)System.Math.Ceiling(value.Z), (float)System.Math.Ceiling(value.W));
}
public static float floor(float value)
{
return (float)System.Math.Floor(value);
}
public static float2 floor(float2 value)
{
return new float2((float)System.Math.Floor(value.X), (float)System.Math.Floor(value.Y));
}
public static float3 floor(float3 value)
{
return new float3((float)System.Math.Floor(value.X), (float)System.Math.Floor(value.Y), (float)System.Math.Floor(value.Z));
}
public static float4 floor(float4 value)
{
return new float4((float)System.Math.Floor(value.X), (float)System.Math.Floor(value.Y), (float)System.Math.Floor(value.Z), (float)System.Math.Floor(value.W));
}
/// Rounds the specified value to the nearest integer.
public static float round(float value)
{
return (float)System.Math.Round(value);
}
/// Rounds the specified value to the nearest integer.
public static float2 round(float2 value)
{
return new float2((float)System.Math.Round(value.X), (float)System.Math.Round(value.Y));
}
/// Rounds the specified value to the nearest integer.
public static float3 round(float3 value)
{
return new float3((float)System.Math.Round(value.X), (float)System.Math.Round(value.Y), (float)System.Math.Round(value.Z));
}
/// Rounds the specified value to the nearest integer.
public static float4 round(float4 value)
{
return new float4((float)System.Math.Round(value.X), (float)System.Math.Round(value.Y), (float)System.Math.Round(value.Z), (float)System.Math.Round(value.W));
}
#endregion
#region min / max
public static float min(float x, float y)
{
return (float)System.Math.Min(x, y);
}
public static float2 min(float2 x, float2 y)
{
return new float2((float)System.Math.Min(x.X, y.X), (float)System.Math.Min(x.Y, y.Y));
}
public static float3 min(float3 x, float3 y)
{
return new float3((float)System.Math.Min(x.X, y.X), (float)System.Math.Min(x.Y, y.Y), (float)System.Math.Min(x.Z, y.Z));
}
public static float4 min(float4 x, float4 y)
{
return new float4((float)System.Math.Min(x.X, y.X), (float)System.Math.Min(x.Y, y.Y), (float)System.Math.Min(x.Z, y.Z), (float)System.Math.Min(x.W, y.W));
}
public static float max(float x, float y)
{
return (float)System.Math.Max(x, y);
}
public static float2 max(float2 x, float2 y)
{
return new float2((float)System.Math.Max(x.X, y.X), (float)System.Math.Max(x.Y, y.Y));
}
public static float3 max(float3 x, float3 y)
{
return new float3((float)System.Math.Max(x.X, y.X), (float)System.Math.Max(x.Y, y.Y), (float)System.Math.Max(x.Z, y.Z));
}
public static float4 max(float4 x, float4 y)
{
return new float4((float)System.Math.Max(x.X, y.X), (float)System.Math.Max(x.Y, y.Y), (float)System.Math.Max(x.Z, y.Z), (float)System.Math.Max(x.W, y.W));
}
#endregion
#region exp, pow, log
// TODO: log, log10, log2
// Returns x raised to the power of y.
public static float pow(float x, float y)
{
return (float)System.Math.Pow(x, y);
}
/// Returns x raised to the power of y.
public static float2 pow(float2 x, float2 y)
{
return new float2((float)System.Math.Pow(x.X, y.X), (float)System.Math.Pow(x.Y, y.Y));
}
/// Returns x raised to the power of y.
public static float3 pow(float3 x, float3 y)
{
return new float3((float)System.Math.Pow(x.X, y.X), (float)System.Math.Pow(x.Y, y.Y), (float)System.Math.Pow(x.Z, y.Z));
}
/// Returns x raised to the power of y.
public static float4 pow(float4 x, float4 y)
{
return new float4((float)System.Math.Pow(x.X, y.X), (float)System.Math.Pow(x.Y, y.Y), (float)System.Math.Pow(x.Z, y.Z), (float)System.Math.Pow(x.W, y.W));
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float exp(float x)
{
return (float)System.Math.Exp(x);
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float2 exp(float2 x)
{
return new float2((float)System.Math.Exp(x.X), (float)System.Math.Exp(x.Y));
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float3 exp(float3 x)
{
return new float3((float)System.Math.Exp(x.X), (float)System.Math.Exp(x.Y), (float)System.Math.Exp(x.Z));
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float4 exp(float4 x)
{
return new float4((float)System.Math.Exp(x.X), (float)System.Math.Exp(x.Y), (float)System.Math.Exp(x.Z), (float)System.Math.Exp(x.W));
}
/// Returns the base 2 exponential, or 2^x, of the specified value.
public static float exp2(float x)
{
return (float)System.Math.Pow(2, x);
}
/// Returns the base 2 exponential, or 2^x, of the specified value.
public static float2 exp2(float2 x)
{
return new float2((float)System.Math.Pow(2, x.X), (float)System.Math.Pow(2, x.Y));
}
/// Returns the base 2 exponential, or 2^x, of the specified value.
public static float3 exp2(float3 x)
{
return new float3((float)System.Math.Pow(2, x.X), (float)System.Math.Pow(2, x.Y), (float)System.Math.Pow(2, x.Z));
}
/// Returns the base 2 exponential, or 2^x, of the specified value.
public static float4 exp2(float4 x)
{
return new float4((float)System.Math.Pow(2, x.X), (float)System.Math.Pow(2, x.Y), (float)System.Math.Pow(2, x.Z), (float)System.Math.Pow(2, x.W));
}
#endregion
#region Degrees / Radians
public static float toDegrees(float radians) => radians * RadToDeg;
public static float2 toDegrees(float2 radians) => radians * RadToDeg;
public static float3 toDegrees(float3 radians) => radians * RadToDeg;
public static float4 toDegrees(float4 radians) => radians * RadToDeg;
public static float toRadians(float degrees) => degrees * DegToRad;
public static float2 toRadians(float2 degrees) => degrees * DegToRad;
public static float3 toRadians(float3 degrees) => degrees * DegToRad;
public static float4 toRadians(float4 degrees) => degrees * DegToRad;
#endregion
#region Clamp
public static float clamp(float value, float min, float max)
{
return value < min ? min : (value > max ? max : value);
}
public static float2 clamp(float2 value, float2 min, float2 max)
{
return new float2(clamp(value.X, min.X, max.X), clamp(value.Y, min.Y, max.Y));
}
public static float3 clamp(float3 value, float3 min, float3 max)
{
return new float3(clamp(value.X, min.X, max.X), clamp(value.Y, min.Y, max.Y), clamp(value.Z, min.Z, max.Z));
}
public static float4 clamp(float4 value, float4 min, float4 max)
{
return new float4(clamp(value.X, min.X, max.X), clamp(value.Y, min.Y, max.Y), clamp(value.Z, min.Z, max.Z), clamp(value.W, min.W, max.W));
}
public static int clamp(int value, int min, int max)
{
return value < min ? min : (value > max ? max : value);
}
public static int2 clamp(int2 value, int2 min, int2 max)
{
return new int2(clamp(value.X, min.X, max.X), clamp(value.Y, min.Y, max.Y));
}
public static int3 clamp(int3 value, int3 min, int3 max)
{
return new int3(clamp(value.X, min.X, max.X), clamp(value.Y, min.Y, max.Y), clamp(value.Z, min.Z, max.Z));
}
public static int4 clamp(int4 value, int4 min, int4 max)
{
return new int4(clamp(value.X, min.X, max.X), clamp(value.Y, min.Y, max.Y), clamp(value.Z, min.Z, max.Z), clamp(value.W, min.W, max.W));
}
#endregion
#region Lerp
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float lerp(float x, float y, float s)
{
return x + s * (y - x);
}
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float2 lerp(float2 x, float2 y, float s)
{
return x + s * (y - x);
}
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float3 lerp(float3 x, float3 y, float s)
{
return x + s * (y - x);
}
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float4 lerp(float4 x, float4 y, float s)
{
return x + s * (y - x);
}
#endregion
// mul? hlsl has like 280 overloads...
public static float normalize(float value) => 1.0f;
public static float2 normalize(float2 value) => value / length(value);
public static float3 normalize(float3 value) => value / length(value);
public static float4 normalize(float4 value) => value / length(value);
// pow
#region Reflect and Refract
/// Returns a reflection vector using an incident ray and a surface normal.
public static float2 reflect(float2 incident, float2 normal) => incident - 2 * normal * dot(incident, normal);
/// Returns a reflection vector using an incident ray and a surface normal.
public static float3 reflect(float3 incident, float3 normal) => incident - 2 * normal * dot(incident, normal);
/// Returns a reflection vector using an incident ray and a surface normal.
public static float4 reflect(float4 incident, float4 normal) => incident - 2 * normal * dot(incident, normal);
// Source: https://thebookofshaders.com/glossary/?search=refract
/// Returns a refraction vector using an entering ray, a surface normal, and a refraction index.
public static float2 refract(float2 incident, float2 normal, float refractionIndex)
{
float dot_n_i = dot(normal, incident);
float k = 1.0f - refractionIndex * refractionIndex * (1.0f - dot_n_i * dot_n_i);
if (k < 0.0f)
return 0.0f;
else
return refractionIndex * incident - (refractionIndex * dot_n_i + sqrt(k));
}
/// Returns a refraction vector using an entering ray, a surface normal, and a refraction index.
public static float3 refract(float3 incident, float3 normal, float refractionIndex)
{
float dot_n_i = dot(normal, incident);
float k = 1.0f - refractionIndex * refractionIndex * (1.0f - dot_n_i * dot_n_i);
if (k < 0.0f)
return 0.0f;
else
return refractionIndex * incident - (refractionIndex * dot_n_i + sqrt(k));
}
/// Returns a refraction vector using an entering ray, a surface normal, and a refraction index.
public static float4 refract(float4 incident, float4 normal, float refractionIndex)
{
float dot_n_i = dot(normal, incident);
float k = 1.0f - refractionIndex * refractionIndex * (1.0f - dot_n_i * dot_n_i);
if (k < 0.0f)
return 0.0f;
else
return refractionIndex * incident - (refractionIndex * dot_n_i + sqrt(k));
}
#endregion
/// Calculates the per component square root of the given value.
public static float sqrt(float value)
{
return (float)System.Math.Sqrt(value);
}
/// Calculates the per component square root of the given value.
public static float2 sqrt(float2 value)
{
return new float2((float)System.Math.Sqrt(value.X), (float)System.Math.Sqrt(value.Y));
}
/// Calculates the per component square root of the given value.
public static float3 sqrt(float3 value)
{
return new float3((float)System.Math.Sqrt(value.X), (float)System.Math.Sqrt(value.Y), (float)System.Math.Sqrt(value.Z));
}
/// Calculates the per component square root of the given value.
public static float4 sqrt(float4 value)
{
return new float4((float)System.Math.Sqrt(value.X), (float)System.Math.Sqrt(value.Y), (float)System.Math.Sqrt(value.Z), (float)System.Math.Sqrt(value.W));
}
// saturate (I don't think there is a faster way than simply using clamp, so simply use clamp...)
#region Step / Smoothstep
/// Compares two values, returning 0 or 1 based on which value is greater.
/// @returns 1 if the x parameter is greater than or equal to the y parameter; otherwise, 0.
public static float step(float y, float x)
{
return (x >= y) ? 1.0f : 0.0f;
}
/// Compares two values, returning 0 or 1 based on which value is greater.
/// @returns 1 if the x parameter is greater than or equal to the y parameter; otherwise, 0.
public static float2 step(float2 y, float2 x)
{
bool2 b = (x >= y);
return new float2(b.X ? 1.0f : 0.0f, b.Y ? 1.0f : 0.0f);
}
/// Compares two values, returning 0 or 1 based on which value is greater.
/// @returns 1 if the x parameter is greater than or equal to the y parameter; otherwise, 0.
public static float3 step(float3 y, float3 x)
{
bool3 b = (x >= y);
return new float3(b.X ? 1.0f : 0.0f, b.Y ? 1.0f : 0.0f, b.Z ? 1.0f : 0.0f);
}
/// Compares two values, returning 0 or 1 based on which value is greater.
/// @returns 1 if the x parameter is greater than or equal to the y parameter; otherwise, 0.
public static float4 step(float4 y, float4 x)
{
bool4 b = (x >= y);
return new float4(b.X ? 1.0f : 0.0f, b.Y ? 1.0f : 0.0f, b.Z ? 1.0f : 0.0f, b.W ? 1.0f : 0.0f);
}
// Source: https://thebookofshaders.com/glossary/?search=smoothstep
/// Returns a smooth Hermite interpolation between 0 and 1, if x is in the range [min, max].
/// @returns Returns 0 if x is less than min; 1 if x is greater than max; otherwise, a value between 0 and 1 if x is in the range [min, max].
public static float smoothstep(float min, float max, float x)
{
float t = clamp((x - min) / (max - min), 0.0f, 1.0f);
return t * t * (3.0f - 2.0f * t);
}
/// Returns a smooth Hermite interpolation between 0 and 1, if x is in the range [min, max].
/// @returns Returns 0 if x is less than min; 1 if x is greater than max; otherwise, a value between 0 and 1 if x is in the range [min, max].
public static float2 smoothstep(float2 min, float2 max, float2 x)
{
float2 t = clamp((x - min) / (max - min), 0.0f, 1.0f);
return t * t * (3.0f - 2.0f * t);
}
/// Returns a smooth Hermite interpolation between 0 and 1, if x is in the range [min, max].
/// @returns Returns 0 if x is less than min; 1 if x is greater than max; otherwise, a value between 0 and 1 if x is in the range [min, max].
public static float3 smoothstep(float3 min, float3 max, float3 x)
{
float3 t = clamp((x - min) / (max - min), 0.0f, 1.0f);
return t * t * (3.0f - 2.0f * t);
}
/// Returns a smooth Hermite interpolation between 0 and 1, if x is in the range [min, max].
/// @returns Returns 0 if x is less than min; 1 if x is greater than max; otherwise, a value between 0 and 1 if x is in the range [min, max].
public static float4 smoothstep(float4 min, float4 max, float4 x)
{
float4 t = clamp((x - min) / (max - min), 0.0f, 1.0f);
return t * t * (3.0f - 2.0f * t);
}
#endregion
#region Reject / Project
/**
* Calculates the projection of a onto b
*/
public static float2 project(float2 a, float2 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the projection of a onto b
*/
public static float3 project(float3 a, float3 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the projection of a onto b
*/
public static float4 project(float4 a, float4 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float2 reject(float2 a, float2 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float3 reject(float3 a, float3 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float4 reject(float4 a, float4 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
#endregion
#region dot
public static float dot(float2 left, float2 right)
{
return left.X * right.X + left.Y * right.Y;
}
public static float dot(float3 left, float3 right)
{
return left.X * right.X + left.Y * right.Y + left.Z * right.Z;
}
public static float dot(float4 left, float4 right)
{
return left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
}
public static int dot(int2 left, int2 right)
{
return left.X * right.X + left.Y * right.Y;
}
public static int dot(int3 left, int3 right)
{
return left.X * right.X + left.Y * right.Y + left.Z * right.Z;
}
public static int dot(int4 left, int4 right)
{
return left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
}
#endregion
#region lengthSq / length / DistanceSq / Distance
public static float lengthSq(float2 value) => dot(value, value);
public static float lengthSq(float3 value) => dot(value, value);
public static float lengthSq(float4 value) => dot(value, value);
public static int lengthSq(int2 value) => dot(value, value);
public static int lengthSq(int3 value) => dot(value, value);
public static int lengthSq(int4 value) => dot(value, value);
public static float length(float2 value) => (float)System.Math.Sqrt(lengthSq(value));
public static float length(float3 value) => (float)System.Math.Sqrt(lengthSq(value));
public static float length(float4 value) => (float)System.Math.Sqrt(lengthSq(value));
public static float distanceSq(float2 left, float2 right) => dot(left, right);
public static float distanceSq(float3 left, float3 right) => dot(left, right);
public static float distanceSq(float4 left, float4 right) => dot(left, right);
public static float distance(float2 left, float2 right) => (float)System.Math.Sqrt(distanceSq(left, right));
public static float distance(float3 left, float3 right) => (float)System.Math.Sqrt(distanceSq(left, right));
public static float distance(float4 left, float4 right) => (float)System.Math.Sqrt(distanceSq(left, right));
#endregion
public static float3 cross(float3 left, float3 right)
{
return new float3(
left.Y * right.Z - left.Z * right.Y,
left.Z * right.X - left.X * right.Z,
left.X * right.Y - left.Y * right.X);
}
// transpose und determinante für Matrizen
// sin, cos, tan, asin, acos, atan, atan2, cosh, sinh, tanh
}
ScriptCore/Math/UIntVectors.cs
+46
View File
@@ -0,0 +1,46 @@
using System;
using GlitchyEngine.Math;
using GlitchyEngine.Math.Attributes;
namespace GlitchyEngine.Math;
// TODO: Currently no VectorMath-Attribute because -uint results in long
[Vector(typeof(uint), 2, "uint")]
[VectorLogic]
[ComparableVector]
[VectorCast(typeof(int2), true)]
[VectorCast(typeof(float2), true)]
public partial struct uint2
{
public static uint2 operator ~(uint2 value)
{
return new uint2(~value.X, ~value.Y);
}
}
[Vector(typeof(uint), 3, "uint")]
[VectorLogic]
[ComparableVector]
[VectorCast(typeof(int3), true)]
[VectorCast(typeof(float3), true)]
public partial struct uint3
{
public static uint3 operator ~(uint3 value)
{
return new uint3(~value.X, ~value.Y, ~value.Z);
}
}
[Vector(typeof(uint), 4, "uint")]
[VectorLogic]
[ComparableVector]
[VectorCast(typeof(int4), true)]
[VectorCast(typeof(float4), true)]
public partial struct uint4
{
public static uint4 operator ~(uint4 value)
{
return new uint4(~value.X, ~value.Y, ~value.Z, ~value.W);
}
}
ScriptCore/Math/Vector2.cs
-122
View File
@@ -1,122 +0,0 @@
using System;
using System.Runtime.CompilerServices;
namespace GlitchyEngine.Math;
public struct Vector2
{
public static readonly Vector2 Zero = new(0.0f, 0.0f);
public static readonly Vector2 UnitX = new(1.0f, 0.0f);
public static readonly Vector2 UnitY = new(0.0f, 1.0f);
public static readonly Vector2 One = new(0.0f, 0.0f);
public const int ComponentCount = 2;
public float X, Y;
public Vector2()
{
X = Y = 0.0f;
}
public Vector2(float x, float y)
{
X = x;
Y = y;
}
public float this[int index]
{
get
{
switch(index)
{
case 0: return X;
case 1: return Y;
default: throw new IndexOutOfRangeException();
}
}
set
{
switch(index)
{
case 0:
X = value;
break;
case 1:
Y = value;
break;
default: throw new IndexOutOfRangeException();
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator +(in Vector2 a, in Vector2 b) => new(a.X + b.X, a.Y + b.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator +(float a, in Vector2 b) => new(a + b.X, a + b.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator +(in Vector2 a, float b) => new(a.X + b, a.Y + b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator +(in Vector2 a) => a;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator -(in Vector2 a, in Vector2 b) => new(a.X - b.X, a.Y - b.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator -(float a, in Vector2 b) => new(a - b.X, a - b.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator -(in Vector2 a, float b) => new(a.X - b, a.Y - b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator -(in Vector2 a) => new Vector2(-a.X, -a.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator *(in Vector2 a, in Vector2 b) => new(a.X * b.X, a.Y * b.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator *(float a, in Vector2 b) => new(a * b.X, a * b.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator *(in Vector2 a, float b) => new(a.X * b, a.Y * b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator /(in Vector2 a, in Vector2 b) => new(a.X / b.X, a.Y / b.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator /(float a, in Vector2 b) => new(a / b.X, a / b.Y);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator /(in Vector2 a, float b) => new(a.X / b, a.Y / b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator ==(Vector2 a, Vector2 b)
{
float diffX = a.X - b.X;
float diffY = a.Y - b.Y;
return diffX * diffX + diffY * diffY < 0.00001f;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator !=(Vector2 a, Vector2 b)
{
return !(a == b);
}
public float Length()
{
return (float)System.Math.Sqrt(X * X + Y * Y);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = X.GetHashCode();
hashCode = (hashCode * 397) ^ Y.GetHashCode();
return hashCode;
}
}
public override string ToString()
{
return $"X:{X}, Y:{Y}";
}
}
ScriptCore/Math/Vector3.cs
-139
View File
@@ -1,139 +0,0 @@
using System;
using System.CodeDom;
using System.Runtime.CompilerServices;
namespace GlitchyEngine.Math;
public struct Vector3
{
public static readonly Vector3 Zero = new(0.0f, 0.0f, 0.0f);
public static readonly Vector3 UnitX = new(1.0f, 0.0f, 0.0f);
public static readonly Vector3 UnitY = new(0.0f, 1.0f, 0.0f);
public static readonly Vector3 UnitZ = new(0.0f, 0.0f, 1.0f);
public static readonly Vector3 One = new(0.0f, 0.0f, 0.0f);
public static readonly Vector3 Forward = new(0.0f, 0.0f, 1.0f);
public static readonly Vector3 Backward = new(0.0f, 0.0f, -1.0f);
public static readonly Vector3 Left = new(-1.0f, 0.0f, 0.0f);
public static readonly Vector3 Right = new(1.0f, 0.0f, 0.0f);
public static readonly Vector3 Up = new(0.0f, 1.0f, 0.0f);
public static readonly Vector3 Down = new(0.0f, -1.0f, 0.0f);
public const int ComponentCount = 3;
public float X, Y, Z;
public Vector3()
{
X = Y = Z = 0.0f;
}
public Vector3(float x, float y, float z)
{
X = x;
Y = y;
Z = z;
}
public Vector3(Vector2 xy, float z)
{
X = xy.X;
Y = xy.Y;
Z = z;
}
public float this[int index]
{
get
{
switch(index)
{
case 0: return X;
case 1: return Y;
case 2: return Z;
default: throw new IndexOutOfRangeException();
}
}
set
{
switch(index)
{
case 0:
X = value;
break;
case 1:
Y = value;
break;
case 2:
Z = value;
break;
default: throw new IndexOutOfRangeException();
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator +(in Vector3 a, in Vector3 b) => new(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator +(float a, in Vector3 b) => new(a + b.X, a + b.Y, a + b.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator +(in Vector3 a, float b) => new(a.X + b, a.Y + b, a.Z + b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator +(in Vector3 a) => a;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator -(in Vector3 a, in Vector3 b) => new(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator -(float a, in Vector3 b) => new(a - b.X, a - b.Y, a - b.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator -(in Vector3 a, float b) => new(a.X - b, a.Y - b, a.Z - b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator -(in Vector3 a) => new Vector3(-a.X, -a.Y, -a.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator *(in Vector3 a, in Vector3 b) => new(a.X * b.X, a.Y * b.Y, a.Z * b.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator *(float a, in Vector3 b) => new(a * b.X, a * b.Y, a * b.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator *(in Vector3 a, float b) => new(a.X * b, a.Y * b, a.Z * b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator /(in Vector3 a, in Vector3 b) => new(a.X / b.X, a.Y / b.Y, a.Z / b.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator /(float a, in Vector3 b) => new(a / b.X, a / b.Y, a / b.Z);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector3 operator /(in Vector3 a, float b) => new(a.X / b, a.Y / b, a.Z / b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator ==(Vector3 a, Vector3 b)
{
float diffX = a.X - b.X;
float diffY = a.Y - b.Y;
float diffZ = a.Z - b.Z;
return diffX * diffX + diffY * diffY + diffZ * diffZ < 0.00001f;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator !=(Vector3 a, Vector3 b)
{
return !(a == b);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = X.GetHashCode();
hashCode = (hashCode * 397) ^ Y.GetHashCode();
hashCode = (hashCode * 397) ^ Z.GetHashCode();
return hashCode;
}
}
public override string ToString()
{
return $"X:{X}, Y:{Y}, Z:{Z}";
}
}
ScriptCore/Math/Vector4.cs
-155
View File
@@ -1,155 +0,0 @@
using System;
using System.Runtime.CompilerServices;
namespace GlitchyEngine.Math;
public struct Vector4
{
//public static readonly Vector3 Zero = new(0.0f, 0.0f, 0.0f);
//public static readonly Vector3 UnitX = new(1.0f, 0.0f, 0.0f);
//public static readonly Vector3 UnitY = new(0.0f, 1.0f, 0.0f);
//public static readonly Vector3 UnitZ = new(0.0f, 0.0f, 1.0f);
//public static readonly Vector3 One = new(0.0f, 0.0f, 0.0f);
//public static readonly Vector3 Forward = new(0.0f, 0.0f, 1.0f);
//public static readonly Vector3 Backward = new(0.0f, 0.0f, -1.0f);
//public static readonly Vector3 Left = new(-1.0f, 0.0f, 0.0f);
//public static readonly Vector3 Right = new(1.0f, 0.0f, 0.0f);
//public static readonly Vector3 Up = new(0.0f, 1.0f, 0.0f);
//public static readonly Vector3 Down = new(0.0f, -1.0f, 0.0f);
public const int ComponentCount = 4;
public float X, Y, Z, W;
public Vector4()
{
X = Y = Z = W = 0.0f;
}
public Vector4(float x, float y, float z, float w)
{
X = x;
Y = y;
Z = z;
W = w;
}
public Vector4(Vector2 xy, Vector2 zw)
{
X = xy.X;
Y = xy.Y;
Z = zw.X;
W = zw.Y;
}
public Vector4(Vector3 xyz, float w)
{
X = xyz.X;
Y = xyz.Y;
Z = xyz.Z;
W = w;
}
public float this[int index]
{
get
{
switch (index)
{
case 0: return X;
case 1: return Y;
case 2: return Z;
case 3: return W;
default: throw new IndexOutOfRangeException();
}
}
set
{
switch (index)
{
case 0:
X = value;
break;
case 1:
Y = value;
break;
case 2:
Z = value;
break;
case 3:
W = value;
break;
default: throw new IndexOutOfRangeException();
}
}
}
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator +(in Vector3 a, in Vector3 b) => new(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator +(float a, in Vector3 b) => new(a + b.X, a + b.Y, a + b.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator +(in Vector3 a, float b) => new(a.X + b, a.Y + b, a.Z + b);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator +(in Vector3 a) => a;
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator -(in Vector3 a, in Vector3 b) => new(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator -(float a, in Vector3 b) => new(a - b.X, a - b.Y, a - b.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator -(in Vector3 a, float b) => new(a.X - b, a.Y - b, a.Z - b);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator -(in Vector3 a) => new Vector3(-a.X, -a.Y, -a.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator *(in Vector3 a, in Vector3 b) => new(a.X * b.X, a.Y * b.Y, a.Z * b.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator *(float a, in Vector3 b) => new(a * b.X, a * b.Y, a * b.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator *(in Vector3 a, float b) => new(a.X * b, a.Y * b, a.Z * b);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator /(in Vector3 a, in Vector3 b) => new(a.X / b.X, a.Y / b.Y, a.Z / b.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator /(float a, in Vector3 b) => new(a / b.X, a / b.Y, a / b.Z);
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
//public static Vector3 operator /(in Vector3 a, float b) => new(a.X / b, a.Y / b, a.Z / b);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator ==(Vector4 a, Vector4 b)
{
float diffX = a.X - b.X;
float diffY = a.Y - b.Y;
float diffZ = a.Z - b.Z;
float diffW = a.W - b.W;
return diffX * diffX + diffY * diffY + diffZ * diffZ + diffW * diffW < 0.00001f;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator !=(Vector4 a, Vector4 b)
{
return !(a == b);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = X.GetHashCode();
hashCode = (hashCode * 397) ^ Y.GetHashCode();
hashCode = (hashCode * 397) ^ Z.GetHashCode();
hashCode = (hashCode * 397) ^ Z.GetHashCode();
return hashCode;
}
}
public override string ToString()
{
return $"X:{X}, Y:{Y}, Z:{Z}, W:{W}";
}
}
ScriptCore/Math/float2.cs
-22
View File
@@ -1,22 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using GlitchyEngine.Math;
using ScriptCore.Math.Attributes;
namespace GlitchyEngine.Math;
[Vector(typeof(float), 2, "float")]
public partial struct float2
{
}
[Vector(typeof(float), 3, "float")]
public partial struct float3
{
}
[Vector(typeof(float), 4, "float")]
public partial struct float4
{
}
ScriptCore/Physics2D.cs
+2 -2
View File
@@ -10,11 +10,11 @@ public static class Physics2D
/// <summary>
/// Gets or sets the gravity of the current scene.
/// </summary>
public static Vector2 Gravity
public static float2 Gravity
{
get
{
ScriptGlue.Physics2D_GetGravity(out Vector2 gravity);
ScriptGlue.Physics2D_GetGravity(out float2 gravity);
return gravity;
}
set => ScriptGlue.Physics2D_SetGravity(in value);
ScriptCore/ScriptCore.csproj
+4
View File
@@ -11,6 +11,10 @@
<Exec Command="PowerShell ./postbuild.ps1 -sourceDir $(OutDir) -destinationDir &quot;..\GlitchyEditor\resources\scripts&quot;" />
</Target>
<ItemGroup>
<PackageReference Include="Half" Version="1.0.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ScriptCoreGenerator\ScriptCoreGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
</ItemGroup>
ScriptCore/ScriptCore.csproj.DotSettings
+2
View File
@@ -0,0 +1,2 @@
<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=generated/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
ScriptCore/ScriptGlue.cs
+22 -6
View File
@@ -32,31 +32,47 @@ internal static class ScriptGlue
#region TransformComponent
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void Transform_GetTranslation(UUID entityId, out Vector3 translation);
internal static extern void Transform_GetTranslation(UUID entityId, out float3 translation);
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void Transform_SetTranslation(UUID entityId, in Vector3 translation);
internal static extern void Transform_SetTranslation(UUID entityId, in float3 translation);
#endregion TransformComponent
#region RigidBody2D
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void RigidBody2D_ApplyForce(UUID entityId, in Vector2 force, Vector2 point, bool wakeUp);
internal static extern void RigidBody2D_ApplyForce(UUID entityId, in float2 force, float2 point, bool wakeUp);
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void RigidBody2D_ApplyForceToCenter(UUID entityId, in Vector2 force, bool wakeUp);
internal static extern void RigidBody2D_ApplyForceToCenter(UUID entityId, in float2 force, bool wakeUp);
#endregion RigidBody2D
#region Physics2D
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void Physics2D_GetGravity(out Vector2 gravity);
internal static extern void Physics2D_GetGravity(out float2 gravity);
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void Physics2D_SetGravity(in Vector2 gravity);
internal static extern void Physics2D_SetGravity(in float2 gravity);
#endregion Physics2D
#region Math
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern float modf_float(float x, out float integerPart);
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern float2 modf_float2(float2 x, out float2 integerPart);
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern float3 modf_float3(float3 x, out float3 integerPart);
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern float4 modf_float4(float4 x, out float4 integerPart);
#endregion
}