scene.h

#pragma once
 
#include <json.h>
#include <fstream>
#include "../utils/rigidbodyHandler.h"
#include "../utils/ai.h"
 
#include "../rendering/shaderProgram.h"
#include "../rendering/camera.h"
#include "../rendering/shadows.h"
#include "../rendering/skybox.h"
#include "../rendering/billboard.h"
#include "../rendering/water.h"
#include "../rendering/hud.h"
#include "../rendering/particle.h"
 
#include "../audio/audioEngine.h"
#include "../audio/audioSource.h"
 
#include "terrain.h"
#include "texManager.h"
#include "meshManager.h"
#include "model.h"
#include "light.h"
#include "animator.h"
 
namespace Aire
{
    class Scene
    {
    public:
        Scene(Window* window, Camera& camera, TextureManager& texManager, MeshManager& meshManager, 
            Clock& clock, RigidbodyHandler* rigidbodyHandler, HUD* hudManager);
        
        ~Scene();
 
        // Setters for shaders
 
        void setTerrainShader(ShaderProgram& shader) { terrainShader = &shader; }
 
        void setModelShader(ShaderProgram& shader) { modelShader = &shader; }
 
        void setAnimationShader(ShaderProgram& shader) { animationShader = &shader; }
 
        void setBillboardShader(ShaderProgram& shader) { billboardShader = &shader; }
 
        // Boid Manager
 
        void setBoidManager(BoidManager* boidManager) { this->boidManager = boidManager; }
 
        BoidManager* getBoidManager() { return boidManager; }
 
        // Particle Generator
 
        void setParticleGenerator(ParticleGenerator* particleGenerator) { this->particleGenerator = particleGenerator; }
 
        ParticleGenerator* getParticleGenerator() { return particleGenerator; }
 
        // Audio Engine
 
        void setAudioEngine(AudioEngine* audioEngine) { this->audioEngine = audioEngine; }
 
        AudioEngine* getAudioEngine() { return audioEngine; }
 
        void setBoidSounds(const std::string& soundPath);
 
        void updateBoidSounds(const std::string& soundPath);
 
        // Scene elements setters
 
        void setSkybox(Skybox* skybox) { this->skybox = skybox; }
 
        void setDirectionalLight(Light& light) { directionalLight = light; }
 
        void setPointLights(std::vector<Light>& lights) { pointLights = lights; }
 
        void addPointLight(Light& light) { pointLights.push_back(light); }
 
        // Shadow mapping
 
        void enableDirectionalShadows();
 
        void enablePointShadows();
 
        // Scene elements management
 
        void addTerrain(Terrain* terrain);
 
        std::vector<Terrain*> getTerrains() { return terrains; }
 
        Terrain* getTerrain(int index);
 
 
        void addModel(Model* model) { models.push_back(model); }
 
        std::vector<Model*> getModels() { return models; }
 
        Model* getModel(int index);
 
        void addAnimator(Animator* animator) { animators.push_back(animator); }
 
        std::vector<Animator*> getAnimators() { return animators; }
 
        Animator* getAnimator(int index);
 
        void addBillboard(Billboard* billboard) { billboards.push_back(billboard); }
        
        std::vector<Billboard*> getBillboards() { return billboards; }
 
        Billboard* getBillboard(int index);
        
        void bindTerrainToRigidbody(int index);
 
        void load(const char* scenePath);
 
        void render(bool debug, bool pause);
 
        void update();
 
        void computeBillboardInstances(std::vector<Billboard*> billboards, Terrain* terrain, int numBillboards);
 
        void renderBillboards(ShaderProgram& shader, Camera& camera);
 
    private:
        Aire::Window* window = nullptr; 
        Aire::Camera* camera = nullptr; 
        Aire::Clock* clock = nullptr; 
        Aire::RigidbodyHandler* rigidbodyHandler = nullptr; 
        Aire::TextureManager* textureManager = nullptr; 
        Aire::MeshManager* meshManager = nullptr; 
        Aire::BoidManager* boidManager = nullptr; 
        Aire::ParticleGenerator* particleGenerator = nullptr; 
        Aire::HUD* hudManager = nullptr; 
        Aire::AudioEngine* audioEngine = nullptr; 
        std::vector<Aire::AudioSource*> boidSounds; 
        Aire::HUD::HUD_TEXT* debugText = nullptr; 
        Aire::HUD::HUD_TEXT* pauseText = nullptr; 
        float currentFrame = 0.0f; 
        float deltaTime = 0.0f; 
        float lastFrame = 0.0f; 
        Aire::ShaderProgram* terrainShader = nullptr; 
        Aire::ShaderProgram* modelShader = nullptr; 
        Aire::ShaderProgram* animationShader = nullptr; 
        Aire::ShaderProgram* billboardShader = nullptr; 
        Aire::ShaderProgram* pointShadowShader = nullptr; 
        Aire::ShaderProgram* directionalShadowShader = nullptr; 
        Aire::ShaderProgram* animationPointShadowShader = nullptr; 
        Aire::ShaderProgram* animationDirectionalShadowShader = nullptr; 
        Aire::Skybox* skybox = nullptr; 
        Light directionalLight = Light{ glm::vec3(1.f, 1.f, 1.f), glm::vec3(1, 1, 1) }; 
        std::vector<Light> pointLights; 
        // Collisions and physics
        std::vector<Rigidbody*> obstacles; 
        std::vector<Rigidbody*> enemies; 
        // Debug
        bool debug = false; 
        Aire::ShaderProgram* debugShader = nullptr; 
        Model* sphere = nullptr; 
        Model* box = nullptr; 
        std::vector<Terrain*> terrains; 
        std::vector<Model*> models; 
        std::vector<Animator*> animators; 
        std::vector<Billboard*> billboards; 
        std::vector<BillboardInstance> billboardInstances; 
        Aire::PointShadows* pShadows = nullptr; 
        Aire::DirectionalShadows* dShadows = nullptr; 
        bool dirShadowsEnabled = false; 
        bool pointShadowsEnabled = false; 
        void setSceneUniforms(ShaderProgram* shader);
    };
 
}; // namespace Aire