check_type(M, aabb, MATH_TYPE_VEC4);

const float *v = math_value(M, aabb);

return {

*(const glm::vec4 *)(v),

*(const glm::vec4 *)(v+4)

};

check_type(M, id, MATH_TYPE_VEC4);

float * buf = math_init(M, id);

return {

*(glm::vec4 *)buf,

*(glm::vec4 *)(buf+4),

};

math_t r;

glm::mat4x4 &m = allocmat(M, &r);

m[0] = VEC(M, c1);

m[1] = VEC(M, c2);

m[2] = VEC(M, c3);

m[3] = VEC(M, c4);

return r;

math_t r;

glm::mat4x4 &m = allocmat(M, &r);

m = glm::mat4x4(QUAT(M, quat));

return r;

math_t r;

glm::quat &q = allocquat(M, &r);

q = glm::quat_cast(MAT(M, mat));

return r;

math_t r;

const float *axis = math_value(M, axis_id);

glm::vec3 a(axis[0],axis[1],axis[2]);

glm::quat &q = allocquat(M, &r);

q = glm::angleAxis(radian, a);

return r;

math_t r;

glm::quat &q = allocquat(M, &r);

q = glm::quat(VEC3(M, a), VEC3(M, b));

return r;

math_t id;

glm::mat4x4 &srt = allocmat(M, &id);

int ident = 1;

if (!math_isnull(s) && !scale1(M, s)) {

srt = glm::mat4x4(1);

const glm::vec3 &scale = VEC3(M, s);

srt[0][0] = scale[0];

srt[1][1] = scale[1];

srt[2][2] = scale[2];

ident = 0;

}

if (!math_isnull(r) && !rot0(M, r)) {

const glm::quat &q = QUAT(M, r);

if (!ident) {

srt = glm::mat4x4(q) * srt;

} else {

srt = glm::mat4x4(q);

}

ident = 0;

} else if (ident) {

srt = glm::mat4x4(1);

}

if (!math_isnull(t) && !trans0(M, t)) {

const glm::vec3 &translate = VEC3(M, t);

srt[3][0] = translate[0];

srt[3][1] = translate[1];

srt[3][2] = translate[2];

srt[3][3] = 1;

ident = 0;

}

if (ident) {

return math_identity(MATH_TYPE_MAT);

}

return id;

const glm::mat4x4 &m = MAT(M, mat);

v[0] = math_vec4(M, NULL);

v[1] = math_quat(M, NULL);

v[2] = math_vec4(M, NULL);

float *scale = math_init(M, v[0]);

float *quat = math_init(M, v[1]);

float *trans = math_init(M, v[2]);

glm::vec3 skew;

glm::vec4 perspective;

glm::decompose(m, *(glm::vec3*)scale, *(glm::quat *)quat, *(glm::vec3*)trans, skew, perspective);

union {

float f;

uint32_t n;

} u;

u.f = f;

return ((u.n + 0x1f) & ~0x3f) == 0x3f800000; // float 1

math_t id = math_vec4(M, NULL);

float * scale = math_init(M, id);

const glm::mat4& m = MAT(M, mat);

int ii;

scale[3] = 0;

for (ii = 0; ii < 3; ++ii) {

const float* v = &m[ii].x;

float dot = glm::dot(*(const glm::vec3 *)v, *(const glm::vec3 *)v);

if (equal_one(dot)) {

scale[ii] = 1.0f;

} else {

scale[ii] = sqrtf(dot);

if (scale[ii] == 0) {

// invalid scale, use 1 instead

scale[0] = scale[1] = scale[2] = 1.0f;

return id;

}

}

if (glm::determinant(m) < 0){

scale[ii] *= -1;

}

}

return id;

math_t id;

glm::quat &q = allocquat(M, &id);

glm::mat4 rotMat(MAT(M, mat));

math_t s = math3d_decompose_scale(M, mat);

const float *scale = math_value(M, s);

int ii;

for (ii = 0; ii < 3; ++ii) {

rotMat[ii] /= scale[ii];

}

q = glm::quat_cast(rotMat);

return id;

math_t id;

glm::vec4 &r = allocvec4(M, &id);

r = VEC(M, v1) + VEC(M, v2);

return id;

math_t id;

glm::vec4 &r = allocvec4(M, &id);

r = VEC(M, v1) - VEC(M, v2);

return id;

math_t id;

glm::vec4 &r = allocvec4(M, &id);

r = VEC(M, v1) * VEC(M, v2);

return id;

if (math_isidentity(v1)) {

return v2;

}

if (math_isidentity(v2)) {

return v1;

}

math_t id;

glm::quat &quat = allocquat(M, &id);

quat = QUAT(M, v1) * QUAT(M, v2);

return id;

if (math_isidentity(v1)) {

return v2;

}

if (math_isidentity(v2)) {

return v1;

}

math_t id;

glm::mat4x4 &mat = allocmat(M, &id);

mat = MAT(M, v1) * MAT(M, v2);

return id;

glm::mat4x4 & omat = *(glm::mat4x4 *)(output);

const glm::mat4x4 & mat1 = *(const glm::mat4x4 *)(m1);

const glm::mat4x4 & mat2 = *(const glm::mat4x4 *)(m2);

omat = mat1 * mat2;

int reverse = 0;

int sz = math_size(M, array_mat);

if (sz == 1) {

sz = math_size(M, mat);

reverse = 1;

math_t tmp = mat;

mat = array_mat;

array_mat = tmp;

} else {

int matsz = math_size(M, mat);

if (matsz > 1) {

// array(mat) * array(array_mat)

if (matsz < sz)

sz = matsz;

if (math_isnull(output_ref)) {

output_ref = math_import(M, NULL, MATH_TYPE_MAT, sz);

} else {

int output_sz = math_size(M, output_ref);

if (output_sz < sz)

sz = output_sz;

}

int i;

const float * lm = math_value(M, mat);

const float * rm = math_value(M, array_mat);

float * out_buf = math_init(M, output_ref);

for (i=0;i<sz;i++) {

matrix_mul(out_buf + i * 16, lm + i * 16, rm + i * 16);

}

return output_ref;

}

}

// matrix * array

if (math_isidentity(mat)) {

// mul identity, copy array

if (math_isnull(output_ref)) {

return array_mat;

} else {

float * result = math_init(M, output_ref);

const float * source = math_value(M, array_mat);

int sz_output = math_size(M, output_ref);

if (sz_output < sz)

sz = sz_output;

memcpy(result, source, sz * 16 * sizeof(float));

return output_ref;

}

}

if (math_isnull(output_ref)) {

output_ref = math_import(M, NULL, MATH_TYPE_MAT, sz);

} else {

int output_sz = math_size(M, output_ref);

if (output_sz < sz)

sz = output_sz;

}

int i;

const float * m = math_value(M, mat);

float * out_buf = math_init(M, output_ref);

const float * in_buf = math_value(M, array_mat);

if (reverse) {

for (i=0;i<sz;i++) {

matrix_mul(out_buf + i * 16, in_buf + i * 16, m);

}

} else {

for (i=0;i<sz;i++) {

matrix_mul(out_buf + i * 16, m, in_buf + i * 16);

}

}

return output_ref;

math_t id = math_vec4(M, NULL);

float *vv = math_init(M, id);

check_type(M, v, MATH_TYPE_VEC4);

const float *value = math_value(M, v);

vv[0] = floor(value[0]);

vv[1] = floor(value[1]);

vv[2] = floor(value[2]);

vv[3] = floor(value[3]);

return id;

math_t id = math_vec4(M, NULL);

float *vv = math_init(M, id);

check_type(M, v, MATH_TYPE_VEC4);

const float *value = math_value(M, v);

vv[0] = ceil(value[0]);

vv[1] = ceil(value[1]);

vv[2] = ceil(value[2]);

vv[3] = ceil(value[3]);

return id;

glm::vec3 c = glm::cross(VEC3(M, v1), VEC3(M, v2));

math_t id = math_vec4(M, NULL);

float *r = math_init(M, id);

r[0] = c[0];

r[1] = c[1];

r[2] = c[2];

r[3] = 0;

return id;

const float *v = math_value(M, id);

glm::vec3 v3 = glm::normalize(*(const glm::vec3 *)(v));

math_t result = math_vec4(M, NULL);

float *r = math_init(M, result);

r[0] = v3[0];

r[1] = v3[1];

r[2] = v3[2];

r[3] = v[3];

return result;

math_t id;

glm::quat &q = allocquat(M, &id);

q = glm::normalize(QUAT(M, quat));

return id;

math_t id;

glm::mat4x4 &r = allocmat(M, &id);

r = glm::transpose(MAT(M, mat));

return id;

math_t id;

glm::quat &q = allocquat(M, &id);

q = glm::inverse(QUAT(M, quat));

return id;

math_t id;

glm::mat4x4 &r = allocmat(M, &id);

r = glm::inverse(MAT(M, mat));

return id;

math_t id;

const auto &m = MAT(M, mat);

glm::mat4x4 &r = allocmat(M, &id);

r = m;

assert( is_zero(glm::dot(V3R(m[0]), V3R(m[1])), 1e-6f) &&

is_zero(glm::dot(V3R(m[1]), V3R(m[2])), 1e-6f) &&

is_zero(glm::dot(V3R(m[2]), V3R(m[0])), 1e-6f));

// DO NOT write: auto m3 = (glm::mat3*)(&m);

// transpose 3x3

std::swap(r[0][1], r[1][0]);

std::swap(r[0][2], r[2][0]);

std::swap(r[1][2], r[2][1]);

glm::vec3& c3 = *(glm::vec3*)(&r[3]);

// rotate t -> T = r * t ==> glm::vec3(dot(row0(r), t), dot(row1(r), t), dot(row2(r), t), here row0(r) = col0(m)

c3 = -glm::vec3(glm::dot(V3R(m[0]), c3), glm::dot(V3R(m[1]), c3), glm::dot(V3R(m[2]), c3));

return id;

math_t id;

glm::vec4 &vv = allocvec4(M, &id);

vv = glm::rotate(QUAT(M, quat), VEC(M, v));

return id;

math_t id;

glm::vec4 &vv = allocvec4(M, &id);

vv = MAT(M, mat) * VEC(M, v);

return id;

math_t id;

glm::vec4 &r = allocvec4(M, &id);

check_type(M, v, MATH_TYPE_VEC4);

const float *vec = math_value(M, v);

if (vec[3] != 1.f){

glm::vec4 tmp ( vec[0], vec[1], vec[2], 1 );

r = MAT(M, mat) * tmp;

} else {

r = MAT(M, mat) * (*(const glm::vec4 *)(vec));

}

if (r.w != 0) {

r /= fabs(r.w);

r.w = 1.f;

}

return id;

math_t id;

glm::vec4 &vv = allocvec4(M, &id);

check_type(M, v, MATH_TYPE_VEC4);

const float *value = math_value(M, v);

const glm::vec4 & vec = *(const glm::vec4 *)(value);

vv = 1.f / vec;

vv[3] = value[3];

return id;

math_t id;

glm::mat4x4 &m = allocmat(M, &id);

const float *up;

if (math_isnull(up_id)) {

static const float default_up[3] = {0,1,0};

up = default_up;

} else {

check_type(M, up_id, MATH_TYPE_VEC4);

up = math_value(M, up_id);

}

const glm::vec3 &eyev = VEC3(M, eye);

if (direction) {

const glm::vec3 vat = eyev + VEC3(M, at);

m = glm::lookAtLH(eyev, vat, *(const glm::vec3 *)(up));

} else {

m = glm::lookAtLH(eyev, VEC3(M, at), *(const glm::vec3 *)(up));

}

return id;

float A, B;

if (flags.infinity_far){

if (flags.homogeneous_depth){

//(far+near) / (far-near);

// flags.invert_z ==> near/-near ==> -1

// far/far ==> 1

A = flags.invert_z ? -1.f : 1.f;

} else {

//far / (far-near);

//flags.invert_z ==> far/-near ==> -0 ==> -glm::epsilon<float>()

// ==> far/far ==> 1

A = flags.invert_z ? -glm::epsilon<float>() : 1.f;

}

// -(far*near) / (far-near)

//if invert_z ==> -far*near/-near = far

// ==> -far*near/far =-near

B = flags.invert_z ? far : -near;

} else {

const float zrange = far-near;

A = (flags.homogeneous_depth ? (far+near) : far) / zrange;

B =-(far*near) / zrange;

}

return glm::vec2(A, B);

{

if (flags.invert_z){

std::swap(near, far);

}

assert(abs(aspect - glm::epsilon<float>()) > 0);

const float tanHalfFovy = tan(fovy / 2);

glm::mat4 r(0);

r[0][0] = 1 / (aspect * tanHalfFovy);

r[1][1] = 1 / (tanHalfFovy);

r[2][3] = 1;

const glm::vec2 AB = perspective_AB(near, far, flags);

r[2][2] = AB[0];

r[3][2] = AB[1];

return r;

{

if (flags.invert_z){

std::swap(near, far);

}

const float xrange = (right - left);

const float yrange = (top - bottom);

glm::mat4 r(0);

r[0][0] = 2.f* near / xrange;

r[1][1] = 2.f* near / yrange;

r[2][0] = (right + left) / xrange;

r[2][1] = (top + bottom) / yrange;

r[2][3] = 1.f;

const glm::vec2 AB = perspective_AB(near, far, flags);

r[2][2] = AB[0];

r[3][2] = AB[1];

return r;

{

if (flags.invert_z){

std::swap(near, far);

}

glm::mat4 r(1);

const float xrange = (right - left);

const float yrange = (top - bottom);

r[0][0] = 2.f / xrange;

r[1][1] = 2.f / yrange;

r[3][0] =-(right + left)/xrange;

r[3][1] =-(top + bottom)/yrange;

if (flags.infinity_far){

//(1.f/(far-near)) | (2.f/(far-near)) ==> c/(far-near)

//flags.invert_z ==> c/-near ==> -0 ==>-glm::epsilon<float>()

// c/far ==> 0

r[2][2] = flags.invert_z ? -glm::epsilon<float>() : glm::epsilon<float>();

if (flags.homogeneous_depth){

//-(far+near)/(far-near);

//flags.invert_z ==> -near/-near ==> 1

// -far/far ==> -1

r[3][2] = flags.invert_z ? 1.f : -1.f;

} else {

//-near/(far-near);

//flags.invert_z ==> -near/-near ==> 1

// -0/far ==> -0 ==> -glm::epsilon<float>()

r[3][2] = flags.invert_z ? 1.f : -glm::epsilon<float>();

}

} else {

const float zrange = (far - near);

if (flags.homogeneous_depth){

r[2][2] = 2.f /zrange;

r[3][2] =-(far+near)/zrange;

} else {

r[2][2] = 1.f /zrange;

r[3][2] =-near/zrange;

}

}

return r;

math_t id;

glm::mat4x4 &mat = allocmat(M, &id);

mat = perspectiveLH(fov, aspect, near, far, flags);

return id;

math_t id;

glm::mat4x4 &mat = allocmat(M, &id);

mat = frustumLH(left, right, bottom, top, near, far, flags);

return id;

math_t id;

glm::mat4x4 &mat = allocmat(M, &id);

mat = orthoLH(left, right, bottom, top, near, far, flags);

return id;

math_t result = math_import(M, NULL, MATH_TYPE_VEC4, 2);

glm::vec4 &up = initvec4(M, math_index(M, result, 0));

glm::vec4 &right = initvec4(M, math_index(M, result, 1));

const glm::vec4 &forward = VEC(M, forward_id);

const glm::vec3 &forward3 = VEC3(M, forward_id);

if (is_equal(forward, ZAXIS)) {

up = YAXIS;

right = XAXIS;

} else {

if (is_equal(forward, YAXIS)) {

up = NZAXIS;

right = XAXIS;

} else if (is_equal(forward, NYAXIS)) {

up = ZAXIS;

right = XAXIS;

} else {

right = glm::vec4(glm::normalize(glm::cross(*(const glm::vec3 *)(&YAXIS.x), forward3)), 0);

up = glm::vec4(glm::normalize(glm::cross(forward3, *(const glm::vec3 *)(&right.x))), 0);

}

}

return result;

math_t id;

glm::vec4 &d = allocvec4(M, &id);

d = glm::rotate(QUAT(M, quat), glm::vec4(0, 0, 1, 0));

return id;

math_t id;

glm::vec4 &d = allocvec4(M, &id);

d = MAT(M, mat) * glm::vec4(0, 0, 1, 0);

return id;

float tmp[4] = {0, 0, 1, 0};

math_t vv = math_vec4(M, tmp);

return math3d_quat_between_2vectors(M, vv, v);

const float * left = math_value(M, v0);

const float * right = math_value(M, v1);

float tmp[4];

int left_n = 0;

int right_n = 0;

int i;

for (i=0;i<3;i++) {

if (left[i] <= right[i]) {

if (left[i] == right[i])

++right_n;

++left_n;

tmp[i] = left[i];

} else {

// left[i] > right[i]

++right_n;

tmp[i] = right[i];

}

}

if (left_n == 3) {

return v0;

} else if (right_n == 3) {

return v1;

}

tmp[3] = 0;

return math_vec4(M, tmp);

const float * left = math_value(M, v0);

const float * right = math_value(M, v1);

float tmp[4];

int left_n = 0;

int right_n = 0;

int i;

for (i=0;i<3;i++) {

if (left[i] >= right[i]) {

if (left[i] == right[i])

++right_n;

++left_n;

tmp[i] = left[i];

} else {

// left[i] < right[i]

++right_n;

tmp[i] = right[i];

}

}

if (left_n == 3) {

return v0;

} else if (right_n == 3) {

return v1;

}

tmp[3] = 0;

return math_vec4(M, tmp);

glm::vec4 v = VEC(M, p);

v.w = 1.f;//we assue p must be a point

v = m * v;

return v / v.w;

const size_t numpoints = math_size(M, points);

if (numpoints == 0)

return MATH_NULL;

const math_t p = math_index(M, points, 0);

glm::vec4 minmax[2];

if (math_isnull(transform)){

minmax[0] = minmax[1] = VEC(M, p);

for (int ii=1; ii<(int)numpoints; ++ii){

const auto& pp = VEC(M, math_index(M, points, ii));

minmax[0] = glm::min(minmax[0], pp);

minmax[1] = glm::max(minmax[1], pp);

}

} else {

const glm::mat4& m = MAT(M, transform);

minmax[0] = minmax[1] = transform_pt(M, m, p);

for (int ii=1; ii<(int)numpoints; ++ii){

const glm::vec4 tpp = transform_pt(M, m, math_index(M, points, ii));

minmax[0] = glm::min(minmax[0], tpp);

minmax[1] = glm::max(minmax[1], tpp);

}

}

return math_import(M, (const float*)minmax, MATH_TYPE_VEC4, 2);

check_type(M, aabblhs, MATH_TYPE_VEC4);

check_type(M, aabbrhs, MATH_TYPE_VEC4);

const math_t lhsmin = math_index(M, aabblhs, 0);

const math_t lhsmax = math_index(M, aabblhs, 1);

const math_t rhsmin = math_index(M, aabbrhs, 0);

const math_t rhsmax = math_index(M, aabbrhs, 1);

math_t min_id = minv(M, lhsmin, rhsmin);

math_t max_id = maxv(M, lhsmax, rhsmax);

if (math_issame(min_id, lhsmin) && math_issame(max_id, lhsmax)) {

return aabblhs;

}

if (math_issame(min_id, rhsmin) && math_issame(max_id, rhsmax)) {

return aabbrhs;

}

math_t r = math_import(M, NULL, MATH_TYPE_VEC4, 2);

float *value = math_init(M, r);

memcpy(value, math_value(M, min_id), 4 * sizeof(float));

memcpy(value+4, math_value(M, max_id), 4 * sizeof(float));

return r;

math_t id;

glm::vec4 &r = allocvec4(M, &id);

r = glm::lerp(VEC(M, v0), VEC(M, v1), ratio);

return id;

math_t id;

glm::quat &r = allocquat(M, &id);

r = glm::lerp(QUAT(M, v0), QUAT(M, v1), ratio);

return id;