AxisCubeComponent.cpp

#include "AxisCubeComponent.h"
 
#include "Types.h"
#include "Context.h"
#include "EntityStore.h"
 
#include "Resources/Mesh.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/DefaultMaterial.h"
#include "Resources/VertexFormats.h"
#include "Resources/FontManager.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Components/Core/TextComponent.h"
#include "Components/Core/TransformComponent.h"
#include "../Components/AnnotationAxisComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/MeshSystem.h"
#include "Systems/Core/RenderSystem.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
#include <sstream>
#include <numeric>
#include <array>
 
using namespace Cogs::Reflection;
using namespace Cogs::Geometry;
 
namespace
{
  struct
  {
    unsigned int ix[4]; // Quad triangle strip indices.
    glm::mat3x2 proj;   // Projection from R^3 corners to R^2 parameter plane.
  } faceDefinitions[6] =
  {
    { { 4, 6, 7, 5 }, { glm::vec2(0.f, 1.f), glm::vec2(1.f, 0.f), glm::vec2(0.f, 0.f) } }, // Top
    { { 0, 1, 3, 2 }, { glm::vec2(0.f, 1.f), glm::vec2(1.f, 0.f), glm::vec2(0.f, 0.f) } }, // Bottom
    { { 0, 4, 5, 1 }, { glm::vec2(1.f, 0.f), glm::vec2(0.f, 0.f), glm::vec2(0.f, 1.f) } }, // Front
    { { 2, 3, 7, 6 }, { glm::vec2(1.f, 0.f), glm::vec2(0.f, 0.f), glm::vec2(0.f, 1.f) } }, // Back
    { { 1, 5, 7, 3 }, { glm::vec2(0.f, 0.f), glm::vec2(0.f, 1.f), glm::vec2(1.f, 0.f) } }, // right
    { { 0, 2, 6, 4 }, { glm::vec2(0.f, 0.f), glm::vec2(0.f, 1.f), glm::vec2(1.f, 0.f) } }  // left
  };
 
  struct
  {
    int ix[2];  // Edge end corner indices
    int nb[2];  // Neighbor quads (references into faceDefinition array)
  } edgeDefinitions[12] = {
      // Edges parallel to x-axis
      { { 0, 1 }, { 2, 1 } },
      { { 2, 3 }, { 1, 3 } },
      { { 6, 7 }, { 3, 0 } },
      { { 4, 5 }, { 0, 2 } },
      // Edges parallel to y-axis
      { { 0, 2 }, { 5, 1 } },
      { { 1, 3 }, { 1, 4 } },
      { { 5, 7 }, { 4, 0 } },
      { { 4, 6 }, { 0, 5 } },
      // Edges parallel to z-axis
      { { 0, 4 }, { 5, 2 } },
      { { 1, 5 }, { 2, 4 } },
      { { 3, 7 }, { 4, 3 } },
      { { 2, 6 }, { 3, 5 } }
  };
}
 
void Cogs::Core::AxisCubeComponent::registerType()
{
  Field fields[] = {
    Field(Name("minCorner"), &AxisCubeComponent::minCorner),
    Field(Name("maxCorner"), &AxisCubeComponent::maxCorner),
    Field(Name("zScale"), &AxisCubeComponent::zScale),
    Field(Name("maxAxisValues"), &AxisCubeComponent::maxAxisValues),
    Field(Name("axisTitles"), &AxisCubeComponent::axisTitles),
    Field(Name("unitNames"), &AxisCubeComponent::unitNames),
    Field(Name("unitScales"), &AxisCubeComponent::unitScales),
    Field(Name("useAxisAnnotations"), &AxisCubeComponent::useAxisAnnotations),
    Field(Name("autoAdjustToLargestDimension"), &AxisCubeComponent::autoAdjustToLargestDimension),
 
    Field(Name("autoNodes"), &AxisCubeComponent::autoNodes),
    Field(Name("autoAdjustMargin"), &AxisCubeComponent::autoAdjustMargin),
    Field(Name("tickSizeOffset"), &AxisCubeComponent::tickSizeOffset),
    Field(Name("textColor"), &AxisCubeComponent::textColor),
 
    Field(Name("topQuadMaterial"), &AxisCubeComponent::topQuadMaterial),
    Field(Name("bottomQuadMaterial"), &AxisCubeComponent::bottomQuadMaterial),
    Field(Name("frontQuadMaterial"), &AxisCubeComponent::frontQuadMaterial),
    Field(Name("backQuadMaterial"), &AxisCubeComponent::backQuadMaterial),
    Field(Name("rightQuadMaterial"), &AxisCubeComponent::rightQuadMaterial),
    Field(Name("leftQuadMaterial"), &AxisCubeComponent::leftQuadMaterial),
    Field(Name("renderLayer"), &AxisCubeComponent::renderLayer)
  };
 
  Method methods[] = {
    Method(Name("initialize"), &AxisCubeComponent::initialize),
    Method(Name("update"), &AxisCubeComponent::update),
  };
 
  DynamicComponent::registerDerivedType<AxisCubeComponent>()
    .setFields(fields)
    .setMethods(methods);
}
 
void Cogs::Core::AxisCubeComponent::initialize(Context * ctx)
{
  context = ctx;
 
  // Material used for grid lines
  gridMatInstH = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
  MaterialInstance* lineMatInst = gridMatInstH.resolve();
  lineMatInst->setBoolProperty(DefaultMaterial::EnableLighting, false);
  lineMatInst->setPermutation("Line");
 
  // Material used for box edges
  edgeMatInstH = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
  MaterialInstance* edgeMatInst = edgeMatInstH.resolve();
  edgeMatInst->setBoolProperty(DefaultMaterial::EnableLighting, false);
  edgeMatInst->setFloatProperty(DefaultMaterial::LineWidth, 2.0f);
  edgeMatInst->setPermutation("Line");
 
  for (int i = 0; i < 6; i++) {
    PerFaceData& f = faces[i];
 
    f.solid = context->store->createChildEntity("AxisCubeFace", getContainer());
 
    MeshComponent* qMeshComp = f.solid->getComponent<MeshComponent>();
    if (qMeshComp->meshHandle == MeshHandle::NoHandle) {
      qMeshComp->meshHandle = context->meshManager->create();
    }
 
    f.grid = context->store->createChildEntity("SubMeshPart", getContainer());
 
    MeshComponent* meshComp = f.grid->getComponent<MeshComponent>();
    if (meshComp->meshHandle == MeshHandle::NoHandle) {
      meshComp->meshHandle = context->meshManager->create();
    }
    auto meshRenderComp = f.grid->getComponent<SubMeshRenderComponent>();
    //meshRenderComp->material = gridMatInstH;
    meshRenderComp->setMaterial(gridMatInstH);
    meshRenderComp->layer = renderLayer;
 
    f.visible = true;
  }
 
  axisTitlesRightEntity = context->store->createChildEntity("Text", getContainer());
  auto textRendLeftComp = axisTitlesRightEntity->getComponent<TextComponent>();
  textRendLeftComp->positionMode = PositionMode::World;
  textRendLeftComp->horizontalJustification = HorizontalJustification::Right;
  textRendLeftComp->verticalAlignment = VerticalAlignment::Center;
 
  axisTitlesLeftEntity = context->store->createChildEntity("Text", getContainer());
  auto textRendRightComp = axisTitlesLeftEntity->getComponent<TextComponent>();
  textRendRightComp->positionMode = PositionMode::World;
  textRendRightComp->horizontalJustification = HorizontalJustification::Left;
  textRendRightComp->verticalAlignment = VerticalAlignment::Center;
 
  for (int i = 0; i < 12; i++) {
    PerEdgeData& e = edges[i];
 
    e.annotationEntity = context->store->createChildEntity("AxisCubeEdge", getContainer());
 
    MeshComponent* meshComp = e.annotationEntity->getComponent<MeshComponent>();
    if (meshComp->meshHandle == MeshHandle::NoHandle) {
      meshComp->meshHandle = context->meshManager->create();
    }
 
    auto meshRenderComp = e.annotationEntity->getComponent<SubMeshRenderComponent>();
    meshRenderComp->setMaterial(edgeMatInstH);
    meshRenderComp->layer = renderLayer;
    e.visible = true;
  }
  initialUpdate = true;
}
 
void Cogs::Core::AxisCubeComponent::update()
{
  auto transformComponent = getComponent<TransformComponent>();
 
  worldToLocal = glm::inverse(context->transformSystem->getLocalToWorld(transformComponent));
 
  // Determine extent of autonodes. See below for notes wrt populating this array
  if (!unprocessedAutoNodes.empty()) {
    auto bbox = Geometry::makeEmptyBoundingBox<Geometry::BoundingBox>();
    
    for (auto & entity : unprocessedAutoNodes){
      auto transComp = entity->getComponent<TransformComponent>();
      auto meshComp = entity->getComponent<MeshComponent>();
 
      if (meshComp && transComp) {
        // Get world space bounds of entity.
        const auto & bboxNode = context->renderSystem->getWorldBounds(entity->getComponent<MeshRenderComponent>());
 
        for (int i = 0; i < 8; i++) {
          const glm::vec4 pw = worldToLocal * glm::vec4((i & 1) == 0 ? bboxNode.min.x : bboxNode.max.x,
                                                  (i & 2) == 0 ? bboxNode.min.y : bboxNode.max.y,
                                                  (i & 4) == 0 ? bboxNode.min.z : bboxNode.max.z,
                                                  1.f);
 
          bbox += (1.f / pw.w) * glm::vec3(pw.x, pw.y, pw.z);
        }
      }
    }
 
    unprocessedAutoNodes.clear();
 
    // If we got a non-empty bounding box, update min and max-corner properties,
    // and trigger a change. This will be picked up further down and adjusted
    // corners will be set there.
    if (!isEmpty(bbox)) {
      minCorner = bbox.min - autoAdjustMargin;
      maxCorner = bbox.max + autoAdjustMargin;
      setChanged();
    }
  }
 
  // If entities has been added to autonodes, append them on the list of
  // entities that define the extent of the cube. Actually determining
  // the size of the cube will be done in the next frame, when all the
  // geometry of the entities has been created and extents defined.
  if (!autoNodes.empty()) {
    for (auto & n : autoNodes) {
      auto locked = n.lock();
 
      if (locked) {
        unprocessedAutoNodes.push_back(locked);
      }
    }
    autoNodes.clear();
  }
 
  if (initialUpdate || hasChanged()) {
    if (glm::all(glm::lessThanEqual(minCorner, maxCorner))) {
      updateAdjustedMinAndMax(minCorner, maxCorner);
    }
 
    updateTickSizes();
    updateCorners();
 
    updateQuadGeometry(0, topQuadMaterial);
    updateQuadGeometry(1, bottomQuadMaterial);
    updateQuadGeometry(2, frontQuadMaterial);
    updateQuadGeometry(3, backQuadMaterial);
    updateQuadGeometry(4, rightQuadMaterial);
    updateQuadGeometry(5, leftQuadMaterial);
 
    for (int i = 0; i < 6; i++) {
      updateGridGeometry(i);
    }
 
    updateAnnotationAxes();
 
    updateFaceVisibilites(true);
    updateEdgeVisibilites(true);
    updateAxisLabels(true);
  } else {
    updateFaceVisibilites(false);
    updateEdgeVisibilites(false);
    updateAxisLabels(false);
  }
 
  auto matComp = getComponent<MaterialComponent>();
  if (initialUpdate || matComp->hasChanged()) {
    gridMatInstH->setVec4Property(DefaultMaterial::DiffuseColor, glm::vec4(glm::vec3(matComp->diffuseColor * 0.7f), 1.0f));
    edgeMatInstH->setVec4Property(DefaultMaterial::DiffuseColor, matComp->diffuseColor);
  }
 
  initialUpdate = false;
}
 
void Cogs::Core::AxisCubeComponent::updateAnnotationAxes()
{
  for (int i = 0; i < 12; i++) {
    auto & edgeData = edges[i];
    edgeData.visible = useAxisAnnotations;
 
    auto text = edgeData.annotationEntity->getComponent<TextComponent>();
    text->color = textColor;
    text->getComponent<SpriteRenderComponent>()->setVisible(edgeData.visible);
    text->setChanged();
 
    auto aaComp = edgeData.annotationEntity->getComponent<AnnotationAxisComponent>();
    aaComp->visible = edgeData.visible;
    aaComp->positions.clear();
    aaComp->strings.clear();
    aaComp->distance = annotationGap;
    aaComp->setChanged();
 
    // We store the edge mesh in the annotation axis entity to get the directional visibility toggle.
    auto mesh = edgeData.annotationEntity->getComponent<MeshComponent>()->meshHandle;
    Cogs::Core::PositionVertex V[2] = { { corners[edgeDefinitions[i].ix[0]] }, { corners[edgeDefinitions[i].ix[1]] } };
    std::array<uint32_t, 2> I = { 0, 1 };
    mesh->setVertexData(V, 2);
    mesh->clearIndexes();
    mesh->addSubMesh(std::span(I), Cogs::PrimitiveType::LineList);
  }
 
  if (!useAxisAnnotations) return;
 
  unitNames.resize(3);
 
  std::stringstream o;
  for (int a = 0; a < 3; a++) {
    int l = int(glm::ceil((adjustedMinCorner[a] * (a == 2 ? 1.f / zScale : 1.f)) * unitScales[a] / tickSizes[a]));
    int u = int(glm::floor((adjustedMaxCorner[a] * (a == 2 ? 1.f / zScale : 1.f)) * unitScales[a] / tickSizes[a]));
      
    for (int k = 0; k < 4; k++) {
      int i_ = 4 * a + k;
 
      // Update annotation labels
      auto aaComp = edges[i_].annotationEntity->getComponent<AnnotationAxisComponent>();
 
      glm::vec4 t = faces[edgeDefinitions[i_].nb[0]].equation
                  + faces[edgeDefinitions[i_].nb[1]].equation;
      glm::vec3 p = corners[edgeDefinitions[i_].ix[0]] - tickProtrusion*glm::vec3(t.x, t.y, t.z);
 
      for (int i = l; i <= u; i++) {
 
        float uu = tickSizes[a] * i; // value at tick
        p[a] = (uu* (a == 2 ? zScale : 1.f)) / unitScales[a];     // value scaled to local coordinate system
 
        o.str("");
        o << uu << unitNames[a];
 
        aaComp->positions.push_back(p);
        aaComp->strings.push_back(o.str());
      }
 
      aaComp->viewDependentAnchor = true;
      aaComp->viewDependentAnchorReference = -glm::normalize(corners[edgeDefinitions[i_].ix[0]] +
                                                              corners[edgeDefinitions[i_].ix[1]] -
                                                              adjustedMinCorner[a] -
                                                              adjustedMaxCorner[a]);
    }
  }
}
 
void Cogs::Core::AxisCubeComponent::updateCorners()
{
  for (int i = 0; i < 8; i++) {
    corners[i].x = (i & 1) == 0 ? adjustedMinCorner.x : adjustedMaxCorner.x;
    corners[i].y = (i & 2) == 0 ? adjustedMinCorner.y : adjustedMaxCorner.y;
    corners[i].z = (i & 4) == 0 ? adjustedMinCorner.z : adjustedMaxCorner.z;
  }
}
 
void Cogs::Core::AxisCubeComponent::updateAdjustedMinAndMax(const glm::vec3 & minCorner, const glm::vec3 & maxCorner)
{
  if (autoAdjustToLargestDimension) {
    glm::vec3 d = maxCorner - minCorner;
    float h = 0.5f * glm::max(glm::max(d.x, d.y), d.z);
    glm::vec3 o = 0.5f * (minCorner + maxCorner);
    adjustedMinCorner = o - glm::vec3(h);
    adjustedMaxCorner = o + glm::vec3(h);
  } else {
    adjustedMinCorner = minCorner;
    adjustedMaxCorner = maxCorner;
  }
}
 
void Cogs::Core::AxisCubeComponent::updateTickSizes()
{
  glm::vec3 l = adjustedMaxCorner - adjustedMinCorner;
  tickProtrusion = std::min(100.f, tickSizeOffset*(0.5f / 3.f)*(l.x + l.y + l.z));
 
  for (int i = 0; i < 3; i++) {
    float local_d = std::max(std::numeric_limits<float>::epsilon(), adjustedMaxCorner[i] - adjustedMinCorner[i]);
    float d = local_d*(i == 2 ? 1.f / zScale : 1.f)*unitScales[i];
    float a = float(std::max(1, maxAxisValues));
    float d_over_a = std::max(std::numeric_limits<float>::epsilon(), d / a);
 
    // We want tick-sizes that have the correct magnitude, and we allow that
    // size to be subdivided into halfs or quarters. In other words, we seek
    //
    //   d/a <= 2^q 10^m,   q \in {0,-1,-2},  m \in Z,
    //
    // thus if,
    //
    //   l = log10(d/a)
    //
    //   m = ceil( l ),
    // 
    //   q = round( log2( (d/a)/10^m ) )
    //     = round( log2( d/a ) - log2(10^m) )
    //     = round( log10( d/a )log2(10) - m log2(10) )
    //     = round( log2(10)( l - m) ) ).
    float l_ = std::log10(d_over_a);
    float m = std::ceil(l_);
    float q = std::round(std::log2(10.f)*(l_ - m));
    tickSizes[i] = std::exp2(q)*std::pow(10.f, m);
  }
}
 
void Cogs::Core::AxisCubeComponent::updateEdgeVisibilites(bool forceUpdate)
{
  for (int i = 0; i < 12; i++) {
    PerEdgeData& e = edges[i];
 
    // An edge is visible if at least one of the two adjacent faces are visible.
    bool visible = faces[edgeDefinitions[i].nb[0]].visible ||
                   faces[edgeDefinitions[i].nb[1]].visible;
    if (forceUpdate || (e.visible != visible)) {
      auto mesh = e.annotationEntity->getComponent<RenderComponent>();
      mesh->setVisible(visible);
      mesh->setChanged();
 
      TextComponent * text = e.annotationEntity->getComponent<TextComponent>();
      text->getComponent<SpriteRenderComponent>()->setVisible(visible);
      text->setChanged();
 
      e.visible = visible;
    }
  }
}
 
void Cogs::Core::AxisCubeComponent::updateAxisLabels(bool /*forceUpdate*/)
{
  using namespace glm;
  using std::accumulate;
  using std::numeric_limits;
 
  auto camComp = context->cameraSystem->getMainCamera();
  auto & camData = context->cameraSystem->getData(camComp);
  auto trComp = getComponent<TransformComponent>();
 
  mat4 localToClip = camData.viewProjection * context->transformSystem->getLocalToWorld(trComp);
 
  vec3 cubeMidLocal = (1.f/8.f)*accumulate(corners, corners + 8, vec3(0.f));
 
  auto textRendLeftComp = axisTitlesRightEntity->getComponent<TextComponent>();
  textRendLeftComp->color = textColor;
  textRendLeftComp->texts.clear();
  textRendLeftComp->positions.clear();
 
  auto textRendRightComp = axisTitlesLeftEntity->getComponent<TextComponent>();
  textRendRightComp->color = textColor;
  textRendRightComp->texts.clear();
  textRendRightComp->positions.clear();
 
  vec3 viewXLocal(localToClip[0][0], localToClip[1][0], localToClip[2][0]);
  vec3 viewZLocal(localToClip[0][2], localToClip[1][2], localToClip[2][2]);
 
  axisTitles.resize(3);
  for (int i = 0; i < 3; i++) {
    if (axisTitles[i].empty()) continue;
 
    // Add label to all edges that have a visible and an invisible quad abutting
    for (int j = 0; j < 4; j++) {
      int e = 4 * i + j;
      if (faces[edgeDefinitions[e].nb[0]].visible != faces[edgeDefinitions[e].nb[1]].visible) {
 
        // direction from cube center to edge midpoint
        vec3 edgeMidLocal = (1.f / 2.f)*(corners[edgeDefinitions[e].ix[0]] + corners[edgeDefinitions[e].ix[1]]);
        vec3 edgeDirLocal = normalize(edgeMidLocal - cubeMidLocal);
 
        // Project direction into view plane
        vec3 edgeDirInViewPlaneLocal = edgeDirLocal - (dot(edgeDirLocal, viewZLocal) / dot(viewZLocal, viewZLocal))*viewZLocal;
 
        // Determine if label should be left- or right-adjusted.
        if (dot(viewXLocal, edgeDirInViewPlaneLocal) < 0.f) {
          textRendLeftComp->texts.push_back(axisTitles[i]);
          textRendLeftComp->positions.push_back(edgeMidLocal + 8.f*tickProtrusion * edgeDirInViewPlaneLocal);
        } else {
          textRendRightComp->texts.push_back(axisTitles[i]);
          textRendRightComp->positions.push_back(edgeMidLocal + 8.f*tickProtrusion * edgeDirInViewPlaneLocal);
        }
      }
    }
  }
 
  textRendLeftComp->setChanged();
  textRendRightComp->setChanged();
}
 
void Cogs::Core::AxisCubeComponent::updateFaceVisibilites(bool forceUpdate)
{
  // --- Get reference vector to use for visibility tests --------------------
  //
  // If the projection is a perspective projection, we compute the local
  // coords position of the view-point, and do a half-plane check for each of
  // the cube sides. If the view-point is inside the corresponding half-space,
  // the front-facing test succeeds.
  //
  // On the other hand, if the projection is an orthographic projection, the
  // actual view-point has been pushed to infinity. In this case, we just use
  // the view-direction transformed to local space.
 
  glm::vec4 refVec;
  const auto camComp = context->cameraSystem->getMainCamera();
  const auto & cameraData = context->cameraSystem->getData(camComp);
  auto transform = getComponent<TransformComponent>();
  glm::vec4 viewDirWorldSpace = glm::vec4(0.f, 0.f, 1.f, 0.f)*cameraData.viewMatrix;
  glm::vec4 viewDirLocalSpace = viewDirWorldSpace * context->transformSystem->getLocalToWorld(transform);
 
  glm::bvec3 newMarkerFaces = glm::lessThan(glm::vec3(viewDirLocalSpace.x, viewDirLocalSpace.y, viewDirLocalSpace.z), glm::vec3(0.f));
  if (glm::any(glm::notEqual(markerFaces, newMarkerFaces))) {
    markerFaces = newMarkerFaces;
    setChanged();
  }
 
  if (camComp->projectionMode == ProjectionMode::Perspective) {
    glm::vec4 viewPointWorldCoords = cameraData.inverseViewMatrix * glm::vec4(0.f, 0.f, 0.f, 1.f);
    glm::vec4 viewPointLocalCoords = glm::inverse(context->transformSystem->getLocalToWorld(transform)) * viewPointWorldCoords;
    refVec = viewPointLocalCoords;
  } else {
    refVec = viewDirLocalSpace;
    refVec.w = 0.f;
  }
 
  // --- Check visibility and update -----------------------------------------
  for (int face = 0; face < 6; face++) {
    PerFaceData& f = faces[face];
 
    bool visible = glm::dot(refVec, f.equation) >= 0.f;
 
    if (forceUpdate || (f.visible != visible)) {
      auto qMeshRC = f.solid->getComponent<RenderComponent>();
      qMeshRC->setVisible(visible);
      qMeshRC->setChanged();
 
      auto lMeshRC = f.grid->getComponent<RenderComponent>();
      lMeshRC->setVisible(visible);
      lMeshRC->setChanged();
 
      setChanged();
    }
    f.visible = visible;
  }
}
 
void Cogs::Core::AxisCubeComponent::updateQuadGeometry(int face, EntityPtr material)
{
  PerFaceData & f = faces[face];
 
  const glm::vec3 & p0 = corners[faceDefinitions[face].ix[0]];
  const glm::vec3 & p1 = corners[faceDefinitions[face].ix[1]];
  const glm::vec3 & p2 = corners[faceDefinitions[face].ix[2]];
  const glm::vec3 & p3 = corners[faceDefinitions[face].ix[3]];
 
  glm::vec3 n = glm::normalize(glm::cross(p1 - p0, p3 - p0));
  f.equation = glm::vec4(n.x, n.y, n.z, -glm::dot(n, p0));
 
  if (material) {
    auto qMesh = context->meshManager->get(f.solid->getComponent<MeshComponent>()->meshHandle);
 
    Cogs::Core::PositionNormalVertex V[4] = { { p0, n }, { p1, n }, { p2, n }, { p3, n } };
    qMesh->setVertexData(V, 4);
 
    auto materialComponent = f.solid->getComponent<MaterialComponent>();
    materialComponent->material = material;
 
    auto masterMaterialComponent = material->getComponent<MaterialComponent>();
    masterMaterialComponent->depthBiasEnable = true;
    if(context->variables->get("renderer.reverseDepth", false)){
      masterMaterialComponent->depthBiasConstant = -2.0f;
      masterMaterialComponent->depthBiasSlope = -2.0f;
    }
    else{
      masterMaterialComponent->depthBiasConstant = 2.0f;
      masterMaterialComponent->depthBiasSlope = 2.0f;
    }
 
    qMesh->clearIndexes();
    std::array<uint32_t, 4> I{ 0, 1, 3, 2 };
    qMesh->addSubMesh(std::span(I), Cogs::PrimitiveType::TriangleStrip);
  } else {
    auto qMesh = context->meshManager->get(f.solid->getComponent<MeshComponent>()->meshHandle);
    qMesh->clearIndexes();
  }
}
 
void Cogs::Core::AxisCubeComponent::updateGridGeometry(int face)
{
  const glm::vec3& p0 = corners[faceDefinitions[face].ix[0]];
  const glm::vec3& p1 = corners[faceDefinitions[face].ix[1]];
  const glm::vec3& p2 = corners[faceDefinitions[face].ix[2]];
 
  glm::vec3 tap = -tickProtrusion*glm::normalize(glm::cross(p1 - p0, p2 - p0));
 
  const glm::vec2 t0 = faceDefinitions[face].proj*p0;
  const glm::vec2 t2 = faceDefinitions[face].proj*p2;
 
  const glm::vec2 ticks = faceDefinitions[face].proj*tickSizes;
  const glm::vec2 scale = faceDefinitions[face].proj*unitScales
    * glm::mix(glm::vec2(1.f), glm::vec2(1.f / zScale), glm::notEqual(faceDefinitions[face].proj[2], glm::vec2(0.f)));
 
  const glm::mat2x3 projTr = glm::transpose(faceDefinitions[face].proj);
 
  std::vector<Cogs::Core::PositionVertex> V;
  std::vector<unsigned int> I;
 
  glm::ivec2 ll(glm::ceil(t0*scale / ticks));
  glm::ivec2 ur(glm::floor(t2*scale / ticks));
 
  for (int k = 0; k < 2; k++) {
    glm::vec3 keep = glm::vec3(1.f) - projTr[k];
 
    // Skip if no inner edges present.
    if (ur[k] - ll[k] < 3) continue;
 
    for (int i = ll[k] + 1; i <= ur[k] - 1; i++) {
      int o = static_cast<int>(V.size());
      I.push_back(o);
      I.push_back(o + 1);
 
      I.push_back(o + 1);
      I.push_back(o + 2);
 
      I.push_back(o + 2);
      I.push_back(o + 3);
 
      float u = ticks[k] * i;
      V.push_back({ keep*p0 + (u / scale[k])*projTr[k] + tap });
      V.push_back({ keep*p0 + (u / scale[k])*projTr[k] });
      V.push_back({ keep*p2 + (u / scale[k])*projTr[k] });
      V.push_back({ keep*p2 + (u / scale[k])*projTr[k] + tap });
    }
  }
 
  auto mesh = context->meshManager->get(faces[face].grid->getComponent<MeshComponent>()->meshHandle);
 
  mesh->setVertexData(V.data(), V.size());
  mesh->clearIndexes();
  mesh->addSubMesh(std::span(I), Cogs::PrimitiveType::LineList);
}