public bool IntersectsPlane(GodotPlane plane) { GodotVector3[] vector3Array = new GodotVector3[8] { new GodotVector3(position.x, position.y, position.z), new GodotVector3(position.x, position.y, position.z + size.z), new GodotVector3(position.x, position.y + size.y, position.z), new GodotVector3(position.x, position.y + size.y, position.z + size.z), new GodotVector3(position.x + size.x, position.y, position.z), new GodotVector3(position.x + size.x, position.y, position.z + size.z), new GodotVector3(position.x + size.x, position.y + size.y, position.z), new GodotVector3(position.x + size.x, position.y + size.y, position.z + size.z) }; bool flag1 = false; bool flag2 = false; for (int index = 0; index < 8; ++index) { if (plane.DistanceTo(vector3Array[index]) > 0.0) { flag1 = true; } else { flag2 = true; } } return(flag2 & flag1); }
public GodotAABB Expand(GodotVector3 to_point) { GodotVector3 position = this.position; GodotVector3 vector3 = this.position + size; if (to_point.x < (double)position.x) { position.x = to_point.x; } if (to_point.y < (double)position.y) { position.y = to_point.y; } if (to_point.z < (double)position.z) { position.z = to_point.z; } if (to_point.x > (double)vector3.x) { vector3.x = to_point.x; } if (to_point.y > (double)vector3.y) { vector3.y = to_point.y; } if (to_point.z > (double)vector3.z) { vector3.z = to_point.z; } return(new GodotAABB(position, vector3 - position)); }
public GodotAABB Intersection(GodotAABB with) { GodotVector3 position1 = position; GodotVector3 vector3_1 = position + size; GodotVector3 position2 = with.position; GodotVector3 vector3_2 = with.position + with.size; if (position1.x > vector3_2.x || vector3_1.x < position2.x) { return(new GodotAABB()); } GodotVector3 position3; position3.x = position1.x > position2.x ? position1.x : position2.x; GodotVector3 vector3_3; vector3_3.x = vector3_1.x < vector3_2.x ? vector3_1.x : vector3_2.x; if (position1.y > vector3_2.y || vector3_1.y < position2.y) { return(new GodotAABB()); } position3.y = position1.y > position2.y ? position1.y : position2.y; vector3_3.y = vector3_1.y < vector3_2.y ? vector3_1.y : vector3_2.y; if (position1.z > vector3_2.z || vector3_1.z < position2.z) { return(new GodotAABB()); } position3.z = position1.z > position2.z ? position1.z : position2.z; vector3_3.z = vector3_1.z < vector3_2.z ? vector3_1.z : vector3_2.z; return(new GodotAABB(position3, vector3_3 - position3)); }
public GodotTransform LookingAt(GodotVector3 target, GodotVector3 up) { GodotTransform transform = this; transform.SetLookAt(origin, target, up); return(transform); }
public GodotBasis(GodotVector3 axis, float phi) { GodotVector3 vector3 = new GodotVector3(axis.x * axis.x, axis.y * axis.y, axis.z * axis.z); float num1 = GodotMathf.Cos(phi); float num2 = GodotMathf.Sin(phi); x = new GodotVector3(vector3.x + (num1 * (1f - vector3.x)), (float)((axis.x * axis.y * (1.0 - num1)) - (axis.z * num2)), (float)((axis.z * axis.x * (1.0 - num1)) + (axis.y * num2))); y = new GodotVector3((float)((axis.x * axis.y * (1.0 - num1)) + (axis.z * num2)), vector3.y + (num1 * (1f - vector3.y)), (float)((axis.y * axis.z * (1.0 - num1)) - (axis.x * num2))); z = new GodotVector3((float)((axis.z * axis.x * (1.0 - num1)) - (axis.y * num2)), (float)((axis.y * axis.z * (1.0 - num1)) + (axis.x * num2)), vector3.z + (num1 * (1f - vector3.z))); }
public GodotAABB Merge(GodotAABB with) { GodotVector3 position1 = position; GodotVector3 position2 = with.position; GodotVector3 vector3_1 = new GodotVector3(size.x, size.y, size.z) + position1; GodotVector3 vector3_2 = new GodotVector3(with.size.x, with.size.y, with.size.z) + position2; GodotVector3 position3 = new GodotVector3(position1.x < position2.x ? position1.x : position2.x, position1.y < position2.y ? position1.y : position2.y, position1.z < position2.z ? position1.z : position2.z); GodotVector3 vector3_3 = new GodotVector3(vector3_1.x > vector3_2.x ? vector3_1.x : vector3_2.x, vector3_1.y > vector3_2.y ? vector3_1.y : vector3_2.y, vector3_1.z > vector3_2.z ? vector3_1.z : vector3_2.z); return(new GodotAABB(position3, vector3_3 - position3)); }
public bool Encloses(GodotAABB with) { GodotVector3 position1 = position; GodotVector3 vector3_1 = position + size; GodotVector3 position2 = with.position; GodotVector3 vector3_2 = with.position + with.size; if (position1.x <= position2.x && vector3_1.x > (double)vector3_2.x && (position1.y <= (double)position2.y && vector3_1.y > (double)vector3_2.y) && position1.z <= (double)position2.z) { return(vector3_1.z > vector3_2.z); } return(false); }
public GodotVector3 Xform(GodotVector3 v) { GodotVector3 vector3 = this[0]; float num1 = vector3.Dot(v); vector3 = this[1]; float num2 = vector3.Dot(v); vector3 = this[2]; float num3 = vector3.Dot(v); return(new GodotVector3(num1, num2, num3)); }
public void SetLookAt(GodotVector3 eye, GodotVector3 target, GodotVector3 up) { GodotVector3 vector3_1 = eye - target; vector3_1.Normalize(); GodotVector3 vector3_2 = up.Cross(vector3_1); GodotVector3 yAxis = vector3_1.Cross(vector3_2); vector3_2.Normalize(); yAxis.Normalize(); basis = GodotBasis.CreateFromAxes(vector3_2, yAxis, vector3_1); origin = eye; }
public GodotBasis Orthonormalized() { GodotVector3 axis1 = GetAxis(0); GodotVector3 axis2 = GetAxis(1); GodotVector3 axis3 = GetAxis(2); axis1.Normalize(); GodotVector3 yAxis = axis2 - (axis1 * axis1.Dot(axis2)); yAxis.Normalize(); GodotVector3 zAxis = axis3 - (axis1 * axis1.Dot(axis3)) - (yAxis * yAxis.Dot(axis3)); zAxis.Normalize(); return(CreateFromAxes(axis1, yAxis, zAxis)); }
public GodotBasis( float xx, float xy, float xz, float yx, float yy, float yz, float zx, float zy, float zz) { x = new GodotVector3(xx, xy, xz); y = new GodotVector3(yx, yy, yz); z = new GodotVector3(zx, zy, zz); }
public GodotBasis Scaled(GodotVector3 scale) { GodotBasis basis = this; basis[0, 0] *= scale.x; basis[0, 1] *= scale.x; basis[0, 2] *= scale.x; basis[1, 0] *= scale.y; basis[1, 1] *= scale.y; basis[1, 2] *= scale.y; basis[2, 0] *= scale.z; basis[2, 1] *= scale.z; basis[2, 2] *= scale.z; return(basis); }
public bool IntersectsSegment(GodotVector3 from, GodotVector3 to) { float num1 = 0.0f; float num2 = 1f; for (int index = 0; index < 3; ++index) { float num3 = from[index]; float num4 = to[index]; float num5 = position[index]; float num6 = num5 + size[index]; float num7; float num8; if (num3 < num4) { if (num3 > num6 || num4 < num5) { return(false); } float num9 = num4 - num3; num7 = num3 < num5 ? (num5 - num3) / num9 : 0.0f; num8 = num4 > num6 ? (num6 - num3) / num9 : 1f; } else { if (num4 > num6 || num3 < num5) { return(false); } float num9 = num4 - num3; num7 = num3 > num6 ? (num6 - num3) / num9 : 0.0f; num8 = num4 < num5 ? (num5 - num3) / num9 : 1f; } if (num7 > num1) { num1 = num7; } if (num8 < num2) { num2 = num8; } if (num2 < num1) { return(false); } } return(true); }
public GodotVector3 IntersectRay(GodotVector3 from, GodotVector3 dir) { float s = normal.Dot(dir); if (GodotMathf.Abs(s) <= 9.99999997475243E-07) { return(new GodotVector3()); } float num = (normal.Dot(from) - d) / s; if (num > 9.99999997475243E-07) { return(new GodotVector3()); } return(from + (dir * -num)); }
public GodotVector3 GetShortestAxis() { GodotVector3 vector3 = new GodotVector3(1f, 0.0f, 0.0f); float num = size.x; if (size.y < num) { vector3 = new GodotVector3(0.0f, 1f, 0.0f); num = size.y; } if (size.z < num) { vector3 = new GodotVector3(0.0f, 0.0f, 1f); float z = size.z; } return(vector3); }
public GodotVector3 IntersectSegment(GodotVector3 begin, GodotVector3 end) { GodotVector3 b = begin - end; float s = normal.Dot(b); if (GodotMathf.Abs(s) <= 9.99999997475243E-07) { return(new GodotVector3()); } float num = (normal.Dot(begin) - d) / s; if (num < -9.99999997475243E-07 || num > 1.00000095367432) { return(new GodotVector3()); } return(begin + (b * -num)); }
public GodotBasis(GodotQuat quat) { float qdot = 2f / quat.LengthSquared(); float qx = quat.x * qdot; float qy = quat.y * qdot; float qz = quat.z * qdot; float qwx = quat.w * qx; float qwy = quat.w * qy; float qwz = quat.w * qz; float qxx = quat.x * qx; float qxy = quat.x * qy; float qxz = quat.x * qz; float qyy = quat.y * qy; float qyz = quat.y * qz; float qzz = quat.z * qz; x = new GodotVector3(1.0f - (qyy + qzz), qxy - qwz, qxz + qwy); y = new GodotVector3(qxy + qwz, 1.0f - (qxx + qzz), qyz - qwx); z = new GodotVector3(qxz - qwy, qyz + qwx, 1.0f - (qxx + qyy)); }
public GodotQuat(GodotVector3 axis, float angle) { float num1 = axis.Length(); if (num1 == 0.0) { x = 0.0f; y = 0.0f; z = 0.0f; w = 0.0f; } else { float num2 = GodotMathf.Sin(angle * 0.5f) / num1; x = axis.x * num2; y = axis.y * num2; z = axis.z * num2; w = GodotMathf.Cos(angle * 0.5f); } }
public GodotVector3 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(); } } }
public bool HasPoint(GodotVector3 point) { return(point.x >= position.x && point.y >= position.y && (point.z >= position.z && point.x <= position.x + size.x) && (point.y <= position.y + size.y && point.z <= position.z + size.z)); }
public GodotTransform Scaled(GodotVector3 scale) { return(new GodotTransform(basis.Scaled(scale), origin * scale)); }
public GodotAABB(GodotVector3 position, GodotVector3 size) { this.position = position; this.size = size; }
public GodotBasis(GodotVector3 xAxis, GodotVector3 yAxis, GodotVector3 zAxis) { x = xAxis; y = yAxis; z = zAxis; }
public GodotVector3 XformInv(GodotVector3 v) { return(new GodotVector3((this[0, 0] * v.x) + (this[1, 0] * v.y) + (this[2, 0] * v.z), (this[0, 1] * v.x) + (this[1, 1] * v.y) + (this[2, 1] * v.z), (this[0, 2] * v.x) + (this[1, 2] * v.y) + (this[2, 2] * v.z))); }
public GodotVector3 Xform(GodotVector3 v) { GodotQuat quat = this * v *Inverse(); return(new GodotVector3(quat.x, quat.y, quat.z)); }
public GodotTransform Rotated(GodotVector3 axis, float phi) { return(new GodotTransform(new GodotBasis(axis, phi), new GodotVector3()) * this); }
public float Tdotz(GodotVector3 with) { return((this[0, 2] * with[0]) + (this[1, 2] * with[1]) + (this[2, 2] * with[2])); }
public GodotTransform Translated(GodotVector3 ofs) { GodotBasis basis = this.basis; ref GodotVector3 local1 = ref this.origin;
public GodotBasis Rotated(GodotVector3 axis, float phi) { return(new GodotBasis(axis, phi) * this); }
internal static GodotBasis CreateFromAxes(GodotVector3 xAxis, GodotVector3 yAxis, GodotVector3 zAxis) { return(new GodotBasis(new GodotVector3(xAxis.x, yAxis.x, zAxis.x), new GodotVector3(xAxis.y, yAxis.y, zAxis.y), new GodotVector3(xAxis.z, yAxis.z, zAxis.z))); }