mgs/ecsgame
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Some cleanup and comments

Browse Source
This commit is contained in:
karl 2021-01-16 22:28:34 +01:00
parent 27dcc00e68
commit 6801208905
4 changed files with 20 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ECS/Systems/CollisionSystem.h
View File

@ -28,7 +28,8 @@ class CollisionSystem : public EntitySystem {
std::map<Vector, Point *> triangle_map;
// TODO: Iterate over vertices, add triangles by also iterating over indices
// We iterate over the index array and add the resulting triangles to a hash map of
// vertices. That way, each vertex holds a list of all triangles it is involved in.
for (int i = 0; i < mesh->vertex_count; i += 3) {
// Build vertices from this triangle
float v0p0 = vertices[indices[i + 0] * 14 + 0];
@ -90,9 +91,7 @@ class CollisionSystem : public EntitySystem {
// TODO
});
std::cout << "Start building kdtree with " << points.size() << " points" << std::endl;
kdtree = new KDTree(points);
std::cout << "Done" << std::endl;
}
void tick(World *pWorld, float deltaTime) override {

2
Util/geometry.h
View File

@ -22,6 +22,7 @@ struct Vector {
return Vector(c[0] - other.c[0], c[1] - other.c[1], c[2] - other.c[2]);
}
// Arbitrary but functional definition of '<', primarily for use in an std::map.
bool operator<(const Vector &other) const {
if ((c[2] < other.c[2])) { return true; }
if ((c[2] == other.c[2]) && (c[1] < other.c[1])) { return true; }
@ -30,6 +31,7 @@ struct Vector {
return false;
}
// Component-wise multiplication with a scalar
Vector operator*(float scalar) const {
return Vector(c[0] * scalar, c[1] * scalar, c[2] * scalar);
}

14
Util/kdtree.h
View File

@ -1,3 +1,5 @@
#pragma once
#include "geometry.h"
#include <algorithm>
#include <chrono>
@ -9,7 +11,7 @@
class KDTree {
public:
KDTree(std::vector<Point *> points) {
std::cout << "Starting to build tree with " << points.size() << " points took ";
std::cout << "Building tree with " << points.size() << " points took ";
auto start = std::chrono::high_resolution_clock::now();
root = build(points, 0);
auto end = std::chrono::high_resolution_clock::now();
@ -109,13 +111,17 @@ class KDTree {
void intersect_ray_recurse(const Triangle *&nearest_triangle, Vector &result, Ray ray,
Node *node, int depth, float &nearest) {
// Exit condition: There was no collision
// Exit condition: This node was iterated towards, but does not exist
if (node == nullptr) { return; }
// Check for a collision here
// Iterate over all Triangles which this Point is involved in
for (const Triangle *triangle : node->point->triangles) {
Vector current_result(0, 0, 0);
float current_distance;
// If we have a collision, and it is closer to the ray origin than the closest previous
// collision, remember it
if (ray.intersects_triangle(triangle, current_result, current_distance)) {
if (current_distance < nearest) {
nearest = current_distance;
@ -125,14 +131,16 @@ class KDTree {
}
}
// Is the left or right child node closer to this point?
// Is the ray origin within the left or right child node bounding box?
Node *near =
ray.origin[node->axis] > node->point->pos[node->axis] ? node->right : node->left;
Node *far = near == node->right ? node->left : node->right;
if (ray.direction[node->axis] == 0.0) {
// The ray is parallel to the splitting axis, so we only need to check within this box.
intersect_ray_recurse(nearest_triangle, result, ray, near, depth + 1, nearest);
} else {
// Calculate the distance from the ray origin to the splitting axis
float t =
(node->point->pos[node->axis] - ray.origin[node->axis]) / ray.direction[node->axis];

9
main.cpp
View File

@ -204,11 +204,11 @@ int main(int argc, char **argv) {
Entity *sun = world->create();
sun->assign<DirectionalLight>(glm::normalize(glm::vec3(1.0, 1.0, 1.0)));
Entity *kdtree_vis = world->create();
// We're done loading geometry -> build the collision structure
collision_system->build();
// Save the visualized kdtree as another entity
Entity *kdtree_vis = world->create();
kdtree_vis->assign<Lines>(collision_system->kdtree->get_lines());
Shader defaultShader("Shaders/default-vertex.vs", "Shaders/default-fragment.fs");
@ -229,15 +229,16 @@ int main(int argc, char **argv) {
world->tick(delta);
renderSystem->render(world, defaultShader, shadowShader, debugShader, lineShader);
// Animations
/* ring->get<Transform>()->rotate(delta * 100.0, glm::vec3(0.0, 1.0, 0.0));
sun->get<DirectionalLight>()->direction = glm::normalize(glm::vec3(
glm::rotate(glm::mat4(1), (float)elapsed_time * 0.5f, glm::vec3(0.0, 1.0, 0.0))
* glm::vec4(1.0, 1.0, 1.0, 0.0))); */
/* Swap front and back buffers */
// Swap front and back buffers
glfwSwapBuffers(window);
/* Poll for and process events */
// Poll for and process events
glfwPollEvents();
}