MarkerPointSetSystem.cpp

#include "MarkerPointSetSystem.h"
#include "MarkerPointSetPicker.h"
#include "Context.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/InstancedMeshRenderComponent.h"
#include "Scene/RayPick.h"
#include "Services/DPIService.h"
#include "Resources/Mesh.h"
#include "Resources/VertexFormats.h"
#include "Resources/MeshManager.h"
#include "Systems/Core/CameraSystem.h"
#include "Utilities/Math.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ICapabilities.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("MarkerPointSetSystem");
}
 
void Cogs::Core::MarkerPointSetSystem::initialize(Context* context)
{
  ComponentSystemWithDataPool::initialize(context);
 
  // Initialize material
  pointMaterial = context->materialManager->loadMaterial("MarkerPointSetMaterial.material");
  context->materialManager->processLoading();
 
  Material* mat = pointMaterial.resolve();
  diffuseColorKey = mat->getVec4Key("diffuseColor");
  outlineColorKey = mat->getVec4Key("outlineColor");
  viewPlaneLocalKey = mat->getVec4Key("viewPlaneLocal");
  viewXLocalKey = mat->getVec4Key("viewXLocal");
  viewYLocalKey = mat->getVec4Key("viewYLocal");
  pointSizeKey = mat->getVec2Key("pointSize");
  outlineRelativeRadiusSquaredKey = mat->getFloatKey("outlineRelativeRadiusSquared");
  nearDistanceKey = mat->getFloatKey("nearDistance");
  farDistanceKey = mat->getFloatKey("farDistance");
}
 
 
ComponentHandle Cogs::Core::MarkerPointSetSystem::createComponent()
{
  ComponentHandle componentHandle = ComponentSystemWithDataPool::createComponent();
 
  if(pool.size() == 1) {
    assert(!quad);
    quad = context->meshManager->create();
 
    std::array<glm::vec2, 4> vertices = {
      glm::vec2(-0.5f, -0.5f),
      glm::vec2(0.5f, -0.5f),
      glm::vec2(-0.5f,  0.5f),
      glm::vec2(0.5f,  0.5f),
    };
    quad->set(VertexDataType::Positions, VertexFormats::Pos2f, vertices);
    quad->setBounds(Geometry::BoundingBox{ glm::vec3(-1.f, -1.f, 0.f), glm::vec3(1.f, 1.f, 0.f) });
    quad->primitiveType = Cogs::PrimitiveType::TriangleStrip;
 
    assert(!picker);
    picker = std::make_unique<MarkerPointSetPicker>(this);
    context->rayPicking->addPickable(picker.get());
    LOG_DEBUG(logger, "Registered marker point set picker extension");
  }
  return componentHandle;
}
 
void Cogs::Core::MarkerPointSetSystem::destroyComponent(ComponentHandle componentHandle)
{
  ComponentSystemWithDataPool::destroyComponent(componentHandle);
 
  if (pool.size() == 0) {
    assert(quad);
    quad = MeshHandle();
 
    assert(picker);
    context->rayPicking->removePickable(picker.get());
    picker.reset();
 
    LOG_DEBUG(logger, "Last component destroyed, unregistered marker point set picker extension");
  }
}
 
void Cogs::Core::MarkerPointSetSystem::update(Context*)
{
  const CameraData& mainCamData = context->cameraSystem->getMainCameraData();
  const float dpiScale = context->getDefaultView()->dpiService->getScaleFactor();
 
  for(MarkerPointSetComponent& comp : pool) {
 
    TransformComponent* trComp = comp.getComponent<TransformComponent>();
    if (!trComp) { continue; }  // just to avoid crash on ill-defined components
 
    MarkerPointSetData& data = getData(&comp);
    if (!data.initialized) {
      data.materialInstance = context->materialInstanceManager->createMaterialInstance(pointMaterial);
 
      MeshComponent* meshComp = comp.getComponent<MeshComponent>();
      meshComp->meshHandle = quad;
      meshComp->setChanged();
 
      InstancedMeshRenderComponent* mshRndComp = comp.getComponent<InstancedMeshRenderComponent>();
      mshRndComp->unsetRenderFlag(RenderFlags::SelfPickable | RenderFlags::ParentPickable); // Picking is handled by MarkerPointSetPicker
      mshRndComp->material = data.materialInstance;
      mshRndComp->setChanged();
      data.initialized = true;
    }
 
    // We use the main cam to determine view-dependent orientation etc. This is usually the camera that is used
    // for rendering. In VR applications, we have a camera per eye, and what they see have to agree, so by using
    // the main camera to define orientation (and not the the camera used for rendering) they agree.
    glm::mat4 viewFromLocal = mainCamData.viewMatrix * context->transformSystem->getLocalToWorld(trComp);
    data.viewPlaneLocal = glm::vec4(0.f, 0.f, -1.f, 0.f) * viewFromLocal;
    data.viewXLocal = glm::vec3(1.f, 0.f, 0.f) * glm::mat3(viewFromLocal);
    data.viewYLocal = glm::vec3(0.f, 1.f, 0.f) * glm::mat3(viewFromLocal);
    data.materialInstance->setVec4Property(viewPlaneLocalKey, data.viewPlaneLocal);
    data.materialInstance->setVec4Property(viewXLocalKey, glm::vec4(data.viewXLocal, 1.f));
    data.materialInstance->setVec4Property(viewYLocalKey, glm::vec4(data.viewYLocal, 1.f));
 
    // Near and far distances are relative to the main camera (distance from viewPLaneLocal)
    data.materialInstance->setFloatProperty(nearDistanceKey, comp.nearDistance);
    data.materialInstance->setFloatProperty(farDistanceKey, comp.farDistance);
 
    // Calculate the amount of the point radius that is inside the outline.
    float insideOutlineRatio = glm::clamp(1.f - comp.outline / (0.5f * comp.pointSize), 0.f, 1.f);
    data.materialInstance->setFloatProperty(outlineRelativeRadiusSquaredKey, 0.5f * 0.5f * insideOutlineRatio * insideOutlineRatio);
 
    data.materialInstance->setVec4Property(diffuseColorKey, comp.diffuseColor);
    data.materialInstance->setVec4Property(outlineColorKey, comp.outlineColor);
    data.materialInstance->options.blendMode = comp.smooth ? BlendMode::Blend : BlendMode::None;
 
    switch (comp.shape) {
    case MarkerPointSetShape::ViewAlignedDisc:
      data.materialInstance->setVariant("Shape", "ViewAlignedDisc");
      data.materialInstance->setVec2Property(pointSizeKey, glm::vec2(comp.pointSize));  // Point size is object space units.
      break;
    case MarkerPointSetShape::ObjectSpaceFloorDisc:
      data.materialInstance->setVariant("Shape", "ObjectSpaceFloorDisc");
      data.materialInstance->setVec2Property(pointSizeKey, glm::vec2(comp.pointSize));  // Point size is object space units.
      break;
    case MarkerPointSetShape::FixedScreenSizeDisc:
      data.materialInstance->setVariant("Shape", "FixedScreenSizeDisc");
      // Point size is pixels, and should be dpi and viewport-scaled.
      data.materialInstance->setVec2Property(pointSizeKey, glm::vec2(dpiScale * comp.pointSize) / (0.5f * mainCamData.viewportSize));
      break;
    default:
      break;
    };
 
    // Point positions changed, update instance mesh with new positions.
    if (comp.hasFieldChanged(&MarkerPointSetComponent::positions)) {
      InstancedMeshRenderComponent* mshRndComp = comp.getComponent<InstancedMeshRenderComponent>();
      if (!mshRndComp->instanceMesh) {
        mshRndComp->instanceMesh = context->meshManager->create();
      }
      mshRndComp->instanceMesh->clear();
      mshRndComp->instanceMesh->set(VertexDataType::Positions, VertexFormats::InstancePos3f, comp.positions);
    }
 
  }
}