EffectsGL20.h

#pragma once
 
#include "../Base/EffectsCommon.h"
 
#include "AttributesGL20.h"
 
namespace Cogs 
{
  class GraphicsDeviceGL20;
  struct CapabilitiesGL20;
 
  struct AtomicCounterVariableGL20
  {
    std::string name;
    GLuint uniformIndex;
    GLint bufferIndex;
    GLint bufferOffset;
  };
 
  struct AtomicCounterBufferGL20
  {
    GLint binding = -1;
    GLint dataSize = 0;
    BufferHandle backingBuffer;
  };
 
  struct SamplerMapGL20
  {
    EffectHandle effectHandle;
    size_t name = (size_t)-1;
  };
 
  struct ShaderSource
  {
    std::string shaderSource;
 
    std::string vsSource;
    std::string gsSource;
    std::string psSource;
  };
 
  struct EffectGL20 : public Effect
  {
    GLuint programId;
 
    unsigned char attributeMap[MaxVertexAttributesGL20];
 
    unsigned unitsInUse = 0;
    std::unordered_map<size_t, std::pair<uint32_t, uint32_t>> samplers;
    std::unordered_map<size_t, uint32_t> textures;
    std::unordered_map<size_t, std::vector<size_t>> real_sampler;
    std::unordered_map<size_t, SamplerMapGL20*> sampler_map;
 
    std::vector<AtomicCounterVariableGL20> atomicCounterVariables;
    std::vector<AtomicCounterBufferGL20> atomicCounterBuffers;
  };
 
  struct EffectsGL20 : EffectsCommon
  {
    void initialize(GraphicsDeviceGL20* device, CapabilitiesGL20 * capabilities, IBuffers * buffers);
 
    EffectHandle loadComputeEffect(const StringView & fileName, EffectFlags::EEffectFlags effectFlags) override;
    EffectHandle loadComputeEffect(const StringView & fileName, const PreprocessorDefinitions & definitions, EffectFlags::EEffectFlags effectFlags) override;
 
    void releaseEffect(EffectHandle handle) override;
    void releaseShader(ShaderHandle shaderHandle);
 
    ConstantBufferBindingHandle getConstantBufferBinding(EffectHandle effectHandle, const StringView & name) override;
    TextureBindingHandle getTextureBinding(EffectHandle effectHandle, const StringView & name, const unsigned int slot) override;
    SamplerStateBindingHandle getSamplerStateBinding(EffectHandle effectHandle, const StringView & name, const unsigned int slot) override;
 
    void releaseResources() override;
 
    void annotate(EffectHandle handle, const StringView & name) override;
    void annotateVS(EffectHandle handle, const StringView & name) override;
    void annotateGS(EffectHandle handle, const StringView & name) override;
    void annotatePS(EffectHandle handle, const StringView & name) override;
    void annotateCS(EffectHandle handle, const StringView & name) override;
 
    BufferBindingHandle getBufferBinding(EffectHandle effectHandle, const StringView & name) override;
    void releaseBufferBinding(BufferBindingHandle bufferBindingHandle) override;
 
    EffectHandle load(const ProcessedContent & vsSource,
                      const ProcessedContent & hsSource,
                      const ProcessedContent & dsSource,
                      const ProcessedContent & gsSource,
                      const ProcessedContent & psSource,
                      const StringView & vsEntryPoint,
                      const StringView & hsEntryPoint,
                      const StringView & dsEntryPoint,
                      const StringView & gsEntryPoint,
                      const StringView & psEntryPoint,
                      const EffectDescription & desc) override;
  private:
    ShaderHandle loadShader(GLenum shaderType, const char * pSource, EffectFlags::EEffectFlags effectFlags, PreprocessorDefinitions definitions = PreprocessorDefinitions());
    EffectHandle loadProgram(ShaderHandle vsHandle, ShaderHandle hsHandle, ShaderHandle dsHandle, ShaderHandle gsHandle, ShaderHandle psHandle, EffectFlags::EEffectFlags effectFlags, bool hlsl = false);
 
    CapabilitiesGL20 * capabilities = nullptr;
  public:
    ResourceMap<EffectHandle, EffectGL20> effects;
    ResourceMap<ShaderHandle, GLuint>     shaderIds;
    ResourceMap<BufferHandle, GLuint>     backingBuffers;
 
    AttributesGL20                        attributes;
    GraphicsDeviceGL20*                   graphicsDevice;
  };
}