light.h

Go to the documentation of this file.

#ifndef LIGHT_H
#define LIGHT_H
#include <easylogging++.h>
#include <glm/glm.hpp>
#include <glm/ext.hpp>
#include <iostream>
#include "component.h"
//= SCRIPTABLE
//= SCRIPTABLE BASES Component

namespace Graphics {
  class Light : public Component {
    public:
      //= SCRIPTABLE ENUM
      enum Type : unsigned int { POINT, SPOT };
    private:
      Type type;
      glm::vec3 color;
      float intensity;
      float linear_attenuation;
      float quadratic_attenuation;
      int quantized_bands;
      float cone_angle;
      glm::vec3 cone_direction;
    public:
      virtual void onStart() override;
      virtual bool onUpdate(const double delta) override;
      virtual void onDestroy() override;

      //= BEGIN SCRIPTABLE

      Light(const Light::Type& type = Type::POINT);
      ~Light();
      void setColor(const glm::vec3 color) noexcept;
      glm::vec3 getColor() const noexcept;
      void setIntensity(const float intensity) noexcept;
      float getIntensity() const noexcept;
      void setLinearAttenuation(const float linear) noexcept;
      float getLinearAttenuation() const noexcept;
      void setQuadraticAttenuation(const float quadratic) noexcept;
      float getQuadraticAttenuation() const noexcept;

      bool castsQuantizedBands() const noexcept;
      void setNumberOfQuantizedBands(const int bands) noexcept;
      int getNumberOfQuantizedBands() const noexcept;

      void setConeAngle(const float angle) noexcept;
      float getConeAngle() const noexcept;
      void setConeDirection(const glm::vec3 direction) noexcept;
      glm::vec3 getConeDirection() const noexcept;

      Light::Type getType() const noexcept;

      float influenceOnComponent(const Component& component) const;
      virtual std::string className() const noexcept override;
      //= END SCRIPTABLE

      virtual unsigned long long getValueForSorting() const noexcept override;

      virtual void log(el::base::type::ostream_t& os) const override;

      static inline const Light::Type stringToType(const std::string& str) {
        if(str == "Spot" || str == "spot" || str == "SPOT")
          return Light::Type::SPOT;
        else if(str == "Point" || str == "point" || str == "POINT")
          return Light::Type::POINT;
        else
          return Light::Type::POINT;
      }

      static inline const std::string typeToString(const Light::Type& type) {
        if(type == Light::Type::SPOT)
          return std::string("Spot");
        else if(type == Light::Type::POINT)
          return std::string("Point");
        else
          return std::string("N/A");
      }

  };
}

#endif