CommonGLES30.h

#pragma once
 
#include "../BaseGL/GLFuncPointers.h"
 
#ifdef __APPLE__
#include <OpenGLES/ES2/gl.h>
#endif
 
#ifdef __native_client__
#define nullptr NULL
#endif
 
#include <cassert>
#include <atomic>
 
#include "../Common.h"
#include "../Base/ResourceMap.h"
#include "../VertexFormat.h"
#include "../Flags.h"
 
#include <OsoMemoryProfiler/CogsMemoryProfile.h>
 
#include "../BlendState.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Memory/MemoryBuffer.h"
 
namespace Cogs
{
  namespace OpenGLES30 {
 
    // Typical WebGL limits
    constexpr size_t maxTexUnits = 32;
    constexpr size_t maxVertexAttributes = 32;
    constexpr size_t maxUniformBuffers = 32;
 
    enum struct BufferTarget : uint8_t
    {
      ArrayBuffer = 0,
      ElementArrayBuffer,
      UniformBuffer,
      PixelPackBuffer,
      CopyReadBuffer,
      CopyWriteBuffer,
      TransformFeedbackBuffer,
      Count
    };
 
    const char* framebuffersStatusString(GLenum status);
  }
 
  struct InputLayoutGLES30
  {
    const VertexFormat* formats[8] = {};
    size_t numFormats = 0;
  };
 
  struct BufferGLES30
  {
    BufferGLES30() : mappedData(MemBlockType::MMapBackingStore) {}
 
    Memory::MemoryBuffer mappedData;        
    union
    {
      GLenum indexType;                     
      const VertexFormat* vertexFormat;     
    };
    uint32_t size;                          
    GLuint bufferId;                        
    OpenGLES30::BufferTarget target;        
    uint32_t bindFlags = 0;                 
    struct {
      unsigned short keepMapBacking : 1;    
      unsigned short writeBackMap : 1;      
      unsigned short isMapped : 1;          
      unsigned short isIndexBuffer : 1;     
    };
  };
 
  struct VertexArrayObjectGLES30
  {
    GLuint glName = 0;
    GLenum indexType = GL_INVALID_ENUM;
    GLsizei indexCount = 0;
    GLsizei indexStride = 0;
  };
 
  struct EffectGLES30
  {
    struct SemanticSlot {
      uint8_t semantic;
      uint8_t slot;
    };
    struct TextureSlot {
      size_t nameHash;
    };
    struct UniformBlockBinding {
      size_t nameHash;
    };
 
    GLuint        programId;
    uint8_t       activeAttributes = 0;
    uint8_t       activeTextureUnits = 0;
    SemanticSlot  attributeSemantic[OpenGLES30::maxVertexAttributes];
    GLint         attributeLocation[OpenGLES30::maxVertexAttributes];
    TextureSlot   textureSlots[OpenGLES30::maxTexUnits];
    UniformBlockBinding uniformBlockBindings[OpenGLES30::maxUniformBuffers];
 
    uint32_t      readyAtFrame = 0;
  };
 
  struct BlendStateGLES30
  {
    struct {
      BlendState::Blend colorSrc = BlendState::Blend::One;
      BlendState::Blend colorDst = BlendState::Blend::Zero;
      BlendState::Blend alphaSrc = BlendState::Blend::One;
      BlendState::Blend alphaDst = BlendState::Blend::Zero;
    } blend;
    struct {
      BlendState::BlendOperation color = BlendState::BlendOperation::Add;
      BlendState::BlendOperation alpha = BlendState::BlendOperation::Add;
    } operation;
    uint8_t enabled : 1;
  };
}
 
#if defined COGS_OPENGL20 || defined COGS_OPENGLES30
extern const char* getErrorString(GLint errorCode);
extern void logGLString(const char* name, GLenum key);
extern void checkGLError(const char* operation);
 
#ifdef COGS_WGL
// Under WGL, we use GL_DEBUG_KHR for catching errors.
#define CHECKED(x) x
#else
#ifdef _DEBUG
#define CHECKED(x) x; checkGLError(#x);
#else
#define CHECKED(x) x
#endif
#endif
#endif