ContextGL20.h

#pragma once
 
#include "../IContext.h"
 
#include "CommonGL20.h"
#include "../Base/ContextCommon.h"
#include "../BaseGL/SyncObjects.h"
 
namespace Cogs
{
  struct CapabilitiesGL20;
  struct BufferGL20;
  struct BuffersGL20;
  struct TexturesGL20;
  struct EffectsGL20;
  struct RenderTargetsGL20;
 
  struct AtomicCounterMapGL20
  {
    int effectAtomicCounterVariableIndex;
    GLuint backingBuffer;
  };
 
  struct InputAssemblerStateGL20 : public InputAssemblerStateCommon
  {
    BufferGL20 * currentVertexBuffers[kMaxVertexInputSlots];
    BufferGL20 * currentIndexBuffer;
    uint32_t indexBufferStride = 4;
  };
 
  struct ContextGL20 : ContextCommon
  {
    ContextGL20();
 
    void initialize(CapabilitiesGL20*   capabilities,
                    BuffersGL20*        buffers,
                    TexturesGL20*       textures,
                    EffectsGL20*        effects,
                    RenderTargetsGL20*  renderTargets,
                    GLSyncObjects*      sync);
                    
    void releaseResources();
 
    EffectHandle getCurrentEffect() override;
    IEffects * getEffects() override;
    InputAssemblerStateCommon * getIAState() override { return &iaState; }
    InputAssemblerStateGL20 iaState = {};
 
    CapabilitiesGL20 * capabilities = nullptr;
    BuffersGL20 * buffers = nullptr;
    TexturesGL20 * textures = nullptr;
    EffectsGL20 * effects = nullptr;
    RenderTargetsGL20 * renderTargets = nullptr;
    GLSyncObjects* syncObjects = nullptr;
 
    void signal(FenceHandle fenceHandle) override;
 
    void beginRenderPass(const RenderPassInfo &info) override;
    void endRenderPass() override;
 
    void setRenderTarget(const RenderTargetHandle handle, const DepthStencilHandle depthStencilHandle) override;
    void setViewport(const float x, const float y, const float width, const float height) override;
    void setScissor(const int x, const int y, const int width, const int height) override;
 
    void clearRenderTarget(const float * color) override;
    void clearRenderTarget(const float ** colors, const int count) override;
 
    void clearDepth(const float depth = 1.0f) override;
 
    void setDepthStencilState(const DepthStencilStateHandle handle) override;
    void setBlendState(const BlendStateHandle handle, const float* constant) override;
    void setRasterizerState(const RasterizerStateHandle handle) override;
 
    void resolveResource(TextureHandle source, TextureHandle destination) override;
 
    void setEffect(EffectHandle effectHandle) override;
    EffectHandle getEffect() const;
 
    void setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle) override;
    void setTexture(const TextureBindingHandle textureBindingHandle, TextureViewHandle textureViewHandle) override;
    void setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle) override;
 
    void setInputLayout(const InputLayoutHandle inputLayoutHandle) override;
    void setVertexBuffers(const VertexBufferHandle * vertexBufferHandles, const size_t count, const uint32_t * strides, const uint32_t * offsets) override;
    void setVertexBuffers(const VertexBufferHandle * vertexBufferHandles, const size_t count) override;
    void setIndexBuffer(IndexBufferHandle indexBufferHandle, uint32_t stride, uint32_t offset) override;
 
    void setConstantBuffer(const ConstantBufferBindingHandle bufferBinding, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size) override;
 
    void setBuffer(const BufferBindingHandle bufferBindingHandle, BufferHandle bufferHandle) override;
    void setBufferCounter(BufferHandle bufferHandle, uint32_t value) override;
    void setBufferCounter(BufferHandle bufferHandle, BufferHandle sourceBufferHandle) override;
    void getBufferCounter(BufferHandle bufferHandle, BufferHandle destinationBufferHandle) override;
 
    uint32_t getBufferCounter(BufferHandle bufferHandle) override;
 
    void draw(PrimitiveType primitiveType, const size_t startVertex, const size_t numPrimitives) override;
    void drawIndexed(PrimitiveType primitiveType, const size_t startIndex, const size_t numIndexes, const size_t startVertex = 0) override;
 
    void drawInstanced(PrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances) override;
    void drawInstancedIndexed(PrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndexes) override;
 
    void dispatchCompute(const unsigned int threadGroupsX, const unsigned int threadGroupsY, const unsigned int threadGroupsZ) override;
 
    void readDepthBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer framebuffer) override;
    void readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer framebuffer) override;
 
    void * map(BufferHandle bufferHandle, MapMode::EMapMode mapMode, uint32_t * stride) override;
    void unmap(BufferHandle bufferHandle) override;
 
    void * map(TextureHandle /*textureHandle*/, MapMode::EMapMode /*accessMode*/, uint32_t * /*rowPitch*/, uint32_t * /*depthPitch*/) override { return nullptr; }
    void unmap(TextureHandle) override {}
 
    void updateSubTexture(TextureHandle textureHandle, const size_t level, const void * data) override;
    void updateSubBuffer(BufferHandle bufferHandle, const size_t offset, const size_t size, const void * data) override;
 
    void copyResource(BufferHandle destinationHandle, BufferHandle sourceHandle) override;
    void copyResource(TextureHandle destinationHandle, TextureHandle sourceHandle) override;
 
    void copySubResource(BufferHandle destinationHandle, size_t destinationOffset, BufferHandle sourceHandle, size_t sourceOffset, size_t size);
 
    void copyTexture(TextureHandle dstHandle, unsigned dstSub, unsigned dstX, unsigned dstY, unsigned dstZ, TextureHandle sourceHandle, unsigned srcSub) override;
 
    void clearResource(BufferHandle destinationHandle, uint32_t *Values) override;
    void clearResource(BufferHandle destinationHandle, float *Values) override;
 
    void preDraw();
    void postDraw();
 
    void syncCounterToEffect(const AtomicCounterMapGL20 mapping);
    void syncCounterFromEffect(const AtomicCounterMapGL20 mapping);
 
    void setDefaults();
    void reset() override;
    void setupVertexAttributes();
    void clearInputState();
 
    void pushCommandGroupAnnotation(const StringView & name) override;
    void popCommandGroupAnnotation() override;
    void setAnnotationMarker(const StringView & name) override;
 
    SamplerStateHandle defaultSamplerStateHandle;
 
  private:
    std::vector<AtomicCounterMapGL20> atomicCounterMappings;
 
    EffectHandle currentEffect;
    GLuint currentProgramId = 0;
    unsigned char * currentAttributeMap = nullptr;
 
    bool inRenderPass = false;
    RenderPassInfo renderPassInfo = {};
 
    RenderTargetHandle currentRenderTarget;
    DepthStencilStateHandle currentDepthStencilState;
 
    std::vector<GLint> enabledAttributes;
 
    TextureHandle boundTextures[192];
    SamplerStateHandle boundSamplerStates[192];
    GLuint boundTarget[192];
#ifndef __APPLE__
    GLuint maxImageUnits = 8;
#endif
 
    GLuint vao = 0;
 
    bool needVertexAttributeSetup = true;
    bool enableMappingWorkaround = true;
    bool unorderedMemoryAcccess = false;
  };
}