VectorFieldRenderer.cpp

#include "VectorFieldRenderer.h"
#include "VectorFieldSystem.h"
 
#include "Context.h"
#include "EntityStore.h"
#include "ExtensionRegistry.h"
#include "Renderer/Renderer.h"
#include "Renderer/RenderStateUpdater.h"
#include "Renderer/Tasks/RenderListTask.h"
#include "Renderer/ParameterBuffers.h"
#include "Renderer/RenderTarget.h"
#include "Resources/Mesh.h"
#include "Resources/Model.h"
#include "Resources/VertexFormats.h"
#include "Resources/DefaultMaterial.h"
#include "Services/Time.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Rendering/CommandGroupAnnotation.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IRenderTargets.h"
 
#include <random>
 
namespace Cogs::Core::VectorField
{
  
  void VectorFieldRenderer::initialize(Cogs::Core::Context *set_context, IGraphicsDevice *set_device)
  {
    context = set_context;
    device = set_device;
    vectorFieldSystem = ExtensionRegistry::getExtensionSystem<VectorFieldSystem>(context);
  }
  void VectorFieldRenderer::handleEvent(uint32_t eventId, const DrawContext * renderingContext)
  {
    if (!renderingContext) return;
 
    switch (eventId) {
    case RenderingEvent::PostRender:
      for (auto & vector_field : vectorFieldSystem->pool) {
        postRender(vector_field, renderingContext);
      }
      break;
    default:
      break;
    }
  }
  enum{
    DC_CAP,
    DC_BASE,
  };
  static void vectorFieldCallback(RenderTaskContext *renderingContext, DrawContext *drawContext, const RenderItem * item, int type)
  {
    VectorFieldData &data = *item->getCallbackData<VectorFieldData>();
    VectorFieldSystem *vectorFieldSystem = data.system;
    Model *model = nullptr;
    if(type == DC_CAP)
      model = vectorFieldSystem->model_cap.resolve();
    else if(type == DC_BASE)
      model = vectorFieldSystem->model_base.resolve();
    if(!model || !model->isLoaded()) return;
    Mesh *mesh = model->meshes[0].resolve();
 
    Renderer *renderer = renderingContext->renderer;
    IGraphicsDevice *device = renderer->getDevice();
    RenderStates &renderStates = renderer->getRenderStates();
    RenderMesh *renderMesh = renderer->getRenderResources().getRenderMesh(model->meshes[0]);
    IContext *deviceContext = device->getImmediateContext();
    VectorFieldComponent &component = *data.handle.resolveComponent<VectorFieldComponent>();
    size_t count = 0;
    if(component.positions)
      count = component.positions.size();
    if(count == 0) return;
 
    CommandGroupAnnotation commandGroup(deviceContext, "VectorFieldRenderer::generateCommands");
 
    // PSO state
    deviceContext->setDepthStencilState(renderStates.defaultDepthStencilStateHandle);
    deviceContext->setBlendState(renderStates.blendStates[size_t(BlendMode::None)].handle);
    deviceContext->setRasterizerState(renderStates.defaultRasterizerStateHandle);
 
    applyMaterialPermutation(renderingContext, drawContext, item->binding, item->renderMaterialInstance);
    updateEnvironmentBindings(drawContext, item->binding);
    applyMaterialInstance(drawContext, item->binding, item->renderMaterialInstance);
 
    // Copy Buffers
    {
      size_t size = count * sizeof(glm::vec3);
      MappedBuffer<InstanceData> i_data(deviceContext, data.buffer_handle, Cogs::MapMode::WriteDiscard, size);
      for(size_t i=0; i<count; i++){
        glm::vec3 p = component.positions[i];
        glm::vec3 d = component.directions[i];
        glm::vec3 pos = p;
        if(component.dither)
          pos += data.dither_offset[i];
        float t = fmod(data.time+data.time_offset[i], 1.0f);
        if(component.animation && component.animationUseSpeed)
          t = data.time_offset_speed[i];
        if(!component.centerArrow)
          pos += d*component.scale*component.length*0.5f;
        if(component.animation){
          float anim_scale = component.scale*component.length*component.animationScale;
          if(component.centerArrow)
            pos += d*anim_scale*(t-0.5f);
          else
            pos += d*anim_scale*t;
        }
        i_data[i].pos = pos;
 
        glm::vec4 c = component.colors[i];
        uint32_t col =
          uint32_t(c.x*255) << 0 |
          uint32_t(c.y*255) << 8 |
          uint32_t(c.z*255) << 16 |
          uint32_t(c.w*255) << 24;
        i_data[i].color = col;
 
        glm::vec3 u = glm::vec3(0.0, 1.0, 0.0);
        glm::vec3 v = glm::normalize(component.directions[i]);
        glm::vec3 w;
        float dot = glm::dot(u, v);
        if(fabsf(dot+1.0f) < 0.001f)
          w = glm::vec3(1.0, 0.0, 0.0);
        else
          w = glm::cross(u, v);
        glm::quat q(1.0f + dot, w);
        i_data[i].rot = glm::normalize(q);
        i_data[i].scale = glm::vec4(component.scale, 1.0, component.tailScale, glm::length(d)*component.length);
        if(component.animation && component.animationFade){
          float start = component.animationFadeTime;
          float end = 1.0f-start;
          float st = 1.0;
          if(t<start) st = t/start;
          else if(t>end) st = 1.0f-(t-end)/(1.0f-end);
          i_data[i].scale *= glm::vec4(st, st, 1.0, 1.0);
        }
      }
    }
 
    // Vertex buffers
    std::array<Cogs::VertexBufferHandle, MeshStreamsLayout::maxStreams> vertexBuffers;
    std::array<uint32_t, MeshStreamsLayout::maxStreams> strides;
 
    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.buffer_handle;
    strides[n++] = sizeof(InstanceData);
    deviceContext->setVertexBuffers(vertexBuffers.data(), n, strides.data(), nullptr);
    bool indexed = renderMesh->indexBuffer != IndexBufferHandle::NoHandle;
    if(indexed) deviceContext->setIndexBuffer(renderMesh->indexBuffer);
 
 
    RenderItem oItem = *item;
    oItem.worldMatrix = &data.worldMatrix;
    applyMaterialPerObject(drawContext, item->renderMaterialInstance, oItem);
 
    // Draw
    auto submeshCount = mesh->submeshCount;
    if(!submeshCount){
      if(renderMesh->numVertexes == 0) return;
      if(!indexed) deviceContext->drawInstanced(item->primitiveType, 0, item->numIndexes, 0, count);
      else deviceContext->drawInstancedIndexed(item->primitiveType, 0, count, 0, renderMesh->numVertexes);
    }
    else{
      auto subMeshes = mesh->mapSubMeshes(submeshCount + 1);
      for(size_t m = 0; m < submeshCount; m++){
        SubMesh &subMesh = subMeshes[m];
        if(subMesh.numIndexes == 0) continue;
        if(!indexed) deviceContext->drawInstanced(subMesh.primitiveType, subMesh.startIndex, subMesh.numIndexes, 0, count);
        else deviceContext->drawInstancedIndexed(subMesh.primitiveType, 0, count, subMesh.startIndex, subMesh.numIndexes);
      }
    }
  }
  static void vectorFieldCallbackCap(RenderTaskContext *renderingContext, DrawContext *drawContext, const RenderItem * item)
  {
    vectorFieldCallback(renderingContext, drawContext, item, DC_CAP);
  }
  static void vectorFieldCallbackBase(RenderTaskContext *renderingContext, DrawContext *drawContext, const RenderItem * item)
  {
    vectorFieldCallback(renderingContext, drawContext, item, DC_BASE);
  }
  void VectorFieldRenderer::generateCommands(const RenderTaskContext *renderingContext, RenderList *renderList)
  {
    IBuffers *buffers = device->getBuffers();
 
    for(VectorFieldComponent &component : vectorFieldSystem->pool){
      VectorFieldData &data = vectorFieldSystem->getData(&component);
      Model *model_cap = vectorFieldSystem->model_cap.resolve();
      Model *model_base = vectorFieldSystem->model_base.resolve();
      if(!model_cap || !model_cap->isLoaded()) return;
      if(!model_base || !model_base->isLoaded()) return;
      Mesh *mesh_cap = model_cap->meshes[0].resolve();
      Mesh *mesh_base = model_base->meshes[0].resolve();
      if (!mesh_cap || !mesh_cap->isLoaded()) return;
      if (!mesh_base || !mesh_base->isLoaded()) return;
 
      // Set up streams layout of mesh and instance streams
      if (data.layout_cap.numStreams == 0) {
        data.layout_cap = mesh_cap->getStreamsLayout();
        assert(data.layout_cap.numStreams + 1 < MeshStreamsLayout::maxStreams);
        data.layout_cap.vertexFormats[data.layout_cap.numStreams++] = data.pos_format;
        data.layout_cap.updateHash();
      }
 
      if (data.layout_base.numStreams == 0) {
        data.layout_base = mesh_cap->getStreamsLayout();
        assert(data.layout_base.numStreams + 1 < MeshStreamsLayout::maxStreams);
        data.layout_base.vertexFormats[data.layout_base.numStreams++] = data.pos_format;
        data.layout_base.updateHash();
      }
 
      data.handle = vectorFieldSystem->getHandle(&component);
 
      auto *transComp = component.getComponent<TransformComponent>();
      data.worldMatrix = renderingContext->context->transformSystem->getLocalToWorld(transComp);
 
      auto *camTransComp = renderingContext->cameraData->camera.resolve()->getComponent<TransformComponent>();
      data.cam_pos = camTransComp->position;
 
      // Buffer
      size_t count = 0;
      if(component.positions)
        count = component.positions.size();
      if(count > data.buffer_count){
        if(HandleIsValid(data.buffer_handle)) buffers->releaseVertexBuffer(data.buffer_handle);
        data.buffer_handle = buffers->loadVertexBuffer(nullptr, count, data.pos_format);
        buffers->annotate(data.buffer_handle, "VectorField:posBuffer");
        data.buffer_count = count;
      }
 
      glm::vec4 lightDir = glm::vec4(0.0, 0.0, 1.0, 0.0);
      EntityPtr dir_light = renderingContext->context->store->getEntity("DirectionalLight", false);
      if(dir_light){
        LightComponent *light_comp = dir_light->getComponent<LightComponent>();
        if (light_comp && light_comp->enabled) {
          auto* trComp = dir_light->getComponent<TransformComponent>();
          lightDir = context->transformSystem->getLocalToWorld(trComp) * glm::vec4(0, 0, -1, 0);
        }
      }
      vectorFieldSystem->material_instance_cap->setProperty("lightDir", &lightDir, sizeof(lightDir));
      vectorFieldSystem->material_instance_base->setProperty("lightDir", &lightDir, sizeof(lightDir));
 
      static std::mt19937 gen(0);
      if(data.time_offset.size() != count){
        std::uniform_real_distribution<float> dist(0.0f, 1.0f);
        size_t start = data.time_offset.size();
        data.time_offset.resize(count);
        for(size_t i=start; i < count; i++){
          data.time_offset[i] = dist(gen);
        }
      }
 
      if(data.time_offset_speed.size() != count){
        std::uniform_real_distribution<float> dist(0.0f, 1.0f);
        size_t start = data.time_offset_speed.size();
        data.time_offset_speed.resize(count);
        for(size_t i=start; i < count; i++){
          data.time_offset_speed[i] = dist(gen);
        }
      }
 
      if(data.dither_offset.size() != count || data.ditherSize != component.ditherSize){
        std::uniform_real_distribution<float> dist(-component.ditherSize, component.ditherSize);
        size_t start = data.dither_offset.size();
        data.dither_offset.resize(count);
        if(data.ditherSize != component.ditherSize)
          start = 0;
        for(size_t i=start; i < count; i++){
          data.dither_offset[i] = glm::vec3(dist(gen), dist(gen), dist(gen));
        }
        data.ditherSize = component.ditherSize;
      }
 
      if(component.animation && component.animationScale >= 0.00000001f){
        std::uniform_real_distribution<float> dist(-component.ditherSize, component.ditherSize);
        float add = (1.0f/component.animationScale)*component.animationSpeed*(float)renderingContext->context->time->getAnimationTimeDelta();
 
        if(component.animationUseSpeed){
          if(component.dither){
            for(size_t i=0; i < count; i++){
              if(data.time_offset_speed[i]+add*component.speed[i] >= 1.0){
                data.dither_offset[i] = glm::vec3(dist(gen), dist(gen), dist(gen));
              }
            }
          }
          for(size_t i=0; i < count; i++){
            data.time_offset_speed[i] = fmod(data.time_offset_speed[i]+add*component.speed[i], 1.0f);
          }
        }
        else if(component.dither){
          for(size_t i=0; i < count; i++){
            float offset = data.time_offset[i];
            if(fmod(data.time + offset, 1.0f)+add >= 1.0){
              data.dither_offset[i] = glm::vec3(dist(gen), dist(gen), dist(gen));
            }
          }
        }
 
        data.time += add;
        data.time = fmod(data.time, 1.0f);
      }
 
      {
        RenderItem &item = renderList->createCustom(&data.layout_cap);
        item.layer = RenderLayers::Default;
        item.materialInstance = vectorFieldSystem->material_instance_cap.resolve();
        item.drawOrder = 0;
        item.depth = 0;
        item.blendState = (uint16_t)item.materialInstance->options.blendMode;
        item.depthState = (uint16_t)DepthMode::Default;
        item.setBounds(&data.bbox);
        item.flags |= RenderItemFlags::Custom;
        item.flags |= !mesh_cap->isCCW() ? RenderItemFlags::Clockwise : RenderItemFlags::None;
        item.setCallbackData(&data);
        item.callback = vectorFieldCallbackCap;
      }
      {
        RenderItem &item = renderList->createCustom(&data.layout_base);
        item.layer = RenderLayers::Default;
        item.materialInstance = vectorFieldSystem->material_instance_base.resolve();
        item.drawOrder = 0;
        item.depth = 0;
        item.blendState = (uint16_t)item.materialInstance->options.blendMode;
        item.depthState = (uint16_t)DepthMode::Default;
        item.setBounds(&data.bbox);
        item.flags |= RenderItemFlags::Custom;
        item.flags |= !mesh_base->isCCW() ? RenderItemFlags::Clockwise : RenderItemFlags::None;
        item.setCallbackData(&data);
        item.callback = vectorFieldCallbackBase;
      }
    }
  }
  void VectorFieldRenderer::postRender(VectorFieldComponent &component, const DrawContext *renderingContext)
  {
    if(component.animation){
      renderingContext->context->engine->setDirty();
    }
  }
}// namespace ...