scene.hpp

Go to the documentation of this file.

#pragma once
 
#include <entity.hpp>
#include <camera.hpp>
 
class Scene{
public:
    Scene(){
        m_ScalingFactor=0.5f;
        OnPhysicsStart();
    }
    Scene(const std::string &name);
 
    std::string &GetName();
    void SetScalingFactor(float scaling_factor);
    void SetGravity(float x,float y);
 
    void SetGravity(Vec2 gravity);
 
    [[nodiscard]] uint32_t AddEntity();
    void AddEntity(uint32_t uid);
    Entity* GetEntity(uint32_t uid);
    void RemoveEntity(uint32_t uid);
 
    void MoveEntity(uint32_t uid,float x_offset,float y_offset);
    void SetEntityPosition(uint32_t uid,float x,float y);
 
    template<typename T,typename ...Args>
    void AddComponent(uint32_t uid,Args...args){
        PROFILE_FUNCTION();
        
        T temp(std::forward<Args>(args)...,uid);
 
        // auto printArg=[](const auto &arg){ std::cout<<arg<<' '; };
        // (printArg(args),...);
 
        // std::cout<<std::endl;
        
        if constexpr(std::is_same<T,RigidbodyComponent>::value){
            Entity *entity=GetEntity(uid);
            b2BodyDef body_def;
            body_def.type=RigidbodyTypeToBox2DBody(temp.m_BodyType);
            body_def.position.Set(entity->m_X*m_ScalingFactor,entity->m_Y*m_ScalingFactor);
            body_def.angle=0.0f;
 
            b2Body *body=m_PhysicsWorld->CreateBody(&body_def);
            body->SetFixedRotation(temp.m_FixedRotation);
            temp.m_RuntimeBody=body;
        }else if constexpr(std::is_same<T,BoxColliderComponent>::value){
            RigidbodyComponent *rigidbody=GetComponent<RigidbodyComponent>(uid);
            if(rigidbody==nullptr){
                printf("Entity %d does not have a rigidbody\n",uid);
                return;
            }
 
            b2PolygonShape box_shape;
            box_shape.SetAsBox(temp.m_Width/2.0f*m_ScalingFactor,temp.m_Height/2.0f*m_ScalingFactor,b2Vec2((temp.m_XOffset+temp.m_Width/2.0f)*m_ScalingFactor,(temp.m_YOffset+temp.m_Height/2.0f)*m_ScalingFactor),0.0f);
 
            b2FixtureDef fixture_def;
            fixture_def.shape=&box_shape;
            fixture_def.density=temp.m_Density;
            fixture_def.friction=temp.m_Friction;
            fixture_def.restitution=temp.m_Restitution;
            fixture_def.restitutionThreshold=temp.m_RestitutionThreshold;
            temp.m_RuntimeFixture=rigidbody->m_RuntimeBody->CreateFixture(&fixture_def);
        }else if constexpr(std::is_same<T,CircleColliderComponent>::value){
            RigidbodyComponent *rigidbody=GetComponent<RigidbodyComponent>(uid);
            if(rigidbody==nullptr){
                printf("Entity %d does not have a rigidbody\n",uid);
                return;
            }
 
            b2CircleShape circle_shape;
            circle_shape.m_p.Set((temp.m_XOffset)*m_ScalingFactor,(temp.m_YOffset)*m_ScalingFactor);
            circle_shape.m_radius=(temp.m_Radius)*m_ScalingFactor;
 
            b2FixtureDef fixture_def;
            fixture_def.shape=&circle_shape;
            fixture_def.density=temp.m_Density;
            fixture_def.friction=temp.m_Friction;
            fixture_def.restitution=temp.m_Restitution;
            fixture_def.restitutionThreshold=temp.m_RestitutionThreshold;
            temp.m_RuntimeFixture=rigidbody->m_RuntimeBody->CreateFixture(&fixture_def);
        }
 
        AddComponentToContainer<T>(temp,uid);
    }
 
    template<typename T>
    void RemoveComponent(uint32_t uid);
 
    template<typename T>
    T* GetComponent(uint32_t uid);
 
    void OnPhysicsStart();
    void OnPhysicsUpdate(double frame_time);
    void OnPhysicsStop();
 
    void Update(double frame_time);
    void Render();
 
    std::vector<Entity> &GetEntities();
    template<typename T,ComponentType<T> = 0>
    std::vector<T> &GetComponents();
 
    inline Camera &GetCamera(){ return m_Camera; }
 
    inline b2World *GetPhysicsWorld(){ return m_PhysicsWorld; }
 
    void DebugDraw();
private:
    friend class SceneSerializer;
    friend class Application;
 
    template<typename T>
    void AddComponentToContainer(T &component,uint32_t uid);
 
    b2World *m_PhysicsWorld=nullptr;
    float m_ScalingFactor=0.5f;
    Vec2 m_Gravity;
 
    Camera m_Camera;
 
    std::vector<Entity> m_Entities;
    ComponentManager<TagComponent> m_TagComponents;
    ComponentManager<TextureComponent> m_TextureComponents;
    ComponentManager<AnimatedTextureComponent> m_AnimatedTextureComponents;
    ComponentManager<RigidbodyComponent> m_RigidbodyComponents;
    ComponentManager<BoxColliderComponent> m_BoxColliderComponents;
    ComponentManager<CircleColliderComponent> m_CircleColliderComponents;
    ComponentManager<LightComponent> m_LightComponents;
    ComponentManager<NativeScriptComponent> m_NativeScriptComponents;
    ComponentManager<TextComponent> m_TextComponents;
 
    std::vector<std::vector<uint32_t>> m_TexturesEntities; 
    std::vector<std::vector<uint32_t>> m_AnimatedTexturesEntities; 
 
    std::string m_Name;
};