graphicsmanager.h

Go to the documentation of this file.

#ifndef ION_GFX_GRAPHICSMANAGER_H_
#define ION_GFX_GRAPHICSMANAGER_H_

#include <bitset>
#include <cstring>
#include <iostream>  // NOLINT
#include <memory>
#include <sstream>
#include <string>

#include "ion/base/logging.h"
#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocset.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/graphicsmanagermacrodefs.h"
#include "ion/gfx/statetable.h"
#include "ion/gfx/tracinghelper.h"
#include "ion/math/range.h"
#include "ion/portgfx/glheaders.h"

namespace ion {
namespace gfx {

class ION_API GraphicsManager : public base::Referent {
 public:
  struct ShaderPrecision {
    ShaderPrecision(const math::Range1i& range_in, const int precision_in)
        : range(range_in), precision(precision_in) {}
    bool IsValid() const {
      return (range != math::Range1i(0, 0)) || precision != 0;
    }
    inline bool operator==(const ShaderPrecision& other) const {
      return range == other.range && precision == other.precision;
    }
    math::Range1i range;
    int precision;
  };

  enum Capability {
    kAliasedLineWidthRange,                      // math::Range1f
    kAliasedPointSizeRange,                      // math::Range1f
    kCompressedTextureFormats,                   // std::vector<int>
    kImplementationColorReadFormat,              // int
    kImplementationColorReadType,                // int
    kMaxColorAttachments,                        // int
    kMaxCombinedTextureImageUnits,               // int
    kMaxCubeMapTextureSize,                      // int
    kMaxDrawBuffers,                             // int
    kMaxFragmentUniformComponents,               // int
    kMaxFragmentUniformVectors,                  // int
    kMaxRenderbufferSize,                        // int
    kMaxSampleMaskWords,                         // int
    kMaxTextureImageUnits,                       // int
    kMaxTextureMaxAnisotropy,                    // float
    kMaxTextureSize,                             // int
    kMaxTransformFeedbackBuffers,                // int
    kMaxTransformFeedbackInterleavedComponents,  // int
    kMaxTransformFeedbackSeparateAttribs,        // int
    kMaxTransformFeedbackSeparateComponents,     // int
    kMaxVaryingVectors,                          // int
    kMaxVertexAttribs,                           // int
    kMaxVertexTextureImageUnits,                 // int
    kMaxVertexUniformComponents,                 // int
    kMaxVertexUniformVectors,                    // int
    kMaxViewportDims,                            // math::Range1i
    kShaderBinaryFormats,                        // std::vector<int>
    kTransformFeedbackVaryingMaxLength,          // int
    kMaxDebugLoggedMessages,                     // int
    kMaxDebugMessageLength,                      // int
    kFragmentShaderHighFloatPrecisionFormat,
    kFragmentShaderHighIntPrecisionFormat,
    kFragmentShaderLowFloatPrecisionFormat,
    kFragmentShaderLowIntPrecisionFormat,
    kFragmentShaderMediumFloatPrecisionFormat,
    kFragmentShaderMediumIntPrecisionFormat,
    kVertexShaderHighFloatPrecisionFormat,
    kVertexShaderHighIntPrecisionFormat,
    kVertexShaderLowFloatPrecisionFormat,
    kVertexShaderLowIntPrecisionFormat,
    kVertexShaderMediumFloatPrecisionFormat,
    kVertexShaderMediumIntPrecisionFormat,
    kCapabilityCount,
  };

  enum FunctionGroupId {
    kCore,  // Core OpenGL ES2 functions.
    kDebugLabel,
    kDebugMarker,
    kDebugOutput,
    kChooseBuffer,
    kFramebufferBlit,
    kFramebufferMultisample,
    kMultisampleFramebufferResolve,
    kEglImage,
    kGetString,
    kGpuShader4,
    kMapBuffer,
    kMapBufferBase,
    kMapBufferRange,
    kCopyBufferSubData,
    kPointSize,
    kRaw,
    kSamplerObjects,
    kTexture3d,
    kTextureMultisample,
    kTextureStorage,
    kTextureStorageMultisample,
    kInstancedDrawing,
    kSync,
    kTransformFeedback,
    kVertexArrays,
    kNumFunctionGroupIds,
  };

  enum GlApi {
    kDesktop,
    kEs,
    kWeb,

    kNumApis
  };

  enum GlProfile {
    kCompatibilityProfile,
    kCoreProfile,
  };

 private:
  class FunctionGroup;

  class WrapperBase {
   public:
    WrapperBase(const char* func_name, FunctionGroupId group)
        : ptr_(NULL),
          func_name_(func_name),
          group_(group) {
      GraphicsManager::AddWrapper(this);
    }
    const char* GetFuncName() const { return func_name_; }
    bool Init(GraphicsManager* gm) {
      const std::string gl_name = "gl" + std::string(func_name_);
      ptr_ = gm->Lookup(gl_name.c_str(), group_ == kCore);
      gm->AddFunctionToGroup(group_, func_name_, ptr_);
      return ptr_ != NULL;
    }
    void Reset() { ptr_ = NULL; }

   protected:
    void* ptr_;

   private:
    const char* func_name_;
    FunctionGroupId group_;
  };

 public:
  GraphicsManager();

  template <typename T> const T GetCapabilityValue(Capability cap);

  bool IsFunctionAvailable(const std::string& function_name) const {
    return wrapped_function_names_.count(function_name) > 0;
  }

  bool IsFunctionGroupAvailable(FunctionGroupId group) const;

  void EnableFunctionGroup(FunctionGroupId group, bool enable);

  bool IsExtensionSupported(const std::string& name) const;

  void EnableErrorChecking(bool enable) { is_error_checking_enabled_ = enable; }
  bool IsErrorCheckingEnabled() const { return is_error_checking_enabled_; }

  void SetTracingStream(std::ostream* s) { tracing_ostream_ = s; }
  std::ostream* GetTracingStream() const { return tracing_ostream_; }

  void SetTracingPrefix(const std::string& s) { tracing_prefix_ = s; }
  const std::string& GetTracingPrefix() const { return tracing_prefix_; }

  GLuint GetGlVersion() const { return gl_version_; }
  const std::string& GetGlVersionString() const { return gl_version_string_; }
  const std::string& GetGlRenderer() const { return gl_renderer_; }
  GlApi GetGlApiStandard() const { return gl_api_standard_; }
  GlProfile GetGlProfileType() const { return gl_profile_type_; }

  bool IsValidStateTableCapability(const StateTable::Capability cap) const {
    return valid_statetable_caps_.test(cap);
  }

#include "ion/gfx/glfunctions.inc"

 public:
  static const char* ErrorString(GLenum error_code);

 protected:
  struct GlVersions {
    GlVersions(GLuint desktop, GLuint es, GLuint web) {
      versions[kDesktop] = desktop;
      versions[kEs] = es;
      versions[kWeb] = web;
    }
    GLuint operator[](GlApi i) const { return versions[i]; }
    GLuint versions[kNumApis];
  };

  explicit GraphicsManager(GraphicsManager* gm);

  ~GraphicsManager() override;

  void ReinitFunctions();

  void InitGlInfo();

  virtual void EnableFunctionGroupIfAvailable(
      FunctionGroupId group, const GlVersions& versions,
      const std::string& extensions, const std::string& disabled_renderers);

 private:
  typedef base::AllocVector<WrapperBase*> WrapperVec;
  typedef base::AllocVector<FunctionGroup> FunctionGroupVector;

  class WrapperVecHolder;

  class CapabilityHelper;

  class ErrorChecker {
   public:
    ErrorChecker(GraphicsManager* gm, const std::string& func_call)
        : graphics_manager_(gm),
          func_call_(func_call) {
      graphics_manager_->CheckForErrors("before", func_call_);
    }
    ~ErrorChecker() {
      graphics_manager_->CheckForErrors("after", func_call_);
    }
   private:
    GraphicsManager* graphics_manager_;
    const std::string func_call_;
  };

  static WrapperVecHolder* GetWrapperVecHolder();

  static void AddWrapper(WrapperBase* wrapper);

  void AddFunctionToGroup(
      FunctionGroupId group, const char* func_name, void* function);

  void Init(bool init_functions_from_gl);

  void InitFunctions();

  void AddWrappedFunctionName(const std::string& function_name) {
    wrapped_function_names_.insert(function_name);
  }

  void CheckForErrors(const char* when, const std::string& func_call);

  virtual void* Lookup(const char* name, bool is_core);

  WrapperVec wrappers_;

  FunctionGroupVector function_groups_;

  std::unique_ptr<CapabilityHelper> capability_helper_;

  base::AllocSet<std::string> wrapped_function_names_;

  std::string extensions_;

  bool is_error_checking_enabled_;

  std::ostream* tracing_ostream_;

  std::string tracing_prefix_;

  TracingHelper tracing_helper_;

  std::string gl_renderer_;

  std::string gl_version_string_;

  GLuint gl_version_;

  GlApi gl_api_standard_;

  GlProfile gl_profile_type_;

  std::bitset<StateTable::kNumCapabilities> valid_statetable_caps_;
};

typedef base::ReferentPtr<GraphicsManager>::Type GraphicsManagerPtr;

}  // namespace gfx
}  // namespace ion

#include "ion/gfx/graphicsmanagermacroundefs.h"

#endif  // ION_GFX_GRAPHICSMANAGER_H_