135 lines
3.8 KiB
GDScript
135 lines
3.8 KiB
GDScript
extends Node
|
|
class_name SummerDayMathHelper
|
|
|
|
|
|
static func matrix_to_points(
|
|
p01: Vector2, p02: Vector2, p03: Vector2, p04: Vector2
|
|
) -> Basis:
|
|
var j = p01.x - p02.x - p03.x + p04.x
|
|
if j == 0.0:
|
|
j = 0.00000001
|
|
var k = -p01.x - p02.x + p03.x + p04.x
|
|
var l = -p01.x + p02.x - p03.x + p04.x
|
|
var m = p01.y - p02.y - p03.y + p04.y
|
|
var n = -p01.y - p02.y + p03.y + p04.y
|
|
var o = -p01.y + p02.y - p03.y + p04.y
|
|
var i = 1;
|
|
|
|
var q = m * k - j * n
|
|
if q == 0.0:
|
|
q = 0.00000001
|
|
|
|
var h = (j * o - m * l) * i / q
|
|
var g = (k * h + l * i) / j
|
|
var f = (p01.y * (g + h + i) + p03.y * (-g - h + i)) / 2
|
|
var e = (p01.y * (g + h + i) - p02.y * (g - h + i)) / 2
|
|
var d = p01.y * (g + h + i) - f - e
|
|
var c = (p01.x * (g + h + i) + p03.x * (-g - h + i)) / 2
|
|
var b = (p01.x * (g + h + i) - p02.x * (g - h + i)) / 2
|
|
var a = p01.x * (g + h + i) - c - b
|
|
|
|
return Basis(
|
|
Vector3(a, d, g),
|
|
Vector3(b, e, h),
|
|
Vector3(c, f, i)
|
|
)
|
|
|
|
|
|
static func basis_from_to_points(
|
|
s01: Vector2, s02: Vector2, s03: Vector2, s04: Vector2,
|
|
d01: Vector2, d02: Vector2, d03: Vector2, d04: Vector2
|
|
):
|
|
var matrix_to_source = matrix_to_points(s01, s02, s03, s04)
|
|
var matrix_from_source = matrix_to_source.inverse()
|
|
|
|
var matrix_to_dest = matrix_to_points(d01, d02, d03, d04)
|
|
|
|
var from_source_to_dest = matrix_to_dest * matrix_from_source
|
|
return from_source_to_dest
|
|
|
|
|
|
# This just calculates a rotation-matrix that flattens the z-coordinates of
|
|
# the given Quad. You could also say that it makes the normal of the Quad
|
|
# point directly to the camera. (-z)
|
|
static func plane_to_xy_basis(
|
|
p01: Vector3, p02: Vector3, p03: Vector3, p04: Vector3
|
|
) -> Basis:
|
|
|
|
var sample_normal_01 = (p02 - p01).cross(p04 - p02).normalized()
|
|
var sample_normal_02 = (p03 - p02).cross(p04 - p03).normalized()
|
|
|
|
if sample_normal_01.dot(sample_normal_02) <= 0.99999:
|
|
push_error("The given form is not a plane and can" +
|
|
"therefore not be transformed correctly")
|
|
|
|
var normal = sample_normal_01.linear_interpolate(sample_normal_02, 0.5)
|
|
normal = normal.normalized()
|
|
|
|
var dest_normal = Vector3.BACK
|
|
|
|
if normal.dot(dest_normal) >= 0.99999:
|
|
return Basis()
|
|
|
|
var rot_axis = normal.cross(dest_normal).normalized()
|
|
var rot_angle = normal.dot(dest_normal)
|
|
|
|
var quad = Quat(-rot_axis, acos(rot_angle))
|
|
var basis = Basis(quad)
|
|
|
|
return basis.inverse()
|
|
|
|
|
|
# This basically takes four Vector3 that form a Quad somewhere in the
|
|
# space and a second (this time two-dimensional) Quad to calculate
|
|
# the transformation-matrix that is required to get from the former
|
|
# to the latter. Returned is said transformation-matrix.
|
|
static func plane_3d_to_xy(
|
|
p3d_01: Vector3, p3d_02: Vector3, p3d_03: Vector3, p3d_04: Vector3,
|
|
d_01: Vector2, d_02: Vector2, d_03: Vector2, d_04: Vector2):
|
|
|
|
var rotation_matrix = plane_to_xy_basis(
|
|
p3d_01, p3d_02,
|
|
p3d_03, p3d_04
|
|
)
|
|
|
|
var to_plane_transform = Transform(
|
|
rotation_matrix, Vector3(0.0, 0.0,
|
|
-rotation_matrix.xform(p3d_01).z
|
|
)
|
|
)
|
|
|
|
var plane_points = [
|
|
to_plane_transform.xform(p3d_01),
|
|
to_plane_transform.xform(p3d_02),
|
|
to_plane_transform.xform(p3d_03),
|
|
to_plane_transform.xform(p3d_04)
|
|
]
|
|
|
|
|
|
var xy_points = [
|
|
Vector2(plane_points[0].x, plane_points[0].y),
|
|
Vector2(plane_points[1].x, plane_points[1].y),
|
|
Vector2(plane_points[2].x, plane_points[2].y),
|
|
Vector2(plane_points[3].x, plane_points[3].y),
|
|
]
|
|
|
|
var basis_2d = basis_from_to_points(
|
|
xy_points[0], xy_points[1], xy_points[2], xy_points[3],
|
|
d_01, d_02, d_03, d_04)
|
|
|
|
var transform_2d = Transform(
|
|
Vector3(basis_2d.x.x, basis_2d.y.x, 0.0),
|
|
Vector3(basis_2d.x.y, basis_2d.y.y, 0.0),
|
|
Vector3.ZERO,
|
|
Vector3(basis_2d.x.z, basis_2d.y.z, 0.0)
|
|
)
|
|
|
|
var transform = transform_2d * to_plane_transform
|
|
|
|
var cool = SummerDayMatrix4.mult(
|
|
SummerDayMatrix4.from_Basis(basis_2d),
|
|
SummerDayMatrix4.from_Transform(to_plane_transform)
|
|
)
|
|
|
|
return cool
|