InstancedMeshBuilderSystem.cpp

#include "InstancedMeshBuilderSystem.h"
#include "Components/Core/InstancedMeshRenderComponent.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Resources/Mesh.h"
#include "Resources/MeshManager.h"
#include "Resources/VertexFormats.h"
 
#include "Services/DPIService.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Geometry/Glm.hpp"
 
#include "Context.h"
 
using namespace Cogs::Core;
 
namespace {
 
  void buildMatrices(std::span<glm::mat4> matrices,
                     std::span<const glm::vec3> positions,
                     std::span<const glm::quat> rotations,
                     std::span<const glm::vec3> scales,
                     size_t instanceCount)
  {
    for (size_t i = 0; i < instanceCount; ++i) {
      const glm::vec3 position = !positions.empty() ? positions[i] : glm::vec3(0.0f);
      const glm::quat rotation = !rotations.empty() ? rotations[i] : glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
      const glm::vec3 scale = !scales.empty() ? scales[i] : glm::vec3(1.0f);
      matrices[i] = glm::translate(glm::mat4(1.0f), position) * glm::mat4_cast(rotation) * glm::scale(glm::mat4(1.0f), scale);
    }
  }
 
  size_t scaleMatrices(std::span<glm::mat4> matricesOut,
                       std::span<glm::vec4> colorsOut,
                       std::span<const glm::mat4> matricesIn,
                       std::span<const glm::vec4> colorsIn,
                       const glm::mat4& localToWorld,
                       const glm::mat4& viewMatrix,
                       const glm::mat4& rawProjectionMatrix,
                       const float viewportHeight,
                       const float dpiScale,
                       const float maxDistance)
  {
    assert(matricesOut.size() == matricesIn.size());
    assert(colorsOut.size() == colorsIn.size());
 
    const glm::mat4 M = viewMatrix * localToWorld;
    const glm::vec4 M_row2 = glm::transpose(M)[2];
    const glm::vec4 PM_row3 = glm::transpose(rawProjectionMatrix * M)[3];
    const float pixelScale = 2.0f * dpiScale / (rawProjectionMatrix[1][1] * viewportHeight);
 
    size_t activeCount = 0;
    for (size_t i = 0, N = matricesIn.size(); i < N; i++) {
      glm::mat4 m = matricesIn[i];
      const glm::vec4 pos = glm::vec4(glm::vec3(m[3]), 1.0f);
 
      const float camZ = dot(M_row2, pos);
      if (0 < maxDistance && camZ < -maxDistance) continue;
 
      const float clipW = glm::dot(PM_row3, pos);
      const float scale = pixelScale * clipW;
      if (scale <= 0.f) continue;
 
      matricesOut[activeCount] = glm::mat4(scale*m[0], scale*m[1], scale*m[2], m[3]);
      if (!colorsIn.empty()) {
        colorsOut[activeCount] = colorsIn[i];
      }
 
      activeCount++;
    }
    return activeCount;
  }
 
}
 
void Cogs::Core::InstancedMeshBuilderSystem::update(Context* context)
{
  const CameraData& mainCamData = context->cameraSystem->getMainCameraData();
  const float dpiScale = context->getDefaultView()->dpiService->getScaleFactor();
 
  for (const InstancedMeshBuilderComponent& comp : pool) {
    InstancedMeshBuilderData& data = getData(&comp);
 
    bool forceUpdate = false;
 
    if (comp.hasChanged()) {
      size_t positionCount = comp.positions.size();
      size_t rotationCount = comp.rotations.size();
      size_t scaleCount = comp.scales.size();
      size_t colorCount = comp.colors.size();
 
      data.instanceCount = 0;
      for (size_t count : { positionCount, rotationCount, scaleCount, colorCount }) {
        if (count) {
          data.instanceCount = data.instanceCount ? std::min(data.instanceCount, count) : count;
        }
      }
 
      if (data.instanceCount == 0) {
        data.instanceMesh = MeshHandle::NoHandle;
        data.useMatrix = false;
        data.usePositions = false;
        data.useColors = false;
        data.dynamicScaling = false;
        data.matrices.resize(0, false);
      }
      else {
        if (!data.instanceMesh) {
          data.instanceMesh = context->meshManager->create();
        }
        data.instanceMesh->clear();
 
        data.useColors = colorCount;
        data.dynamicScaling = comp.fixedSize;
        if (data.dynamicScaling) {
          data.useMatrix = true;
          data.usePositions = false;
          data.matrices.resize(sizeof(glm::mat4)*data.instanceCount, false);
          buildMatrices(std::span(static_cast<glm::mat4*>(data.matrices.data()), data.instanceCount),
                        std::span(comp.positions.data(), comp.positions.size()),
                        std::span(comp.rotations.data(), comp.rotations.size()),
                        std::span(comp.scales.data(), comp.scales.size()),
                        data.instanceCount);
          forceUpdate = true;
        }
        else {
          data.useMatrix = rotationCount > 0 || scaleCount > 0;
          data.usePositions = !data.useMatrix && positionCount;
          if (data.useMatrix) {
            MappedStream<glm::mat4> matrices = data.instanceMesh->map<glm::mat4>(VertexDataType::Positions, VertexFormats::InstanceMat4f, 0, data.instanceCount, true);
            buildMatrices(std::span(matrices.data, data.instanceCount),
                          std::span(comp.positions.data(), comp.positions.size()),
                          std::span(comp.rotations.data(), comp.rotations.size()),
                          std::span(comp.scales.data(), comp.scales.size()),
                          data.instanceCount);
          }
          if (data.usePositions) {
            data.instanceMesh->setInstancePositions(std::span<const glm::vec3>(comp.positions.data(), data.instanceCount));
          }
          if (data.useColors) {
            data.instanceMesh->setInstanceColors(std::span<const glm::vec4>(comp.colors.data(), data.instanceCount));
          }
          data.instanceMesh->setInstanceCount(data.instanceCount);
        }
      }
    }
 
    if (data.dynamicScaling) {
      assert(data.matrices.size() == sizeof(glm::mat4)*data.instanceCount);
 
      if (const TransformComponent* trComp = comp.getComponent<TransformComponent>(); trComp) {
        const glm::mat4& localToWorld = context->transformSystem->getLocalToWorld(trComp);
        const size_t viewStateHash = Cogs::hashSequence(localToWorld,
                                                        mainCamData.viewMatrix,
                                                        mainCamData.rawProjectionMatrix,
                                                        mainCamData.viewportSize.y,
                                                        dpiScale);
 
        if (forceUpdate || data.viewStateHash != viewStateHash) {
          data.viewStateHash = viewStateHash;
 
          size_t currentInstanceCount = 0;
          MappedStream<glm::mat4> outMatrices = data.instanceMesh->map<glm::mat4>(VertexDataType::Positions, VertexFormats::InstanceMat4f, 0, data.instanceCount, true);
          if (data.useColors) {
            MappedStream<glm::vec4> outColors = data.instanceMesh->map<glm::vec4>(VertexDataType::Colors0, VertexFormats::InstanceColor4f, 0, data.instanceCount, true);
            currentInstanceCount = scaleMatrices(std::span<glm::mat4>(outMatrices.data, data.instanceCount),
                                                 std::span<glm::vec4>(outColors.data, data.instanceCount),
                                                 std::span<const glm::mat4>(static_cast<const glm::mat4*>(data.matrices.data()), data.instanceCount),
                                                 std::span<const glm::vec4>(comp.colors.data(), data.instanceCount),
                                                 localToWorld,
                                                 mainCamData.viewMatrix,
                                                 mainCamData.rawProjectionMatrix,
                                                 mainCamData.viewportSize.y,
                                                 dpiScale,
                                                 comp.fixedSizeMaxDistance);
          }
          else {
            currentInstanceCount = scaleMatrices(std::span<glm::mat4>(outMatrices.data, data.instanceCount),
                                                 std::span<glm::vec4>(),
                                                 std::span<const glm::mat4>(static_cast<const glm::mat4*>(data.matrices.data()), data.instanceCount),
                                                 std::span<const glm::vec4>(),
                                                 localToWorld,
                                                 mainCamData.viewMatrix,
                                                 mainCamData.rawProjectionMatrix,
                                                 mainCamData.viewportSize.y,
                                                 dpiScale,
                                                 comp.fixedSizeMaxDistance);
          }
          data.instanceMesh->setCount(currentInstanceCount);
          data.instanceMesh->setInstanceCount(currentInstanceCount);
        }
      }
    }
 
    InstancedMeshRenderComponent* renderComp = comp.getComponent<InstancedMeshRenderComponent>();
    if (renderComp) {
      if (renderComp->instanceMesh != data.instanceMesh) {
        renderComp->instanceMesh = data.instanceMesh;
        renderComp->setChanged();
      }
      if (renderComp->material) {
        renderComp->material->setVariant("InstancedMatrix", data.useMatrix);
        renderComp->material->setVariant("InstancedPositions", data.usePositions);
        renderComp->material->setVariant("InstancedColors", data.useColors);
      }
    }
  }
}