//Structure public Pixel4F(float v1, float v2, float v3, float v4) { this.m_v1 = UMath.Clamp01(v1); this.m_v2 = UMath.Clamp01(v2); this.m_v3 = UMath.Clamp01(v3); this.m_v4 = UMath.Clamp01(v4); }
public static unsafe Vec4 operator *(Vec4 left, float right) { #if IMOET_UNSAFE UMath.MassMultiply((float *)&left, right, 4); return(left); #else return(new Vec4(left.x * right, left.y * right, left.z * right, left.w * right)); #endif }
public static unsafe Vec4 operator /(Vec4 left, float right) { #if IMOET_UNSAFE UMath.MassDivided((float *)&left, right, 4); return(left); #else return(new Vec4(left.x / right, left.y / right, left.z / right, left.w / right)); #endif }
//Operator public static Matrix4x4 operator +(Matrix4x4 a, Matrix4x4 b) { #if IMOET_UNSAFE Matrix4x4 m = new Matrix4x4(); UMath.MassAdd(a.Ptr, b.Ptr, m.Ptr, 9); return(m); #else return(UMath.AddMatrix(a, b)); #endif }
public static unsafe Vec3 operator *(Vec3 l, float r) { #if IMOET_UNSAFE Vec3 res = l; UMath.MassMultiply((float *)&res, r, 3); return(res); #else return(new Vec3(l.x * r, l.y * r, l.z * r)); #endif }
public static unsafe Vec4 operator -(Vec4 left, Vec4 right) { #if IMOET_UNSAFE var res = default(Vec4); UMath.MassAdd((float *)&left, (float *)&right, (float *)&res, 4); return(res); #else return(new Vec4(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.z)); #endif }
//Operator public static Matrix3x3 operator +(Matrix3x3 a, Matrix3x3 b) { #if IMOET_UNSAFE var m = a; UMath.MassAdd(a.Ptr, b.Ptr, m.Ptr, 9); return(m); #else return(UMath.AddMatrix(a, b)); #endif }
public static unsafe Vec3 operator +(Vec3 l, Vec3 r) { #if IMOET_UNSAFE Vec3 res = zero; UMath.MassAdd((float *)&l, (float *)&r, (float *)&res, 3); return(res); #else return(new Vec3(l.x + r.x, l.y + r.y, l.z + r.z)); #endif }
public static Matrix3x3 operator -(Matrix3x3 a, Matrix3x3 b) { #if IMOET_UNSAFE Matrix3x3 m = new Matrix3x3(); UMath.MassSubtract(a.Ptr, b.Ptr, m.Ptr, 9); return(m); #else return(UMath.SubtractMatrix(a, b)); #endif }
public static unsafe Vec2 operator *(Vec2 a, float d) { #if IMOET_UNSAFE Vec2 res = a; UMath.MassMultiply((float *)&res, d, 2); return(res); #else return(new Vec2(a.x * d, a.y * d)); #endif }
public static unsafe Vec2 operator -(Vec2 a, Vec2 b) { #if IMOET_UNSAFE Vec2 res = zero; UMath.MassSubtract((float *)&a, (float *)&b, (float *)&res, 2); return(res); #else return(new Vec2(a.x - b.x, a.y - b.y)); #endif }
public static unsafe Vec3 operator -(Vec3 l, Vec3 r) { #if IMOET_UNSAFE Vec3 res = zero; UMath.MassSubtract((float *)&l, (float *)&r, (float *)&res, 3); return(res); #else return(new Vec3(l.x - r.x, l.y - r.y, l.z - r.z)); #endif }
public static unsafe Vec2 operator /(Vec2 a, float d) { #if IMOET_UNSAFE Vec2 res = a; UMath.MassDivided((float *)&a, d, 2); return(res); #else return(new Vec2(a.x / d, a.y / d)); #endif }
public void GetCorner(Vec2[] corner) { if (corner == null) { throw new ArgumentNullException("Corner must not null array"); } int count = corner.Length; count = (int)UMath.Clamp(count, 0, 4); for (int i = 0; i < count; i++) { corner[0] = new Vec2(x, y); corner[1] = new Vec2(x + width, y); corner[2] = new Vec2(x, y + height); corner[3] = new Vec2(x + width, y + height); } }
public Vec3 Evaluate(float amount, CurveType type) { if (m_points.Count < 2) { throw new ArgumentException("Number of CurverPoint is less than 2"); } //Evaluate Point Only At particular time //Find Which "Pair" that we want to calculate var tr = 1.0f / (m_points.Count - 1); var tIdxF = UMath.LerpPercent(amount - 0.0000001f, 0.0f, tr); var tIdx = (int)UMath.Floor(tIdxF); var r = tIdxF - tIdx; //Get Point var p0 = m_points[tIdx].point; var p1 = m_points[tIdx].handleB; var p2 = m_points[tIdx + 1].handleA; var p3 = m_points[tIdx + 1].point; //Apply calculation var u = 1f - r; var u2 = u * u; var u3 = u2 * u; var r2 = r * r; var r3 = r2 * r; switch (type) { case CurveType.Linear: return(p0 + (p1 - p0) * r); case CurveType.Bezier: return(u3 * p0 + (3f * u2 * r) * p1 + (3f * u * r2) * p2 + r3 * p3); case CurveType.CatmullRom: return(0.5f * (2.0f * p0 + (p3 - p1) * r + (2.0f * p1 - 5.0f * p0 + 4.0f * p3 - p2) * r2 + (-p1 + 3.0f * p0 - 3.0f * p3 + p2) * r3)); case CurveType.Hermite: return((2 * p0 - 2 * p3 + p3 + p1) * r3 + (3 * p3 - 3 * p0 - 2 * p1 - p2) * r2 + p1 * r + p0); default: throw new ArgumentException("Something Goes Wrong"); } }
public static Vec2 SmoothDamp(Vec2 current, Vec2 target, ref Vec2 currentVelocity, float smoothTime, float maxSpeed, float deltaTime) { smoothTime = UMath.Max(0.0001f, smoothTime); float num = 2f / smoothTime; float num2 = num * deltaTime; float d = 1f / (1f + num2 + 0.48f * num2 * num2 + 0.235f * num2 * num2 * num2); Vec2 vector = current - target; Vec2 Vec2 = target; float maxLength = maxSpeed * smoothTime; vector = ClampMagnitude(vector, maxLength); target = current - vector; Vec2 vector3 = (currentVelocity + num * vector) * deltaTime; currentVelocity = (currentVelocity - num * vector3) * d; Vec2 vector4 = target + (vector + vector3) * d; if (Dot(Vec2 - current, vector4 - Vec2) > 0f) { vector4 = Vec2; currentVelocity = (vector4 - Vec2) / deltaTime; } return(vector4); }
public static Vec2 LerpClamped(Vec2 from, Vec2 to, float t) { t = UMath.Clamp01(t); return(new Vec2(from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t)); }
public static Matrix3x3 operator -(Matrix3x3 a) { return(UMath.MultiplyMatrix(a, -1)); }
public static Matrix3x3 operator /(Matrix3x3 a, float b) { return(UMath.DivideMatrix(a, b)); }
public static Matrix3x3 operator *(Matrix3x3 a, float b) { return(UMath.MultiplyMatrix(a, b)); }
public static float AngleRad(Vec2 from, Vec3 to) { return(UMath.Acos(UMath.Clamp(Vec2.Dot(from.normalized, to.normalized), -1f, 1f))); }
public override int GetHashCode() { return(UMath.Max(x + y + z, int.MaxValue).GetHashCode()); }
//Structure public Pixel3F(float v1, float v2, float v3) { this.m_v1 = UMath.Clamp01(v1); this.m_v2 = UMath.Clamp01(v2); this.m_v3 = UMath.Clamp01(v3); }
public static Matrix4x4 operator *(Matrix4x4 a, Matrix4x4 b) { return(UMath.MultiplyMatrix(a, b)); }