ContextGLES30.h

#pragma once
 
#include "../IContext.h"
 
#include "CommonGLES30.h"
#include "../Base/ContextCommon.h"
#include "../RasterizerState.h"
#include "../BlendState.h"
#include "../DepthStencilState.h"
#include "../BaseGL/SyncObjects.h"
 
#include <map>
 
namespace Cogs
{
  struct TextureGLES30;
  struct BuffersGLES30;
  struct TexturesGLES30;
  struct EffectsGLES30;
  struct RenderTargetsGLES30;
  struct CapabilitiesGLES30;
 
  struct InputAssemblerStateGLES30 : public InputAssemblerStateCommon
  {
    BufferGLES30* currentVertexBuffers[kMaxVertexInputSlots];
    BufferGLES30* currentIndexBuffer = nullptr;
    size_t requiredVertexBuffers = 0;
    size_t indexBufferStride;
  };
 
  struct ContextGLES30 : ContextCommon
  {
    friend struct TexturesGLES30;
    friend struct BuffersGLES30;
 
    void initialize(BuffersGLES30 * buffers, TexturesGLES30 * textures, EffectsGLES30 * effects, RenderTargetsGLES30 * renderTargets, CapabilitiesGLES30* caps, GLSyncObjects* sync) {
      this->buffers = buffers;
      this->textures = textures;
      this->effects = effects;
      this->renderTargets = renderTargets;
      this->capabilities = caps;
      this->syncObjects = sync;
    }
 
    InputAssemblerStateCommon* getIAState() override { return nullptr; }
 
    EffectHandle getCurrentEffect() override { return currentEffect.handle; }
    IEffects* getEffects() override;
 
    void setDefaults();
    void clearCachedState() final;
 
    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 setEffect(EffectHandle handle) override;
    EffectHandle getEffect() { return currentEffect.handle; }
 
    void setTexture(const TextureBindingHandle textureBindingHandle, TextureViewHandle textureViewHandle) final;
    void setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle) final;
    void setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle) override;
    void setConstantBuffer(const ConstantBufferBindingHandle bufferBindingHandle, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size) 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 numVertexBuffers) override;
 
    void setIndexBuffer(IndexBufferHandle indexBufferHandle, uint32_t stride, uint32_t offset) override;
 
    void setVertexArrayObject(VertexArrayObjectHandle vertexArrayObject) override;
 
    void draw(PrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes) 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*/) {}
 
    //
    // Render target, texture and buffer manipulation.
    //
 
    void resolveResource(TextureHandle source, TextureHandle destination) 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 = nullptr) override;
    void * map(TextureHandle /*textureHandle*/, MapMode::EMapMode /*accessMode*/, uint32_t* /*rowPitch*/, uint32_t* /*depthPitch*/) override { return nullptr; }
 
    void unmap(BufferHandle bufferHandle) override;
    void unmap(TextureHandle) override {}
 
    void updateBuffer(BufferHandle bufferHandle, const void* data, size_t size) 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 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 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 copyResource(BufferHandle destinationHandle, BufferHandle sourceHandle) override;
    void copyResource(TextureHandle destinationHandle, TextureHandle sourceHandle) override;
 
    void reset() override;
 
 
  protected:
 
    // wrapper for glBindTexture that updates state. Slot=-1 means just recycle current slot.
    // Returns either a pointer to the bound texture or null
    TextureGLES30* bindTexture(TextureHandle texture, GLuint unit = GLuint(~0u));
    
    GLenum bindBuffer(OpenGLES30::BufferTarget target, GLuint buffer);
 
    // Wrapper for binding a buffer for transfer operations.
    // 
    // Here we usually use GL_COPY_(READ|WRITE)_BUFFER to avoid messing with the draw bind
    // points. However, WebGL does not allow a buffer ever bound to anything else than
    // GL_ELEMENT_ARRAY_BUFFER to be used as an index buffer, so we must use that as binding
    // target. And binding that target can mess with the current VAO if one is bound. So
    // we must unbind the VAO first in that case
    GLenum bindBufferCopy(OpenGLES30::BufferTarget target, BufferGLES30& buffer)
    {
      if (buffer.target == OpenGLES30::BufferTarget::ElementArrayBuffer) {
        unbindVAO();
        return bindBuffer(OpenGLES30::BufferTarget::ElementArrayBuffer, buffer.bufferId);
      }
      return bindBuffer(target, buffer.bufferId);
    }
 
    // Run through all binding points and release if bound
    void unbindBuffer(GLuint buffer);
 
    void unbindVAO();
 
  private:
    void setupVertexAttributes(size_t baseVertex);
 
    bool setupState();
    bool setupDraw(size_t baseVertex);
    bool setupIndexedDraw(GLenum& indexType, GLsizei& indexCount, const GLvoid*& indexOffset, const size_t startIndex, const size_t numIndices, const size_t baseVertex);
 
    BuffersGLES30* buffers = nullptr;
    TexturesGLES30* textures = nullptr;
    EffectsGLES30* effects = nullptr;
    RenderTargetsGLES30* renderTargets = nullptr;
    CapabilitiesGLES30* capabilities = nullptr;
    GLSyncObjects* syncObjects = nullptr;
 
    SamplerStateHandle defaultSamplerStateHandle = SamplerStateHandle::NoHandle;
  
    GLuint activeTexUnit = 0;
    struct {
      TextureHandle texture = TextureHandle::NoHandle;
      SamplerStateHandle sampler = SamplerStateHandle::NoHandle;
      GLenum target = GL_TEXTURE_2D;
    } texUnits[OpenGLES30::maxTexUnits];
 
    bool inRenderPass = false;
    RenderPassInfo renderPassInfo = {};
 
    RenderTargetHandle currentRenderTarget = RenderTargetHandle::NoHandle;
    DepthStencilHandle currentDepthStencilTarget = DepthStencilHandle::NoHandle;
 
    struct {
      GLuint buffer = 0;
    } bufferTargets[size_t(OpenGLES30::BufferTarget::Count)];
 
    // Empty uniform buffer at block index 0 so that unused
    // but defined uniform buffers have an index that passes
    // validation. Bound in setDefaults.
    BufferHandle emptyUniformBuffer = BufferHandle::NoHandle;
 
    struct {
      GLuint buffer = 0;
      GLuint offset = 0;
      GLuint size = 0;
    } uniformBufferTargets[size_t(OpenGLES30::maxUniformBuffers)];
 
    struct {
      struct {
        VertexBufferHandle handle = VertexBufferHandle::NoHandle;
        uint32_t stride = 0;
        uint32_t offset = 0;
      } currItems[OpenGLES30::maxVertexAttributes];
      uint32_t baseVertex = 0;                            // baseVertex is the vertex that corresponds to index 0.
      uint32_t count = 0;
    } vertexBuffers;
 
    struct {
      InputLayoutHandle prevHandle = InputLayoutHandle::NoHandle;
      InputLayoutHandle currHandle = InputLayoutHandle::NoHandle;
    } inputLayout;
 
    struct {
      IndexBufferHandle handle = IndexBufferHandle::NoHandle;
      uint32_t stride = 0;
      uint32_t offset = 0;
      //uint32_t count = 0;
      //GLenum type = 0;
    } indexBuffer;
 
    struct {
      VertexArrayObjectHandle prevHandle = VertexArrayObjectHandle::NoHandle;
      VertexArrayObjectHandle currHandle = VertexArrayObjectHandle::NoHandle;
      GLenum indexType = GL_INVALID_ENUM;
      GLsizei indexCount = 0;
      GLsizei indexStride = 0;
    } vertexArrayObject;
 
    struct {
      EffectHandle handle = EffectHandle::NoHandle;
      EffectGLES30* ptr = nullptr;
    } currentEffect;
    uint32_t currentAttributeMask = 0;
 
    RasterizerState currentRasterizerState = RasterizerState::DefaultState();
 
    struct {
      BlendStateHandle handle = BlendStateHandle::NoHandle;
      float constant[4] = {};
      BlendStateGLES30 state;
    } currBlendState;
 
    struct {
      BlendStateHandle handle = BlendStateHandle::NoHandle;
      float constant[4] = {};
    } nextBlendState;
 
    DepthStencilState currentDepthStencilState = DepthStencilState::DefaultState();
 
    bool needVertexAttributeSetup = true;
  };
}