RenderStates.cpp

#include "RenderStates.h"
 
#include <functional>
 
#include "Foundation/Logging/Logger.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IRenderTargets.h"
#include "Rendering/ITextures.h"
#include "Rendering/IBuffers.h"
 
#include "Resources/MaterialOptions.h"
#include "Systems/Core/CameraSystem.h"
#include "Resources/VertexFormats.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderStates");
}
 
void Cogs::Core::RenderStates::initialize(IGraphicsDevice * device)
{
  this->device = device;
  auto renderTargets = device->getRenderTargets();
  auto textures = device->getTextures();
 
  auto rs = RasterizerState::DefaultState();
  rs.cullMode = RasterizerState::Front;
  rs.frontCounterClockwise = false;
  rs.noDepthClip = true;
  getRasterizerState(rs);
 
  rs.cullMode = RasterizerState::Front;
  rs.frontCounterClockwise = true;
  rs.noDepthClip = true;
  getRasterizerState(rs);
 
  rs.cullMode = RasterizerState::Back;
  rs.frontCounterClockwise = false;
  rs.noDepthClip = true;
  getRasterizerState(rs);
 
  rs.cullMode = RasterizerState::Back;
  rs.frontCounterClockwise = true;
  rs.noDepthClip = true;
  getRasterizerState(rs);
 
  rs.cullMode = RasterizerState::None;
  rs.frontCounterClockwise = false;
  rs.noDepthClip = true;
  getRasterizerState(rs);
 
  rs.cullMode = RasterizerState::None;
  rs.frontCounterClockwise = true;
  rs.noDepthClip = true;
  getRasterizerState(rs);
 
  rs = RasterizerState::DefaultState();
  rs.noDepthClip = true;
  defaultRasterizerStateHandle = device->getRenderTargets()->loadRasterizerState(rs);
  rs.frontCounterClockwise = true;
  defaultCCWasterizerStateHandle = device->getRenderTargets()->loadRasterizerState(rs);
 
  { // BlendMode::Blend
    auto& blend = blendStates[size_t(BlendMode::Blend)];
    blend.color.enabled = true;
    blend.color.sourceBlend = BlendState::Blend::SourceAlpha;
    blend.color.destinationBlend = BlendState::Blend::InverseSourceAlpha;
    blend.color.operation = BlendState::BlendOperation::Add;
    blend.alpha.enabled = true;
    blend.alpha.sourceBlend = BlendState::Blend::One;
    blend.alpha.destinationBlend = BlendState::Blend::InverseSourceAlpha;
    blend.alpha.operation = BlendState::BlendOperation::Add;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha);
  }
 
  { // BlendMode::Add
    auto& blend = blendStates[size_t(BlendMode::Add)];
    blend.color.enabled = true;
    blend.color.sourceBlend = BlendState::Blend::SourceAlpha;
    blend.color.destinationBlend = BlendState::Blend::One;
    blend.color.operation = BlendState::BlendOperation::Add;
    blend.alpha.enabled = true;
    blend.alpha.sourceBlend = BlendState::Blend::One;
    blend.alpha.destinationBlend = BlendState::Blend::One;
    blend.alpha.operation = BlendState::BlendOperation::Add;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha);
  }
 
  { // BlendMode::PremultipliedBlend
    auto& blend = blendStates[size_t(BlendMode::PremultipliedBlend)];
    blend.color.enabled = true;
    blend.color.sourceBlend = BlendState::Blend::One;
    blend.color.destinationBlend = BlendState::Blend::InverseSourceAlpha;
    blend.color.operation = BlendState::BlendOperation::Add;
    blend.alpha.enabled = true;
    blend.alpha.sourceBlend = BlendState::Blend::One;
    blend.alpha.destinationBlend = BlendState::Blend::InverseSourceAlpha;
    blend.alpha.operation = BlendState::BlendOperation::Add;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha);
  }
 
  { // BlendMode::AlphaToCoverage
    auto& blend = blendStates[size_t(BlendMode::AlphaToCoverage)];
    blend.color.enabled = false;
    blend.alpha.enabled = false;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha, Cogs::BlendFlags::AlphaToCoverage);
  }
 
  { // BlendMode::None
    auto& blend = blendStates[size_t(BlendMode::None)];
    blend.color.enabled = false;
    blend.alpha.enabled = false;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha);
  }
 
  { // BlendMode::Zero
    auto& blend = blendStates[size_t(BlendMode::Zero)];
    blend.color.enabled = true;
    blend.color.sourceBlend = BlendState::Blend::Zero;
    blend.color.destinationBlend = BlendState::Blend::One;
    blend.color.operation = BlendState::BlendOperation::Add;
    blend.alpha = blend.color;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha);
  }
 
  { // BlendMode::One_One_Zero_InverseSourceAlpha
    auto& blend = blendStates[size_t(BlendMode::One_One_Zero_InverseSourceAlpha)];
    blend.color.enabled = true;
    blend.color.sourceBlend = BlendState::Blend::One;
    blend.color.destinationBlend = BlendState::Blend::One;
    blend.color.operation = BlendState::BlendOperation::Add;
    blend.alpha.enabled = true;
    blend.alpha.sourceBlend = BlendState::Blend::Zero;
    blend.alpha.destinationBlend = BlendState::Blend::InverseSourceAlpha;
    blend.alpha.operation = BlendState::BlendOperation::Add;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha);
  }
 
  { // BlendMode::InverseSourceAlpha_SourceAlpha
    auto& blend = blendStates[size_t(BlendMode::InverseSourceAlpha_SourceAlpha)];
    blend.color.enabled = true;
    blend.color.sourceBlend = BlendState::Blend::InverseSourceAlpha;
    blend.color.destinationBlend = BlendState::Blend::SourceAlpha;
    blend.color.operation = BlendState::BlendOperation::Add;
    blend.alpha = blend.color;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha);
  }
 
  { // BlendMode::DestinationAlpha_InverseDestinationAlpha
    auto& blend = blendStates[size_t(BlendMode::DestinationAlpha_InverseDestinationAlpha)];
    blend.color.enabled = true;
    blend.color.sourceBlend = BlendState::Blend::DestinationAlpha;
    blend.color.destinationBlend = BlendState::Blend::InverseDestinationAlpha;
    blend.color.operation = BlendState::BlendOperation::Add;
    blend.alpha = blend.color;
    blend.handle = renderTargets->loadBlendState(blend.color, blend.alpha);
  }
 
  setupDepthStates(device);
  defaultSampler = textures->loadSamplerState(SamplerState::DefaultState());
 
  SamplerState states[] = {
    { SamplerState::Wrap, SamplerState::Wrap, SamplerState::Wrap, SamplerState::MinMagMipLinear, SamplerState::Never, 0, {0.f} },
    { SamplerState::Clamp, SamplerState::Clamp, SamplerState::Clamp, SamplerState::MinMagMipLinear, SamplerState::Never, 0, {0.f} },
    { SamplerState::Wrap, SamplerState::Wrap, SamplerState::Wrap, SamplerState::MinMagMipPoint, SamplerState::Never, 0, {0.f} },
    { SamplerState::Clamp, SamplerState::Clamp, SamplerState::Clamp, SamplerState::MinMagMipPoint, SamplerState::Never, 0, {0.f} },
  };
 
  for (size_t i = 0; i < 4; ++i) {
    commonSamplerStates[i] = textures->loadSamplerState(states[i]);
  }
 
  SamplerState shadowSamplerState{};
  switch (device->getType()) {
  case GraphicsDeviceType::OpenGLES30:
  case GraphicsDeviceType::WebGPU:
    shadowSamplerState.addressModeS = SamplerState::Wrap;
    shadowSamplerState.addressModeT = SamplerState::Wrap;
    shadowSamplerState.addressModeW = SamplerState::Wrap;
    shadowSamplerState.comparisonFunction = reverseDepth ? SamplerState::GreaterEqual : SamplerState::LessEqual;
    shadowSamplerState.filter = SamplerState::ComparisonMinMagMipLinear;
    break;
  default:
    shadowSamplerState.addressModeS = SamplerState::Border;
    shadowSamplerState.addressModeT = SamplerState::Border;
    shadowSamplerState.addressModeW = SamplerState::Border;
    shadowSamplerState.comparisonFunction = reverseDepth ? SamplerState::GreaterEqual : SamplerState::LessEqual;
    shadowSamplerState.filter = SamplerState::ComparisonMinMagMipLinear;
    for (size_t i = 0; i < 4; i++) {
      shadowSamplerState.borderColor[i] = reverseDepth ? 0.f : 1.f;
    }
    break;
  }
  shadowSampler = textures->loadSamplerState(shadowSamplerState);
 
  IBuffers * buffers = device->getBuffers();
 
  const glm::vec4 fst[] =
  {
    {-1.0, -1.0, 0.0, 1.f},
    { 3.0, -1.0, 0.0, 1.f},
    {-1.0,  3.0, 0.0, 1.f},
  };
 
  fullScreenTriangle = buffers->loadVertexBuffer(fst, sizeof(fst) / sizeof(fst[0]), VertexFormats::Pos4f);
}
 
void Cogs::Core::RenderStates::setupDepthStates(IGraphicsDevice* device) {
  auto renderTargets = device->getRenderTargets();
  DepthStencilState defaultState = DepthStencilState::DefaultState();
  if (reverseDepth) defaultState.depthFunction = DepthStencilState::Greater;
  defaultDepthStencilStateHandle = renderTargets->loadDepthStencilState(defaultState);
  commonDepthStates[(int)DepthMode::Default] = defaultDepthStencilStateHandle;
 
  DepthStencilState depthState = { true, false, DepthStencilState::Less };
  if (reverseDepth) depthState.depthFunction = DepthStencilState::Greater;
  noWriteDepthStencilStateHandle = renderTargets->loadDepthStencilState(depthState);
  commonDepthStates[(int)DepthMode::NoWrite] = noWriteDepthStencilStateHandle;
 
  DepthStencilState noTestDepthState = { true, true, DepthStencilState::Always };
  noTestDepthStencilStateHandle = renderTargets->loadDepthStencilState(noTestDepthState);
  commonDepthStates[(int)DepthMode::AlwaysWrite] = noTestDepthStencilStateHandle;
  DepthStencilState noDepthState = { false, false, DepthStencilState::Always };
  noDepthStencilStateHandle = renderTargets->loadDepthStencilState(noDepthState);
  commonDepthStates[(int)DepthMode::Disabled] = noDepthStencilStateHandle;
 
  DepthStencilState leqState = { true, true, DepthStencilState::LessOrEqual };
  if (reverseDepth) leqState.depthFunction = DepthStencilState::GreaterOrEqual;
  leqDepthStencilStateHandle = renderTargets->loadDepthStencilState(leqState);
 
  for (int depthMode = 0; depthMode < 4; depthMode++) {
    for (int depthFunc = 0; depthFunc < 5; depthFunc++) {
      DepthStencilState::DepthFunction depthFunction = DepthStencilState::DepthFunction::Less;
      switch (DepthFunc(depthFunc)) {
      case DepthFunc::Less:
        depthFunction = reverseDepth ? DepthStencilState::DepthFunction::Greater : DepthStencilState::DepthFunction::Less;
        break;
      case DepthFunc::Always:
        depthFunction = DepthStencilState::DepthFunction::Always;
        break;
      case DepthFunc::LessOrEqual:
        depthFunction = reverseDepth ? DepthStencilState::DepthFunction::GreaterOrEqual : DepthStencilState::DepthFunction::LessOrEqual;
        break;
      case DepthFunc::NotEqual:
        depthFunction = DepthStencilState::DepthFunction::NotEqual;
        break;
      case DepthFunc::Equal:
        depthFunction = DepthStencilState::DepthFunction::Equal;
        break;
      case DepthFunc::Count:
        assert(false);
        break;
      }
      DepthStencilState state = DepthStencilState::DefaultState();
      state.depthFunction = depthFunction;
      switch (DepthMode(depthMode)) {
      case DepthMode::Default:
        break;
      case DepthMode::NoWrite:
        state = { true, false, depthFunction };
        break;
      case DepthMode::AlwaysWrite:
        state = DepthStencilState::DefaultState();
        break;
      case DepthMode::Disabled:
        state = { false, false, depthFunction };
        break;
      case DepthMode::Count:
        assert(false);
        break;
      }
      commonDepthStates[depthFunc * (int)DepthMode::Count + depthMode] = renderTargets->loadDepthStencilState(state);
    }
  }
}
 
void Cogs::Core::RenderStates::cleanup()
{
  for (auto & d : depthStencilStates) {
    device->getRenderTargets()->releaseDepthStencilState(d.second);
  }
 
  for (auto & r : rasterizerStates) {
    device->getRenderTargets()->releaseRasterizerState(r.second.handle);
  }
 
  for (auto & s : samplerStates) {
    device->getTextures()->releaseSamplerState(s.second);
  }
 
  depthStencilStates.clear();
  rasterizerStates.clear();
  samplerStates.clear();
}
 
namespace {
 
  size_t getDefaultRenderPassOptionsHash() {
    Cogs::Core::RenderPassOptions options{};
    options.updateHash();
    return options.hash;
  }
 
}
 
 
uint16_t Cogs::Core::RenderStates::getRasterizerState(const Cogs::Core::RenderPassOptions& passOptions,
                                                      RasterizerState::CullMode cullMode,
                                                      bool wireFrame,
                                                      bool counterClockWise)
{
 
  static const size_t defaultRenderPassOptionsHash = getDefaultRenderPassOptionsHash();
  if (wireFrame || passOptions.hash != defaultRenderPassOptionsHash) {
 
    RasterizerState rasterizerState = RasterizerState::DefaultState();
    rasterizerState.wireFrame = wireFrame;
    rasterizerState.cullMode = cullMode;
    rasterizerState.frontCounterClockwise = counterClockWise;
    rasterizerState.noDepthClip = passOptions.getFlag(RenderPassOptions::Flags::NoDepthClip);
    rasterizerState.depthBias = passOptions.depthBias;
    rasterizerState.slopeScaledDepthBias = passOptions.depthSlopedBias;
    rasterizerState.depthBiasClamp = passOptions.depthBiasClamp;
    rasterizerState.scissor = passOptions.getFlag(RenderPassOptions::Flags::ScissorTest);
 
    return getRasterizerState(rasterizerState);
  } else {
    return (uint16_t)(cullMode * 2 + counterClockWise);
  }
}
 
uint16_t Cogs::Core::RenderStates::getRasterizerState(const RasterizerState & rs_a)
{
  RasterizerState rs = rs_a;
  if(reverseDepth){
    rs.depthBias = -rs.depthBias;
    rs.slopeScaledDepthBias = -rs.slopeScaledDepthBias;
    rs.depthBiasClamp = -rs.depthBiasClamp;
  }
  auto it = rasterizerStates.find(rs);
 
  if (it == rasterizerStates.end()) {
    LOG_TRACE(logger, "Created rasterizer state %d.", int(rasterizerStates.size()));
 
    auto rsh = device->getRenderTargets()->loadRasterizerState(rs);
 
    auto index = static_cast<uint16_t>(rasterizerStateHandles.size());
    rasterizerStateHandles.emplace_back(rsh);
 
    rasterizerStates[rs] = { index, rsh };
 
    return index;
  } else {
    return it->second.index;
  }
}
 
Cogs::DepthStencilStateHandle Cogs::Core::RenderStates::getDepthStencilState(const DepthStencilState & ds_a)
{
  DepthStencilState ds = ds_a;
  if(reverseDepth){
    if(ds.depthFunction == DepthStencilState::Less)
      ds.depthFunction = DepthStencilState::Greater;
    if(ds.depthFunction == DepthStencilState::LessOrEqual)
      ds.depthFunction = DepthStencilState::GreaterOrEqual;
  }
     
  auto it = depthStencilStates.find(ds);
 
  if (it == depthStencilStates.end()) {
    LOG_TRACE(logger, "Created depth stencil state %d.", int(rasterizerStates.size()));
 
    auto dsh = device->getRenderTargets()->loadDepthStencilState(ds);
 
    depthStencilStates[ds] = dsh;
 
    return dsh;
  } else {
    return it->second;
  }
}
 
Cogs::SamplerStateHandle Cogs::Core::RenderStates::getSamplerState(const SamplerState & ss)
{
  auto it = samplerStates.find(ss);
 
  if (it == samplerStates.end()) {
    LOG_TRACE(logger, "Created sampler state %d.", int(samplerStates.size()));
 
    auto ssh = device->getTextures()->loadSamplerState(ss);
 
    samplerStates[ss] = ssh;
 
    return ssh;
  } else {
    return it->second;
  }
}