Redacted/Re3D
3
0
Fork 1
Code Issues 7 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Refactor & Cleanup

Browse Source
This commit is contained in:
Redacted
2024-03-19 11:35:01 -04:00
parent 0380010262
commit 389da5d713
9 changed files with 49 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/collision.h → include/engine/collision.h
View File

@@ -16,20 +16,20 @@ class Collider : public VertexArray {
public:
ColliderType type;
void draw() override;
std::vector<Triangle> getTriangles();
[[nodiscard]] std::vector<Triangle> getTriangles() const;
//Useful for everything except AABB.
Vector3 angle;
};
namespace Collision {
Collider calculateOrientedBoundingBox(VertexArray* vArray, const Vector3& angle);
Collider calculateOrientedBoundingBox(const VertexArray& vArray, const Vector3& angle);
Collider calculateAxisAlignedBoundingBox(const VertexArray& vArray);
bool triangleVSAxisAlignedBoundingBoxCollides(const Triangle& triangle, const Collider& boundingBox);
bool vertexInsideAxisAlignedBoundingBox(const Vector3& position, Collider boundingBox);
bool vertexInsideAxisAlignedBoundingBox(const Vector3& position, const Collider& boundingBox);
bool vertexInsideOrientedBoundingBox(const Vector3& position, const Collider& boundingBox);
bool triangleVSAxisAlignedBoundingBoxCollides(const Triangle& triangle, const Collider& boundingBox);
bool orientedBoundingBoxCollides(const Collider& boundingBox, const Collider& boundingBox2);
bool axisAlignedBoundingBoxCollides(const Collider& boundingBox, const Collider& boundingBox2);
bool collisionMapVSAxisAlignedBoundingBoxCollides(const Collider& boundingBox, Collider* collisionMap);
bool collisionMapVSAxisAlignedBoundingBoxCollides(const Collider& boundingBox, const Collider& collisionMap);
}

2
include/types/entity/entity.h
View File

@@ -5,7 +5,7 @@
#include <J3ML/LinearAlgebra/Matrix4x4.h>
#include <J3ML/LinearAlgebra/Vector3.h>
#include <archive.h>
#include <collision.h>
#include <engine/collision.h>
//#include <JGL/JGL.h>
//#include <JGL/Colors.h>

9
include/types/vertex.h
View File

@@ -10,12 +10,10 @@
using J3ML::LinearAlgebra::Vector3;
using J3ML::LinearAlgebra::Vector2;
struct Vertex {
float x, y, z;
GLfloat u, v;
Vector3 normal;
};
typedef Vector3 Vertex;
typedef Vector2 TextureCoordinate;
class VertexArray {
private:
@@ -24,6 +22,7 @@ public:
std::string name;
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
std::vector<TextureCoordinate> texCoords;
VertexArray getBoundingVolume(Vector3 angle);
void rotate(const Vector3& angle);
void load(const std::string& filename);

2
src/demo/RuntimeTest/src/cube.cpp
View File

@@ -1,5 +1,5 @@
#include <cube.h>
#include <collision.h>
#include <engine/collision.h>
#include <sphere.h>
void Cube::pre_render() {
hVelocity = 1.4;

2
src/demo/RuntimeTest/src/sphere.cpp
View File

@@ -1,5 +1,5 @@
#include <sphere.h>
#include <collision.h>
#include <engine/collision.h>
void Sphere::pre_render() {
hVelocity = 1;
hMove(velAngle, hVelocity);

12
src/collision.cpp → src/engine/collision.cpp
View File

@@ -1,7 +1,7 @@
#include <cfloat>
#include <collision.h>
#include <engine/collision.h>
bool Collision::vertexInsideAxisAlignedBoundingBox(const Vector3& position, Collider boundingBox) {
bool Collision::vertexInsideAxisAlignedBoundingBox(const Vector3& position, const Collider& boundingBox) {
Vector3 minimum = {boundingBox.vertices.front().x, boundingBox.vertices.front().y, boundingBox.vertices.front().z};
Vector3 maximum = {boundingBox.vertices.back().x, boundingBox.vertices.back().y, boundingBox.vertices.back().z};
@@ -128,12 +128,12 @@ bool Collision::triangleVSAxisAlignedBoundingBoxCollides(const Triangle &triangl
return axisAlignedBoundingBoxCollides(boundingBox, boundingBox2);
}
bool Collision::collisionMapVSAxisAlignedBoundingBoxCollides(const Collider &boundingBox, Collider* collisionMap) {
bool Collision::collisionMapVSAxisAlignedBoundingBoxCollides(const Collider &boundingBox, const Collider& collisionMap) {
if (!axisAlignedBoundingBoxCollides(boundingBox, Collision::calculateAxisAlignedBoundingBox((VertexArray) *collisionMap)))
if (!axisAlignedBoundingBoxCollides(boundingBox, Collision::calculateAxisAlignedBoundingBox((VertexArray) collisionMap)))
return false;
for (auto& triangle : collisionMap->getTriangles())
for (auto& triangle : collisionMap.getTriangles())
if (triangleVSAxisAlignedBoundingBoxCollides(triangle, boundingBox))
return true;
return false;
@@ -159,7 +159,7 @@ void Collider::draw() {
drawWireframe();
}
std::vector<Triangle> Collider::getTriangles() {
std::vector<Triangle> Collider::getTriangles() const {
std::vector<Triangle> triangles;
for (size_t i = 0; i < indices.size(); i += 3) {
if (i + 2 < indices.size()) {

39
src/types/boundingVolume.cpp
View File

@@ -1,7 +1,7 @@
#include <collision.h>
#include <engine/collision.h>
#include <limits>
Collider Collision::calculateOrientedBoundingBox(VertexArray* vArray, const Vector3& angle) {
Collider Collision::calculateOrientedBoundingBox(const VertexArray& vArray, const Vector3& angle) {
Collider output;
float minX = std::numeric_limits<float>::max();
float minY = std::numeric_limits<float>::max();
@@ -10,7 +10,7 @@ Collider Collision::calculateOrientedBoundingBox(VertexArray* vArray, const Vect
float maxY = -std::numeric_limits<float>::max();
float maxZ = -std::numeric_limits<float>::max();
for (const auto& vertex : vArray->vertices) {
for (const auto& vertex : vArray.vertices) {
if (vertex.x < minX)
minX = vertex.x;
if (vertex.y < minY)
@@ -26,14 +26,14 @@ Collider Collision::calculateOrientedBoundingBox(VertexArray* vArray, const Vect
maxZ = vertex.z;
}
output.vertices.push_back(Vertex(minX, minY, minZ));
output.vertices.push_back(Vertex(maxX, minY, minZ));
output.vertices.push_back(Vertex(minX, maxY, minZ));
output.vertices.push_back(Vertex(maxX, maxY, minZ));
output.vertices.push_back(Vertex(minX, minY, maxZ));
output.vertices.push_back(Vertex(maxX, minY, maxZ));
output.vertices.push_back(Vertex(minX, maxY, maxZ));
output.vertices.push_back(Vertex(maxX, maxY, maxZ));
output.vertices.emplace_back(minX, minY, minZ);
output.vertices.emplace_back(maxX, minY, minZ);
output.vertices.emplace_back(minX, maxY, minZ);
output.vertices.emplace_back(maxX, maxY, minZ);
output.vertices.emplace_back(minX, minY, maxZ);
output.vertices.emplace_back(maxX, minY, maxZ);
output.vertices.emplace_back(minX, maxY, maxZ);
output.vertices.emplace_back(maxX, maxY, maxZ);
output.rotate(angle);
output.type = ColliderType::OrientedBoundingBox;
@@ -65,15 +65,14 @@ Collider Collision::calculateAxisAlignedBoundingBox(const VertexArray& vArray) {
if (vertex.z > maxZ)
maxZ = vertex.z;
}
output.vertices.push_back(Vertex(minX, minY, minZ));
output.vertices.push_back(Vertex(maxX, minY, minZ));
output.vertices.push_back(Vertex(minX, maxY, minZ));
output.vertices.push_back(Vertex(maxX, maxY, minZ));
output.vertices.push_back(Vertex(minX, minY, maxZ));
output.vertices.push_back(Vertex(maxX, minY, maxZ));
output.vertices.push_back(Vertex(minX, maxY, maxZ));
output.vertices.push_back(Vertex(maxX, maxY, maxZ));
output.vertices.emplace_back(minX, minY, minZ);
output.vertices.emplace_back(maxX, minY, minZ);
output.vertices.emplace_back(minX, maxY, minZ);
output.vertices.emplace_back(maxX, maxY, minZ);
output.vertices.emplace_back(minX, minY, maxZ);
output.vertices.emplace_back(maxX, minY, maxZ);
output.vertices.emplace_back(minX, maxY, maxZ);
output.vertices.emplace_back(maxX, maxY, maxZ);
output.type = ColliderType::AxisAlignedBoundingBox;
return output;

4
src/types/entity/entity.cpp
View File

@@ -1,9 +1,7 @@
#include <types/entity/entity.h>
#include <engine/occlusion.h>
#include <types/entity/camera.h>
#include <collision.h>
#include <uuid_v4.h>
#include <collision.h>
#include "JGL/JGL.h"
#include "JGL/Colors.h"
@@ -192,5 +190,5 @@ bool Entity::isCollidingWith(Entity *entity) {
return Collision::orientedBoundingBoxCollides(thisCollider, otherCollider);
if (thisCollider.type == ColliderType::AxisAlignedBoundingBox && otherCollider.type == ColliderType::CollisionMap)
return Collision::collisionMapVSAxisAlignedBoundingBoxCollides(thisCollider, &otherCollider);
return Collision::collisionMapVSAxisAlignedBoundingBoxCollides(thisCollider, otherCollider);
}

20
src/types/vertexArray.cpp
View File

@@ -1,6 +1,6 @@
#include <engine/engine.h>
#include <types/vertex.h>
#include <collision.h>
#include <engine/collision.h>
#include <cmath>
void VertexArray::load (const std::string& filename) {
@@ -20,11 +20,11 @@ void VertexArray::load (const std::string& filename) {
if (prefix == "v") {
float x, y, z;
stream >> x >> y >> z;
positions.push_back(Vector3(x, y, z));
positions.emplace_back(x, y, z);
} else if (prefix == "vt") {
float u, v;
stream >> u >> v;
uvs.push_back(Vector2(u, v));
uvs.emplace_back(u, v);
} else if (prefix == "f") {
unsigned int vertexIndex[3], texCoordIndex[3];
char slash;
@@ -36,13 +36,12 @@ void VertexArray::load (const std::string& filename) {
for (int i = 0; i < 3; ++i) {
Vertex vertex;
vertex.x = positions[vertexIndex[i]].x;
vertex.y = positions[vertexIndex[i]].y;
vertex.z = positions[vertexIndex[i]].z;
vertex.u = uvs[texCoordIndex[i]].x;
vertex.v = uvs[texCoordIndex[i]].y;
TextureCoordinate textureCoordinate;
vertex = positions[vertexIndex[i]];
textureCoordinate = uvs[texCoordIndex[i]];
vertices.push_back(vertex);
texCoords.push_back(textureCoordinate);
indices.push_back(static_cast<unsigned int>(indices.size()));
}
}
@@ -62,6 +61,7 @@ void VertexArray::load (const std::string& filename) {
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
//This breaks stuff if the model is *very* big.
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), &verts, GL_STATIC_DRAW); //GL_STATIC_DRAW means the VBO won't be changed atall.
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
@@ -69,7 +69,7 @@ void VertexArray::load (const std::string& filename) {
//TODO: This will probably need to be changed when pill collider & skeletal animation is added.
//Create OBB once when object is loaded because recalculating it every frame is a LOT slower than rotating it every frame.
boundingVolume = Collision::calculateOrientedBoundingBox(this, {0,0,0}).vertices;
boundingVolume = Collision::calculateOrientedBoundingBox(*this, {0,0,0}).vertices;
}
@@ -79,7 +79,7 @@ void VertexArray::draw() {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), &vertices[0].u);
glTexCoordPointer(2, GL_FLOAT, sizeof(TextureCoordinate), &texCoords[0].x);
if (!engine->useVBO)
glVertexPointer(3, GL_FLOAT, sizeof(Vertex), &vertices[0].x);