CubeMarkerSystem.cpp

#include "CubeMarkerSystem.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 "Components/Appearance/MaterialComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshComponent.h"
#include "../Components/AxisCubeComponent.h"
#include "Components/Core/SceneComponent.h"
 
#include "Systems/Core/TransformSystem.h"
 
#include "Utilities/Math.h"
 
namespace Cogs
{
  namespace Core
  {
    void CubeMarkerSystem::createWallMarkers(CubeMarkerData & cmapData, CubeMarkerComponent & cmapComp)
    {
      EntityPtr cube = cmapData.cube.lock();
 
      if (cmapData.wallMarkerShapes[0].lock()) {
        return; // we already have the entities, nothing to do.
      }
      if (!cube) {
        return; // no cube into which to embed, nothing to do
      }
 
      auto axisCubeComp = cube->getComponent<AxisCubeComponent>();
      auto cubeTransformComp = cube->getComponent<TransformComponent>();
 
      if (!axisCubeComp || !cubeTransformComp) {
        return; // not a suitable entity
      }
 
      ComponentHandle cubeTransformCompH = context->transformSystem->getHandle(cubeTransformComp);
 
      for (int axis = 0; axis < 3; axis++) {
        // Create entity
        EntityPtr wallMarker = context->store->createChildEntity("SubMeshPart", cmapComp.getContainer());
        cmapData.wallMarkerShapes[axis] = wallMarker;
 
        // Add mesh
        auto meshComp = wallMarker->getComponent<MeshComponent>();
        meshComp->meshHandle = createWallMarkerMesh(context);
 
        // Setup transform and transform relationship
        auto transformComponent = wallMarker->getComponent<TransformComponent>();
        glm::vec3 a(axis == 0 ? 1.f : 0.f, axis == 1 ? 1.f : 0.f, axis == 2 ? 1.f : 0.f);
        transformComponent->rotation = Cogs::Core::getRotation(glm::vec3(0.f, 0.f, 1.f), a);
        transformComponent->scale = glm::vec3(cmapComp.markerSize, cmapComp.markerSize, 1.f);
        transformComponent->parent = cubeTransformCompH;
        context->transformSystem->updateTransformData(*transformComponent);
      }
 
      updateWallMarkers(cmapData, cmapComp, true);
    }
 
    void CubeMarkerSystem::updateWallMarkers(CubeMarkerData& cubeMarkerData, CubeMarkerComponent& cubeMarkerComp, bool force)
    {
      // update colors
      glm::vec4 colors[3] = { cubeMarkerComp.xColor, cubeMarkerComp.yColor, cubeMarkerComp.zColor };
 
      // Update wall marker position and length
      EntityPtr cube = cubeMarkerData.cube.lock();
      if (cubeMarkerComp.showWallMarkers && cube) {
        AxisCubeComponent* axisCubeComp = cube->getComponent<AxisCubeComponent>();
        TransformComponent* cubeTransformComp = cube->getComponent<TransformComponent>();
        TransformComponent* markerTransformComp = cubeMarkerComp.getComponent<TransformComponent>();
        if (force || axisCubeComp->hasChanged() || cubeTransformComp->hasChanged() || markerTransformComp->hasChanged()) {
          glm::vec4 ph =
            axisCubeComp->worldToLocal *
            context->transformSystem->getLocalToWorld(markerTransformComp)*glm::vec4(0.f, 0.f, 0.f, 1.f);
 
          glm::vec3 p = (1.f / ph.w)*glm::vec3(ph.x, ph.y, ph.z);
          for (int axis = 0; axis < 3; axis++) {
            EntityPtr wallMarker = cubeMarkerData.wallMarkerShapes[axis].lock();
            if (wallMarker) {
              TransformComponent* wallMarkertransformComp = wallMarker->getComponent<TransformComponent>();
              wallMarkertransformComp->position = p;
              wallMarkertransformComp->scale = glm::vec3(cubeMarkerComp.markerSize,
                                                         cubeMarkerComp.markerSize,
                                                         glm::mix(axisCubeComp->adjustedMinCorner[axis],
                                                         axisCubeComp->adjustedMaxCorner[axis],
                                                         axisCubeComp->markerFaces[axis]) - p[axis]);
              wallMarkertransformComp->setChanged();
 
              uint32_t key = ((uint32_t(255.f*colors[axis].r) & 0xff) << 24)
                           | ((uint32_t(255.f*colors[axis].g) & 0xff) << 16)
                           | ((uint32_t(255.f*colors[axis].b) & 0xff) << 8)
                           | ((uint32_t(255.f*colors[axis].a) & 0xff));
 
              if (force || (cubeMarkerData.colorKeys[axis] != key)) {
                // update material
 
                auto meshRenderComp = wallMarker->getComponent<SubMeshRenderComponent>();
                auto it = wallMarkerMaterials.find(key);
                auto jt = wallMarkerMaterials.find(cubeMarkerData.colorKeys[axis]);  // Note, it is O.K if colorKey is uninitialized.
                if (it != wallMarkerMaterials.end()) {
                  // We already have a matching material, lets use that one.
                  meshRenderComp->materials.resize(3);
                  meshRenderComp->materials[0] = it->second.solid;
                  meshRenderComp->materials[1] = it->second.line;
                  meshRenderComp->materials[2] = it->second.line;
 
                  // Check if anyone uses the handle to our old material, and if not, remove our ref to it (and let it be deleted).
                  if (jt != wallMarkerMaterials.end()) {
                    if (jt->second.solid.resolve()->referenceCount() == 1) {
                      wallMarkerMaterials.erase(jt);
                    }
                  }
                }
                else {
                  // No matching material, either make a new one or recycle the one we have.
 
                  WallMarkerMaterials materials;
                  if ((jt != wallMarkerMaterials.end()) && (jt->second.solid.resolve()->referenceCount() == 2)) {
                    // We have an existing material that is not in use by anyone else, we use that one.
                    materials = jt->second;
                    wallMarkerMaterials.erase(jt);
                  }
                  else {
 
                    // Either we didn't have a material beforehand, or the one was in use by additional parties.
                    materials.solid = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
                    materials.solid->setVariant("LightModel", "BaseColor");
                    materials.solid->setVariant("EnableLighting", false);
                    materials.solid->setBoolProperty(DefaultMaterial::EnableLighting, false);
                    materials.solid->options.depthBiasEnabled = true;
                    materials.solid->options.depthBias.constant = -1.f;
                    materials.solid->options.depthBias.slope = -1.f;
                    materials.solid->options.depthBias.clamp = 100.f;
                    materials.solid->options.cullMode = CullMode::None;
 
                    materials.line = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
                    materials.line->setPermutation("Line");
                    materials.line->setBoolProperty(DefaultMaterial::EnableLighting, false);
                    materials.line->options.depthBiasEnabled = true;
                    materials.line->options.depthBias.constant = -1.f;
                    materials.line->options.depthBias.slope = -1.f;
                    materials.line->options.depthBias.clamp = 100.f;
                  }
 
                  // Update refs and set colors
                  meshRenderComp->materials.resize(3);
                  meshRenderComp->materials[0] = materials.solid;
                  meshRenderComp->materials[1] = materials.line;
                  meshRenderComp->materials[2] = materials.line;
                  materials.solid->setVec4Property(DefaultMaterial::DiffuseColor, 0.5f*colors[axis]);
                  materials.line->setVec4Property(DefaultMaterial::DiffuseColor, colors[axis]);
                  wallMarkerMaterials[key] = materials;
                }
                cubeMarkerData.colorKeys[axis] = key;
                meshRenderComp->setChanged();
              }
            }
 
          }
        }
      }
    }
 
    void CubeMarkerSystem::destroyWallMarkers(CubeMarkerData& cmapData, CubeMarkerComponent& cmapComp)
    {
      for (int axis = 0; axis < 3; axis++) {
        EntityPtr wallMarker = cmapData.wallMarkerShapes[axis].lock();
        if (wallMarker) {
          context->store->removeChild(cmapComp.getContainer(), wallMarker.get());
          cmapData.wallMarkerShapes[axis].reset();
        }
      }
    }
 
    void CubeMarkerSystem::createCenterMarker(CubeMarkerData& cmapData, CubeMarkerComponent& cmapComp)
    {
      EntityPtr centerMarker = cmapData.centerMarkerShape.lock();
      if (centerMarker) {
        return; // Nothing to do
      }
      centerMarker = context->store->createChildEntity("Sphere", cmapComp.getContainer());
      cmapData.centerMarkerShape = centerMarker;
 
      auto * thisMatComp = cmapComp.getComponent<MaterialComponent>();
      auto * thatMatComp = centerMarker->getComponent<MaterialComponent>();
      thatMatComp->copyProperties(thisMatComp);
      updateCenterMarker(cmapData, cmapComp, true);
    }
 
    void CubeMarkerSystem::updateCenterMarker(CubeMarkerData& cubeMarkerData, CubeMarkerComponent& cubeMarkerComp, bool force)
    {
      EntityPtr centerMarker = cubeMarkerData.centerMarkerShape.lock();
      if (centerMarker) {
        if (force || cubeMarkerComp.hasChanged()) {
          TransformComponent* mtfComp = centerMarker->getComponent<TransformComponent>();
          mtfComp->scale = glm::vec3(cubeMarkerComp.markerSize);
          mtfComp->setChanged();
        }
      }
    }
 
    void CubeMarkerSystem::destroyCenterMarker(CubeMarkerData& cmapData, CubeMarkerComponent& cmapComp)
    {
      EntityPtr centerMarker = cmapData.centerMarkerShape.lock();
      if (centerMarker) {
        context->store->removeChild(cmapComp.getContainer(), centerMarker.get());
        cmapData.centerMarkerShape.reset();
      }
    }
 
    void CubeMarkerSystem::update(Context * context)
    {
      if (this->context != context) {
        initialize(context);
      }
 
      for (auto& cubeMarkerComp : pool) {
 
        auto& cubeMarkerData = getData(&cubeMarkerComp);
 
 
        auto * matComp = cubeMarkerComp.getComponent<MaterialComponent>();
        if (matComp->hasChanged()) {
          EntityPtr centerMarker = cubeMarkerData.centerMarkerShape.lock();
          if (centerMarker) {
            auto * thatMatComp = centerMarker->getComponent<MaterialComponent>();
            thatMatComp->copyProperties(matComp);
          }
        }
 
        // turn on and off stuff
        if (cubeMarkerComp.hasChanged()) {
          EntityPtr compCube = cubeMarkerComp.cube.lock();
          EntityPtr dataCube = cubeMarkerData.cube.lock();
 
          // cube embedding has changed, explicitly destroy wall markers
          if (compCube != dataCube) {
            destroyWallMarkers(cubeMarkerData, cubeMarkerComp);
            cubeMarkerData.cube = cubeMarkerComp.cube;
          }
          if (cubeMarkerComp.showWallMarkers) {
            createWallMarkers(cubeMarkerData, cubeMarkerComp);
          }
          else {
            destroyWallMarkers(cubeMarkerData, cubeMarkerComp);
          }
 
          if (cubeMarkerComp.showCenterMarker) {
            createCenterMarker(cubeMarkerData, cubeMarkerComp);
          }
          else {
            destroyCenterMarker(cubeMarkerData, cubeMarkerComp);
          }
        }
        updateCenterMarker(cubeMarkerData, cubeMarkerComp, false);
        updateWallMarkers(cubeMarkerData, cubeMarkerComp, false);
      }
    }
 
    MaterialInstanceHandle CubeMarkerSystem::createUnshadedMaterialInstance(Context * context, const glm::vec4 color)
    {
      MaterialInstanceHandle matH = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
      MaterialInstance* matI = matH.resolve();
      matI->setPermutation("Line");
      matI->setBoolProperty(DefaultMaterial::EnableLighting, false);
      matI->setVec4Property(DefaultMaterial::DiffuseColor, color);
      matI->setVariant("LightModel", "BaseColor");
      matI->setVariant("EnableLighting", false);
      return matH;
    }
 
    MeshHandle CubeMarkerSystem::createWallMarkerMesh(Context * context)
    {
      static const int N = 20;  // samples currently hard-coded.
 
      std::vector<Cogs::Core::PositionVertex> V;
      for (int i = 0; i < N; i++) {
        float theta = float(i) * float((2.0 * glm::pi<double>()) / N);
        float c = std::cos(theta);
        float s = std::sin(theta);
 
        V.push_back({ glm::vec3(c, s, 1.f) });
        V.push_back({ glm::vec3(0.5f*c, 0.5f*s, 1.f) });
      }
      V.push_back({ glm::vec3(0.f, 0.f, 1.f) });
      V.push_back({ glm::vec3(0.f, 0.f, 0.f) });
 
      std::vector<unsigned int> tristrip;
      for (int i = 0; i < N; i++) {
        tristrip.push_back(2 * i + 0);
        tristrip.push_back(2 * i + 1);
      }
      tristrip.push_back(0);
      tristrip.push_back(1);
 
      std::vector<unsigned int> linestrip;
      for (int i = 0; i < N; i++) {
        linestrip.push_back(2 * i);
      }
      linestrip.push_back(0);
 
      std::vector<unsigned int> line;
      line.push_back(2 * N);
      line.push_back(2 * N+1);
 
 
      MeshHandle M = context->meshManager->create();
      Mesh* m = context->meshManager->get(M);
      if (m) {
        m->setVertexData(V.data(), V.size());
 
        m->addSubMesh(std::span(tristrip), PrimitiveType::TriangleStrip);
        m->addSubMesh(std::span(linestrip), PrimitiveType::LineStrip);
        m->addSubMesh(std::span(line), PrimitiveType::LineList);
      }
 
      M->setBounds(Geometry::BoundingBox{ glm::vec3(-1, -1, -1), glm::vec3(1, 1, 1) });
 
      return M;
    }
  } // namespace Core
} // namespace Cogs