ContextCommon.cpp

#include "ContextCommon.h"
 
#include "../IBuffers.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  static Cogs::Logging::Log logger = Cogs::Logging::getLogger("ContextCommon");
}
 
const Cogs::FrameStatistics& Cogs::ContextCommon::getLastFrameStatistics()
{
  return prevStats;
}
 
const Cogs::UploadStatistics& Cogs::ContextCommon::getLastUploadStatistics()
{
  return prevUploadStats;
}
 
void Cogs::ContextCommon::frameStatisticsBeginFrame() {
  prevStats = currStats;
  currStats = FrameStatistics{};
 
  prevUploadStats = currUploadStats;
  currUploadStats = UploadStatistics{};
}
 
void Cogs::ContextCommon::frameStatisticsAccountDrawCall(size_t count, bool indexed)
{
  // bucket is position of most significant bit, zero is zero.
  unsigned bucket = 0;
  size_t t = count;
  if ((t & 0xFFFF0000) != 0) { bucket += 16; t = t >> 16u; }
  if ((t & 0x0000FF00) != 0) { bucket += 8; t = t >> 8u; }
  if ((t & 0x000000F0) != 0) { bucket += 4; t = t >> 4u; }
  if ((t & 0x0000000C) != 0) { bucket += 2; t = t >> 2u; }
  if ((t & 0x00000002) != 0) { bucket += 1; }
 
#ifdef _DEBUG
  assert(uint64_t(count) < (uint64_t(1) << (bucket + 1)));
  if (count) {
    assert((uint64_t(1) << bucket) <= uint64_t(count));
  }
  else {
    assert(bucket == 0);
  }
#endif
 
  currStats.drawCallHistogram[bucket]++;
  currStats.vertices += count;
  if (indexed) currStats.indices += count;
}
 
void Cogs::ContextCommon::uploadStatisticsBufferUpload(size_t size)
{
  currUploadStats.bufferUploads++;
  currUploadStats.bufferUploadSize += size;
}
 
void Cogs::ContextCommon::uploadStatisticsTextureUpload(size_t size)
{
  currUploadStats.textureUploads++;
  currUploadStats.textureUploadSize += size;
}
 
void Cogs::ContextCommon::setMatrixVariable(const EffectVariableHandle variableHandle, const float * value)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 16);
}
 
void Cogs::ContextCommon::setMatrixVariable(const EffectVariableHandle variableHandle, const float * value, size_t count)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 16 * count);
}
 
void Cogs::ContextCommon::setScalarVariable(const EffectVariableHandle variableHandle, const float value)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(&value), sizeof(float) * 1);
}
 
void Cogs::ContextCommon::setScalarVariable(const EffectVariableHandle variableHandle, const float* value, size_t count)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(value), sizeof(float) * count);
}
 
void Cogs::ContextCommon::setScalarVariable(const EffectVariableHandle variableHandle, int value)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(&value), sizeof(int) * 1);
}
 
void Cogs::ContextCommon::setScalarVariable(const EffectVariableHandle variableHandle, const int* value, size_t count)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(value), sizeof(int) * count);
}
 
void Cogs::ContextCommon::setVector2Variable(const EffectVariableHandle variableHandle, const float * value, size_t count)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 2 * count);
}
 
void Cogs::ContextCommon::setVector3Variable(const EffectVariableHandle variableHandle, const float * value, size_t count)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 3 * count);
}
 
void Cogs::ContextCommon::setVector4Variable(const EffectVariableHandle variableHandle, const float * value, size_t count)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 4 * count);
}
 
void Cogs::ContextCommon::setVector4Variable(const EffectVariableHandle variableHandle, const int * value, size_t count)
{
  setVariable(variableHandle, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 4 * count);
}
 
void Cogs::ContextCommon::setConstantBuffer(const StringView& name, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size)
{
  setConstantBuffer(getEffects()->getConstantBufferBinding(getCurrentEffect(), name), bufferHandle, offset, size);
}
void Cogs::ContextCommon::setBuffer(const StringView& name, BufferHandle bufferHandle)
{
  auto binding = getEffects()->getBufferBinding(getCurrentEffect(), name);
  setBuffer(binding, bufferHandle);
  getEffects()->releaseBufferBinding(binding);
}
void Cogs::ContextCommon::setTexture(const StringView& name, unsigned int unit, TextureHandle textureHandle)
{
  setTexture(getEffects()->getTextureBinding(getCurrentEffect(), name, unit), textureHandle);
}
void Cogs::ContextCommon::setTexture(const StringView& name, TextureViewHandle textureViewHandle)
{
  setTexture(getEffects()->getTextureBinding(getCurrentEffect(), name, 0), textureViewHandle);
}
void Cogs::ContextCommon::setSamplerState(const StringView& name, unsigned int unit, SamplerStateHandle handle)
{
  setSamplerState(getEffects()->getSamplerStateBinding(getCurrentEffect(), name, unit), handle);
}
 
void Cogs::ContextCommon::setCurrentEffect(Effect * currentEffect)
{
  this->effect = currentEffect;
}
 
void Cogs::ContextCommon::updateConstantBuffers()
{
  if (!effect) return;
 
  auto updateConstantBuffer = [&](ShaderConstantBuffer & constantBuffer) {
    if (!constantBuffer.dirty || constantBuffer.manual) return;
 
    MappedBuffer<uint8_t> mappedBuffer(this, constantBuffer.buffer, MapMode::WriteDiscard);
 
    if (mappedBuffer) {
      std::memcpy(mappedBuffer, constantBuffer.memoryBuffer.data(), constantBuffer.memoryBuffer.size());
    }
    constantBuffer.dirty = false;
  };
 
  for (auto & shader : effect->shaders) {
    for (auto & constantBuffer : shader.reflection.constantBuffers) {
      if (HandleIsValid(constantBuffer.buffer)) {
        updateConstantBuffer(constantBuffer);
      }
    }
  }
}
 
void Cogs::ContextCommon::updateBuffer(BufferHandle bufferHandle, const void* data, size_t size)
{
  MappedBuffer<uint8_t> mappedBuffer(this, bufferHandle, MapMode::WriteDiscard);
  if (mappedBuffer) {
    std::memcpy(mappedBuffer, data, size);
  }
  else {
    LOG_ERROR_ONCE(logger, "updateBuffer: Faild to map buffer");
  }
}
 
void Cogs::ContextCommon::setMatrixVariable(const StringView& name, const float * value)
{
  setVariable(name, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 16);
}
 
void Cogs::ContextCommon::setVariable(const EffectVariableHandle handle, const uint8_t * data, size_t size)
{
  if (!HandleIsValid(handle)) return;
 
  auto effectVariable = reinterpret_cast<EffectVariable *>(handle.handle);
 
  for (auto & variable : effectVariable->variables) {
    std::memcpy(variable.buffer->memoryBuffer.data() + variable.offset, data, size);
    variable.buffer->dirty = true;
  }
 
  constantBuffersUpdated = false;
}
 
void Cogs::ContextCommon::setVariable(const StringView& name, const uint8_t * data, size_t size)
{
  setVariable(getEffects()->getEffectVariable(getCurrentEffect(), name), data, size);
}
 
void Cogs::ContextCommon::setVertexArrayObject(VertexArrayObjectHandle /*vertexArrayObject*/)
{
  LOG_ERROR_ONCE(logger, "Rendering context does not support vertex array objects.");
}