6132588926

Committed 09 Sep 2023 06:38PM UTC coverage: 14.013% (-44.7%) from 58.701%

Build # 6132588926

Build Type

push

github

Committed by

FatalError42O

Commit Message

fixed Busted support (hopefully)

Run Details

975 of 6958 relevant lines covered (14.01%)

10.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.26

/spec/mat4_spec.lua

local mat4        = require "modules.mat4"
local vec3        = require "modules.vec3"
local quat        = require "modules.quat"
local utils       = require "modules.utils"
local FLT_EPSILON = require("modules.constants").FLT_EPSILON

describe("mat4:", function()
        it("creates an identity matrix", function()
                local a = mat4()
                assert.is.equal(1, a[1])
                assert.is.equal(0, a[2])
                assert.is.equal(0, a[3])
                assert.is.equal(0, a[4])
                assert.is.equal(0, a[5])
                assert.is.equal(1, a[6])
                assert.is.equal(0, a[7])
                assert.is.equal(0, a[8])
                assert.is.equal(0, a[9])
                assert.is.equal(0, a[10])
                assert.is.equal(1, a[11])
                assert.is.equal(0, a[12])
                assert.is.equal(0, a[13])
                assert.is.equal(0, a[14])
                assert.is.equal(0, a[15])
                assert.is.equal(1, a[16])
                assert.is_true(a:is_mat4())
        end)

        it("creates a filled matrix", function()
                local a = mat4 {
                        3, 3, 3, 3,
                        4, 4, 4, 4,
                        5, 5, 5, 5,
                        6, 6, 6, 6
                }
                assert.is.equal(3, a[1])
                assert.is.equal(3, a[2])
                assert.is.equal(3, a[3])
                assert.is.equal(3, a[4])
                assert.is.equal(4, a[5])
                assert.is.equal(4, a[6])
                assert.is.equal(4, a[7])
                assert.is.equal(4, a[8])
                assert.is.equal(5, a[9])
                assert.is.equal(5, a[10])
                assert.is.equal(5, a[11])
                assert.is.equal(5, a[12])
                assert.is.equal(6, a[13])
                assert.is.equal(6, a[14])
                assert.is.equal(6, a[15])
                assert.is.equal(6, a[16])
        end)

        it("creates a filled matrix from vec4s", function()
                local a = mat4 {
                        { 3, 3, 3, 3 },
                        { 4, 4, 4, 4 },
                        { 5, 5, 5, 5 },
                        { 6, 6, 6, 6 }
                }
                assert.is.equal(3, a[1])
                assert.is.equal(3, a[2])
                assert.is.equal(3, a[3])
                assert.is.equal(3, a[4])
                assert.is.equal(4, a[5])
                assert.is.equal(4, a[6])
                assert.is.equal(4, a[7])
                assert.is.equal(4, a[8])
                assert.is.equal(5, a[9])
                assert.is.equal(5, a[10])
                assert.is.equal(5, a[11])
                assert.is.equal(5, a[12])
                assert.is.equal(6, a[13])
                assert.is.equal(6, a[14])
                assert.is.equal(6, a[15])
                assert.is.equal(6, a[16])
        end)

        it("creates a filled matrix from a 3x3 matrix", function()
                local a = mat4 {
                        3, 3, 3,
                        4, 4, 4,
                        5, 5, 5
                }
                assert.is.equal(3, a[1])
                assert.is.equal(3, a[2])
                assert.is.equal(3, a[3])
                assert.is.equal(0, a[4])
                assert.is.equal(4, a[5])
                assert.is.equal(4, a[6])
                assert.is.equal(4, a[7])
                assert.is.equal(0, a[8])
                assert.is.equal(5, a[9])
                assert.is.equal(5, a[10])
                assert.is.equal(5, a[11])
                assert.is.equal(0, a[12])
                assert.is.equal(0, a[13])
                assert.is.equal(0, a[14])
                assert.is.equal(0, a[15])
                assert.is.equal(1, a[16])
        end)

        it("creates a matrix from perspective", function()
                local a = mat4.from_perspective(45, 1, 0.1, 1000)
                assert.is_true(utils.tolerance( 2.414-a[1],  0.001))
                assert.is_true(utils.tolerance( 2.414-a[6],  0.001))
                assert.is_true(utils.tolerance(-1    -a[11], 0.001))
                assert.is_true(utils.tolerance(-1    -a[12], 0.001))
                assert.is_true(utils.tolerance(-0.2  -a[15], 0.001))
        end)

        it("creates a matrix from HMD perspective", function()
                local t = {
                        LeftTan  = 2.3465312,
                        RightTan = 0.9616399,
                        UpTan    = 2.8664987,
                        DownTan  = 2.8664987
                }
                local a = mat4.from_hmd_perspective(t, 0.1, 1000, false, false)
                assert.is_true(utils.tolerance(a[1] -  0.605, 0.001))
                assert.is_true(utils.tolerance(a[6] -  0.349, 0.001))
                assert.is_true(utils.tolerance(a[9] - -0.419, 0.001))
                assert.is_true(utils.tolerance(a[11]- -1.000, 0.001))
                assert.is_true(utils.tolerance(a[12]- -1.000, 0.001))
                assert.is_true(utils.tolerance(a[15]- -0.200, 0.001))
        end)

        it("clones a matrix", function()
                local a = mat4.identity()
                local b = a:clone()
                assert.is.equal(a, b)
        end)

        it("multiplies two 4x4 matrices", function()
                local a = mat4 {
                        1, 5, 9,  13,
                        2, 6, 10, 14,
                        3, 7, 11, 15,
                        4, 8, 12, 16
                }
                local b = mat4 {
                        1,  2,  3,  4,
                        5,  6,  7,  8,
                        9,  10, 11, 12,
                        13, 14, 15, 16
                }
                local c = mat4():mul(a, b)
                local d = a * b
                local e = mat4():mul{a, b}
                assert.is.equal(30,  c[1])
                assert.is.equal(70,  c[2])
                assert.is.equal(110, c[3])
                assert.is.equal(150, c[4])
                assert.is.equal(70,  c[5])
                assert.is.equal(174, c[6])
                assert.is.equal(278, c[7])
                assert.is.equal(382, c[8])
                assert.is.equal(110, c[9])
                assert.is.equal(278, c[10])
                assert.is.equal(446, c[11])
                assert.is.equal(614, c[12])
                assert.is.equal(150, c[13])
                assert.is.equal(382, c[14])
                assert.is.equal(614, c[15])
                assert.is.equal(846, c[16])
                assert.is.equal(c, d)
                assert.is.equal(c, e)
        end)

        it("multiplies a matrix and a vec4", function()
                local a = mat4 {
                        1,  2,  3,  4,
                        5,  6,  7,  8,
                        9,  10, 11, 12,
                        13, 14, 15, 16
                }
                local b = { 10, 20, 30, 40 }
                local c = mat4.mul_vec4(mat4(), a, b)
                local d = a * b
                assert.is.equal(900,  c[1])
                assert.is.equal(1000, c[2])
                assert.is.equal(1100, c[3])
                assert.is.equal(1200, c[4])

                assert.is.equal(c[1], d[1])
                assert.is.equal(c[2], d[2])
                assert.is.equal(c[3], d[3])
                assert.is.equal(c[4], d[4])
        end)

        it("verifies mat4 composition order", function()
                local a = mat4 {
                        1, 5, 9,  13,
                        2, 6, 10, 14,
                        3, 7, 11, 15,
                        4, 8, 12, 16
                }
                local b = mat4 {
                        2,  3,  5,  7,
                        11, 13, 17, 19,
                        23, 29, 31, 37,
                        41, 43, 47, 53
                }
                local c = mat4():mul(a, b)
                local d = a * b

                local v = { 10, 20, 30, 40 }

                local cv = c * v
                local abv = a*(b*v)

                assert.is.equal(cv.x, abv.x) -- Verify (a*b)*v == a*(b*v)
                assert.is.equal(cv.y, abv.y)
                assert.is.equal(cv.z, abv.z)
        end)

        it("scales a matrix", function()
                local a = mat4():scale(mat4(), vec3(5, 5, 5))
                assert.is.equal(5, a[1])
                assert.is.equal(5, a[6])
                assert.is.equal(5, a[11])
        end)

        it("rotates a matrix", function()
                local a = mat4():rotate(mat4(), math.rad(45), vec3.unit_z)
                assert.is_true(utils.tolerance( 0.7071-a[1], 0.001))
                assert.is_true(utils.tolerance( 0.7071-a[2], 0.001))
                assert.is_true(utils.tolerance(-0.7071-a[5], 0.001))
                assert.is_true(utils.tolerance( 0.7071-a[6], 0.001))
        end)

        it("translates a matrix", function()
                local a = mat4():translate(mat4(), vec3(5, 5, 5))
                assert.is.equal(5, a[13])
                assert.is.equal(5, a[14])
                assert.is.equal(5, a[15])
        end)

        it("inverts a matrix", function()
                local a = mat4()
                a = a:rotate(a, math.pi/4, vec3.unit_y)
                a = a:translate(a, vec3(4, 5, 6))

                local b = mat4.invert(mat4(), a)
                local c = a * b
                assert.is.equal(mat4(), c)

                local d = mat4()
                d:rotate(d, math.pi/4, vec3.unit_y)
                d:translate(d, vec3(4, 5, 6))

                local e = -d
                local f = d * e
                assert.is.equal(mat4(), f)
        end)

        it("transposes a matrix", function()
                local a = mat4({
                        1, 1, 1, 1,
                        2, 2, 2, 2,
                        3, 3, 3, 3,
                        4, 4, 4, 4
                })
                a = a:transpose(a)
                assert.is.equal(1, a[1])
                assert.is.equal(2, a[2])
                assert.is.equal(3, a[3])
                assert.is.equal(4, a[4])
                assert.is.equal(1, a[5])
                assert.is.equal(2, a[6])
                assert.is.equal(3, a[7])
                assert.is.equal(4, a[8])
                assert.is.equal(1, a[9])
                assert.is.equal(2, a[10])
                assert.is.equal(3, a[11])
                assert.is.equal(4, a[12])
                assert.is.equal(1, a[13])
                assert.is.equal(2, a[14])
                assert.is.equal(3, a[15])
                assert.is.equal(4, a[16])
        end)

        it("shears a matrix", function()
                local yx, zx, xy, zy, xz, yz = 1, 1, 1, -1, -1, -1
                local a = mat4():shear(mat4(), yx, zx, xy, zy, xz, yz)
                assert.is.equal( 1, a[2])
                assert.is.equal( 1, a[3])
                assert.is.equal( 1, a[5])
                assert.is.equal(-1, a[7])
                assert.is.equal(-1, a[9])
                assert.is.equal(-1, a[10])
        end)

        it("reflects a matrix along a plane", function()
                local origin = vec3(5, 1, 0)
                local normal = vec3(0, -1, 0):normalize()
                local a = mat4():reflect(mat4(), origin, normal)
                local p = a * vec3(-5, 2, 5)
                assert.is.equal(p.x, -5)
                assert.is.equal(p.y, 0)
                assert.is.equal(p.z, 5)
        end)

        it("projects a point into screen space", function()
                local znear = 0.1
                local zfar = 1000
                local proj = mat4.from_perspective(45, 1, znear, zfar)
                local vp = { 0, 0, 400, 400 }

                -- -z is away from the viewer into the far plane
                local p1 = vec3(0, 0, -znear)
                local c1 = mat4.project(p1, proj, vp)
                assert.is.near(0, c1.z, 0.0001)
                assert.is.equal(200, c1.x)
                assert.is.equal(200, c1.y)

                local p2 = vec3(0, 0, -zfar)
                local c2 = mat4.project(p2, proj, vp)
                assert.is.near(1, c2.z, 0.0001)
                assert.is.equal(200, c2.x)
                assert.is.equal(200, c2.y)

                local p3 = vec3(0, 0, zfar)
                local c3 = mat4.project(p3, proj, vp)
                assert.is_true(c3.z < 0)
                assert.is.equal(200, c3.x)
                assert.is.equal(200, c3.y)
        end)

        it("unprojects a point into world space", function()
                local p  = vec3(0, 0, -10)
                local proj = mat4.from_perspective(45, 1, 0.1, 1000)
                local vp = { 0, 0, 400, 400 }
                local c  = mat4.project(p, proj, vp)
                local d  = mat4.unproject(c, proj, vp)
                assert.is.near(0.0, p.x-d.x, 0.0001)
                assert.is.near(0.0, p.y-d.y, 0.0001)
                assert.is.near(0.0, p.z-d.z, 0.0001)
        end)

        it("transforms a matrix to look at a point", function()
                local e = vec3(0, 0, 1.55)
                local c = vec3(4, 7, 1)
                local u = vec3(0, 0, 1)
                local a = mat4():look_at(e, c, u)

                assert.is_true(utils.tolerance( 0.868-a[1], 0.001))
                assert.is_true(utils.tolerance( 0.034-a[2], 0.001))
                assert.is_true(utils.tolerance(-0.495-a[3], 0.001))
                assert.is_true(utils.tolerance( 0    -a[4], 0.001))

                assert.is_true(utils.tolerance(-0.496-a[5], 0.001))
                assert.is_true(utils.tolerance( 0.059-a[6], 0.001))
                assert.is_true(utils.tolerance(-0.866-a[7], 0.001))
                assert.is_true(utils.tolerance( 0    -a[8], 0.001))

                assert.is_true(utils.tolerance( 0    -a[9],  0.001))
                assert.is_true(utils.tolerance( 0.998-a[10], 0.001))
                assert.is_true(utils.tolerance( 0.068-a[11], 0.001))
                assert.is_true(utils.tolerance( 0    -a[12], 0.001))

                assert.is_true(utils.tolerance( 0    -a[13], 0.001))
                assert.is_true(utils.tolerance(-1.546-a[14], 0.001))
                assert.is_true(utils.tolerance(-0.106-a[15], 0.001))
                assert.is_true(utils.tolerance( 1    -a[16], 0.001))
        end)

        it("converts a matrix to vec4s", function()
                local a = mat4 {
                        1,  2,  3,  4,
                        5,  6,  7,  8,
                        9,  10, 11, 12,
                        13, 14, 15, 16
                }
                local v = a:to_vec4s()
                assert.is_true(type(v)    == "table")
                assert.is_true(type(v[1]) == "table")
                assert.is_true(type(v[2]) == "table")
                assert.is_true(type(v[3]) == "table")
                assert.is_true(type(v[4]) == "table")

                assert.is.equal(1,  v[1][1])
                assert.is.equal(2,  v[1][2])
                assert.is.equal(3,  v[1][3])
                assert.is.equal(4,  v[1][4])

                assert.is.equal(5,  v[2][1])
                assert.is.equal(6,  v[2][2])
                assert.is.equal(7,  v[2][3])
                assert.is.equal(8,  v[2][4])

                assert.is.equal(9,  v[3][1])
                assert.is.equal(10, v[3][2])
                assert.is.equal(11, v[3][3])
                assert.is.equal(12, v[3][4])

                assert.is.equal(13, v[4][1])
                assert.is.equal(14, v[4][2])
                assert.is.equal(15, v[4][3])
                assert.is.equal(16, v[4][4])
        end)

        it("converts a matrix to vec4s, column-wise", function()
                local a = mat4 {
                        1,  2,  3,  4,
                        5,  6,  7,  8,
                        9,  10, 11, 12,
                        13, 14, 15, 16
                }
                local v = a:to_vec4s_cols()
                assert.is_true(type(v)    == "table")
                assert.is_true(type(v[1]) == "table")
                assert.is_true(type(v[2]) == "table")
                assert.is_true(type(v[3]) == "table")
                assert.is_true(type(v[4]) == "table")

                assert.is.equal(1,  v[1][1])
                assert.is.equal(5,  v[1][2])
                assert.is.equal(9,  v[1][3])
                assert.is.equal(13, v[1][4])

                assert.is.equal(2,  v[2][1])
                assert.is.equal(6,  v[2][2])
                assert.is.equal(10, v[2][3])
                assert.is.equal(14, v[2][4])

                assert.is.equal(3,  v[3][1])
                assert.is.equal(7,  v[3][2])
                assert.is.equal(11, v[3][3])
                assert.is.equal(15, v[3][4])

                assert.is.equal(4,  v[4][1])
                assert.is.equal(8,  v[4][2])
                assert.is.equal(12, v[4][3])
                assert.is.equal(16, v[4][4])
        end)

        it("converts a matrix to a quaternion", function()
                local q = mat4({
                        0, 0, 1, 0,
                        1, 0, 0, 0,
                        0, 1, 0, 0,
                        0, 0, 0, 0
                }):to_quat()
                assert.is.equal(-0.5, q.x)
                assert.is.equal(-0.5, q.y)
                assert.is.equal(-0.5, q.z)
                assert.is.equal( 0.5, q.w)
        end)

        it("converts a matrix to a frustum", function()
                local a = mat4()
                local b = mat4.from_perspective(45, 1, 0.1, 1000)
                local f = (b * a):to_frustum()

                assert.is_true(utils.tolerance( 0.9239-f.left.a, 0.001))
                assert.is_true(utils.tolerance( 0     -f.left.b, 0.001))
                assert.is_true(utils.tolerance(-0.3827-f.left.c, 0.001))
                assert.is_true(utils.tolerance( 0     -f.left.d, 0.001))

                assert.is_true(utils.tolerance(-0.9239-f.right.a, 0.001))
                assert.is_true(utils.tolerance( 0     -f.right.b, 0.001))
                assert.is_true(utils.tolerance(-0.3827-f.right.c, 0.001))
                assert.is_true(utils.tolerance( 0     -f.right.d, 0.001))

                assert.is_true(utils.tolerance( 0     -f.bottom.a, 0.001))
                assert.is_true(utils.tolerance( 0.9239-f.bottom.b, 0.001))
                assert.is_true(utils.tolerance(-0.3827-f.bottom.c, 0.001))
                assert.is_true(utils.tolerance( 0     -f.bottom.d, 0.001))

                assert.is_true(utils.tolerance( 0     -f.top.a, 0.001))
                assert.is_true(utils.tolerance(-0.9239-f.top.b, 0.001))
                assert.is_true(utils.tolerance(-0.3827-f.top.c, 0.001))
                assert.is_true(utils.tolerance( 0     -f.top.d, 0.001))

                assert.is_true(utils.tolerance( 0  -f.near.a, 0.001))
                assert.is_true(utils.tolerance( 0  -f.near.b, 0.001))
                assert.is_true(utils.tolerance(-1  -f.near.c, 0.001))
                assert.is_true(utils.tolerance(-0.1-f.near.d, 0.001))

                assert.is_true(utils.tolerance( 0   -f.far.a, 0.001))
                assert.is_true(utils.tolerance( 0   -f.far.b, 0.001))
                assert.is_true(utils.tolerance( 1   -f.far.c, 0.001))
                assert.is_true(utils.tolerance( 1000-f.far.d, 0.001))
        end)

        it("checks to see if data is a valid matrix (not a table)", function()
                assert.is_not_true(mat4.is_mat4(0))
        end)

        it("checks to see if data is a valid matrix (invalid data)", function()
                assert.is_not_true(mat4.is_mat4({}))
        end)

        it("gets a string representation of a matrix", function()
                local a = mat4():to_string()
                local z = "+0.000"
                local o = "+1.000"
                local s = string.format(
                        "[ %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s ]",
                        o, z, z, z, z, o, z, z, z, z, o, z, z, z ,z, o
                )
                assert.is.equal(s, a)
        end)

        it("creates a matrix out of transform values", function()
                local scale = vec3(1, 2, 3)
                local rot = quat.from_angle_axis(math.pi * 0.5, vec3(0, 1, 0))
                local trans = vec3(3, 4, 5)
                local a = mat4.from_transform(trans, rot, scale)

                local v = vec3(-2, 3, 4)
                -- scaled, rotated, then translated
                -- v * mT * mR * mS

                local result = a * v
                local expected = vec3(-9, 10, 3)

                -- float margin is considered
                assert.is_true(math.abs(expected.x - result.x) < FLT_EPSILON)
                assert.is_true(math.abs(expected.y - result.y) < FLT_EPSILON)
                assert.is_true(math.abs(expected.z - result.z) < FLT_EPSILON)
        end)

end)

--[[
        from_angle_axis
        from_quaternion
        from_direction
        from_transform
        from_ortho
--]]

1	local mat4 = require "modules.mat4"	5✔
2	local vec3 = require "modules.vec3"	×
3	local quat = require "modules.quat"	×
4	local utils = require "modules.utils"	×
5	local FLT_EPSILON = require("modules.constants").FLT_EPSILON	×
6
7	describe("mat4:", function()	×
8	it("creates an identity matrix", function()	×
9	local a = mat4()	×
10	assert.is.equal(1, a[1])	×
11	assert.is.equal(0, a[2])	×
12	assert.is.equal(0, a[3])	×
13	assert.is.equal(0, a[4])	×
14	assert.is.equal(0, a[5])	×
15	assert.is.equal(1, a[6])	×
16	assert.is.equal(0, a[7])	×
17	assert.is.equal(0, a[8])	×
18	assert.is.equal(0, a[9])	×
19	assert.is.equal(0, a[10])	×
20	assert.is.equal(1, a[11])	×
21	assert.is.equal(0, a[12])	×
22	assert.is.equal(0, a[13])	×
23	assert.is.equal(0, a[14])	×
24	assert.is.equal(0, a[15])	×
25	assert.is.equal(1, a[16])	×
26	assert.is_true(a:is_mat4())	×
27	end)
28
29	it("creates a filled matrix", function()	×
30	local a = mat4 {	×
31	3, 3, 3, 3,
32	4, 4, 4, 4,
33	5, 5, 5, 5,
34	6, 6, 6, 6	×
35	}
36	assert.is.equal(3, a[1])	×
37	assert.is.equal(3, a[2])	×
38	assert.is.equal(3, a[3])	×
39	assert.is.equal(3, a[4])	×
40	assert.is.equal(4, a[5])	×
41	assert.is.equal(4, a[6])	×
42	assert.is.equal(4, a[7])	×
43	assert.is.equal(4, a[8])	×
44	assert.is.equal(5, a[9])	×
45	assert.is.equal(5, a[10])	×
46	assert.is.equal(5, a[11])	×
47	assert.is.equal(5, a[12])	×
48	assert.is.equal(6, a[13])	×
49	assert.is.equal(6, a[14])	×
50	assert.is.equal(6, a[15])	×
51	assert.is.equal(6, a[16])	×
52	end)
53
54	it("creates a filled matrix from vec4s", function()	×
55	local a = mat4 {	×
56	{ 3, 3, 3, 3 },	×
57	{ 4, 4, 4, 4 },	×
58	{ 5, 5, 5, 5 },	×
59	{ 6, 6, 6, 6 }	×
60	}
61	assert.is.equal(3, a[1])	×
62	assert.is.equal(3, a[2])	×
63	assert.is.equal(3, a[3])	×
64	assert.is.equal(3, a[4])	×
65	assert.is.equal(4, a[5])	×
66	assert.is.equal(4, a[6])	×
67	assert.is.equal(4, a[7])	×
68	assert.is.equal(4, a[8])	×
69	assert.is.equal(5, a[9])	×
70	assert.is.equal(5, a[10])	×
71	assert.is.equal(5, a[11])	×
72	assert.is.equal(5, a[12])	×
73	assert.is.equal(6, a[13])	×
74	assert.is.equal(6, a[14])	×
75	assert.is.equal(6, a[15])	×
76	assert.is.equal(6, a[16])	×
77	end)
78
79	it("creates a filled matrix from a 3x3 matrix", function()	×
80	local a = mat4 {	×
81	3, 3, 3,
82	4, 4, 4,
83	5, 5, 5	×
84	}
85	assert.is.equal(3, a[1])	×
86	assert.is.equal(3, a[2])	×
87	assert.is.equal(3, a[3])	×
88	assert.is.equal(0, a[4])	×
89	assert.is.equal(4, a[5])	×
90	assert.is.equal(4, a[6])	×
91	assert.is.equal(4, a[7])	×
92	assert.is.equal(0, a[8])	×
93	assert.is.equal(5, a[9])	×
94	assert.is.equal(5, a[10])	×
95	assert.is.equal(5, a[11])	×
96	assert.is.equal(0, a[12])	×
97	assert.is.equal(0, a[13])	×
98	assert.is.equal(0, a[14])	×
99	assert.is.equal(0, a[15])	×
100	assert.is.equal(1, a[16])	×
101	end)
102
103	it("creates a matrix from perspective", function()	×
104	local a = mat4.from_perspective(45, 1, 0.1, 1000)	×
105	assert.is_true(utils.tolerance( 2.414-a[1], 0.001))	×
106	assert.is_true(utils.tolerance( 2.414-a[6], 0.001))	×
107	assert.is_true(utils.tolerance(-1 -a[11], 0.001))	×
108	assert.is_true(utils.tolerance(-1 -a[12], 0.001))	×
109	assert.is_true(utils.tolerance(-0.2 -a[15], 0.001))	×
110	end)
111
112	it("creates a matrix from HMD perspective", function()	×
113	local t = {	×
114	LeftTan = 2.3465312,
115	RightTan = 0.9616399,
116	UpTan = 2.8664987,
117	DownTan = 2.8664987	×
118	}
119	local a = mat4.from_hmd_perspective(t, 0.1, 1000, false, false)	×
120	assert.is_true(utils.tolerance(a[1] - 0.605, 0.001))	×
121	assert.is_true(utils.tolerance(a[6] - 0.349, 0.001))	×
122	assert.is_true(utils.tolerance(a[9] - -0.419, 0.001))	×
123	assert.is_true(utils.tolerance(a[11]- -1.000, 0.001))	×
124	assert.is_true(utils.tolerance(a[12]- -1.000, 0.001))	×
125	assert.is_true(utils.tolerance(a[15]- -0.200, 0.001))	×
126	end)
127
128	it("clones a matrix", function()	×
129	local a = mat4.identity()	×
130	local b = a:clone()	×
131	assert.is.equal(a, b)	×
132	end)
133
134	it("multiplies two 4x4 matrices", function()	×
135	local a = mat4 {	×
136	1, 5, 9, 13,
137	2, 6, 10, 14,
138	3, 7, 11, 15,
139	4, 8, 12, 16	×
140	}
141	local b = mat4 {	×
142	1, 2, 3, 4,
143	5, 6, 7, 8,
144	9, 10, 11, 12,
145	13, 14, 15, 16	×
146	}
147	local c = mat4():mul(a, b)	×
148	local d = a * b	×
149	local e = mat4():mul{a, b}	×
150	assert.is.equal(30, c[1])	×
151	assert.is.equal(70, c[2])	×
152	assert.is.equal(110, c[3])	×
153	assert.is.equal(150, c[4])	×
154	assert.is.equal(70, c[5])	×
155	assert.is.equal(174, c[6])	×
156	assert.is.equal(278, c[7])	×
157	assert.is.equal(382, c[8])	×
158	assert.is.equal(110, c[9])	×
159	assert.is.equal(278, c[10])	×
160	assert.is.equal(446, c[11])	×
161	assert.is.equal(614, c[12])	×
162	assert.is.equal(150, c[13])	×
163	assert.is.equal(382, c[14])	×
164	assert.is.equal(614, c[15])	×
165	assert.is.equal(846, c[16])	×
166	assert.is.equal(c, d)	×
167	assert.is.equal(c, e)	×
168	end)
169
170	it("multiplies a matrix and a vec4", function()	×
171	local a = mat4 {	×
172	1, 2, 3, 4,
173	5, 6, 7, 8,
174	9, 10, 11, 12,
175	13, 14, 15, 16	×
176	}
177	local b = { 10, 20, 30, 40 }	×
178	local c = mat4.mul_vec4(mat4(), a, b)	×
179	local d = a * b	×
180	assert.is.equal(900, c[1])	×
181	assert.is.equal(1000, c[2])	×
182	assert.is.equal(1100, c[3])	×
183	assert.is.equal(1200, c[4])	×
184
185	assert.is.equal(c[1], d[1])	×
186	assert.is.equal(c[2], d[2])	×
187	assert.is.equal(c[3], d[3])	×
188	assert.is.equal(c[4], d[4])	×
189	end)
190
191	it("verifies mat4 composition order", function()	×
192	local a = mat4 {	×
193	1, 5, 9, 13,
194	2, 6, 10, 14,
195	3, 7, 11, 15,
196	4, 8, 12, 16	×
197	}
198	local b = mat4 {	×
199	2, 3, 5, 7,
200	11, 13, 17, 19,
201	23, 29, 31, 37,
202	41, 43, 47, 53	×
203	}
204	local c = mat4():mul(a, b)	×
205	local d = a * b	×
206
207	local v = { 10, 20, 30, 40 }	×
208
209	local cv = c * v	×
210	local abv = a(bv)	×
211
212	assert.is.equal(cv.x, abv.x) -- Verify (ab)v == a(bv)	×
213	assert.is.equal(cv.y, abv.y)	×
214	assert.is.equal(cv.z, abv.z)	×
215	end)
216
217	it("scales a matrix", function()	×
218	local a = mat4():scale(mat4(), vec3(5, 5, 5))	×
219	assert.is.equal(5, a[1])	×
220	assert.is.equal(5, a[6])	×
221	assert.is.equal(5, a[11])	×
222	end)
223
224	it("rotates a matrix", function()	×
225	local a = mat4():rotate(mat4(), math.rad(45), vec3.unit_z)	×
226	assert.is_true(utils.tolerance( 0.7071-a[1], 0.001))	×
227	assert.is_true(utils.tolerance( 0.7071-a[2], 0.001))	×
228	assert.is_true(utils.tolerance(-0.7071-a[5], 0.001))	×
229	assert.is_true(utils.tolerance( 0.7071-a[6], 0.001))	×
230	end)
231
232	it("translates a matrix", function()	×
233	local a = mat4():translate(mat4(), vec3(5, 5, 5))	×
234	assert.is.equal(5, a[13])	×
235	assert.is.equal(5, a[14])	×
236	assert.is.equal(5, a[15])	×
237	end)
238
239	it("inverts a matrix", function()	×
240	local a = mat4()	×
241	a = a:rotate(a, math.pi/4, vec3.unit_y)	×
242	a = a:translate(a, vec3(4, 5, 6))	×
243
244	local b = mat4.invert(mat4(), a)	×
245	local c = a * b	×
246	assert.is.equal(mat4(), c)	×
247
248	local d = mat4()	×
249	d:rotate(d, math.pi/4, vec3.unit_y)	×
250	d:translate(d, vec3(4, 5, 6))	×
251
252	local e = -d	×
253	local f = d * e	×
254	assert.is.equal(mat4(), f)	×
255	end)
256
257	it("transposes a matrix", function()	×
258	local a = mat4({	×
259	1, 1, 1, 1,
260	2, 2, 2, 2,
261	3, 3, 3, 3,
262	4, 4, 4, 4	×
263	})
264	a = a:transpose(a)	×
265	assert.is.equal(1, a[1])	×
266	assert.is.equal(2, a[2])	×
267	assert.is.equal(3, a[3])	×
268	assert.is.equal(4, a[4])	×
269	assert.is.equal(1, a[5])	×
270	assert.is.equal(2, a[6])	×
271	assert.is.equal(3, a[7])	×
272	assert.is.equal(4, a[8])	×
273	assert.is.equal(1, a[9])	×
274	assert.is.equal(2, a[10])	×
275	assert.is.equal(3, a[11])	×
276	assert.is.equal(4, a[12])	×
277	assert.is.equal(1, a[13])	×
278	assert.is.equal(2, a[14])	×
279	assert.is.equal(3, a[15])	×
280	assert.is.equal(4, a[16])	×
281	end)
282
283	it("shears a matrix", function()	×
284	local yx, zx, xy, zy, xz, yz = 1, 1, 1, -1, -1, -1	×
285	local a = mat4():shear(mat4(), yx, zx, xy, zy, xz, yz)	×
286	assert.is.equal( 1, a[2])	×
287	assert.is.equal( 1, a[3])	×
288	assert.is.equal( 1, a[5])	×
289	assert.is.equal(-1, a[7])	×
290	assert.is.equal(-1, a[9])	×
291	assert.is.equal(-1, a[10])	×
292	end)
293
294	it("reflects a matrix along a plane", function()	×
295	local origin = vec3(5, 1, 0)	×
296	local normal = vec3(0, -1, 0):normalize()	×
297	local a = mat4():reflect(mat4(), origin, normal)	×
298	local p = a * vec3(-5, 2, 5)	×
299	assert.is.equal(p.x, -5)	×
300	assert.is.equal(p.y, 0)	×
301	assert.is.equal(p.z, 5)	×
302	end)
303
304	it("projects a point into screen space", function()	×
305	local znear = 0.1	×
306	local zfar = 1000	×
307	local proj = mat4.from_perspective(45, 1, znear, zfar)	×
308	local vp = { 0, 0, 400, 400 }	×
309
310	-- -z is away from the viewer into the far plane
311	local p1 = vec3(0, 0, -znear)	×
312	local c1 = mat4.project(p1, proj, vp)	×
313	assert.is.near(0, c1.z, 0.0001)	×
314	assert.is.equal(200, c1.x)	×
315	assert.is.equal(200, c1.y)	×
316
317	local p2 = vec3(0, 0, -zfar)	×
318	local c2 = mat4.project(p2, proj, vp)	×
319	assert.is.near(1, c2.z, 0.0001)	×
320	assert.is.equal(200, c2.x)	×
321	assert.is.equal(200, c2.y)	×
322
323	local p3 = vec3(0, 0, zfar)	×
324	local c3 = mat4.project(p3, proj, vp)	×
325	assert.is_true(c3.z < 0)	×
326	assert.is.equal(200, c3.x)	×
327	assert.is.equal(200, c3.y)	×
328	end)
329
330	it("unprojects a point into world space", function()	×
331	local p = vec3(0, 0, -10)	×
332	local proj = mat4.from_perspective(45, 1, 0.1, 1000)	×
333	local vp = { 0, 0, 400, 400 }	×
334	local c = mat4.project(p, proj, vp)	×
335	local d = mat4.unproject(c, proj, vp)	×
336	assert.is.near(0.0, p.x-d.x, 0.0001)	×
337	assert.is.near(0.0, p.y-d.y, 0.0001)	×
338	assert.is.near(0.0, p.z-d.z, 0.0001)	×
339	end)
340
341	it("transforms a matrix to look at a point", function()	×
342	local e = vec3(0, 0, 1.55)	×
343	local c = vec3(4, 7, 1)	×
344	local u = vec3(0, 0, 1)	×
345	local a = mat4():look_at(e, c, u)	×
346
347	assert.is_true(utils.tolerance( 0.868-a[1], 0.001))	×
348	assert.is_true(utils.tolerance( 0.034-a[2], 0.001))	×
349	assert.is_true(utils.tolerance(-0.495-a[3], 0.001))	×
350	assert.is_true(utils.tolerance( 0 -a[4], 0.001))	×
351
352	assert.is_true(utils.tolerance(-0.496-a[5], 0.001))	×
353	assert.is_true(utils.tolerance( 0.059-a[6], 0.001))	×
354	assert.is_true(utils.tolerance(-0.866-a[7], 0.001))	×
355	assert.is_true(utils.tolerance( 0 -a[8], 0.001))	×
356
357	assert.is_true(utils.tolerance( 0 -a[9], 0.001))	×
358	assert.is_true(utils.tolerance( 0.998-a[10], 0.001))	×
359	assert.is_true(utils.tolerance( 0.068-a[11], 0.001))	×
360	assert.is_true(utils.tolerance( 0 -a[12], 0.001))	×
361
362	assert.is_true(utils.tolerance( 0 -a[13], 0.001))	×
363	assert.is_true(utils.tolerance(-1.546-a[14], 0.001))	×
364	assert.is_true(utils.tolerance(-0.106-a[15], 0.001))	×
365	assert.is_true(utils.tolerance( 1 -a[16], 0.001))	×
366	end)
367
368	it("converts a matrix to vec4s", function()	×
369	local a = mat4 {	×
370	1, 2, 3, 4,
371	5, 6, 7, 8,
372	9, 10, 11, 12,
373	13, 14, 15, 16	×
374	}
375	local v = a:to_vec4s()	×
376	assert.is_true(type(v) == "table")	×
377	assert.is_true(type(v[1]) == "table")	×
378	assert.is_true(type(v[2]) == "table")	×
379	assert.is_true(type(v[3]) == "table")	×
380	assert.is_true(type(v[4]) == "table")	×
381
382	assert.is.equal(1, v[1][1])	×
383	assert.is.equal(2, v[1][2])	×
384	assert.is.equal(3, v[1][3])	×
385	assert.is.equal(4, v[1][4])	×
386
387	assert.is.equal(5, v[2][1])	×
388	assert.is.equal(6, v[2][2])	×
389	assert.is.equal(7, v[2][3])	×
390	assert.is.equal(8, v[2][4])	×
391
392	assert.is.equal(9, v[3][1])	×
393	assert.is.equal(10, v[3][2])	×
394	assert.is.equal(11, v[3][3])	×
395	assert.is.equal(12, v[3][4])	×
396
397	assert.is.equal(13, v[4][1])	×
398	assert.is.equal(14, v[4][2])	×
399	assert.is.equal(15, v[4][3])	×
400	assert.is.equal(16, v[4][4])	×
401	end)
402
403	it("converts a matrix to vec4s, column-wise", function()	×
404	local a = mat4 {	×
405	1, 2, 3, 4,
406	5, 6, 7, 8,
407	9, 10, 11, 12,
408	13, 14, 15, 16	×
409	}
410	local v = a:to_vec4s_cols()	×
411	assert.is_true(type(v) == "table")	×
412	assert.is_true(type(v[1]) == "table")	×
413	assert.is_true(type(v[2]) == "table")	×
414	assert.is_true(type(v[3]) == "table")	×
415	assert.is_true(type(v[4]) == "table")	×
416
417	assert.is.equal(1, v[1][1])	×
418	assert.is.equal(5, v[1][2])	×
419	assert.is.equal(9, v[1][3])	×
420	assert.is.equal(13, v[1][4])	×
421
422	assert.is.equal(2, v[2][1])	×
423	assert.is.equal(6, v[2][2])	×
424	assert.is.equal(10, v[2][3])	×
425	assert.is.equal(14, v[2][4])	×
426
427	assert.is.equal(3, v[3][1])	×
428	assert.is.equal(7, v[3][2])	×
429	assert.is.equal(11, v[3][3])	×
430	assert.is.equal(15, v[3][4])	×
431
432	assert.is.equal(4, v[4][1])	×
433	assert.is.equal(8, v[4][2])	×
434	assert.is.equal(12, v[4][3])	×
435	assert.is.equal(16, v[4][4])	×
436	end)
437
438	it("converts a matrix to a quaternion", function()	×
439	local q = mat4({	×
440	0, 0, 1, 0,
441	1, 0, 0, 0,
442	0, 1, 0, 0,
443	0, 0, 0, 0	×
444	}):to_quat()	×
445	assert.is.equal(-0.5, q.x)	×
446	assert.is.equal(-0.5, q.y)	×
447	assert.is.equal(-0.5, q.z)	×
448	assert.is.equal( 0.5, q.w)	×
449	end)
450
451	it("converts a matrix to a frustum", function()	×
452	local a = mat4()	×
453	local b = mat4.from_perspective(45, 1, 0.1, 1000)	×
454	local f = (b * a):to_frustum()	×
455
456	assert.is_true(utils.tolerance( 0.9239-f.left.a, 0.001))	×
457	assert.is_true(utils.tolerance( 0 -f.left.b, 0.001))	×
458	assert.is_true(utils.tolerance(-0.3827-f.left.c, 0.001))	×
459	assert.is_true(utils.tolerance( 0 -f.left.d, 0.001))	×
460
461	assert.is_true(utils.tolerance(-0.9239-f.right.a, 0.001))	×
462	assert.is_true(utils.tolerance( 0 -f.right.b, 0.001))	×
463	assert.is_true(utils.tolerance(-0.3827-f.right.c, 0.001))	×
464	assert.is_true(utils.tolerance( 0 -f.right.d, 0.001))	×
465
466	assert.is_true(utils.tolerance( 0 -f.bottom.a, 0.001))	×
467	assert.is_true(utils.tolerance( 0.9239-f.bottom.b, 0.001))	×
468	assert.is_true(utils.tolerance(-0.3827-f.bottom.c, 0.001))	×
469	assert.is_true(utils.tolerance( 0 -f.bottom.d, 0.001))	×
470
471	assert.is_true(utils.tolerance( 0 -f.top.a, 0.001))	×
472	assert.is_true(utils.tolerance(-0.9239-f.top.b, 0.001))	×
473	assert.is_true(utils.tolerance(-0.3827-f.top.c, 0.001))	×
474	assert.is_true(utils.tolerance( 0 -f.top.d, 0.001))	×
475
476	assert.is_true(utils.tolerance( 0 -f.near.a, 0.001))	×
477	assert.is_true(utils.tolerance( 0 -f.near.b, 0.001))	×
478	assert.is_true(utils.tolerance(-1 -f.near.c, 0.001))	×
479	assert.is_true(utils.tolerance(-0.1-f.near.d, 0.001))	×
480
481	assert.is_true(utils.tolerance( 0 -f.far.a, 0.001))	×
482	assert.is_true(utils.tolerance( 0 -f.far.b, 0.001))	×
483	assert.is_true(utils.tolerance( 1 -f.far.c, 0.001))	×
484	assert.is_true(utils.tolerance( 1000-f.far.d, 0.001))	×
485	end)
486
487	it("checks to see if data is a valid matrix (not a table)", function()	×
488	assert.is_not_true(mat4.is_mat4(0))	×
489	end)
490
491	it("checks to see if data is a valid matrix (invalid data)", function()	×
492	assert.is_not_true(mat4.is_mat4({}))	×
493	end)
494
495	it("gets a string representation of a matrix", function()	×
496	local a = mat4():to_string()	×
497	local z = "+0.000"	×
498	local o = "+1.000"	×
499	local s = string.format(	×
500	"[ %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s ]",
501	o, z, z, z, z, o, z, z, z, z, o, z, z, z ,z, o	×
502	)
503	assert.is.equal(s, a)	×
504	end)
505
506	it("creates a matrix out of transform values", function()	×
507	local scale = vec3(1, 2, 3)	×
508	local rot = quat.from_angle_axis(math.pi * 0.5, vec3(0, 1, 0))	×
509	local trans = vec3(3, 4, 5)	×
510	local a = mat4.from_transform(trans, rot, scale)	×
511
512	local v = vec3(-2, 3, 4)	×
513	-- scaled, rotated, then translated
514	-- v * mT * mR * mS
515
516	local result = a * v	×
517	local expected = vec3(-9, 10, 3)	×
518
519	-- float margin is considered
520	assert.is_true(math.abs(expected.x - result.x) < FLT_EPSILON)	×
521	assert.is_true(math.abs(expected.y - result.y) < FLT_EPSILON)	×
522	assert.is_true(math.abs(expected.z - result.z) < FLT_EPSILON)	×
523	end)
524
525	end)
526
527	--[[
528	from_angle_axis
529	from_quaternion
530	from_direction
531	from_transform
532	from_ortho
533	--]]

excessive / cpml / 6132588926

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous