Merge branch 'develop' into objloader-refactor
This commit is contained in:
h4570
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
# ______ ____ ___
|
||||
# | \/ ____| |___|
|
||||
# | | | \ | |
|
||||
#-----------------------------------------------------------------------
|
||||
# Copyright 2020, tyra - https://github.com/h4570/tyra
|
||||
# Licenced under Apache License 2.0
|
||||
# Michał Mostowik <mostek3pl@gmail.com>
|
||||
*/
|
||||
|
||||
#include "../include/models/bounding_box.hpp"
|
||||
#include "../include/utils/debug.hpp"
|
||||
#include <cstring>
|
||||
|
||||
/**
|
||||
* Construct a BoundingBox class
|
||||
* Allows for user friendly access to bounding box data.
|
||||
* @param t_vertices Array of 8 Vector3 elements.
|
||||
*/
|
||||
BoundingBox::BoundingBox(Vector3 *t_vertices)
|
||||
{
|
||||
//Perform a deep copy of vertex array parameter
|
||||
memcpy(_vertices, t_vertices, 8 * sizeof(Vector3));
|
||||
|
||||
//This might be shortened with Vector3 operator overloading, but current
|
||||
//implementation is more human readable.
|
||||
_height = _vertices[0].y - _vertices[2].y;
|
||||
_width = _vertices[0].x - _vertices[4].x;
|
||||
_depth = _vertices[0].z - _vertices[1].z;
|
||||
|
||||
_centerVector = _vertices[0];
|
||||
_centerVector.x += (_width / 2);
|
||||
_centerVector.y += (_height / 2);
|
||||
_centerVector.z += (_depth / 2);
|
||||
|
||||
//Z-Axis faces
|
||||
_frontFace = BoundingBoxFace(_vertices[1], _vertices[7], _vertices[1].z);
|
||||
_backFace = BoundingBoxFace(_vertices[0], _vertices[6], _vertices[0].z);
|
||||
//X-Axis faces
|
||||
_leftFace = BoundingBoxFace(_vertices[0], _vertices[3], _vertices[0].x);
|
||||
_rightFace = BoundingBoxFace(_vertices[4], _vertices[7], _vertices[4].x);
|
||||
//Y-Axis faces
|
||||
_topFace = BoundingBoxFace(_vertices[2], _vertices[7], _vertices[2].y);
|
||||
_bottomFace = BoundingBoxFace(_vertices[0], _vertices[5], _vertices[0].y);
|
||||
}
|
||||
|
||||
BoundingBox::~BoundingBox()
|
||||
{
|
||||
}
|
||||
+264
-216
@@ -17,11 +17,16 @@
|
||||
// Constructors/Destructors
|
||||
// ----
|
||||
|
||||
/** Create by specifying all points */
|
||||
Matrix::Matrix(float m11, float m12, float m13, float m14,
|
||||
float m21, float m22, float m23, float m24,
|
||||
float m31, float m32, float m33, float m34,
|
||||
float m41, float m42, float m43, float m44)
|
||||
Matrix::Matrix()
|
||||
{
|
||||
for (u8 i = 0; i < 16; i++)
|
||||
data[i] = 0.0F;
|
||||
}
|
||||
|
||||
Matrix::Matrix(const float &m11, const float &m12, const float &m13, const float &m14,
|
||||
const float &m21, const float &m22, const float &m23, const float &m24,
|
||||
const float &m31, const float &m32, const float &m33, const float &m34,
|
||||
const float &m41, const float &m42, const float &m43, const float &m44)
|
||||
{
|
||||
data[0] = m11;
|
||||
data[1] = m12;
|
||||
@@ -44,30 +49,34 @@ Matrix::Matrix(float m11, float m12, float m13, float m14,
|
||||
data[15] = m44;
|
||||
}
|
||||
|
||||
/** Create with another matrix values */
|
||||
Matrix::Matrix(const Matrix &v)
|
||||
// ----
|
||||
// Operators
|
||||
// ----
|
||||
|
||||
Vector3 Matrix::operator*(const Vector3 &v) const
|
||||
{
|
||||
data[0] = v.data[0];
|
||||
data[1] = v.data[1];
|
||||
data[2] = v.data[2];
|
||||
data[3] = v.data[3];
|
||||
|
||||
data[4] = v.data[4];
|
||||
data[5] = v.data[5];
|
||||
data[6] = v.data[6];
|
||||
data[7] = v.data[7];
|
||||
|
||||
data[8] = v.data[8];
|
||||
data[9] = v.data[9];
|
||||
data[10] = v.data[10];
|
||||
data[11] = v.data[11];
|
||||
|
||||
data[12] = v.data[12];
|
||||
data[13] = v.data[13];
|
||||
data[14] = v.data[14];
|
||||
data[15] = v.data[15];
|
||||
float a[4] = {v.x, v.y, v.z, 1.0F};
|
||||
float res[4];
|
||||
asm volatile(
|
||||
"lqc2 vf4, 0x00(%1) \n\t"
|
||||
"lqc2 vf5, 0x10(%1) \n\t"
|
||||
"lqc2 vf6, 0x20(%1) \n\t"
|
||||
"lqc2 vf7, 0x30(%1) \n\t"
|
||||
"lqc2 vf8, 0x00(%2) \n\t"
|
||||
"vmulax.xyzw ACC, vf4, vf8 \n\t"
|
||||
"vmadday.xyzw ACC, vf5, vf8 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf6, vf8 \n\t"
|
||||
"vmaddw.xyzw vf9, vf7, vf8 \n\t"
|
||||
"sqc2 vf9, 0x00(%0) \n\t"
|
||||
:
|
||||
: "r"(res), "r"(this->data), "r"(a));
|
||||
return Vector3(res[0], res[1], res[2]);
|
||||
}
|
||||
|
||||
// ----
|
||||
// Functions
|
||||
// ----
|
||||
|
||||
void Matrix::identity()
|
||||
{
|
||||
asm volatile(
|
||||
@@ -84,166 +93,7 @@ void Matrix::identity()
|
||||
: "r"(this->data));
|
||||
}
|
||||
|
||||
void Matrix::translate(const Vector3 &t_val)
|
||||
{
|
||||
this->data[12] += t_val.x; // 3,0
|
||||
this->data[13] += t_val.y; // 3,1
|
||||
this->data[14] += t_val.z; // 3,2
|
||||
}
|
||||
|
||||
void Matrix::rotateX(const float &t_radians)
|
||||
{
|
||||
Matrix temp = Matrix();
|
||||
temp.identity();
|
||||
float c = Math::cos(t_radians);
|
||||
float s = Math::sin(t_radians);
|
||||
this->data[5] = c; // 1,1
|
||||
this->data[6] = s; // 1,2
|
||||
this->data[9] = -s; // 2,1
|
||||
this->data[10] = c; // 2,2
|
||||
}
|
||||
|
||||
void Matrix::rotateY(const float &t_radians)
|
||||
{
|
||||
Matrix temp = Matrix();
|
||||
temp.identity();
|
||||
float c = Math::cos(t_radians);
|
||||
float s = Math::sin(t_radians);
|
||||
this->data[0] = c; // 0,0
|
||||
this->data[2] = -s; // 0,3
|
||||
this->data[8] = s; // 2,0
|
||||
this->data[10] = c; // 2,2
|
||||
}
|
||||
|
||||
void Matrix::rotateZ(const float &t_radians)
|
||||
{
|
||||
Matrix temp = Matrix();
|
||||
temp.identity();
|
||||
float c = Math::cos(t_radians);
|
||||
float s = Math::sin(t_radians);
|
||||
this->data[0] = c; // 0,0
|
||||
this->data[1] = s; // 0,1
|
||||
this->data[4] = -s; // 1,0
|
||||
this->data[5] = c; // 1,1
|
||||
}
|
||||
|
||||
Matrix Matrix::operator*(const Matrix &t)
|
||||
{
|
||||
Matrix result;
|
||||
asm volatile(
|
||||
"lqc2 vf1, 0x00(%1) \n\t"
|
||||
"lqc2 vf2, 0x10(%1) \n\t"
|
||||
"lqc2 vf3, 0x20(%1) \n\t"
|
||||
"lqc2 vf4, 0x30(%1) \n\t"
|
||||
"lqc2 vf5, 0x00(%2) \n\t"
|
||||
"lqc2 vf6, 0x10(%2) \n\t"
|
||||
"lqc2 vf7, 0x20(%2) \n\t"
|
||||
"lqc2 vf8, 0x30(%2) \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf1 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf1 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf1 \n\t"
|
||||
"vmaddw.xyzw vf1, vf8, vf1 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf2 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf2 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf2 \n\t"
|
||||
"vmaddw.xyzw vf2, vf8, vf2 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf3 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf3 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf3 \n\t"
|
||||
"vmaddw.xyzw vf3, vf8, vf3 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf4 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf4 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf4 \n\t"
|
||||
"vmaddw.xyzw vf4, vf8, vf4 \n\t"
|
||||
"sqc2 vf1, 0x00(%0) \n\t"
|
||||
"sqc2 vf2, 0x10(%0) \n\t"
|
||||
"sqc2 vf3, 0x20(%0) \n\t"
|
||||
"sqc2 vf4, 0x30(%0) \n\t"
|
||||
:
|
||||
: "r"(result.data), "r"(this->data), "r"(t.data)
|
||||
: "memory");
|
||||
return result;
|
||||
}
|
||||
|
||||
void Matrix::operator*=(const Matrix &t)
|
||||
{
|
||||
asm volatile(
|
||||
"lqc2 vf1, 0x00(%1) \n\t"
|
||||
"lqc2 vf2, 0x10(%1) \n\t"
|
||||
"lqc2 vf3, 0x20(%1) \n\t"
|
||||
"lqc2 vf4, 0x30(%1) \n\t"
|
||||
"lqc2 vf5, 0x00(%2) \n\t"
|
||||
"lqc2 vf6, 0x10(%2) \n\t"
|
||||
"lqc2 vf7, 0x20(%2) \n\t"
|
||||
"lqc2 vf8, 0x30(%2) \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf1 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf1 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf1 \n\t"
|
||||
"vmaddw.xyzw vf1, vf8, vf1 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf2 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf2 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf2 \n\t"
|
||||
"vmaddw.xyzw vf2, vf8, vf2 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf3 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf3 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf3 \n\t"
|
||||
"vmaddw.xyzw vf3, vf8, vf3 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf4 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf4 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf4 \n\t"
|
||||
"vmaddw.xyzw vf4, vf8, vf4 \n\t"
|
||||
"sqc2 vf1, 0x00(%0) \n\t"
|
||||
"sqc2 vf2, 0x10(%0) \n\t"
|
||||
"sqc2 vf3, 0x20(%0) \n\t"
|
||||
"sqc2 vf4, 0x30(%0) \n\t"
|
||||
:
|
||||
: "r"(this->data), "r"(this->data), "r"(t.data)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
/** Create empty matrix */
|
||||
Matrix::Matrix()
|
||||
{
|
||||
data[0] = 0.0F;
|
||||
data[1] = 0.0F;
|
||||
data[2] = 0.0F;
|
||||
data[3] = 0.0F;
|
||||
|
||||
data[4] = 0.0F;
|
||||
data[5] = 0.0F;
|
||||
data[6] = 0.0F;
|
||||
data[7] = 0.0F;
|
||||
|
||||
data[8] = 0.0F;
|
||||
data[9] = 0.0F;
|
||||
data[10] = 0.0F;
|
||||
data[11] = 0.0F;
|
||||
|
||||
data[12] = 0.0F;
|
||||
data[13] = 0.0F;
|
||||
data[14] = 0.0F;
|
||||
data[15] = 0.0F;
|
||||
}
|
||||
|
||||
Matrix::~Matrix() {}
|
||||
|
||||
// ----
|
||||
// Methods
|
||||
// ----
|
||||
|
||||
/** Set up a perspective projection matrix
|
||||
*
|
||||
* Clone of gluPerspective()
|
||||
* https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml
|
||||
* @param fov (FOV in radians)/2
|
||||
* @param aspect Aspect ratio
|
||||
* @param scrW Half of screen width
|
||||
* @param scrH Half of screen height
|
||||
* @param zNear Distance to near plane
|
||||
* @param zFar Distance to far plane
|
||||
* @param projScale Projection scale
|
||||
*/
|
||||
void Matrix::setPerspective(ScreenSettings &t_screen)
|
||||
void Matrix::setPerspective(const ScreenSettings &t_screen)
|
||||
{
|
||||
float fovYdiv2 = Math::HALF_ANG2RAD * t_screen.fov;
|
||||
float cotFOV = 1.0F / (Math::sin(fovYdiv2) / Math::cos(fovYdiv2));
|
||||
@@ -275,42 +125,57 @@ void Matrix::setPerspective(ScreenSettings &t_screen)
|
||||
this->data[15] = 0.0F;
|
||||
}
|
||||
|
||||
/** Create a view matrix that transforms coordinates in
|
||||
* such a way that the user looks at a target vector
|
||||
* direction from a position vector.
|
||||
*
|
||||
* Clone of OpenGL lookAt function
|
||||
* https://learnopengl.com/Getting-started/Camera
|
||||
*/
|
||||
void Matrix::lookAt(Vector3 &t_up, Vector3 &t_position, Vector3 &t_target)
|
||||
void Matrix::lookAt(const Vector3 &t_position, const Vector3 &t_target)
|
||||
{
|
||||
Vector3 camForward, camUp, camRight;
|
||||
VECTOR up_vec, view_vec;
|
||||
VECTOR eye = {t_position.x, t_position.y, t_position.z, 1.0F};
|
||||
VECTOR obj = {t_target.x, t_target.y, t_target.z, 1.0F};
|
||||
asm volatile(
|
||||
"lqc2 vf4, 0x00(%2) # eye \n\t"
|
||||
"lqc2 vf5, 0x00(%3) # obj \n\t"
|
||||
"vsub.xyz vf7, vf4, vf5 # view_vec = vf7 \n\t"
|
||||
"vmove.xyzw vf6, vf0 \n\t"
|
||||
"vaddw.y vf6, vf0, vf0 # vf6 = { 0.0f, 1.0f, 0.0f, 1.0f } \n\t"
|
||||
"vopmula.xyz ACC, vf6, vf7 \n\t"
|
||||
"vopmsub.xyz vf9, vf7, vf6 # vec = vf9 \n\t"
|
||||
"vopmula.xyz ACC, vf7, vf9 \n\t"
|
||||
"vopmsub.xyz vf8, vf9, vf7 # up_vec = vf8 \n\t"
|
||||
"sqc2 vf7, 0x00(%0) # view_vec \n\t"
|
||||
"sqc2 vf6, 0x00(%1) # up_vec \n\t"
|
||||
:
|
||||
: "r"(view_vec), "r"(up_vec), "r"(eye), "r"(obj));
|
||||
Matrix temp;
|
||||
temp.setCamera(eye, view_vec, up_vec);
|
||||
identity();
|
||||
cross(this->data, this->data, temp.data);
|
||||
|
||||
camForward = t_position - t_target;
|
||||
camForward.normalize();
|
||||
camRight = t_up * camForward;
|
||||
camRight.normalize();
|
||||
camUp = camForward * camRight;
|
||||
// Vector3 camForward, camUp, camRight;
|
||||
// Vector3 t_up = Vector3(0.0F, 1.0F, 0.0F);
|
||||
// camForward = t_position - t_target;
|
||||
// camForward.normalize();
|
||||
// camRight = t_up * camForward;
|
||||
// camRight.normalize();
|
||||
// camUp = camForward * camRight;
|
||||
|
||||
data[0] = camRight.x;
|
||||
data[4] = camRight.y;
|
||||
data[8] = camRight.z;
|
||||
data[12] = -camRight.innerProduct(t_position);
|
||||
// data[0] = camRight.x;
|
||||
// data[4] = camRight.y;
|
||||
// data[8] = camRight.z;
|
||||
// data[12] = -camRight.innerProduct(t_position);
|
||||
|
||||
data[1] = camUp.x;
|
||||
data[5] = camUp.y;
|
||||
data[9] = camUp.z;
|
||||
data[13] = -camUp.innerProduct(t_position);
|
||||
// data[1] = camUp.x;
|
||||
// data[5] = camUp.y;
|
||||
// data[9] = camUp.z;
|
||||
// data[13] = -camUp.innerProduct(t_position);
|
||||
|
||||
data[2] = camForward.x;
|
||||
data[6] = camForward.y;
|
||||
data[10] = camForward.z;
|
||||
data[14] = -camForward.innerProduct(t_position);
|
||||
// data[2] = camForward.x;
|
||||
// data[6] = camForward.y;
|
||||
// data[10] = camForward.z;
|
||||
// data[14] = -camForward.innerProduct(t_position);
|
||||
|
||||
data[3] = 0;
|
||||
data[7] = 0;
|
||||
data[11] = 0;
|
||||
data[15] = 1;
|
||||
// data[3] = 0;
|
||||
// data[7] = 0;
|
||||
// data[11] = 0;
|
||||
// data[15] = 1;
|
||||
}
|
||||
|
||||
const void Matrix::print() const
|
||||
@@ -321,3 +186,186 @@ const void Matrix::print() const
|
||||
data[8], data[9], data[10], data[11],
|
||||
data[12], data[13], data[14], data[15]);
|
||||
}
|
||||
|
||||
// ----
|
||||
// Private
|
||||
// ----
|
||||
|
||||
void Matrix::rotationX(const float &t_radians)
|
||||
{
|
||||
float c = Math::cos(t_radians);
|
||||
float s = Math::sin(t_radians);
|
||||
this->data[5] = c; // 1,1
|
||||
this->data[6] = s; // 1,2
|
||||
this->data[9] = -s; // 2,1
|
||||
this->data[10] = c; // 2,2
|
||||
}
|
||||
|
||||
void Matrix::rotationY(const float &t_radians)
|
||||
{
|
||||
float c = Math::cos(t_radians);
|
||||
float s = Math::sin(t_radians);
|
||||
this->data[0] = c; // 0,0
|
||||
this->data[2] = -s; // 0,3
|
||||
this->data[8] = s; // 2,0
|
||||
this->data[10] = c; // 2,2
|
||||
}
|
||||
|
||||
void Matrix::rotationZ(const float &t_radians)
|
||||
{
|
||||
float c = Math::cos(t_radians);
|
||||
float s = Math::sin(t_radians);
|
||||
this->data[0] = c; // 0,0
|
||||
this->data[1] = s; // 0,1
|
||||
this->data[4] = -s; // 1,0
|
||||
this->data[5] = c; // 1,1
|
||||
}
|
||||
|
||||
void Matrix::rotationByAngle(const float &t_angle, const Vector3 &t_axis)
|
||||
{
|
||||
Vector3 localAxis = Vector3(t_axis);
|
||||
localAxis.normalize();
|
||||
float x = localAxis.x;
|
||||
float y = localAxis.y;
|
||||
float z = localAxis.z;
|
||||
|
||||
float c = Math::cos(t_angle);
|
||||
float s = Math::sin(t_angle);
|
||||
|
||||
this->data[0] = x * x * (1 - c) + c;
|
||||
this->data[1] = y * x * (1 - c) + z * s;
|
||||
this->data[2] = x * z * (1 - c) - y * s;
|
||||
this->data[3] = 0.0F;
|
||||
|
||||
this->data[4] = x * y * (1 - c) - z * s;
|
||||
this->data[5] = y * y * (1 - c) + c;
|
||||
this->data[6] = y * z * (1 - c) + x * s;
|
||||
this->data[7] = 0.0F;
|
||||
|
||||
this->data[8] = x * z * (1 - c) + y * s;
|
||||
this->data[9] = y * z * (1 - c) - x * s;
|
||||
this->data[10] = z * z * (1 - c) + c;
|
||||
this->data[11] = 0.0F;
|
||||
|
||||
this->data[12] = 0.0F;
|
||||
this->data[13] = 0.0F;
|
||||
this->data[14] = 0.0F;
|
||||
this->data[15] = 1.0F;
|
||||
}
|
||||
|
||||
void Matrix::translation(const Vector3 &t_val)
|
||||
{
|
||||
this->data[12] = t_val.x; // 3,0
|
||||
this->data[13] = t_val.y; // 3,1
|
||||
this->data[14] = t_val.z; // 3,2
|
||||
}
|
||||
|
||||
void Matrix::setScale(const Vector3 &t_val)
|
||||
{
|
||||
this->data[0] = t_val.x;
|
||||
this->data[5] = t_val.y;
|
||||
this->data[10] = t_val.z;
|
||||
this->data[15] = 1.0F;
|
||||
}
|
||||
|
||||
void Matrix::setCamera(const float t_pos[4], const float t_vz[4], const float t_vy[4])
|
||||
{
|
||||
// Matrix vf4, vf5, vf6, vf7
|
||||
// t_pos vf8
|
||||
// t_vz vf9
|
||||
// t_vy vf10
|
||||
// vtmp vf11
|
||||
asm volatile(
|
||||
"lqc2 vf9, 0x00(%2) \n\t"
|
||||
"lqc2 vf10, 0x00(%3) \n\t"
|
||||
// mtmp.unit()
|
||||
"vsub.w vf5, vf0, vf0 # mtmp[1][PW] = 0.0F \n\t"
|
||||
// vtmp.outerProduct(vy, vz);
|
||||
"vopmula.xyz ACC, vf10, vf9 \n\t"
|
||||
"vopmsub.xyz vf11, vf9, vf10 \n\t"
|
||||
// mtmp[0] = vtmp.normalize();
|
||||
"vmul.xyz vf12, vf11, vf11 \n\t"
|
||||
"vaddy.x vf12, vf12, vf12 \n\t"
|
||||
"vaddz.x vf12, vf12, vf12 \n\t"
|
||||
"vrsqrt Q, vf0w, vf12x \n\t"
|
||||
"vsub.xyzw vf4, vf0, vf0 \n\t"
|
||||
"vwaitq \n\t"
|
||||
"vmulq.xyz vf4, vf11, Q \n\t"
|
||||
// mtmp[2] = vz.normalize();
|
||||
"vmul.xyz vf12, vf9, vf9 \n\t"
|
||||
"vaddy.x vf12, vf12, vf12 \n\t"
|
||||
"vaddz.x vf12, vf12, vf12 \n\t"
|
||||
"vrsqrt Q, vf0w, vf12x \n\t"
|
||||
"vsub.xyzw vf6, vf0, vf0 \n\t"
|
||||
"vwaitq \n\t"
|
||||
"vmulq.xyz vf6, vf9, Q \n\t"
|
||||
// mtmp[1].outerProduct(mtmp[2], mtmp[0]);
|
||||
"vopmula.xyz ACC, vf6, vf4 \n\t"
|
||||
"vopmsub.xyz vf5, vf4, vf6 \n\t"
|
||||
// mtmp.transpose(pos);
|
||||
"lqc2 vf7, 0x00(%1) \n\t"
|
||||
// m = mtmp.inverse();
|
||||
"qmfc2.ni $11, vf0 \n\t"
|
||||
"qmfc2.ni $8, vf4 \n\t"
|
||||
"qmfc2.ni $9, vf5 \n\t"
|
||||
"qmfc2.ni $10, vf6 \n\t"
|
||||
|
||||
"pextlw $12, $9, $8 \n\t"
|
||||
"pextuw $13, $9, $8 \n\t"
|
||||
"pextlw $14, $11, $10 \n\t"
|
||||
"pextuw $15, $11, $10 \n\t"
|
||||
"pcpyld $8, $14, $12 \n\t"
|
||||
"pcpyud $9, $12, $14 \n\t"
|
||||
"pcpyld $10, $15, $13 \n\t"
|
||||
|
||||
"qmtc2.ni $8, vf16 \n\t"
|
||||
"qmtc2.ni $9, vf17 \n\t"
|
||||
"qmtc2.ni $10, vf18 \n\t"
|
||||
"vmulax.xyz ACC, vf16, vf7 \n\t"
|
||||
"vmadday.xyz ACC, vf17, vf7 \n\t"
|
||||
"vmaddz.xyz vf5, vf18, vf7 \n\t"
|
||||
"vsub.xyzw vf5, vf0, vf5 \n\t"
|
||||
|
||||
"sq $8, 0x00(%0) \n\t"
|
||||
"sq $9, 0x10(%0) \n\t"
|
||||
"sq $10, 0x20(%0) \n\t"
|
||||
"sqc2 vf5, 0x30(%0) \n\t"
|
||||
:
|
||||
: "r"(this->data), "r"(t_pos), "r"(t_vz), "r"(t_vy));
|
||||
}
|
||||
|
||||
void Matrix::cross(float res[16], const float a[16], const float b[16]) const
|
||||
{
|
||||
asm volatile(
|
||||
"lqc2 vf1, 0x00(%1) \n\t"
|
||||
"lqc2 vf2, 0x10(%1) \n\t"
|
||||
"lqc2 vf3, 0x20(%1) \n\t"
|
||||
"lqc2 vf4, 0x30(%1) \n\t"
|
||||
"lqc2 vf5, 0x00(%2) \n\t"
|
||||
"lqc2 vf6, 0x10(%2) \n\t"
|
||||
"lqc2 vf7, 0x20(%2) \n\t"
|
||||
"lqc2 vf8, 0x30(%2) \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf1 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf1 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf1 \n\t"
|
||||
"vmaddw.xyzw vf1, vf8, vf1 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf2 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf2 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf2 \n\t"
|
||||
"vmaddw.xyzw vf2, vf8, vf2 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf3 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf3 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf3 \n\t"
|
||||
"vmaddw.xyzw vf3, vf8, vf3 \n\t"
|
||||
"vmulax.xyzw ACC, vf5, vf4 \n\t"
|
||||
"vmadday.xyzw ACC, vf6, vf4 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf7, vf4 \n\t"
|
||||
"vmaddw.xyzw vf4, vf8, vf4 \n\t"
|
||||
"sqc2 vf1, 0x00(%0) \n\t"
|
||||
"sqc2 vf2, 0x10(%0) \n\t"
|
||||
"sqc2 vf3, 0x20(%0) \n\t"
|
||||
"sqc2 vf4, 0x30(%0) \n\t"
|
||||
:
|
||||
: "r"(res), "r"(b), "r"(a)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
+100
-181
@@ -9,63 +9,24 @@
|
||||
*/
|
||||
|
||||
#include "../../include/models/math/vector3.hpp"
|
||||
|
||||
#include "../../include/utils/math.hpp"
|
||||
#include <stdio.h>
|
||||
|
||||
// ----
|
||||
// Constructors/Destructors
|
||||
// ----
|
||||
|
||||
/** Create by specifying 3 points */
|
||||
Vector3::Vector3(float t_x, float t_y, float t_z)
|
||||
{
|
||||
x = t_x;
|
||||
y = t_y;
|
||||
z = t_z;
|
||||
}
|
||||
|
||||
/** Create with another vector values */
|
||||
Vector3::Vector3(const Vector3 &another)
|
||||
{
|
||||
x = another.x;
|
||||
y = another.y;
|
||||
z = another.z;
|
||||
}
|
||||
|
||||
void Vector3::setByLerp(const Vector3 &v1, const Vector3 &v2, const float &t_interp, const float &t_scale)
|
||||
{
|
||||
asm volatile(
|
||||
"lqc2 vf4, 0x0(%1) \n\t" // vf4 = v1
|
||||
"lqc2 vf5, 0x0(%2) \n\t" // vf5 = v2
|
||||
"mfc1 $8, %3 \n\t" // vf6 = t
|
||||
"qmtc2 $8, vf6 \n\t" // lerp:
|
||||
"vsub.xyz vf7, vf5, vf4 \n\t" // vf7 = v2 - v1
|
||||
"vmulx.xyz vf8, vf7, vf6 \n\t" // vf8 = vf7 * t
|
||||
"vadd.xyz vf9, vf8, vf4 \n\t" // vf9 = vf8 + vf4
|
||||
"sqc2 vf9, 0x0(%0) \n\t" // v0 = vf9
|
||||
:
|
||||
: "r"(&this->xyz), "r"(&v1.xyz), "r"(&v2.xyz), "f"(t_interp));
|
||||
x *= t_scale;
|
||||
y *= t_scale;
|
||||
z *= t_scale;
|
||||
}
|
||||
|
||||
/** Create empty vector */
|
||||
Vector3::Vector3()
|
||||
{
|
||||
x = 0;
|
||||
y = 0;
|
||||
z = 0;
|
||||
x = 0.0F;
|
||||
y = 0.0F;
|
||||
z = 0.0F;
|
||||
}
|
||||
|
||||
Vector3::~Vector3() {}
|
||||
|
||||
// ----
|
||||
// Methods
|
||||
// Operators
|
||||
// ----
|
||||
|
||||
Vector3 Vector3::operator+(Vector3 v)
|
||||
Vector3 Vector3::operator+(const Vector3 &v) const
|
||||
{
|
||||
Vector3 result;
|
||||
asm volatile( // VU0 Macro program
|
||||
@@ -78,7 +39,7 @@ Vector3 Vector3::operator+(Vector3 v)
|
||||
return result;
|
||||
}
|
||||
|
||||
Vector3 Vector3::operator-(const Vector3 &v)
|
||||
Vector3 Vector3::operator-(const Vector3 &v) const
|
||||
{
|
||||
Vector3 result;
|
||||
asm volatile( // VU0 Macro program
|
||||
@@ -91,17 +52,7 @@ Vector3 Vector3::operator-(const Vector3 &v)
|
||||
return result;
|
||||
}
|
||||
|
||||
Vector3 Vector3::operator-(void)
|
||||
{
|
||||
Vector3 result;
|
||||
result.x = -x;
|
||||
result.y = -y;
|
||||
result.z = -z;
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Also called "cross product" */
|
||||
Vector3 Vector3::operator*(Vector3 &v)
|
||||
Vector3 Vector3::operator*(const Vector3 &v) const
|
||||
{
|
||||
Vector3 res;
|
||||
asm volatile( // VU0 Macro program
|
||||
@@ -119,7 +70,7 @@ Vector3 Vector3::operator*(Vector3 &v)
|
||||
return res;
|
||||
}
|
||||
|
||||
Vector3 Vector3::operator*(const float &t)
|
||||
Vector3 Vector3::operator*(const float &t) const
|
||||
{
|
||||
Vector3 result;
|
||||
asm volatile(
|
||||
@@ -133,6 +84,26 @@ Vector3 Vector3::operator*(const float &t)
|
||||
return result;
|
||||
}
|
||||
|
||||
Vector3 Vector3::operator/(const float &t) const
|
||||
{
|
||||
Vector3 result;
|
||||
result.x = x / t;
|
||||
result.y = y / t;
|
||||
result.z = z / t;
|
||||
return result;
|
||||
}
|
||||
|
||||
void Vector3::operator+=(const Vector3 &t)
|
||||
{
|
||||
asm volatile( // VU0 Macro program
|
||||
"lqc2 vf4, 0x0(%0) \n\t"
|
||||
"lqc2 vf5, 0x0(%1) \n\t"
|
||||
"vadd.xyz vf4, vf4, vf5 \n\t"
|
||||
"sqc2 vf4, 0x0(%0) \n\t"
|
||||
:
|
||||
: "r"(this->xyz), "r"(t.xyz));
|
||||
}
|
||||
|
||||
void Vector3::operator*=(const float &t)
|
||||
{
|
||||
asm volatile(
|
||||
@@ -145,54 +116,46 @@ void Vector3::operator*=(const float &t)
|
||||
: "r"(this->xyz), "f"(t));
|
||||
}
|
||||
|
||||
Vector3 Vector3::operator/(float t)
|
||||
// ----
|
||||
// Functions
|
||||
// ----
|
||||
|
||||
void Vector3::set(const Vector3 &v)
|
||||
{
|
||||
Vector3 result;
|
||||
result.x = x / t;
|
||||
result.y = y / t;
|
||||
result.z = z / t;
|
||||
asm volatile( // VU0 Macro program
|
||||
"lq $6, 0x0(%1) \n\t"
|
||||
"sq $6, 0x0(%0) \n\t"
|
||||
:
|
||||
: "r"(this->xyz), "r"(v.xyz));
|
||||
}
|
||||
|
||||
void Vector3::set(const float &t_x, const float &t_y, const float &t_z)
|
||||
{
|
||||
x = t_x;
|
||||
y = t_y;
|
||||
z = t_z;
|
||||
}
|
||||
|
||||
float Vector3::innerProduct(const Vector3 &v) const
|
||||
{
|
||||
float result;
|
||||
asm volatile( // VU0 Macro program
|
||||
"lqc2 vf4, 0x0(%1) \n\t"
|
||||
"lqc2 vf5, 0x0(%2) \n\t"
|
||||
"vmul.xyz vf6, vf4, vf5 \n\t"
|
||||
"vaddy.x vf6, vf6, vf6 \n\t"
|
||||
"vaddz.x vf6, vf6, vf6 \n\t"
|
||||
"qmfc2 $2, vf6 \n\t"
|
||||
"mtc1 $2, %0 \n\t"
|
||||
: "=f"(result)
|
||||
: "r"(this->xyz), "r"(v.xyz));
|
||||
return result;
|
||||
// return (x * v.x + y * v.y + z * v.z);
|
||||
}
|
||||
|
||||
u8 Vector3::shouldBeBackfaceCulled(const Vector3 *t_cameraPos, const Vector3 *v0, const Vector3 *v1, const Vector3 *v2)
|
||||
float Vector3::length() const
|
||||
{
|
||||
register float dot;
|
||||
asm volatile(
|
||||
"lqc2 vf4, 0x0(%1) \n\t" // vf4 = cameraPos
|
||||
"lqc2 vf5, 0x0(%2) \n\t" // vf5 = v0
|
||||
"lqc2 vf6, 0x0(%3) \n\t" // vf6 = v1
|
||||
"lqc2 vf7, 0x0(%4) \n\t" // vf7 = v2
|
||||
"vsub.xyz vf8, vf7, vf5 \n\t" // vf8 = vf7(v2) - vf5(v0)
|
||||
"vsub.xyz vf9, vf6, vf5 \n\t" // vf9 = vf6(v1) - vf5(v0)
|
||||
"vopmula.xyz ACC, vf8, vf9 \n\t" // vf6 = cross(vf8, vf9)
|
||||
"vopmsub.xyz vf6, vf9, vf8 \n\t"
|
||||
"vsub.w vf6, vf6, vf6 \n\t"
|
||||
"vsub.xyz vf7, vf5, vf4 \n\t" // vf7 = vf5(v0) - vf4(cameraPos)
|
||||
"vmul.xyz vf5, vf7, vf6 \n\t" // vf5 = dot(vf7, vf6)
|
||||
"vaddy.x vf5, vf5, vf5 \n\t"
|
||||
"vaddz.x vf5, vf5, vf5 \n\t"
|
||||
"qmfc2 $2, vf5 \n\t" // store result on `dot` variable
|
||||
"mtc1 $2, %0 \n\t"
|
||||
: "=f"(dot)
|
||||
: "r"(t_cameraPos->xyz), "r"(v0->xyz), "r"(v1->xyz), "r"(v2->xyz));
|
||||
return dot <= 0.0F;
|
||||
}
|
||||
|
||||
/** Checks intersection with given square */
|
||||
u8 Vector3::collidesSquare(const Vector3 &t_min, const Vector3 &t_max) const
|
||||
{
|
||||
return ((this->x <= t_max.x && this->x >= t_min.x) && (this->y < t_max.y && this->y >= t_min.y) && (this->z <= t_max.z && this->z >= t_min.z)) ? 1 : 0;
|
||||
}
|
||||
|
||||
/** Checks is this vector is on given square */
|
||||
u8 Vector3::isOnSquare(const Vector3 &t_min, const Vector3 &t_max) const
|
||||
{
|
||||
return ((this->x <= t_max.x && this->x >= t_min.x) && (this->y >= t_max.y) && (this->z <= t_max.z && this->z >= t_min.z)) ? 1 : 0;
|
||||
}
|
||||
|
||||
float Vector3::length()
|
||||
{
|
||||
register float result;
|
||||
float result;
|
||||
asm volatile( // VU0 Macro program
|
||||
"lqc2 vf4, 0x0(%1) \n\t"
|
||||
"vmul.xyz vf5, vf4, vf4 \n\t"
|
||||
@@ -227,85 +190,6 @@ void Vector3::normalize()
|
||||
: "r"(this->xyz));
|
||||
}
|
||||
|
||||
/** Also called dot3 */
|
||||
float Vector3::innerProduct(Vector3 &v)
|
||||
{
|
||||
register float result;
|
||||
asm volatile( // VU0 Macro program
|
||||
"lqc2 vf4, 0x0(%1) \n\t"
|
||||
"lqc2 vf5, 0x0(%2) \n\t"
|
||||
"vmul.xyz vf6, vf4, vf5 \n\t"
|
||||
"vaddy.x vf6, vf6, vf6 \n\t"
|
||||
"vaddz.x vf6, vf6, vf6 \n\t"
|
||||
"qmfc2 $2, vf6 \n\t"
|
||||
"mtc1 $2, %0 \n\t"
|
||||
: "=f"(result)
|
||||
: "r"(this->xyz), "r"(v.xyz));
|
||||
return result;
|
||||
// return (x * v.x + y * v.y + z * v.z);
|
||||
}
|
||||
|
||||
void Vector3::set(const float &t_x, const float &t_y, const float &t_z)
|
||||
{
|
||||
x = t_x;
|
||||
y = t_y;
|
||||
z = t_z;
|
||||
}
|
||||
|
||||
void Vector3::rotate(const Vector3 &v, u8 inversed)
|
||||
{
|
||||
VECTOR cameraPos = {x, y, z, 0.0F};
|
||||
VECTOR rotation;
|
||||
if (inversed)
|
||||
{
|
||||
rotation[0] = -v.x;
|
||||
rotation[1] = -v.y;
|
||||
rotation[2] = -v.z;
|
||||
}
|
||||
else
|
||||
{
|
||||
rotation[0] = v.x;
|
||||
rotation[1] = v.y;
|
||||
rotation[2] = v.z;
|
||||
}
|
||||
rotation[3] = 0.0F;
|
||||
|
||||
MATRIX rotationMatrix;
|
||||
matrix_unit(rotationMatrix);
|
||||
matrix_rotate(rotationMatrix, rotationMatrix, rotation);
|
||||
VECTOR result;
|
||||
asm volatile(
|
||||
"lqc2 vf4, 0x0(%1) \n\t"
|
||||
"lqc2 vf5, 0x10(%1) \n\t"
|
||||
"lqc2 vf6, 0x20(%1) \n\t"
|
||||
"lqc2 vf7, 0x30(%1) \n\t"
|
||||
"lqc2 vf8, 0x0(%2) \n\t"
|
||||
"vmulax.xyzw ACC, vf4, vf8 \n\t"
|
||||
"vmadday.xyzw ACC, vf5, vf8 \n\t"
|
||||
"vmaddaz.xyzw ACC, vf6, vf8 \n\t"
|
||||
"vmaddw.xyzw vf9, vf7, vf8 \n\t"
|
||||
"sqc2 vf9, 0x0(%0) \n\t"
|
||||
:
|
||||
: "r"(&result), "r"(&rotationMatrix), "r"(&cameraPos));
|
||||
set(Vector3(result[0], result[1], result[2]));
|
||||
}
|
||||
|
||||
void Vector3::set(const Vector3 &v)
|
||||
{
|
||||
this->x = v.x;
|
||||
this->y = v.y;
|
||||
this->z = v.z;
|
||||
}
|
||||
|
||||
void Vector3::copy(Vector3 &v)
|
||||
{
|
||||
asm volatile( // VU0 Macro program
|
||||
"lq $6, 0x0(%1) \n\t"
|
||||
"sq $6, 0x0(%0) \n\t"
|
||||
:
|
||||
: "r"(v.xyz), "r"(this->xyz));
|
||||
}
|
||||
|
||||
float Vector3::distanceTo(const Vector3 &v) const
|
||||
{
|
||||
register float result;
|
||||
@@ -329,7 +213,42 @@ float Vector3::distanceTo(const Vector3 &v) const
|
||||
// (this->z - v.z) * (this->z - v.z));
|
||||
}
|
||||
|
||||
const void Vector3::print() const
|
||||
u8 Vector3::shouldBeBackfaceCulled(const Vector3 *t_cameraPos, const Vector3 *t_v0, const Vector3 *t_v1, const Vector3 *t_v2)
|
||||
{
|
||||
printf("Vector3(%f, %f, %f)\n", x, y, z);
|
||||
register float dot;
|
||||
asm volatile(
|
||||
"lqc2 vf4, 0x0(%1) \n\t" // vf4 = cameraPos
|
||||
"lqc2 vf5, 0x0(%2) \n\t" // vf5 = v0
|
||||
"lqc2 vf6, 0x0(%3) \n\t" // vf6 = v1
|
||||
"lqc2 vf7, 0x0(%4) \n\t" // vf7 = v2
|
||||
"vsub.xyz vf8, vf7, vf5 \n\t" // vf8 = vf7(v2) - vf5(v0)
|
||||
"vsub.xyz vf9, vf6, vf5 \n\t" // vf9 = vf6(v1) - vf5(v0)
|
||||
"vopmula.xyz ACC, vf8, vf9 \n\t" // vf6 = cross(vf8, vf9)
|
||||
"vopmsub.xyz vf6, vf9, vf8 \n\t"
|
||||
"vsub.w vf6, vf6, vf6 \n\t"
|
||||
"vsub.xyz vf7, vf5, vf4 \n\t" // vf7 = vf5(v0) - vf4(cameraPos)
|
||||
"vmul.xyz vf5, vf7, vf6 \n\t" // vf5 = dot(vf7, vf6)
|
||||
"vaddy.x vf5, vf5, vf5 \n\t"
|
||||
"vaddz.x vf5, vf5, vf5 \n\t"
|
||||
"qmfc2 $2, vf5 \n\t" // store result on `dot` variable
|
||||
"mtc1 $2, %0 \n\t"
|
||||
: "=f"(dot)
|
||||
: "r"(t_cameraPos->xyz), "r"(t_v0->xyz), "r"(t_v1->xyz), "r"(t_v2->xyz));
|
||||
return dot <= 0.0F;
|
||||
}
|
||||
|
||||
void Vector3::setByLerp(const Vector3 &t_v1, const Vector3 &t_v2, const float &t_interp, const float &t_scale)
|
||||
{
|
||||
asm volatile(
|
||||
"lqc2 vf4, 0x0(%1) \n\t" // vf4 = v1
|
||||
"lqc2 vf5, 0x0(%2) \n\t" // vf5 = v2
|
||||
"mfc1 $8, %3 \n\t" // vf6 = t
|
||||
"qmtc2 $8, vf6 \n\t" // lerp:
|
||||
"vsub.xyz vf7, vf5, vf4 \n\t" // vf7 = v2 - v1
|
||||
"vmulx.xyz vf8, vf7, vf6 \n\t" // vf8 = vf7 * t
|
||||
"vadd.xyz vf9, vf8, vf4 \n\t" // vf9 = vf8 + vf4
|
||||
"sqc2 vf9, 0x0(%0) \n\t" // v0 = vf9
|
||||
:
|
||||
: "r"(&this->xyz), "r"(&t_v1.xyz), "r"(&t_v2.xyz), "f"(t_interp));
|
||||
operator*=(t_scale);
|
||||
}
|
||||
|
||||
@@ -347,7 +347,7 @@ u8 Mesh::isInFrustum(Plane *t_frustumPlanes)
|
||||
{
|
||||
Vector3 boxCalcTemp;
|
||||
u8 boxResult = 1, boxIn = 0, boxOut = 0;
|
||||
Vector3 *currentBoundingBox = getCurrentBoundingBox();
|
||||
const Vector3 *currentBoundingBox = getCurrentBoundingBoxVertices();
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
boxOut = 0;
|
||||
|
||||
@@ -39,6 +39,7 @@ MeshFrame::~MeshFrame()
|
||||
delete[] normals;
|
||||
if (_areMaterialsAllocated)
|
||||
delete[] materials;
|
||||
delete boundingBoxObj;
|
||||
}
|
||||
|
||||
// ----
|
||||
@@ -95,6 +96,7 @@ void MeshFrame::allocateMaterials(const u32 &t_val)
|
||||
|
||||
void MeshFrame::calculateBoundingBoxes()
|
||||
{
|
||||
Vector3 boundingBox[8];
|
||||
if (!_areVerticesAllocated)
|
||||
{
|
||||
PRINT_ERR("Can't calculate bounding box, because vertices were not allocated!");
|
||||
@@ -123,6 +125,7 @@ void MeshFrame::calculateBoundingBoxes()
|
||||
if (hiZ < vertices[i].z)
|
||||
hiZ = vertices[i].z;
|
||||
}
|
||||
|
||||
boundingBox[0].set(lowX, lowY, lowZ);
|
||||
boundingBox[1].set(lowX, lowY, hiZ);
|
||||
boundingBox[2].set(lowX, hiY, lowZ);
|
||||
@@ -133,4 +136,8 @@ void MeshFrame::calculateBoundingBoxes()
|
||||
boundingBox[6].set(hiX, hiY, lowZ);
|
||||
boundingBox[7].set(hiX, hiY, hiZ);
|
||||
_isBoundingBoxCalculated = true;
|
||||
|
||||
//BoundingBox is declared on the heap to prevent any ill-formed default
|
||||
//constructor instantiated BoundingBox objects.
|
||||
boundingBoxObj = new BoundingBox(boundingBox);
|
||||
}
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
*/
|
||||
|
||||
#include "../include/models/mesh_material.hpp"
|
||||
#include "../include/models/bounding_box.hpp"
|
||||
#include "../include/utils/debug.hpp"
|
||||
#include "../include/utils/string.hpp"
|
||||
#include <cstdlib>
|
||||
@@ -82,9 +83,9 @@ u8 MeshMaterial::isInFrustum(Plane *t_frustumPlanes, const Vector3 &position)
|
||||
for (u8 y = 0; y < 8 && (boxIn == 0 || boxOut == 0); y++)
|
||||
{
|
||||
boxCalcTemp.set(
|
||||
boundingBox[y].x + position.x,
|
||||
boundingBox[y].y + position.y,
|
||||
boundingBox[y].z + position.z);
|
||||
boundingBoxObj->getVertex(y).x + position.x,
|
||||
boundingBoxObj->getVertex(y).y + position.y,
|
||||
boundingBoxObj->getVertex(y).z + position.z);
|
||||
if (t_frustumPlanes[i].distanceTo(boxCalcTemp) < 0)
|
||||
boxOut++;
|
||||
else
|
||||
@@ -101,6 +102,7 @@ u8 MeshMaterial::isInFrustum(Plane *t_frustumPlanes, const Vector3 &position)
|
||||
|
||||
void MeshMaterial::calculateBoundingBox(Vector3 *t_vertices, u32 t_vertCount)
|
||||
{
|
||||
Vector3 boundingBox[8];
|
||||
float lowX, lowY, lowZ, hiX, hiY, hiZ;
|
||||
lowX = hiX = t_vertices[vertexFaces[0]].x;
|
||||
lowY = hiY = t_vertices[vertexFaces[0]].y;
|
||||
@@ -132,4 +134,8 @@ void MeshMaterial::calculateBoundingBox(Vector3 *t_vertices, u32 t_vertCount)
|
||||
boundingBox[6].set(hiX, hiY, lowZ);
|
||||
boundingBox[7].set(hiX, hiY, hiZ);
|
||||
_isBoundingBoxCalculated = true;
|
||||
|
||||
//BoundingBox is declared on the heap to prevent any ill-formed default
|
||||
//constructor instantiated BoundingBox objects.
|
||||
boundingBoxObj = new BoundingBox(boundingBox);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user