default_components.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cmath>
#include <string>
#include <vector>
 
#include "log.hpp"
#include "math/matrix_4.h"
#include "math/vector_3.h"
#include "sound/soundsource.h"
 
 
class Renderer;
class ResourceManager;
class Window;
class Engine;
class Texture;
class Mesh;
class ComponentManager;
 
enum class CameraProjection {
  kPerspective,  
  kOrtho         
};
 
enum class LightType {
  kPoint,        
  kDirectional,  
  kSpot          
};
 
struct AudioCmp {
  AudioCmp(const std::string& name, const SoundBuffer& buffer,
           float gain = 1.0f, float pitch = 1.0f)
    : src(name, buffer, coma::Vec3{0.f,0.f,0.f}, coma::Vec3{0.f,0.f,0.f},
          gain, pitch) {}
 
  SoundSource src;
};
 
const std::array kAttenuationTable{
  coma::Vec3(0.0f, 10000.0f, 10000.0f),coma::Vec3(1.0f, 4.0f, 120.0f),
  coma::Vec3(3.0f, 1.4f, 10.0f),coma::Vec3(7.0f, 0.7f, 1.8f),
  coma::Vec3(13.0f, 0.35f, 0.44f),coma::Vec3(20.0f, 0.22f, 0.20f),
  coma::Vec3(32.0f, 0.14f, 0.07f),coma::Vec3(50.0f, 0.09f, 0.032f),
  coma::Vec3(65.0f, 0.07f, 0.017f),coma::Vec3(100.0f, 0.045f, 0.0075f),
  coma::Vec3(160.0f, 0.027f, 0.0028f),coma::Vec3(200.0f, 0.022f, 0.0019f),
  coma::Vec3(325.0f, 0.014f, 0.0007f),coma::Vec3(600.0f, 0.007f, 0.0002f),
  coma::Vec3(3250.0f, 0.0014f, 0.000007f)};
 
struct LightCmp {
  void calculateAttenuation() {
    for (int next = 0; next < kAttenuationTable.size(); ++next) {
      if (max_distance_ < kAttenuationTable[next].x) {
        float alpha =
            (max_distance_ - kAttenuationTable[next - 1].x) /
            (kAttenuationTable[next].x - kAttenuationTable[next - 1].x);
        linear_value_ = std::lerp(kAttenuationTable[next - 1].y,
                                  kAttenuationTable[next].y, alpha);
        quadratic_value_ = std::lerp(kAttenuationTable[next - 1].z,
                                     kAttenuationTable[next].z, alpha);
        return;
      }
    }
    linear_value_ = kAttenuationTable[kAttenuationTable.size() - 1].y;
    quadratic_value_ = kAttenuationTable[kAttenuationTable.size() - 1].z;
  }
 
  // Generic
 
  LightType type_ = LightType::kPoint;
  coma::Vec3 light_color_ = coma::Vec3(1.0f, 1.0f, 1.0f);
  float intensity_ = 1.0f;
 
  // Point
 
  float max_distance_ = 13.0f;
  float constant_value_ = 1.0f;
  float linear_value_ = 0.01f;
  float quadratic_value_ = 0.01f;
 
  // Spot
 
  float cutoff_angle_ = 50.0f;
  float falloff_start_ = 0.8f;
 
  bool show_shadows_ = true;
 
  LightCmp(const LightType type, const coma::Vec3& color, const float intensity)
    : type_(type), light_color_(color), intensity_(intensity) {}
 
  LightCmp(const coma::Vec3& color, const float intensity,
           const float max_distance)
    : type_(LightType::kPoint),
      light_color_(color),
      intensity_(intensity),
      max_distance_(max_distance) {
    calculateAttenuation();
  }
 
  LightCmp(const coma::Vec3& color, const float intensity,
           const float cutoff_angle, float falloff_start)
    : type_(LightType::kSpot),
      light_color_(color),
      intensity_(intensity),
      cutoff_angle_(cutoff_angle),
      falloff_start_(falloff_start) {}
};
 
struct CameraCmp {
  CameraProjection projection_ = CameraProjection::kPerspective;
 
  float fov_ = 60.0f;
 
  float z_near_ = 0.01f;
 
  float z_far_ = 1000.0f;
 
  coma::Vec3 target_ = coma::Vec3::zero;
 
  bool rotate_towards_target_ = false;
 
  CameraCmp(const CameraProjection projection, const coma::Vec3& target,
            const float fov = 60.0f, const float z_near = 0.01f,
            const float z_far = 1000.0f)
    : projection_(projection),
      fov_(fov),
      z_near_(z_near),
      z_far_(z_far),
      target_(target),
      rotate_towards_target_(true) {}
 
  CameraCmp(const CameraProjection projection, const float fov = 60.0f,
            const float z_near = 0.01f, const float z_far = 1000.0f)
    : projection_(projection), fov_(fov), z_near_(z_near), z_far_(z_far) {}
};
 
struct RenderTreeCmp {
  friend ComponentManager;
  friend Window;
  friend Renderer;
  friend Editor;
 
  RenderTreeCmp(const unsigned parent, const unsigned id,
                const std::string& editor_name,
                const std::vector<unsigned>& children = {})
    : editor_name_(editor_name),
      parent_(parent),
      id_(id),
      children_(children) {}
 
private:
  std::string editor_name_ = "Object";
  unsigned parent_ = 0;
  unsigned id_ = 0;
  std::vector<unsigned> children_;
};
 
struct RenderCmp {
  Mesh const* mesh_ = nullptr;
 
  Texture const* texture_ = nullptr;
 
  coma::Vec3 color_ = {1.0f,1.0f,1.0f};
 
  float roughness_ = 0.5f;
 
  float shininess_ = 32.0f;
 
  bool cast_shadows_ = true;
 
  RenderCmp(const Mesh* mesh, const Texture* texture,
            const coma::Vec3& color = {1.0f,1.0f,1.0f},
            bool castShadows = true, float roughness = 0.5f,
            float shininess = 32.0f)
    : mesh_(mesh),
      texture_(texture),
      color_(color),
      roughness_(roughness),
      shininess_(shininess),
      cast_shadows_{castShadows} {
    if (mesh == nullptr) {
      Log::newLog("Mesh is Null on Render Component Creation", LogColor::Red);
    }
    if (texture == nullptr) {
      Log::newLog("Texture is Null on Render Component Creation",
                  LogColor::Red);
    }
  }
};
 
struct TransformCmp {
public:
  friend Window;
  friend Renderer;
 
  coma::Vec3 position_ = {0.0f,0.0f,0.0f};
 
  coma::Vec3 rotation_ = {0.0f,0.0f,0.0f};
 
  coma::Vec3 scale_ = {1.0f,1.0f,1.0f};
 
  
 
  coma::Vec3 forward() const { return coma::Vec3::eulerToForward(rotation_); }
 
  coma::Vec3 up() const { return coma::Vec3::up; }
 
  coma::Vec3 right() const {
    return coma::Vec3::CrossProduct(forward(), up()).Normalized();
  }
 
  explicit TransformCmp(const coma::Vec3& position,
                        const coma::Vec3& rotation = {0.0f,180.0f,0.0f},
                        const coma::Vec3& scale = {1.0f,1.0f,1.0f})
    : position_(position), rotation_(rotation), scale_(scale) {}
 
  coma::Mat4 getMatrix() const {
    return coma::Mat4::GetTransform(
        position_, scale_, coma::Radians(rotation_.x),
        coma::Radians(rotation_.y), coma::Radians(rotation_.z));
  }
 
private:
  coma::Mat4 tree_transform_ = coma::Mat4::Identity();
};
 
struct BoxCmp {
public:
  coma::Vec3 position_ = {0.0f,0.0f,0.0f};
 
  coma::Vec3 size_ = {1.0f,1.0f,1.0f};
 
  explicit BoxCmp(const coma::Vec3& position,
                  const coma::Vec3& size = {1.0f,1.0f,1.0f})
    : position_(position), size_(size) {}
};