SpriteRenderSystem.cpp

#include "SpriteRenderSystem.h"
 
#include "Foundation/Logging/Logger.h"
#include "Rendering/ICapabilities.h"
 
#include "Context.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/TextureManager.h"
#include "Resources/MeshManager.h"
#include "Resources/DefaultMaterial.h"
 
#include "Scene/PickingFlags.h"
#include "Scene/RayPick.h"
 
#include "Systems/Core/CameraSystem.h"
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("SpriteRenderSystem");
}
 
Cogs::Core::SpriteRenderSystem::SpriteRenderSystem(Memory::Allocator * allocator, SizeType capacity) :
  ComponentSystemWithDataPool(allocator, capacity)
{
 
}
 
void Cogs::Core::SpriteRenderSystem::initialize(Context * context)
{
  ComponentSystemWithDataPool::initialize(context);
 
  expandSpriteGeometry = !context->device->getCapabilities()->getDeviceCapabilities().GeometryShaders;
 
  if (expandSpriteGeometry) {
    spriteMaterial = context->materialManager->loadMaterial("Materials/SpriteNoGsMaterial.material");
  } else {
    spriteMaterial = context->materialManager->loadMaterial("Materials/SpriteMaterial.material");
  }
  context->materialManager->processLoading();
  spriteMaterial->options.blendMode = BlendMode::PremultipliedBlend;
  spriteMaterial->options.depthWriteEnabled = false;
 
  registerSpriteMaterial(spriteMaterial);
 
  spriteBatches.reserve(1024);
}
 
void Cogs::Core::SpriteRenderSystem::preUpdate(Context * /*context*/)
{
  currentBatch = nullptr;
  spriteBatches.clear();
 
  for (auto & m : materials) {
    m.freeInstances.insert(m.freeInstances.end(), m.frameInstances.begin(), m.frameInstances.end());
    m.frameInstances.clear();
  }
 
  // Reset all batch indexes to ensure no invalid sprites are considered
  // active for picking/bounds/rendering.
  for (auto & sprite : pool) {
    auto & spriteData = getData(&sprite);
    spriteData.batchIndex = NoBatchIndex;
  }
 
  freeMeshes.insert(freeMeshes.end(), frameMeshes.begin(), frameMeshes.end());
  frameMeshes.clear();
}
 
void Cogs::Core::SpriteRenderSystem::postUpdate(Context * /*context*/)
{
  for (auto & sprite : pool) {
    auto & spriteData = getData(&sprite);
 
    if (!sprite.isVisible()) {
      spriteData.batchIndex = NoBatchIndex;
      continue;
    }
 
    if (spriteData.batchIndex == NoBatchIndex) continue;
 
    auto batch = getSpriteBatch(spriteData.batchIndex);
 
    auto spritePosition = glm::vec3(batch->transform * glm::vec4(spriteData.position, 1));
 
    const glm::vec3 kEpsilon = glm::vec3(0.01f);
    spriteData.boundingBox = { spritePosition - kEpsilon, spritePosition + kEpsilon };
  }
 
  base::postUpdate(context);
}
 
ComponentHandle Cogs::Core::SpriteRenderSystem::createComponent()
{
  ComponentHandle componentHandle = base::createComponent();
 
  if(pool.size() == 1) {
    assert(picker == nullptr);
    picker = new SpritePicker(this);
    context->rayPicking->addPickable(picker);
 
    LOG_DEBUG(logger, "Registered sprint picker extension");
  }
 
  return componentHandle;
}
 
void Cogs::Core::SpriteRenderSystem::destroyComponent(ComponentHandle component)
{
  base::destroyComponent(component);
 
  if (pool.size() == 0) {
    assert(picker != nullptr);
    context->rayPicking->removePickable(picker);
    delete picker;
    picker = nullptr;
 
    LOG_DEBUG(logger, "Last component destroyed, unregistered sprite picker extension");
  }
}
 
size_t Cogs::Core::SpriteRenderSystem::registerSpriteMaterial(MaterialHandle material)
{
  materials.resize(materials.size() + 1);
  auto & spriteMaterial = materials.back();
 
  spriteMaterial.material = material;
 
  if (material->isDefaultMaterial()) {
    spriteMaterial.textureKey = DefaultMaterial::DiffuseMap;
    spriteMaterial.colorKey = DefaultMaterial::DiffuseColor;
  } else {
    spriteMaterial.textureKey = material->getTextureKey("spriteTexture");
 
    if (spriteMaterial.textureKey == NoProperty) {
      LOG_ERROR(logger, "Sprite material does not contain texture property.");
      return NoSpriteMaterial;
    }
 
    spriteMaterial.colorKey = material->getVec4Key("spriteColor");
 
    if (spriteMaterial.colorKey == NoProperty) {
      LOG_WARNING(logger, "Sprite material missing color property.");
    }
 
    spriteMaterial.alwaysOnTopKey = material->getBoolKey("alwaysOnTop");
 
    if (spriteMaterial.alwaysOnTopKey == NoProperty) {
      LOG_WARNING(logger, "Sprite material missing 'alwaysOnTop' property.");
    }
  }
 
  return materials.size() - 1;
}
 
Cogs::Core::SpriteBatch * Cogs::Core::SpriteRenderSystem::begin(SpriteMaterialKey materialKey, const StringView & permutation, TextureHandle texture, glm::vec4 color, bool alwaysOnTop)
{
  if (!currentBatch || currentBatch->count != 0) {
    if (currentBatch && !currentBatch->count) {
      LOG_WARNING(logger, "Empty sprite batch detected.");
    }
 
    spriteBatches.resize(spriteBatches.size() + 1);
    currentBatch = &spriteBatches.back();
    currentBatch->index = spriteBatches.size() - 1;
  }
 
  updateBatchMesh();
 
  if (materialKey == NoSpriteMaterial) {
    LOG_WARNING(logger, "Invalid sprite material key, falling back to default.");
 
    materialKey = DefaultSpriteMaterial;
  }
 
  auto & spriteMaterial = materials[materialKey];
 
  if (spriteMaterial.freeInstances.size()) {
    currentBatch->material = spriteMaterial.freeInstances.back();
    spriteMaterial.freeInstances.pop_back();
    currentBatch->material->reset();
  } else {
    currentBatch->material = context->materialInstanceManager->createMaterialInstance(spriteMaterial.material);
  }
 
  spriteMaterial.frameInstances.push_back(currentBatch->material);
 
  if (!currentBatch->material->isDefaultMaterial()) {
    currentBatch->material->setPermutation(permutation);
  } else {
    color = glm::vec4(glm::vec3(color) * color.a, color.a);
    currentBatch->material->setMaterialFlag(MaterialFlags::Sprite);
    currentBatch->material->setBoolProperty(DefaultMaterial::EnableLighting, false);
    currentBatch->material->options.blendMode = BlendMode::Blend;
    currentBatch->material->options.depthWriteEnabled = false;
  }
 
  currentBatch->material->setTextureProperty(spriteMaterial.textureKey, texture);
 
  if (spriteMaterial.colorKey != NoProperty) {
    currentBatch->material->setVec4Property(spriteMaterial.colorKey, color);
  }
 
  if (spriteMaterial.alwaysOnTopKey != NoProperty) {
    currentBatch->material->setBoolProperty(spriteMaterial.alwaysOnTopKey, alwaysOnTop);
  }
 
  currentBatch->flags |= alwaysOnTop ? RenderItemFlags::AlwaysOnTop : RenderItemFlags::None;
 
  return currentBatch;
}
 
Cogs::Core::SpriteBatch * Cogs::Core::SpriteRenderSystem::begin(SpriteMaterialKey material,
  const StringView & postfix,
  PositionMode positionMode,
  SizeMode sizeMode,
  TextureHandle texture,
  glm::vec4 color,
  bool alwaysOnTop)
{
  const auto permutation = getPermutation(positionMode, sizeMode).to_string() + postfix.to_string();
 
  auto batch = begin(material, permutation, texture, color, alwaysOnTop);
 
  batch->positionMode = positionMode;
  batch->sizeMode = sizeMode;
 
  return batch;
}
 
Cogs::Core::SpriteBatch * Cogs::Core::SpriteRenderSystem::begin(SpriteMaterialKey material, TextureHandle texture, glm::vec4 color)
{
  return begin(material, "", texture, color);
}
 
Cogs::Core::SpriteBatch * Cogs::Core::SpriteRenderSystem::begin(TextureHandle texture, glm::vec4 color)
{
  return begin(DefaultSpriteMaterial, texture, color);
}
 
void Cogs::Core::SpriteRenderSystem::addSprite(SpriteRenderComponent * spriteRenderer, glm::vec3 position, glm::vec2 size, glm::vec4 texCoords)
{
  addSprite(spriteRenderer, position, glm::vec2(0, 0), size, texCoords);
}
 
void Cogs::Core::SpriteRenderSystem::addSprite(SpriteRenderComponent * spriteRenderer, glm::vec3 position, glm::vec2 offset, glm::vec2 size, glm::vec4 texCoords)
{
  if (!currentBatch) {
    LOG_ERROR(logger, "Cannot add sprite without active batch.");
    return;
  }
 
  if (!spriteRenderer) {
    LOG_ERROR(logger, "Cannot add sprite without SpriteRenderComponent.");
    return;
  }
 
  if (!spriteRenderer->isVisible()) return;
 
  if (!expandSpriteGeometry) {
    currentBatch->count++;
 
    const size_t spriteIndex = currentBatch->start + currentBatch->count - 1;
 
    auto & spriteData = getData(spriteRenderer);
    spriteData.batchIndex = currentBatch->index;
    spriteData.spriteIndex = spriteIndex;
 
    spriteData.position = position;
    spriteData.offset = offset;
    spriteData.size = size;
 
    if (currentBatch->count == 1) {
      // Get LoD data from the first sprite so we have something consistent
      // for the batch.
      currentBatch->lod = spriteRenderer->lod;
    }
 
    auto mesh = currentBatch->mesh.resolve();
 
    const size_t meshCount = currentBatch->start + currentBatch->count;
    auto vertexData = mesh->map<SpriteVertex>(
      VertexDataType::Interleaved0,
      SpriteVertex::getVertexFormat(),
      0,
      meshCount < kMinBatchSize ? kMinBatchSize : meshCount);
 
    vertexData[spriteIndex].position = glm::vec4(position, 1);
    vertexData[spriteIndex].parameters = glm::vec4(size, offset);
    vertexData[spriteIndex].texCoords = texCoords;
 
    mesh->setCount(meshCount);
  } else {
    currentBatch->expanded = true;
 
    const size_t spriteIndex = currentBatch->start + currentBatch->count;
    currentBatch->count += 6;
 
    auto & spriteData = getData(spriteRenderer);
    spriteData.batchIndex = currentBatch->index;
    spriteData.spriteIndex = spriteIndex/6;
 
    spriteData.position = position;
    spriteData.offset = offset;
    spriteData.size = size;
 
    if (currentBatch->count == 6) {
      // Get LoD data from the first sprite so we have something consistent
      // for the batch.
      currentBatch->lod = spriteRenderer->lod;
    }
 
    auto mesh = currentBatch->mesh.resolve();
 
    const size_t meshCount = currentBatch->start + currentBatch->count;
    auto vertexData = mesh->map<SpriteVertex>(
      VertexDataType::Interleaved0,
      SpriteVertex::getVertexFormat(),
      0,
      meshCount < kMinBatchSize ? kMinBatchSize : meshCount);
 
    const float indices[6] = { 0, 1, 2, 2, 1, 3 };
    for (unsigned i = 0; i < 6; i++) {
      vertexData[spriteIndex + i].position = glm::vec4(position, indices[i]);
      vertexData[spriteIndex + i].parameters = glm::vec4(size, offset);
      vertexData[spriteIndex + i].texCoords = texCoords;
    }
 
    mesh->setCount(meshCount);
  }
}
 
const Cogs::Core::SpriteBatch * Cogs::Core::SpriteRenderSystem::getSpriteBatch(SpriteBatchIndex index) const
{
  if (index >= spriteBatches.size()) return nullptr;
 
  return &spriteBatches[index];
}
 
std::span<const Cogs::Core::SpriteBatch> Cogs::Core::SpriteRenderSystem::getSpriteBatches() const
{
  return spriteBatches;
}
 
Cogs::StringView Cogs::Core::SpriteRenderSystem::getPermutation(PositionMode positionMode, SizeMode sizeMode)
{
  if (sizeMode == SizeMode::Relative) {
    switch (positionMode)
    {
    case PositionMode::Relative:
      return "NoTransformRelativeSize";
    case PositionMode::Pixels:
      return "PixelTransformRelativeSize";
    case PositionMode::World:
    case PositionMode::Local:
      return "ViewTransformRelativeSize";
    default:
      break;
    }
  } else {
    switch (positionMode)
    {
    case PositionMode::Pixels:
      return "PixelTransformPixelSize";
    case PositionMode::World:
    case PositionMode::Local:
      return "ViewTransformPixelSize";
    default:
      break;
    }
  }
 
  return "Default";
}
 
void Cogs::Core::SpriteRenderSystem::updateBatchMesh()
{
  const size_t kMeshMinBatchCount = 1024;
 
  if (freeMeshes.size()) {
    currentBatch->mesh = freeMeshes.back();
    freeMeshes.pop_back();
    frameMeshes.push_back(currentBatch->mesh);
  } else {
    for (auto & m : frameMeshes) {
      if (m->getCount() < kMeshMinBatchCount) {
        currentBatch->mesh = m;
        currentBatch->start = m->getCount();
        break;
      }
    }
 
    if (!currentBatch->mesh) {
      currentBatch->mesh = context->meshManager->create();
 
      currentBatch->mesh->primitiveType = expandSpriteGeometry ? PrimitiveType::TriangleList : PrimitiveType::PointList;
      currentBatch->mesh->setName("SpriteMesh");
      frameMeshes.push_back(currentBatch->mesh);
    }
  }
}
 
 
Cogs::Core::SpritePicker::SpritePicker(SpriteRenderSystem* spriteSystem)
  : spriteSystem(spriteSystem)
{
}
 
bool Cogs::Core::SpritePicker::pickCamera(Context* context,
                                          const CameraComponent& camera,
                                          const glm::vec2& normPosition,
                                          float /*rayLength*/,
                                          float /*radius*/,
                                          PickingFlags pickingFlags,
                                          PicksReturned returnFlag,
                                          const RayPicking::RayPickFilter& filter,
                                          std::vector<RayPicking::RayPickHit>& hits)
{
  if ((pickingFlags & PickingFlags::PickSprites) != PickingFlags::PickSprites) {
    // Picking sprites is disabled
    return {};
  }
 
  const bool returnChildEntity = (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity;
 
  const CameraData& cameraData = context->cameraSystem->getData(&camera);
  const glm::mat4 invProjection = glm::inverse(cameraData.rawViewProjection);
 
  bool hitSomething = false;
 
  for (const SpriteRenderComponent& sprite : spriteSystem->pool) {
    if (!sprite.isVisibleInLayer(filter.layerMask) ||
        !sprite.isPickable() ||
        sprite.lod.currentLod != sprite.lod.selectedLod ||
        filter.isUnwantedType(sprite)) {
      continue;
    }
 
    const SpriteRenderData& data = context->spriteRenderSystem->getData(&sprite);
    const SpriteBatch* batch = context->spriteRenderSystem->getSpriteBatch(data.batchIndex);
    if (!batch || batch->mesh == MeshHandle::NoHandle || batch->count == 0) {
      continue;
    }
 
    const size_t meshCount = batch->start + batch->count;
    auto meshData = batch->mesh->mapReadOnly<SpriteVertex>(VertexDataType::Interleaved0,
                                                    SpriteVertex::getVertexFormat(),
                                                    0,
                                                    meshCount < kMinBatchSize ? kMinBatchSize : meshCount);
    if (!meshData.isValid()) {
      continue;
    }
 
    // Need only check first vertex. SpriteRenderSystem stores same position in every index.
    const SpriteVertex& spriteVertex = meshData[batch->start];
 
    const glm::vec3 position = spriteVertex.position;
    const glm::vec2 offset = glm::vec2(spriteVertex.parameters.z, spriteVertex.parameters.w);
    const glm::vec2 size = glm::vec2(spriteVertex.parameters.x, spriteVertex.parameters.y);
 
    glm::vec4 normPos = glm::vec4(0, 0, 0, 1);
    glm::vec2 normOffset = offset / (0.5f * cameraData.viewportSize);
 
    if (batch->positionMode == PositionMode::Pixels) {
      normPos = glm::vec4(glm::vec2(position) / (0.5f * cameraData.viewportSize) - glm::vec2(1, 1) + normOffset, position.z, 1);
    }
    else if (batch->positionMode == PositionMode::Relative) {
      normPos = glm::vec4(glm::vec2(position) + normOffset, position.z, 1);
    }
    else {
      const glm::vec3 worldPos = glm::vec3(batch->transform * glm::vec4(position, 1));
      normPos = cameraData.rawViewProjection * glm::vec4(worldPos, 1);
      normPos /= normPos.w;
      normPos = glm::vec4(glm::vec2(normPos) + normOffset, normPos.z, 1);
    }
 
    const glm::vec2 normSize = size / cameraData.viewportSize;
 
    const float xMin = normPos.x - glm::abs(normSize.x);
    const float xMax = normPos.x + glm::abs(normSize.x);
    const float yMin = normPos.y - glm::abs(normSize.y);
    const float yMax = normPos.y + glm::abs(normSize.y);
 
    if (normPosition.x > xMin && normPosition.x < xMax && normPosition.y > yMin && normPosition.y < yMax) {
      glm::vec4 worldPos = invProjection * glm::vec4(normPosition.x, normPosition.y, normPos.z, 1.0f);
      worldPos /= worldPos.w;
 
      glm::vec4 clipPos = cameraData.rawViewProjection * glm::vec4(glm::vec3(worldPos), 1.f);
      if ((-clipPos.w <= clipPos.z) && (clipPos.z <= clipPos.w)) {
        
        const glm::vec4 viewPos= cameraData.viewMatrix * worldPos;
        const float viewDist = -viewPos.z;
 
        if (returnFlag == PicksReturned::Closest && !hits.empty()) {
          if (viewDist < hits[0].distance) {
            hits[0] = {sprite, returnChildEntity, position, viewDist};
            hitSomething = true;
          }
          // else, the intersection we found is further, so don't do anything
        }
        else {
          hits.emplace_back(sprite, returnChildEntity, position, viewDist);
          hitSomething = true;
        }
      }
    }
  }
 
  if (returnFlag == PicksReturned::AllSorted) {
    std::sort(hits.begin(), hits.end());
  }
  return hitSomething;
}