h4570
136 lines
3.6 KiB
C++
136 lines
3.6 KiB
C++
/*
|
|
# _____ ____ ___
|
|
# | \/ ____| |___|
|
|
# | | | \ | |
|
|
#-----------------------------------------------------------------------
|
|
# Copyright 2022, tyra - https://github.com/h4570/tyra
|
|
# Licensed under Apache License 2.0
|
|
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
|
|
*/
|
|
|
|
#include "renderer/3d/bbox/bbox.hpp"
|
|
|
|
namespace Tyra {
|
|
|
|
BBox::BBox(CoreBBox** t_bboxes, const u32& count) : CoreBBox(t_bboxes, count) {
|
|
setData();
|
|
}
|
|
|
|
BBox::BBox(Vec4* t_vertices, u32 count) : CoreBBox(t_vertices, count) {
|
|
setData();
|
|
}
|
|
|
|
BBox::BBox(Vec4* t_vertices, u32* faces, u32 count)
|
|
: CoreBBox(t_vertices, faces, count) {
|
|
setData();
|
|
}
|
|
|
|
BBox::BBox(const BBox& t_bbox) : CoreBBox(t_bbox) { setData(); }
|
|
|
|
BBox::BBox(const BBox& t_bbox, const M4x4& t_matrix)
|
|
: CoreBBox(t_bbox, t_matrix) {
|
|
setData();
|
|
}
|
|
|
|
BBox::BBox(Vec4* t_vertices) : CoreBBox(t_vertices) { setData(); }
|
|
|
|
BBox BBox::getTransformed(const M4x4& t_matrix) const {
|
|
return BBox(*this, t_matrix);
|
|
}
|
|
|
|
void BBox::setData() {
|
|
// This might be shortened with Vec4 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 = BBoxFace(vertices[1], vertices[7], vertices[1].z);
|
|
_backFace = BBoxFace(vertices[0], vertices[6], vertices[0].z);
|
|
// X-Axis faces
|
|
_leftFace = BBoxFace(vertices[0], vertices[3], vertices[0].x);
|
|
_rightFace = BBoxFace(vertices[4], vertices[7], vertices[4].x);
|
|
// Y-Axis faces
|
|
_topFace = BBoxFace(vertices[2], vertices[7], vertices[2].y);
|
|
_bottomFace = BBoxFace(vertices[0], vertices[5], vertices[0].y);
|
|
}
|
|
|
|
Vec4 BBox::min() const {
|
|
Vec4 temp, _min;
|
|
u8 isInitialized = 0;
|
|
|
|
for (u8 i = 0; i < 8; i++) {
|
|
temp.set(vertices[i].x, vertices[i].y, vertices[i].z, 1.0F);
|
|
if (isInitialized == 0) {
|
|
isInitialized = 1;
|
|
_min.set(temp);
|
|
}
|
|
|
|
if (_min.x > temp.x) _min.x = temp.x;
|
|
if (_min.y > temp.y) _min.y = temp.y;
|
|
if (_min.z > temp.z) _min.z = temp.z;
|
|
}
|
|
|
|
return _min;
|
|
}
|
|
|
|
Vec4 BBox::max() const {
|
|
Vec4 temp, _max;
|
|
u8 isInitialized = 0;
|
|
|
|
for (u8 i = 0; i < 8; i++) {
|
|
temp.set(vertices[i].x, vertices[i].y, vertices[i].z, 1.0F);
|
|
if (isInitialized == 0) {
|
|
isInitialized = 1;
|
|
_max.set(temp);
|
|
}
|
|
|
|
if (temp.x > _max.x) _max.x = temp.x;
|
|
if (temp.y > _max.y) _max.y = temp.y;
|
|
if (temp.z > _max.z) _max.z = temp.z;
|
|
}
|
|
|
|
return _max;
|
|
}
|
|
|
|
BBox BBox::create(const Vec4& center, const float& size) {
|
|
auto core = CoreBBox::create(center, size);
|
|
return BBox(core.vertices);
|
|
}
|
|
|
|
void BBox::operator=(const BBox& v) {
|
|
for (auto i = 0; i < 8; i++) Vec4::copy(&vertices[i], v.vertices[i].xyzw);
|
|
setData();
|
|
}
|
|
|
|
void BBox::getMinMax(Vec4* res_min, Vec4* res_max) const {
|
|
Vec4 temp = Vec4();
|
|
|
|
u8 isInitialized = 0;
|
|
for (u8 i = 0; i < 8; i++) {
|
|
temp.set(vertices[i].x, vertices[i].y, vertices[i].z, 1.0F);
|
|
if (isInitialized == 0) {
|
|
isInitialized = 1;
|
|
res_min->set(temp);
|
|
res_max->set(temp);
|
|
}
|
|
|
|
if (res_min->x > temp.x) res_min->x = temp.x;
|
|
if (temp.x > res_max->x) res_max->x = temp.x;
|
|
|
|
if (res_min->y > temp.y) res_min->y = temp.y;
|
|
if (temp.y > res_max->y) res_max->y = temp.y;
|
|
|
|
if (res_min->z > temp.z) res_min->z = temp.z;
|
|
if (temp.z > res_max->z) res_max->z = temp.z;
|
|
}
|
|
}
|
|
|
|
} // namespace Tyra
|