ContextCommon.h

#pragma once
 
#include "../IContext.h"
 
#include "../VertexFormat.h"
#include "../Statistics.h"
 
#include "EffectsCommon.h"
 
namespace Cogs
{
  const int kMaxVertexInputSlots = 32;
 
  struct InputAssemblerStateCommon
  {
    size_t numVertexBuffers = 0;
    const VertexFormat * formats[kMaxVertexInputSlots] = {};
    uint32_t strides[kMaxVertexInputSlots] = {};
    uint32_t offsets[kMaxVertexInputSlots] = {};
  };
 
  struct ContextCommon : public IContext
  {
    virtual InputAssemblerStateCommon * getIAState() = 0;
 
    virtual EffectHandle getCurrentEffect() = 0;
    virtual IEffects * getEffects() = 0;
 
    const Cogs::FrameStatistics& getLastFrameStatistics() override;
    const Cogs::UploadStatistics& getLastUploadStatistics() override;
 
    void frameStatisticsConfigure(bool enable) override { frameStatisticsEnabled = enable; }
 
    void setMatrixVariable(const StringView& name, const float * value) override;
 
    void setScalarVariable(const StringView& name, const float value) override {
      this->setVariable(name, reinterpret_cast<const unsigned char *>(&value), sizeof(float));
    }
 
    void setScalarVariable(const StringView& name, int value) override {
      this->setVariable(name, reinterpret_cast<const unsigned char *>(&value), sizeof(int));
    }
 
    void setVector2Variable(const StringView& name, const float * value) override {
      this->setVariable(name, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 2);
    }
 
    void setVector3Variable(const StringView& name, const float * value) override {
      this->setVariable(name, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 3);
    }
 
    void setVector4Variable(const StringView& name, const float * value) override {
      this->setVariable(name, reinterpret_cast<const unsigned char *>(value), sizeof(float) * 4);
    }
 
    void setVariable(const StringView& name, const uint8_t * data, size_t size);
    void setVariable(const EffectVariableHandle index, const uint8_t * data, size_t size) override;
 
    void setMatrixVariable(const EffectVariableHandle variableHandle, const float * value) override;
    void setMatrixVariable(const EffectVariableHandle variableHandle, const float * value, size_t count) override;
 
    void setScalarVariable(const EffectVariableHandle variableHandle, const float value) override;
    void setScalarVariable(const EffectVariableHandle variableHandle, const float* value, size_t count) override;
    void setScalarVariable(const EffectVariableHandle variableHandle, int value) override;
    void setScalarVariable(const EffectVariableHandle variableHandle, const int* value, size_t count) override;
 
    void setVector2Variable(const EffectVariableHandle variableHandle, const float * value, size_t count = 1) override;
    void setVector3Variable(const EffectVariableHandle variableHandle, const float * value, size_t count = 1) override;
    void setVector4Variable(const EffectVariableHandle variableHandle, const float * value, size_t count = 1) override;
 
    void setVector4Variable(const EffectVariableHandle variableHandle, const int * value, size_t count = 1) override;
 
    void setConstantBuffer(const StringView& name, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size) final;
    void setBuffer(const StringView& name, BufferHandle bufferHandle) final;
    void setTexture(const StringView& name, unsigned int unit, TextureHandle textureHandle) final;
    void setTexture(const StringView& name, TextureViewHandle textureViewHandle) final;
    void setSamplerState(const StringView& name, unsigned int unit, SamplerStateHandle handle) final;
 
    using IContext::setConstantBuffer;
    using IContext::setBuffer;
    using IContext::setTexture;
    using IContext::setSamplerState;
 
    void setVertexArrayObject(VertexArrayObjectHandle vertexArrayObject) override;
 
    virtual void signal(FenceHandle /*fenceHandle*/) override {}
 
    void updateBuffer(BufferHandle bufferHandle, const void* data, size_t size) override;
 
    void frameStatisticsBeginFrame();
 
  protected:
    void setCurrentEffect(Effect * currentEffect);
    void updateConstantBuffers();
 
    // Invoked by draw call to account for submission.
    void frameStatisticsAccountDrawCall(size_t count, bool indexed);
 
    // Invoked by upload calls
    void uploadStatisticsBufferUpload(size_t size);
    void uploadStatisticsTextureUpload(size_t size);
 
    FrameStatistics prevStats{};
    FrameStatistics currStats{};
 
    UploadStatistics prevUploadStats{};
    UploadStatistics currUploadStats{};
 
    struct TrackedState
    {
      uint32_t dirtySRV[(int)Cogs::ShaderType::NumShaderSlots] = {};
      uint32_t dirtyCB[(int)Cogs::ShaderType::NumShaderSlots] = {};
      BufferHandle vsCBs[255];
      BufferHandle psCBs[255];
      BufferHandle csCBs[255];
      PrimitiveType::EPrimitiveType primitiveType = (PrimitiveType::EPrimitiveType)~0;
    } state;
 
    Effect * effect = nullptr;
    bool constantBuffersUpdated = true;
    bool frameStatisticsEnabled = false;
    bool uploadStatisticsEnabled = true;
 
    friend struct BuffersD3D11;
    friend struct TexturesD3D11;
  };
}