GameScene.hpp

 
#pragma once
#include <vector>
#include <alicorn/std.fast/unordered-map.hpp>
#include "Defines.hpp"
#include "CubeCoords.hpp"
#include "Constants.hpp"
 
namespace basement
{
 
namespace support
{
 
class GameScene final
{
  using SceneObjects_t = 
    ::alicorn::extension::std::fast::unordered_map<uint64_t, ::std::vector<Id_t>>;
  using CellObject_t = SceneObjects_t::value_type;
  using Callback_t = ::std::function<void(const Id_t)>;
  using RenderObject_t = ::std::pair<float, Id_t>;
 
public:
  class Camera final
  {
  public:
    bool IsVisible(const model::CubeCoords &) const;
    float GetSquaredDistance(const model::CubeCoords &) const;
 
  private:
    float m_X;
    float m_Y;
    float m_CameraOffsetX;
    float m_CameraOffsetY;
    float m_Direction;
 
  public:
    explicit Camera(const float = 0.0f, const float = 0.0f, const float = 0.0f);
  };
 
private:
  class Scene
  {
  public:
    SceneObjects_t Objects;
  };
 
public:
  void SetCameraInfo(const Camera &);
  void Render(const Callback_t &);
  void ProcessAll(const Callback_t &);
 
public:
  void Add(const size_t, const ::std::vector<Id_t> &);
  void Add(const size_t, const ::std::vector<Id_t> &, const model::CubeCoords &);
  ::std::vector<Id_t> Remove(const model::CubeCoords &);
  void CompleteReplace(void);
  void CompleteUpdate(void);
 
private:
  void BuildRenderObjects(void);
  void Add(const size_t, const ::std::vector<Id_t> &, const uint64_t);
 
private:
  ::std::vector<Scene>          m_Scenes;
  ::std::vector<Scene>          m_BkScenes;
  Camera                        m_Camera;
  ::std::vector<RenderObject_t> m_PrepareRenderObjects;
  ::std::vector<RenderObject_t> m_CompleteRenderObjects;
  bool                          m_IsUpdateRenderObjects = false;
};
 
// cppcheck-suppress passedByValue
inline void GameScene::Add(
  const size_t _SceneId,
  const ::std::vector<Id_t> & _ObjectIds)
{
  Add(_SceneId, _ObjectIds, static_cast<uint64_t>(0));
}
 
inline void GameScene::Add(
  const size_t _SceneId,
  const ::std::vector<Id_t> & _ObjectIds,
  const model::CubeCoords & _Position)
{
  Add(_SceneId, _ObjectIds, _Position.GetHash());
}
 
inline void GameScene::Add(
  const size_t _SceneId,
  const ::std::vector<Id_t> & _ObjectIds,
  const uint64_t _CoordHash)
{
  if (_SceneId >= m_BkScenes.size()) m_BkScenes.resize(_SceneId + 1);
  m_BkScenes[_SceneId].Objects[_CoordHash] = _ObjectIds;
}
 
} // namespace support
 
} // namespace basement