body.hpp

Go to the documentation of this file.

#pragma once
#include <stack>
#include <algorithm>

#define GLM_ENABLE_EXPERIMENTAL
#include "glm/glm.hpp"
#include "glm/gtx/string_cast.hpp"
#include "glm/gtx/norm.hpp"
class CollisionBody;
#include "math_3d.hpp"
#include "collision.hpp"

const float pi = 3.141592654f;

class Tri {
public:
    int id;
    vector<vec3> data;
    Tri(int _id, vector<vec3> _data);    
};

class TriOctree {
public:
    static int counter;
    int index;
    vec3 position;
    float hw;
    vector<Tri> triangles;
    float xMin;
    float yMin;
    float zMin;
    float xMax;
    float yMax;
    float zMax;
    vector<TriOctree> children;
    int MAX_TRIANGLES = 50;
    TriOctree();    
};

vector<int> getTriangleSet(TriOctree &octree, CollisionBody &sphereBody, vector<int> &tri_ids);
void createChildren(TriOctree &octree);
void initOctree(TriOctree &octree, int ind, vec3 pos, float hwidth, vector<Tri> tris);
vector<vec4> getAllNodes();

struct Face {
    vector<vec3> verts_ws = {};
    vector<uint> verts_indices = {};
    vec3 position_ws;
    vec3 normal_ws;
    int id = -1;
    Face(const vector<uint> &verts_indices);
    int setData(const vector<vec3> &verts);
    Face(const Face &f);
    ~Face();

};

struct Edge {
    vec3 v1_ws;
    vec3 v2_ws;

    int v1_index;
    int v2_index;

    vector<uint> faces_indices = {};
    vector<Face> faces = {};
    int id = -1;
    Edge(const vector<uint> &verts_indices, const vector<uint> &faces_indices);
    ~Edge();
    int setData(const vector<vec3> &verts, const vector<Face> &faces);
};

enum BodyType { NONE=-1, TRIANGLE=0, BOX=1, SPHERE=2, CYLINDER=3, COMPOSITE=4};

class CollisionBody {
public:
    CollisionBody();
    CollisionBody& operator=(const CollisionBody &other);
    CollisionBody(const CollisionBody &other);
    ~CollisionBody();

    mat4 getModelMatrix();
    int update();
    int calculateVertices();
    static int getIndex(int ID);

public:
    static vector<CollisionBody*> allBodies;
    static int Counter;
    float dX2 = 0.5f;
    float dY2 = 0.5f;
    float dZ2 = 0.5f;

    float bounding_radius;

    BodyType type = BodyType::NONE;
    int id = -1;
    vector<int> triIDs = {};
    vector<int> objectIDs = {};

    bool colliding;

    float coefficient_of_restitution;
    float mass;
    float one_over_mass;
    float density = 1.0f;
    float friction;
    vec3 cm_position;
    mat3 orientation;
    vec3 cm_velocity;
    vec3 angular_momentum;
    vec3 cm_force;
    vec3 torque;
    mat3 inverse_world_inertia_tensor;
    mat3 inverse_body_inertia_tensor;
    vec3 angular_velocity;

    vector<vec3> a_bounding_vertices = { vec3(0,0,0),vec3(0,0,0),vec3(0,0,0),vec3(0,0,0),
                                         vec3(0,0,0),vec3(0,0,0),vec3(0,0,0),vec3(0,0,0) };

    vector<vec3> a_body_bounding_vertices = {};
    vector<Face> faces = {};
    vector<Edge> edges = {};

    mat4 offset;

    void *contactFeature = NULL;
    int compositeBodyIndex = -1;

    bool sleeping = false;

    int group_id = -1;

    bool is_static = false;
};

int initBox(CollisionBody *body, float w, float h, float b);
int initSphere(CollisionBody *body, float r);
int initCylinder(CollisionBody *body, float r1, float r2, float h);
int initTriangle(CollisionBody *body, vector<vec3> verts);
vector<CollisionBody> initTriangleMesh(vector<vec3> verts);

TriOctree *getOctree();

class RigidBody {
public:
    RigidBody();
    ~RigidBody();
    int integrateForces(vec3 gravity, float deltaTime);
    int integrateVelocities(float deltaTime);
    void add(int bodyID);
    mat4 getModelMatrix();
    bool getColliding();

public:

    static int Counter;

    int id = -1;

    float coefficient_of_restitution;
    float mass;
    float one_over_mass;
    float density = 1.0f;
    vec3 cm_position;
    mat3 orientation;
    vec3 cm_velocity;
    vec3 angular_momentum;
    vec3 cm_force;
    vec3 torque;
    mat3 inverse_world_inertia_tensor;
    mat3 inverse_body_inertia_tensor;
    vec3 angular_velocity;

    vector<vec3> a_bounding_vertices = { vec3(0,0,0),vec3(0,0,0),vec3(0,0,0),vec3(0,0,0),
                                         vec3(0,0,0),vec3(0,0,0),vec3(0,0,0),vec3(0,0,0) };

    vector<vec3> a_body_bounding_vertices = {};

    vector<unsigned int> bodyIndexes = {};
    static vector<RigidBody*> allBodies;
    int compositeBodyIndex = -1;
    BodyType type;

    // default false for stability
    bool apply_gyroscopic_term = false;

    bool sleeping = false;
    unsigned int colliding = 0;
};