////////////////////////////////////////////////////////////////////////////////

// Copyright 2017 Intel Corporation

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not

// use this file except in compliance with the License. You may obtain a copy

// of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

// License for the specific language governing permissions and limitations

// under the License.

////////////////////////////////////////////////////////////////////////////////

#include "sample_math.hpp"

#define _USE_MATH_DEFINES

#include <math.h>

#include <string.h>

void load_identity(float4x4 *m)

{

memset(m, 0, sizeof(*m));

m->_11 = 1.0f;

m->_22 = 1.0f;

m->_33 = 1.0f;

m->_44 = 1.0f;

}

void translate(float4x4 *m, float x, float y, float z)

{

m->_14 += m->_11*x + m->_12*y + m->_13*z;

m->_24 += m->_21*x + m->_22*y + m->_23*z;

m->_34 += m->_31*x + m->_32*y + m->_33*z;

m->_44 += m->_41*x + m->_42*y + m->_43*z;

}

void mult_matrix(float4x4 *m, const float4x4 *op)

{

float4x4 temp;

for (int c = 0; c < 4; ++c)

{

for (int r = 0; r < 4; ++r)

{

// column major ordering: mat[row, col] = m[col][row]

// matrix multiplication: out[row r, col c] = dot(row [r] of m, col [c] of op)

temp.m[c][r] =

m->m[0][r] * op->m[c][0] +

m->m[1][r] * op->m[c][1] +

m->m[2][r] * op->m[c][2] +

m->m[3][r] * op->m[c][3];

}

}

*m = temp;

}

void rotate(float4x4 *m, float degrees, float x, float y, float z)

{

float mag = sqrtf(x*x + y*y + z*z);

if (mag <= 0) return;

const float _deg2rad = float(M_PI / 180.0f);

float theta = degrees * _deg2rad;

float s = sinf(theta);

float c = cosf(theta);

float scale = 1.0f / mag;

x *= scale; y *= scale; z *= scale;

float xx = x*x, yy = y*y, zz = z*z;

float xy = x*y, yz = y*z, xz = x*z;

float xs = x*s, ys = y*s, zs = z*s;

float d = 1.0f - c;

float4x4 r;

r._11 = xx*d + c;

r._12 = xy*d - zs;

r._13 = xz*d + ys;

r._14 = 0.0f;

r._21 = xy*d + zs;

r._22 = yy*d + c;

r._23 = yz*d - xs;

r._24 = 0.0f;

r._31 = xz*d - ys;

r._32 = yz*d + xs;

r._33 = zz*d + c;

r._34 = 0.0f;

r._41 = 0.0f;

r._42 = 0.0f;

r._43 = 0.0f;

r._44 = 1.0f;

mult_matrix(m, &r);

}

void load_frustum(float4x4 *m,

float left, float right, float bottom, float top,

float near, float far, float near_depth, float far_depth)

{

float r_l, t_b, f_n;

memset(m, 0, sizeof(*m));

r_l = right - left;

m->_11 = 2 * near / r_l;

m->_13 = (right + left) / r_l;

t_b = top - bottom;

m->_22 = 2 * near / t_b;

m->_23 = (top + bottom) / t_b;

f_n = far - near;

m->_33 = (near*near_depth - far*far_depth) / f_n;

m->_34 = far*near*(near_depth - far_depth) / f_n;

m->_43 = -1.0f;

}

// simplified ortho:

// left = 0, right = width

// top = 0, bottom = height

// near = 0, far = depth

void load_simple_ortho(float4x4 *m, float width, float height, float depth, float near_depth, float far_depth)

{

memset(m, 0, sizeof(*m));

m->_11 = 2.0f / width;

m->_22 = -2.0f / height;

m->_33 = (near_depth - far_depth) / depth;

m->_14 = -1.0f;

m->_24 = 1.0f;

m->_34 = near_depth;

m->_44 = 1.0f;

}

// simplified frustum:

// square, centered on zero

void load_simple_perspective(float4x4 *m, float fov_y, float aspect, float near, float far, float near_depth, float far_depth)

{

const float _half_deg2rad_ = float(M_PI / 360.0);

float hh = tanf(fov_y * _half_deg2rad_) * near;

float hw = hh * aspect;

load_frustum(m, -hw, hw, -hh, hh, near, far, near_depth, far_depth);

}