GameObject.h

/*
 * This file is part of Bubba-3D.
 *
 * Bubba-3D is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Bubba-3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Bubba-3D. If not, see http://www.gnu.org/licenses/.
 */
#pragma once

#include "IDrawable.h"
#include "AABB2.h"
#include "linmath/float4x4.h"
#include <vector>
#include <linmath/Quaternion.h>
#include <Sphere.h>
#include "ShaderProgram.h"

enum EventType {BeforeCollision, DuringCollision, AfterCollision};

typedef int TypeIdentifier;

class Mesh;
class Triangle;
class IRenderComponent;
class IComponent;
class Octree;

class GameObject : public IDrawable {
public:
    GameObject();
    GameObject(GameObject* parent);

    explicit GameObject(Mesh *mesh);
    GameObject(Mesh *mesh, Mesh *colliderMesh);

    GameObject(Mesh *mesh, GameObject* parent);
    GameObject(Mesh *mesh, Mesh *colliderMesh, GameObject* parent);

    virtual ~GameObject();

    virtual void render();
    virtual void renderShadow(ShaderProgram* shaderProgram);

    void addRenderComponent(IRenderComponent* renderer);
    void addComponent(IComponent* newComponent);
    void update(float dt);
    void callEvent(EventType type, GameObject* data);


    chag::float4x4 getModelMatrix();
    void move(chag::float4x4 model_matrix);
    void update(chag::float4x4 update_matrix);

    chag::float3 getRelativeScale();
    chag::float3 getAbsoluteScale();
    void setScale(chag::float3 s);

    chag::Quaternion getRelativeRotation();
    chag::Quaternion getAbsoluteRotation();
    void setRotation(chag::Quaternion r);
    void updateRotation(chag::Quaternion r);

    chag::float3 getRelativeLocation();
    chag::float3 getAbsoluteLocation();
    void setLocation(chag::float3 l);

    void addChild(GameObject* child);

    TypeIdentifier getIdentifier();
    void setIdentifier(TypeIdentifier identifier);
    void addCollidesWith(TypeIdentifier colliderID);
    void addCollidesWith(std::initializer_list<TypeIdentifier> colliderIDs);
    void clearCollidesWithList();
    bool collidesWith(TypeIdentifier id);

    Octree* getOctree();
    std::vector<Triangle*> getTriangles();

    AABB getTransformedAABB();
    Sphere getTransformedSphere();

    bool isDynamicObject();
    void setDynamic(bool isDynamic);

    int getId();

    void makeDirty();
    bool isDirty();


private:
    void initGameObject(Mesh *mesh, Mesh *colliderMesh);

    chag::float4x4 getFullMatrix();

    int getUniqueId();

    Octree* createOctree(Mesh* mesh);

    static int uniqueId;
    int id;

    /* Mesh */
    Mesh *mesh;
    chag::float4x4 m_modelMatrix;
    chag::float3 scale = chag::make_vector(1.0f, 1.0f, 1.0f);
    chag::Quaternion rotation;
    chag::Quaternion rotationPointReference;
    bool hasRotation = false;

    chag::float3 location = chag::make_vector(0.0f, 0.0f, 0.0f);

    bool changed = false;

    /* Hierarchy */
    GameObject* parent = nullptr;
    std::vector<GameObject*> children;

    /* Collision */
    Mesh *collisionMesh;
    AABB aabb;
    Sphere sphere;
    Octree *octree;
    TypeIdentifier typeIdentifier = -1;
    std::vector<TypeIdentifier> canCollideWith;
    bool dynamicObject = false;

    /* Components */
    IRenderComponent* renderComponent = nullptr;
    std::vector<IComponent*> components;

    bool dirty = false;
};