github.com/mojzesh/linmath@v0.0.0-20220615094601-759643be23c3/linmath_test.go (about)

     1  package linmath
     2  
     3  import (
     4  	"log"
     5  	"math/rand"
     6  	"testing"
     7  	"time"
     8  
     9  	native "github.com/mojzesh/linmath"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  const seed = 777
    14  
    15  func TestMat4x4FromQuat(t *testing.T) {
    16  	assert := assert.New(t)
    17  
    18  	for _, test := range []string{"0", "1", "N", "R"} {
    19  		var expected string
    20  		{
    21  			m := n_m(test, seed)
    22  			q := n_q(test, seed)
    23  			native.Mat4x4FromQuat(m, q)
    24  			expected = native.DumpMatrix(m, test)
    25  		}
    26  
    27  		var actual string
    28  		{
    29  			m := m(test, seed)
    30  			q := q(test, seed)
    31  			m.FromQuat(q)
    32  			actual = DumpMatrix(m, test)
    33  		}
    34  		assert.Equal(expected, actual)
    35  		log.Println(test, expected)
    36  	}
    37  }
    38  
    39  func TestQuatFromMat4x4(t *testing.T) {
    40  	assert := assert.New(t)
    41  
    42  	for _, test := range []string{"0", "1", "N", "R"} {
    43  		var expected string
    44  		{
    45  			m := n_m(test, seed)
    46  			q := n_q(test, seed)
    47  			native.QuatFromMat4x4(q, m)
    48  			expected = native.DumpQuat(q, test)
    49  		}
    50  
    51  		var actual string
    52  		{
    53  			m := m(test, seed)
    54  			q := q(test, seed)
    55  			q.FromMat4x4(m)
    56  			actual = DumpQuat(q, test)
    57  		}
    58  		assert.Equal(expected, actual)
    59  		log.Println(test, expected)
    60  	}
    61  }
    62  
    63  func TestMat4x4ScaleAniso(t *testing.T) {
    64  	assert := assert.New(t)
    65  
    66  	for _, test := range []string{"0", "1", "N", "R"} {
    67  		var expected string
    68  		{
    69  			m1 := n_m(test, seed)
    70  			m2 := n_m(test, seed)
    71  			native.Mat4x4ScaleAniso(m1, m2, 1, 2, 3)
    72  			expected = native.DumpMatrix(m1, test)
    73  		}
    74  
    75  		var actual string
    76  		{
    77  			m1 := m(test, seed)
    78  			m2 := m(test, seed)
    79  			m1.ScaleAniso(m2, 1, 2, 3)
    80  			actual = DumpMatrix(m1, test)
    81  		}
    82  		assert.Equal(expected, actual)
    83  		log.Println(test, expected)
    84  	}
    85  }
    86  
    87  func TestMat4x4LookAt(t *testing.T) {
    88  	assert := assert.New(t)
    89  
    90  	for _, test := range []string{"0", "1", "N", "R"} {
    91  		var expected string
    92  		{
    93  			m := n_m(test, seed)
    94  			v1 := n_v3(test, seed)
    95  			v2 := n_v3(test, seed+1)
    96  			v3 := n_v3(test, seed+2)
    97  			native.Mat4x4LookAt(m, v1, v2, v3)
    98  			expected = native.DumpMatrix(m, test)
    99  		}
   100  
   101  		var actual string
   102  		{
   103  			m := m(test, seed)
   104  			v1 := v3(test, seed)
   105  			v2 := v3(test, seed+1)
   106  			v3 := v3(test, seed+2)
   107  			m.LookAt(v1, v2, v3)
   108  			actual = DumpMatrix(m, test)
   109  		}
   110  		assert.Equal(expected, actual)
   111  		log.Println(test, expected)
   112  	}
   113  }
   114  
   115  func q(test string, seed ...int64) *Quat {
   116  	rand := getRand(seed)
   117  
   118  	switch test {
   119  	case "0":
   120  		q := new(Quat)
   121  		for i := 0; i < 4; i++ {
   122  			q[i] = 0
   123  		}
   124  		return q
   125  	case "1":
   126  		q := new(Quat)
   127  		for i := 0; i < 4; i++ {
   128  			q[i] = 1
   129  		}
   130  		return q
   131  	case "N":
   132  		q := new(Quat)
   133  		n := 1
   134  		for i := 0; i < 4; i++ {
   135  			q[i] = float32(n)
   136  			n++
   137  		}
   138  		return q
   139  	case "R":
   140  		q := new(Quat)
   141  		for i := 0; i < 4; i++ {
   142  			q[i] = float32(rand.Intn(100))
   143  		}
   144  		return q
   145  	default:
   146  		panic(test)
   147  	}
   148  }
   149  
   150  func v3(test string, seed ...int64) *Vec3 {
   151  	rand := getRand(seed)
   152  
   153  	switch test {
   154  	case "0":
   155  		q := new(Vec3)
   156  		for i := 0; i < 3; i++ {
   157  			q[i] = 0
   158  		}
   159  		return q
   160  	case "1":
   161  		q := new(Vec3)
   162  		for i := 0; i < 3; i++ {
   163  			q[i] = 1
   164  		}
   165  		return q
   166  	case "N":
   167  		q := new(Vec3)
   168  		n := 1
   169  		for i := 0; i < 3; i++ {
   170  			q[i] = float32(n)
   171  			n++
   172  		}
   173  		return q
   174  	case "R":
   175  		q := new(Vec3)
   176  		for i := 0; i < 3; i++ {
   177  			q[i] = float32(rand.Intn(100))
   178  		}
   179  		return q
   180  	default:
   181  		panic(test)
   182  	}
   183  }
   184  
   185  func v4(test string, seed ...int64) *Vec4 {
   186  	rand := getRand(seed)
   187  
   188  	switch test {
   189  	case "0":
   190  		q := new(Vec4)
   191  		for i := 0; i < 4; i++ {
   192  			q[i] = 0
   193  		}
   194  		return q
   195  	case "1":
   196  		q := new(Vec4)
   197  		for i := 0; i < 4; i++ {
   198  			q[i] = 1
   199  		}
   200  		return q
   201  	case "N":
   202  		q := new(Vec4)
   203  		n := 1
   204  		for i := 0; i < 4; i++ {
   205  			q[i] = float32(n)
   206  			n++
   207  		}
   208  		return q
   209  	case "R":
   210  		q := new(Vec4)
   211  		for i := 0; i < 4; i++ {
   212  			q[i] = float32(rand.Intn(100))
   213  		}
   214  		return q
   215  	default:
   216  		panic(test)
   217  	}
   218  }
   219  
   220  func m(test string, seed ...int64) *Mat4x4 {
   221  	rand := getRand(seed)
   222  
   223  	switch test {
   224  	case "0":
   225  		m := new(Mat4x4)
   226  		for i := 0; i < 4; i++ {
   227  			for j := 0; j < 4; j++ {
   228  				m[i][j] = 0
   229  			}
   230  		}
   231  		return m
   232  	case "1":
   233  		m := new(Mat4x4)
   234  		for i := 0; i < 4; i++ {
   235  			for j := 0; j < 4; j++ {
   236  				m[i][j] = 1
   237  			}
   238  		}
   239  		return m
   240  	case "N":
   241  		m := new(Mat4x4)
   242  		n := 1
   243  		for i := 0; i < 4; i++ {
   244  			for j := 0; j < 4; j++ {
   245  				m[i][j] = float32(n)
   246  				n++
   247  			}
   248  		}
   249  		return m
   250  	case "R":
   251  		m := new(Mat4x4)
   252  		for i := 0; i < 4; i++ {
   253  			for j := 0; j < 4; j++ {
   254  				m[i][j] = float32(rand.Intn(100))
   255  			}
   256  		}
   257  		return m
   258  	default:
   259  		panic(test)
   260  	}
   261  }
   262  
   263  func n_q(test string, seed ...int64) *native.Quat {
   264  	rand := getRand(seed)
   265  
   266  	switch test {
   267  	case "0":
   268  		q := new(native.Quat)
   269  		for i := 0; i < 4; i++ {
   270  			q[i] = 0
   271  		}
   272  		return q
   273  	case "1":
   274  		q := new(native.Quat)
   275  		for i := 0; i < 4; i++ {
   276  			q[i] = 1
   277  		}
   278  		return q
   279  	case "N":
   280  		q := new(native.Quat)
   281  		n := 1
   282  		for i := 0; i < 4; i++ {
   283  			q[i] = float32(n)
   284  			n++
   285  		}
   286  		return q
   287  	case "R":
   288  		q := new(native.Quat)
   289  		for i := 0; i < 4; i++ {
   290  			q[i] = float32(rand.Intn(100))
   291  		}
   292  		return q
   293  	default:
   294  		panic(test)
   295  	}
   296  }
   297  
   298  func n_v3(test string, seed ...int64) *native.Vec3 {
   299  	rand := getRand(seed)
   300  
   301  	switch test {
   302  	case "0":
   303  		q := new(native.Vec3)
   304  		for i := 0; i < 3; i++ {
   305  			q[i] = 0
   306  		}
   307  		return q
   308  	case "1":
   309  		q := new(native.Vec3)
   310  		for i := 0; i < 3; i++ {
   311  			q[i] = 1
   312  		}
   313  		return q
   314  	case "N":
   315  		q := new(native.Vec3)
   316  		n := 1
   317  		for i := 0; i < 3; i++ {
   318  			q[i] = float32(n)
   319  			n++
   320  		}
   321  		return q
   322  	case "R":
   323  		q := new(native.Vec3)
   324  		for i := 0; i < 3; i++ {
   325  			q[i] = float32(rand.Intn(100))
   326  		}
   327  		return q
   328  	default:
   329  		panic(test)
   330  	}
   331  }
   332  
   333  func n_v4(test string, seed ...int64) *native.Vec4 {
   334  	rand := getRand(seed)
   335  
   336  	switch test {
   337  	case "0":
   338  		q := new(native.Vec4)
   339  		for i := 0; i < 4; i++ {
   340  			q[i] = 0
   341  		}
   342  		return q
   343  	case "1":
   344  		q := new(native.Vec4)
   345  		for i := 0; i < 4; i++ {
   346  			q[i] = 1
   347  		}
   348  		return q
   349  	case "N":
   350  		q := new(native.Vec4)
   351  		n := 1
   352  		for i := 0; i < 4; i++ {
   353  			q[i] = float32(n)
   354  			n++
   355  		}
   356  		return q
   357  	case "R":
   358  		q := new(native.Vec4)
   359  		for i := 0; i < 4; i++ {
   360  			q[i] = float32(rand.Intn(100))
   361  		}
   362  		return q
   363  	default:
   364  		panic(test)
   365  	}
   366  }
   367  
   368  func n_m(test string, seed ...int64) *native.Mat4x4 {
   369  	rand := getRand(seed)
   370  
   371  	switch test {
   372  	case "0":
   373  		m := new(native.Mat4x4)
   374  		for i := 0; i < 4; i++ {
   375  			for j := 0; j < 4; j++ {
   376  				m[i][j] = 0
   377  			}
   378  		}
   379  		return m
   380  	case "1":
   381  		m := new(native.Mat4x4)
   382  		for i := 0; i < 4; i++ {
   383  			for j := 0; j < 4; j++ {
   384  				m[i][j] = 1
   385  			}
   386  		}
   387  		return m
   388  	case "N":
   389  		m := new(native.Mat4x4)
   390  		n := 1
   391  		for i := 0; i < 4; i++ {
   392  			for j := 0; j < 4; j++ {
   393  				m[i][j] = float32(n)
   394  				n++
   395  			}
   396  		}
   397  		return m
   398  	case "R":
   399  		m := new(native.Mat4x4)
   400  		for i := 0; i < 4; i++ {
   401  			for j := 0; j < 4; j++ {
   402  				m[i][j] = float32(rand.Intn(100))
   403  			}
   404  		}
   405  		return m
   406  	default:
   407  		panic(test)
   408  	}
   409  }
   410  
   411  func getRand(seed []int64) *rand.Rand {
   412  	if len(seed) > 0 {
   413  		return rand.New(rand.NewSource(seed[0]))
   414  	}
   415  	return rand.New(rand.NewSource(time.Now().UnixNano()))
   416  }