AxisCubeComponent.h

#pragma once
 
#include "../../../../Source/Components/Core/DynamicComponent.h"
#include "../../../../Source/Resources/Resources.h"
#include "EntityPtr.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Components/Core/RenderComponent.h"
 
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
 
#include <string>
 
namespace Cogs
{
  namespace Core
  {
    struct AxisCubeComponent : public DynamicComponent
    {
      AxisCubeComponent() = default;
 
      Context* context = nullptr;
      glm::vec3 minCorner = glm::vec3(-1.f);                
      glm::vec3 maxCorner = glm::vec3(1.f);                 
      float zScale = 1.f;                                   
      int maxAxisValues = 10;                               
      std::vector<std::string> axisTitles;                  
      std::vector<std::string> unitNames;                   
      glm::vec3 unitScales = glm::vec3(1.f);                
      bool useAxisAnnotations = true;                       
      bool autoAdjustToLargestDimension = false;             
      float tickSizeOffset = 0.05f;
      glm::vec4 textColor = glm::vec4(1.f);                 
      float annotationGap = 100.0f;                         
 
      std::vector<WeakEntityPtr> autoNodes;                 
      glm::vec3 autoAdjustMargin = glm::vec3(0.1f);         
 
      EntityPtr topQuadMaterial;
      EntityPtr bottomQuadMaterial;
      EntityPtr frontQuadMaterial;
      EntityPtr backQuadMaterial;
      EntityPtr rightQuadMaterial;
      EntityPtr leftQuadMaterial;
 
      glm::vec3 adjustedMinCorner;          
      glm::vec3 adjustedMaxCorner;          
 
      glm::bvec3 markerFaces;               
      glm::mat4 worldToLocal;               
 
      static void registerType();
 
      void initialize(Context * context);
      void update();
 
    private:
      bool  initialUpdate = true;
      
      glm::vec3 corners[8];                 
      glm::vec3 tickSizes;                  
      float     tickProtrusion = 0.0f;      
 
      MaterialInstanceHandle gridMatInstH;
      MaterialInstanceHandle edgeMatInstH;
      std::vector<EntityPtr> unprocessedAutoNodes;
 
      struct PerFaceData
      {
        bool      visible = false;
        EntityPtr solid;
        EntityPtr grid;
        glm::vec4 equation;
      };
      PerFaceData faces[6];
 
      EntityPtr  axisTitlesRightEntity; // Right-adjusted titles
      EntityPtr  axisTitlesLeftEntity;  // Left-adjusted titles
 
      struct PerEdgeData
      {
        bool       visible = false;
        EntityPtr  annotationEntity;
      };
      PerEdgeData edges[12];
 
      RenderLayers renderLayer = RenderLayers::Annotations;
 
      void updateQuadGeometry(int face, EntityPtr material);
 
      void updateCorners();
 
      void updateAdjustedMinAndMax(const glm::vec3& minCorner, const glm::vec3& maxCorner);
 
      void updateTickSizes();
 
      void updateFaceVisibilites(bool forceUpdate);
 
      void updateEdgeVisibilites(bool forceUpdate);
 
      void updateAxisLabels(bool forceUpdate);
 
      void updateGridGeometry(int face);
 
      void updateAnnotationAxes();
    };
  }
}
 
template<> inline Cogs::StringView getName<Cogs::Core::AxisCubeComponent>() { return "AxisCubeComponent"; }