SeaCurrentsRenderer.cpp

#include "SeaCurrentsRenderer.h"
 
#include "SeaCurrentsSystem.h"
 
#include "Context.h"
#include "ExtensionRegistry.h"
#include "Components/Core/TransformComponent.h"
#include "Renderer/Renderer.h"
#include "Renderer/RenderMaterialInstance.h"
#include "Renderer/RenderStateUpdater.h"
#include "Renderer/Tasks/RenderListTask.h"
#include "Renderer/Tasks/RenderTask.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Rendering/CommandGroupAnnotation.h"
 
namespace Cogs::Core {
  void renderCallback(RenderTaskContext* renderingContext, DrawContext* drawContext, const RenderItem* item) {
    SeaCurrentsData&  data = *item->getCallbackData<Cogs::Core::SeaCurrentsData>();
    size_t            instanceCount = data.mData.size();
 
    if (!instanceCount) {
      return;
    }
 
    Renderer*               renderer = renderingContext->renderer;
    IGraphicsDevice*        device = renderer->getDevice();
    IContext*               deviceContext = device->getImmediateContext();
    CommandGroupAnnotation  commandGroup(deviceContext, "SeaCurrentsRenderer Callback");
    const RenderStates&     renderStates = renderer->getRenderStates();
    RenderMesh*             renderMesh = renderer->getRenderResources().getRenderMesh(data.mSystem->getArrowMesh());
    IBuffers*               buffers = device->getBuffers();
 
    // PSO state
    applyMaterialPermutation(renderingContext, drawContext, item->binding, item->renderMaterialInstance);
    deviceContext->setDepthStencilState(renderStates.defaultDepthStencilStateHandle);
    deviceContext->setBlendState(renderStates.blendStates[size_t(BlendMode::None)].handle);
    deviceContext->setRasterizerState(renderStates.defaultRasterizerStateHandle);
 
    updateEnvironmentBindings(drawContext, item->binding);
    applyMaterialInstance(drawContext, item->binding, item->renderMaterialInstance);
 
 
    // Copy Buffers
    {
      size_t  dataSize = instanceCount * sizeof(InstanceData);
 
      if (dataSize > data.mBufferSize) {
        if (HandleIsValid(data.mBufferHandle)) {
          buffers->releaseVertexBuffer(data.mBufferHandle);
        }
        data.mBufferHandle = buffers->loadVertexBuffer(nullptr, instanceCount, data.mSystem->getVertexFormatHandle());
        buffers->annotate(data.mBufferHandle, "Sea Currents Instance Data");
        data.mBufferSize = dataSize;
      }
 
      MappedBuffer<InstanceData>  instanceData(deviceContext, data.mBufferHandle, Cogs::MapMode::WriteDiscard, dataSize);
 
      if (instanceData) {
        memcpy(static_cast<void*>(instanceData.get()), data.mData.data(), dataSize);
      }
    }
 
    // Vertex buffers
    std::array<VertexBufferHandle, MeshStreamsLayout::maxStreams> vertexBuffers;
    std::array<uint32_t, MeshStreamsLayout::maxStreams> strides;
    SeaCurrentsRenderer* seaCurrentsRenderer = static_cast<SeaCurrentsRenderer*>(item->callbackData2);
 
    uint32_t n = 0;
    for(size_t i = 0; i < renderMesh->streamsLayout.numStreams; i++){
      vertexBuffers[n] = renderMesh->vertexBuffers[i];
      strides[n++] = renderMesh->vertexStrides[i];
    }
    assert(n + 1 < MeshStreamsLayout::maxStreams);
    vertexBuffers[n] = data.mBufferHandle;
    strides[n++] = sizeof(InstanceData);
 
    deviceContext->setVertexBuffers(vertexBuffers.data(), n, strides.data(), nullptr);
    deviceContext->setIndexBuffer(seaCurrentsRenderer->mIndices, 2);
 
    RenderItem copy = *item;
    copy.worldMatrix = &data.mWorldMatrix;
 
    applyMaterialPerObject(drawContext, item->renderMaterialInstance, copy);
 
    // Draw
    deviceContext->drawInstancedIndexed(item->primitiveType, 0, instanceCount, 0, 0);
  }
}
 
void Cogs::Core::SeaCurrentsRenderer::initialize(Context* context, IGraphicsDevice* device) {
  uint16_t indices[] = {
      0,1,2,
      3,4,5,
      6,7,8,
      9,10,11,
      12,13,14,
      15,16,17,
      18,19,20,
  };
 
  mContext = context;
  mDevice = device;
  mSeaCurrentsSystem = ExtensionRegistry::getExtensionSystem<SeaCurrentsSystem>(context);
  mIndices = device->getBuffers()->loadIndexBuffer(indices, sizeof(indices) / 2, 2);
}
 
void Cogs::Core::SeaCurrentsRenderer::handleEvent(uint32_t /*eventId*/, const DrawContext* /*renderingContext*/) {
}
 
void Cogs::Core::SeaCurrentsRenderer::generateCommands(const RenderTaskContext* renderingContext, RenderList* renderList) {
  for(SeaCurrentsComponent& seaCurrentsComp : mSeaCurrentsSystem->pool) {
    RenderItem&             item = renderList->createCustom(&mSeaCurrentsSystem->getArrowInstancesStreamsLayout());
    SeaCurrentsData&        data = mSeaCurrentsSystem->getData(&seaCurrentsComp);
    std::array<glm::vec3, 8> corners;
 
    data.mWorldMatrix = renderingContext->context->transformSystem->getLocalToWorld(seaCurrentsComp.getComponent<TransformComponent>());
    data.mTransformedBounds.min = glm::vec3(std::numeric_limits<float>::max());
    data.mTransformedBounds.max = glm::vec3(std::numeric_limits<float>::lowest());
 
    Geometry::corners(data.mBounds, corners);
    for (const glm::vec3& corner : corners) {
      glm::vec3 transformed = data.mWorldMatrix * glm::vec4(corner, 1.0f);
 
      data.mTransformedBounds.min = glm::min(data.mTransformedBounds.min, transformed);
      data.mTransformedBounds.max = glm::max(data.mTransformedBounds.max, transformed);
    }
 
    item.layer = RenderLayers::Default;
    item.materialInstance = mSeaCurrentsSystem->getMaterialHandle().resolve();
    item.drawOrder = 0;
    item.depth = 0;
    item.blendState = static_cast<uint16_t>(item.materialInstance->options.blendMode);
    item.depthState = static_cast<uint16_t>(DepthMode::Default);
    item.setBounds(&data.mTransformedBounds);
    item.flags |= RenderItemFlags::Custom;
    item.setCallbackData(&data);
    item.setCallbackData2(this);
    item.callback = &renderCallback;
  }
}