light.h

#ifndef LIGHT_H
#define LIGHT_H
 
#include <cstdint>
#include <cstring>
 
#include "xbox_math_vector.h"
class TestHost;
 
class Light {
 public:
  virtual void Commit(TestHost& host) const;
 
  virtual void Commit(TestHost& host, const XboxMath::vector_t& look_direction) const;
 
  [[nodiscard]] uint32_t light_enable_mask() const { return light_enable_mask_; }
 
  void SetAmbient(const float* ambient) { memcpy(ambient_, ambient, sizeof(ambient_)); }
 
  void SetAmbient(float r, float g, float b) {
    ambient_[0] = r;
    ambient_[1] = g;
    ambient_[2] = b;
  }
 
  void SetDiffuse(const float* diffuse) { memcpy(diffuse_, diffuse, sizeof(diffuse_)); }
 
  void SetDiffuse(float r, float g, float b) {
    diffuse_[0] = r;
    diffuse_[1] = g;
    diffuse_[2] = b;
  }
 
  void SetSpecular(const float* specular) { memcpy(specular_, specular, sizeof(specular_)); }
 
  void SetSpecular(float r, float g, float b) {
    specular_[0] = r;
    specular_[1] = g;
    specular_[2] = b;
  }
 
  void SetBackAmbient(const float* ambient) { memcpy(back_ambient_, ambient, sizeof(back_ambient_)); }
 
  void SetBackAmbient(float r, float g, float b) {
    back_ambient_[0] = r;
    back_ambient_[1] = g;
    back_ambient_[2] = b;
  }
 
  void SetBackDiffuse(const float* diffuse) { memcpy(back_diffuse_, diffuse, sizeof(back_diffuse_)); }
 
  void SetBackDiffuse(float r, float g, float b) {
    back_diffuse_[0] = r;
    back_diffuse_[1] = g;
    back_diffuse_[2] = b;
  }
 
  void SetBackSpecular(const float* specular) { memcpy(back_specular_, specular, sizeof(back_specular_)); }
 
  void SetBackSpecular(float r, float g, float b) {
    back_specular_[0] = r;
    back_specular_[1] = g;
    back_specular_[2] = b;
  }
 
 protected:
  Light(uint32_t light_index, uint32_t enable_mask);
 
  virtual ~Light() = default;
 
 protected:
  uint32_t light_index_;
  uint32_t light_enable_mask_;
 
  float ambient_[3]{0.f, 0.f, 0.f};
  float diffuse_[3]{1.f, 1.f, 1.f};
  float specular_[3]{0.f, 0.f, 0.f};
  float back_ambient_[3]{0.f, 0.f, 0.f};
  float back_diffuse_[3]{1.f, 1.f, 1.f};
  float back_specular_[3]{0.f, 0.f, 0.f};
};
 
class Spotlight : public Light {
 public:
  enum class FalloffFactor {
    ZERO,
    ONE_HALF,
    ONE,
    TWO,
    TEN,
  };
 
 public:
  Spotlight() = delete;
 
  Spotlight(uint32_t light_index, const XboxMath::vector_t& position, const XboxMath::vector_t& direction, float range,
            float phi, float theta, float attenuation_constant, float attenuation_linear, float attenuation_quadratic,
            float falloff_1, float falloff_2, float falloff_3);
 
  Spotlight(uint32_t light_index, const XboxMath::vector_t& position, const XboxMath::vector_t& direction, float range,
            float phi, float theta, float attenuation_constant, float attenuation_linear, float attenuation_quadratic,
            FalloffFactor falloff);
 
  void Commit(TestHost& host) const override;
 
 private:
  XboxMath::vector_t position_;
 
  XboxMath::vector_t direction_;
 
  float range_;
 
  float phi_;
 
  float theta_;
 
  float attenuation_[3];
 
  float falloff_[3];
};
 
class DirectionalLight : public Light {
 public:
  DirectionalLight() = delete;
 
  DirectionalLight(uint32_t light_index, const XboxMath::vector_t& direction);
 
  void Commit(TestHost& host) const override;
 
  void Commit(TestHost& host, const XboxMath::vector_t& look_dir) const override;
 
 private:
  XboxMath::vector_t direction_;
};
 
class PointLight : public Light {
 public:
  PointLight() = delete;
 
  PointLight(uint32_t light_index, const XboxMath::vector_t& position, float range, float attenuation_constant,
             float attenuation_linear, float attenuation_quadratic);
 
  void Commit(TestHost& host) const override;
 
 private:
  XboxMath::vector_t position_;
 
  float range_;
 
  float attenuation_[3];
};
 
#endif  // LIGHT_H