RenderTaskFactory.cpp

#include "RenderTaskFactory.h"
 
#include "Serialization/RenderPipelineReader.h"
 
#include "Systems/Core/CameraSystem.h"
 
#include "Services/Variables.h"
#include "Context.h"
 
#include "GenerateListTask.h"
#include "FilterListTask.h"
#include "RenderListTask.h"
 
#include "DeferredLightingTask.h"
#include "TransparencyRenderTask.h"
#include "TransparencyMergeTask.h"
#include "TransparencyTemporalUpscaleTask.h"
#include "TransparencyUpscaleTask.h"
 
#include "PostProcessTask.h"
#include "ComputeTask.h"
#include "MipLevelsTask.h"
 
#include "ClearResourceTask.h"
#include "CopyResourceTask.h"
#include "ResolveResourceTask.h"
#include "ReadbackTask.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderPipelineManager.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Collections/Pool.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TaskFactory");
}
 
namespace Cogs
{
  namespace Core
  {
    std::unordered_map<std::string, TaskCreator> creators;
    std::unordered_map<std::string, TaskDestroyer> destroyers;
 
    template<typename ResourceType>
    Collections::Pool<ResourceType> & getPool()
    {
      static Collections::Pool<ResourceType> pool(128, 128, MemBlockType::RenderResourceStorage);
 
      return pool;
    }
 
    template<typename TaskType>
    TaskType * createTask(RenderTaskContext * renderContext, bool initialize = true)
    {
      auto pool = &getPool<TaskType>();
      auto task = pool->create();
 
      task->deleter = [=]()
      {
        if (renderContext) {
          task->cleanup(renderContext);
        }
 
        pool->destroy(task);
      };
 
      if (renderContext && initialize) {
        task->initialize(renderContext);
      }
 
      return task;
    }
 
    void freeTask(RenderTask * task, RenderTaskContext * renderContext)
    {
      for (auto & d : destroyers) {
        d.second(&task, renderContext);
        if (!task) return;
      }
 
      if (task->deleter) {
        task->deleter();
        return;
      }
 
      LOG_ERROR(logger, "Render task could not be deleted.");
    }
 
    void setProcessTaskEffectParameter(RenderTaskContext* renderContext,
                                       std::list<std::unique_ptr<SubContext>>& subContexts,
                                       ExpressionContext * expressionContext,
                                       ProcessTask* task,
                                       const ParsedValue& parameter)
    {
      task->effectParameter = parameter;
 
      task->scope = expressionContext;
      for (const auto & ep : task->effectParameter.values) {
        if (ep.key == "useVariables") {
          if (task->scope == expressionContext) {
            subContexts.push_back(std::make_unique<SubContext>(expressionContext));
            task->scope = &subContexts.back()->expressionContext;
          }
          subContexts.back()->useVariables(renderContext->context, ep.values);
        }
        else if (ep.key == "setVariables") {
          if (task->scope == expressionContext) {
            subContexts.push_back(std::make_unique<SubContext>(expressionContext));
            task->scope = &subContexts.back()->expressionContext;
          }
          subContexts.back()->setVariables(renderContext->context, ep.values);
        }
        else if (ep.key == "useComponentFields") {
          if (task->scope == expressionContext) {
            subContexts.push_back(std::make_unique<SubContext>(expressionContext));
            task->scope = &subContexts.back()->expressionContext;
          }
          subContexts.back()->useComponentFields(renderContext, ep.values);
        }
      }
 
      for (const auto & ep : task->effectParameter.values) {
        if (ep.key == "properties") {
          for (const auto & p : ep.values) {
            if (p.key == "source") continue;
 
            ProcessTaskProperty prop;
            prop.definition = &p;  // is pointer valid for lifetime of task?
            prop.float4x4Value = p.float4x4Value;
 
            for (const auto & q : p.expressions) {
              //auto name = prefix + "." + p.key + "." + std::to_string(q.first);
              prop.expressions.push_back({ q.first, task->scope->compile(q.second, "") });
            }
            switch (p.type) {
            case ParsedDataType::Texture2D: {
              SamplerState samplerState {
                SamplerState::Clamp,
                SamplerState::Clamp,
                SamplerState::Clamp,
                (p.texture.flags & ParsedValueTextureFlags::LinearSampler) != 0 ? SamplerState::MinMagMipLinear : SamplerState::MinMagMipPoint,
                SamplerState::Never,
                0,
                { 0, 0, 0, 1 }
              };
              prop.texture.samplerName = Strings::get(Strings::add(p.key + "Sampler"));
              prop.texture.samplerState = renderContext->states->getSamplerState(samplerState);
              break;
            }
            default:
              break;
            }
            task->properties.push_back(prop);
          }
        }
        else if (ep.key == "groups" && ep.values.size() == 3) {
          task->groups.expressions.clear();
          for (size_t i = 0; i < 3; i++) {
            auto * e = task->scope->compile(ep.values[i].value, "");
            if (e) {
              task->groups.expressions.push_back({ i, e });
            }
          }
        }
        else if (ep.key == "options") {
          task->options.clear();
          for (const auto& p : ep.values) {
            if (p.type == ParsedDataType::String) {
              task->options.emplace_back(p.key, p.value);
            } else {
              LOG_ERROR(logger, "Process task options should be of type string, key=\"%s\".", p.key.c_str());
            }
          }
        }
      }
    }
 
    struct RenderTaskParameters
    {
      uint32_t flags = 0;
      BucketMask bucketMask = BucketMask::All;
      StateChangeFlags stateChangeMask = StateChangeFlags::ChangeAll;
      size_t permutationIndex = 0;
      RenderLayers renderMask = RenderLayers::All;
      SortFlags sortFlags = SortFlags::Default;
      BlendMode blendMode = BlendMode::None;
      DepthMode depthMode = DepthMode::Default;
      DepthFunc depthFunc = DepthFunc::Less;
 
      bool viewportFromTarget = true; // Use render target size as viewport instead of camera viewport.
      bool temporalOffsets = false;
      bool clearColor = true;
      bool clearDepth = true;
      bool discardColor = false;
      bool discardDepth = false;
      bool allowSelfDependency = false;
      bool drawCallID = false;
      bool blendModeSet = false;
    };
 
    RenderTaskParameters parseParameters(RenderTaskContext * renderContext,
                                         const RenderTaskDefinition & taskDefinition,
                                         const PipelineOptions& options)
    {
      RenderTaskParameters parameters;
 
      { // Override renderTaskParameters from pipeline options
        ParsedValue val;
        for (const PreprocessorDefinition& option : options) {
          switch (StringView(option.first).hash()) {
          case Cogs::hash("clearColor"):
            parseStringValue(option.second, val);
            val.asBool(parameters.clearColor);
            break;
          case Cogs::hash("clearDepth"):
            parseStringValue(option.second, val);
            val.asBool(parameters.clearDepth);
            break;
          default:
            break;
          }
        }
      }
 
      for (auto & p : taskDefinition.parameters) {
 
        switch (StringView(p.key).hash()) {
        case Cogs::hash("bucketMask"):
          parameters.bucketMask = parseEnumFlags(p.value, BucketMask::All);
          break;
        case Cogs::hash("stateChangeMask"):
          parameters.stateChangeMask = parseEnumFlags<StateChangeFlags>(p.value, StateChangeFlags::ChangeAll);
          break;
        case Cogs::hash("permutation"):
          parameters.permutationIndex = renderContext->renderer->getEnginePermutations().getIndex(p.value);
          break;
        case Cogs::hash("blendMode"):
          parameters.blendMode = parseEnum(p.value, parameters.blendMode);
          parameters.blendModeSet = true;
          break;
        case Cogs::hash("depthMode"):
          parameters.depthMode = parseEnum(p.value, parameters.depthMode);
          break;
        case Cogs::hash("depthFunc"):
          parameters.depthFunc = parseEnum(p.value, parameters.depthFunc);
          break;
        case Cogs::hash("clear"):
          p.asBool(parameters.clearColor);
          parameters.clearDepth = parameters.clearColor;
          break;
        case Cogs::hash("clearDepth"):
          p.asBool(parameters.clearDepth);
          break;
        case Cogs::hash("clearColor"):
          p.asBool(parameters.clearColor);
          break;
        case Cogs::hash("discardDepth"):
          p.asBool(parameters.discardDepth);
          break;
        case Cogs::hash("discardColor"):
          p.asBool(parameters.discardColor);
          break;
        case Cogs::hash("viewportFromTarget"):
          p.asBool(parameters.viewportFromTarget);
          break;
        case Cogs::hash("temporalOffsets"):
          p.asBool(parameters.temporalOffsets);
          break;
        case Cogs::hash("allowSelfDependency"):
          p.asBool(parameters.allowSelfDependency);
          break;
        case Cogs::hash("flags"):
          parameters.flags = parseEnumFlags(p.value, RenderTaskFlags::None);
          break;
        case Cogs::hash("drawCallID"):
          p.asBool(parameters.drawCallID);
          break;
        case Cogs::hash("renderMask"): {
          parameters.renderMask = parseEnumFlags(p.value, RenderLayers::None);
          break;
        }
        case Cogs::hash("sortFlags"):
          parameters.sortFlags = parseEnumFlags<SortFlags>(p.value, parameters.sortFlags);
          break;
 
        default:
          break;
        }
      }
 
      return parameters;
    }
  }
}
 
Cogs::Core::RenderTask * Cogs::Core::createRenderTask(RenderTaskContext * renderContext,
                                                      const RenderTaskDefinition & taskDefinition,
                                                      std::list<std::unique_ptr<SubContext>>& subContexts,
                                                      ExpressionContext * expressionContext,
                                                      const PipelineOptions & options)
{
  RenderTask * task = nullptr;
 
  auto parameters = parseParameters(renderContext, taskDefinition, options);
 
  if (taskDefinition.type == "GenerateList") {
    task = createTask<GenerateListTask>(renderContext);
    task->initialize(renderContext);
  } else if (taskDefinition.type == "Filter") {
    FilterListTask* filterTask = createTask<FilterListTask>(renderContext);
    filterTask->bucketMask = parameters.bucketMask;
    filterTask->permutation = parameters.permutationIndex;
    filterTask->drawCallID = parameters.drawCallID;
    filterTask->renderMask = parameters.renderMask;
    filterTask->sortFlags = parameters.sortFlags;
    filterTask->blendMode = parameters.blendMode;
    filterTask->blendModeSet = parameters.blendModeSet;
 
    const CameraData* cameraData = &renderContext->context->cameraSystem->getMainCameraData();
 
    if (renderContext->cameraData != cameraData) {
      filterTask->viewportData = renderContext->cameraData;
    } else {
      // Main camera data should not be taken a direct dependency on.
      filterTask->viewportData = nullptr;
    }
 
    task = filterTask;
  } else if (taskDefinition.type == "RenderList") {
    auto renderTask = createTask<RenderListTask>(renderContext, false);
    renderTask->bucketMask = parameters.bucketMask;
    renderTask->stateChangeMask = parameters.stateChangeMask;
    renderTask->permutationIndex = parameters.permutationIndex;
    renderTask->colorClear = parameters.clearColor;
    renderTask->depthClear = parameters.clearDepth;
    renderTask->discardColor = parameters.discardColor;
    renderTask->discardDepth = parameters.discardDepth;
    renderTask->viewportFromTarget = parameters.viewportFromTarget;
    renderTask->temporalOffsets = parameters.temporalOffsets;
    renderTask->blendMode = parameters.blendMode;
    renderTask->depthMode = parameters.depthMode;
    renderTask->depthFunc = parameters.depthFunc;
    renderTask->initialize(renderContext);
    task = renderTask;
  } else if (taskDefinition.type == "DeferredLighting") {
    auto defTask = createTask<DeferredLightingTask>(renderContext);
    defTask->clear = parameters.clearColor;
    defTask->clearToDefault = true;
    task = defTask;
  } else if (taskDefinition.type == "TransparencyRender") {
    auto tTask = createTask<TransparencyRenderTask>(renderContext);
    tTask->bucketMask = parameters.bucketMask;
    tTask->viewportFromTarget = parameters.viewportFromTarget;
    tTask->temporalOffsets = parameters.temporalOffsets;
    task = tTask;
  } else if (taskDefinition.type == "TransparencyMerge") {
    task = createTask<TransparencyMergeTask>(renderContext);
  } else if (taskDefinition.type == "TransparencyTemporalUpscale") {
    task = createTask<TransparencyTemporalUpscaleTask>(renderContext);
  } else if (taskDefinition.type == "TransparencyUpscale") {
    task = createTask<TransparencyUpscaleTask>(renderContext);
  } else if (taskDefinition.type == "PostProcess") {
    PostProcessTask* pTask = createTask<PostProcessTask>(renderContext, false);
    pTask->viewportFromTarget = parameters.viewportFromTarget;
    pTask->clearColor = parameters.clearColor;
    pTask->clearDepth = parameters.clearDepth;
    for (auto & p : taskDefinition.parameters) {
      if (p.key == "effect") {
        setProcessTaskEffectParameter(renderContext, subContexts, expressionContext, pTask, p);
      } else if (p.key == "blendMode") {
        pTask->blendMode = parseEnum<BlendMode>(p.value, pTask->blendMode);
      } else if (p.key == "writeColor") {
        p.asBool(pTask->writeColor);
      } else if (p.key == "writeDepth") {
        p.asBool(pTask->writeDepth);
      }
    }
 
    pTask->initialize(renderContext, taskDefinition);
 
    task = pTask;
  } else if (taskDefinition.type == "ClearResource") {
    auto pTask = createTask<ClearResourceTask>(renderContext);
 
    for (auto & p : taskDefinition.parameters) {
      if (p.key == "destinationIndex") {
        readSize_t(pTask->destinationIndex, expressionContext, taskDefinition.name, p);
      }
      else if (p.key == "fill") {
        if (p.type == ParsedDataType::UInt) {
          pTask->fill_float = false;
          for(uint32_t i=0; i<4; i++)
            pTask->fill.UValues[i] = p.uintValue;
        }
        else if (p.type == ParsedDataType::Float) {
          pTask->fill_float = true;
          for(uint32_t i=0; i<4; i++)
            pTask->fill.FValues[i] = p.floatValue;
        }
      }
    }
 
    task = pTask;
  } else if (taskDefinition.type == "CopyResource") {
    auto pTask = createTask<CopyResourceTask>(renderContext);
 
    for (auto & p : taskDefinition.parameters) {
      if (p.key == "sourceIndex") {
        readSize_t(pTask->sourceIndex, expressionContext, taskDefinition.name, p);
      } else if (p.key == "destinationIndex") {
        readSize_t(pTask->destinationIndex, expressionContext, taskDefinition.name, p);
      }
    }
 
    task = pTask;
  } else if (taskDefinition.type == "ResolveResource") {
    task = createTask<ResolveResourceTask>(renderContext);
  } else if (taskDefinition.type == "Readback") {
    auto pTask = createTask<ReadbackTask>(renderContext);
 
    for (auto & p : taskDefinition.parameters) {
      if (p.key == "bufferIndex") {
        readSize_t(pTask->bufferIndex, expressionContext, taskDefinition.name, p);
      } else if (p.key == "size") {
        readSize_t(pTask->size, expressionContext, taskDefinition.name, p);
      } else if (p.key == "readbackKey") {
        pTask->key = p.value;
      }
    }
 
    task = pTask;
  } else if (taskDefinition.type == "Compute") {
    auto pTask = createTask<ComputeTask>(renderContext, false);
 
    for (auto & p : taskDefinition.parameters) {
      if (p.key == "effect") {
        setProcessTaskEffectParameter(renderContext, subContexts, expressionContext, pTask, p);
      }
    }
 
    pTask->initialize(renderContext, taskDefinition);
 
    task = pTask;
  } else if (taskDefinition.type == "MipLevels") {
    auto pTask = createTask<MipLevelsTask>(renderContext, false);
 
    for (auto & p : taskDefinition.parameters) {
      if (p.key == "effect") {
        setProcessTaskEffectParameter(renderContext, subContexts, expressionContext, pTask, p);
      } else if (p.key == "firstLevel") {
        readSize_t(pTask->firstLevel, expressionContext, std::to_string((size_t)(pTask)) + ".firstLevel", p);
      } else if (p.key == "lastLevel") {
        readSize_t(pTask->lastLevel, expressionContext, std::to_string((size_t)(pTask)) + ".lastLevel", p);
      } else if (p.key == "blendMode") {
        pTask->blendMode = parseEnum<BlendMode>(p.value, pTask->blendMode);
      }
    }
    pTask->initialize(renderContext, taskDefinition);
    task = pTask;
  } else {
    auto fIt = creators.find(taskDefinition.type);
 
    if (fIt != creators.end()) {
      task = fIt->second(renderContext, taskDefinition, options);
      task->initialize(renderContext);
    }
  }
 
  if (!task) {
    LOG_ERROR(logger, "Could not create task of type %s.", taskDefinition.type.c_str());
    return nullptr;
  }
 
  task->name = taskDefinition.name;
  task->options = options;
  task->flags = (RenderTaskFlags::ERenderTaskFlags)parameters.flags;
  task->allowSelfDependency = parameters.allowSelfDependency;
 
  return task;
}
 
void Cogs::Core::destroyRenderTask(RenderTaskContext* renderContext, RenderTask* task)
{
  freeTask(task, renderContext);
}
 
void Cogs::Core::addTaskType(const StringView & key, TaskCreator creator, TaskDestroyer destroyer)
{
  creators[key.to_string()] = creator;
  destroyers[key.to_string()] = destroyer;
}
 
void Cogs::Core::freeTasks(std::vector<RenderTask *> & tasks, RenderTaskContext * renderContext)
{
  for (auto & task : tasks) {
    if (!(task->flags & RenderTaskFlags::Persistent)) {
      freeTask(task, renderContext);
    }
  }
}