resourcemanager.h

Go to the documentation of this file.

#ifndef ION_GFX_RESOURCEMANAGER_H_
#define ION_GFX_RESOURCEMANAGER_H_

#include <functional>
#include <string>
#include <vector>

#include "ion/base/allocatable.h"
#include "ion/base/lockguards.h"
#include "ion/base/referent.h"
#include "ion/gfx/image.h"
#include "ion/gfx/openglobjects.h"
#include "ion/port/mutex.h"

namespace ion {
namespace gfx {

class AttributeArray;
class BufferObject;
class FramebufferObject;
class GraphicsManager;
class Sampler;
class Shader;
class ShaderProgram;
class TextureBase;
typedef base::ReferentPtr<AttributeArray>::Type AttributeArrayPtr;
typedef base::ReferentPtr<BufferObject>::Type BufferObjectPtr;
typedef base::ReferentPtr<FramebufferObject>::Type FramebufferObjectPtr;
typedef base::ReferentPtr<GraphicsManager>::Type GraphicsManagerPtr;
typedef base::ReferentPtr<Sampler>::Type SamplerPtr;
typedef base::ReferentPtr<Shader>::Type ShaderPtr;
typedef base::ReferentPtr<ShaderProgram>::Type ShaderProgramPtr;
typedef base::ReferentPtr<TextureBase>::Type TextureBasePtr;

class ION_API ResourceManager : public base::Allocatable {
 public:


  struct ResourceInfo {
    ResourceInfo() : id(0) {}
    GLuint id;
    std::string label;
  };

  typedef gfx::ProgramInfo<ResourceInfo> ProgramInfo;
  typedef gfx::RenderbufferInfo<ResourceInfo> RenderbufferInfo;
  typedef gfx::SamplerInfo<ResourceInfo> SamplerInfo;
  typedef gfx::ShaderInfo<ResourceInfo> ShaderInfo;

  struct ArrayResourceInfo : ResourceInfo {
    size_t vertex_count;
  };
  struct BufferTargetInfo : ResourceInfo {
    GLuint target;
  };
  struct FramebufferResourceInfo : ResourceInfo {
    RenderbufferInfo color0_renderbuffer;
    RenderbufferInfo depth_renderbuffer;
    RenderbufferInfo stencil_renderbuffer;
  };
  struct TextureResourceInfo : ResourceInfo {
    GLenum unit;
    GLuint sampler;
    GLuint width;
    GLuint height;
    Image::Format format;
  };

  typedef gfx::ArrayInfo<ArrayResourceInfo> ArrayInfo;
  typedef gfx::BufferInfo<BufferTargetInfo> BufferInfo;
  typedef gfx::FramebufferInfo<FramebufferResourceInfo> FramebufferInfo;
  typedef gfx::TextureInfo<TextureResourceInfo> TextureInfo;

  struct PlatformInfo {
    PlatformInfo() : major_version(-1), minor_version(-1), glsl_version(-1) {}
    GLuint major_version;
    GLuint minor_version;
    GLuint glsl_version;

    GLfloat aliased_line_width_range[2];
    GLfloat aliased_point_size_range[2];

    GLint max_color_attachments;
    GLint max_combined_texture_image_units;
    GLint max_cube_map_texture_size;
    GLint max_draw_buffers;
    GLint max_fragment_uniform_vectors;
    GLint max_renderbuffer_size;
    GLint max_texture_image_units;
    GLint max_texture_size;
    GLint max_transform_feedback_buffers;
    GLint max_transform_feedback_interleaved_components;
    GLint max_transform_feedback_separate_attribs;
    GLint max_transform_feedback_separate_components;
    GLint max_varying_vectors;
    GLint max_vertex_attribs;
    GLint max_vertex_texture_image_units;
    GLint max_vertex_uniform_vectors;
    GLint max_viewport_dims[2];
    GLint transform_feedback_varying_max_length;

    std::vector<GLenum> compressed_texture_formats;
    std::vector<GLenum> shader_binary_formats;

    std::string extensions;
    std::string renderer;
    std::string vendor;
    std::string version_string;
  };

  struct TextureImageInfo {
    TextureImageInfo()
        : images(base::AllocationManager::GetDefaultAllocatorForLifetime(
              base::kMediumTerm)) {}
    TextureBasePtr texture;
    base::AllocVector<ImagePtr> images;
  };

  template <typename T> struct InfoCallback {
    typedef std::function<void(const std::vector<T>& infos)> Type;
  };



  const GraphicsManagerPtr& GetGraphicsManager() const {
    return graphics_manager_;
  }

  template <typename HolderType, typename InfoType>
  void RequestResourceInfo(
      const typename base::ReferentPtr<HolderType>::Type& holder,
      const typename InfoCallback<InfoType>::Type& callback) {
    if (holder.Get()) {
      base::LockGuard lock_guard(&this->request_mutex_);
      GetResourceRequestVector<HolderType, InfoType>()->push_back(
          ResourceRequest<HolderType, InfoType>(holder, callback));
    }
  }

  template <typename HolderType, typename InfoType>
  void RequestAllResourceInfos(
      const typename InfoCallback<InfoType>::Type& callback) {
    base::LockGuard lock_guard(&this->request_mutex_);
    GetResourceRequestVector<HolderType, InfoType>()->push_back(
        ResourceRequest<HolderType, InfoType>(
            typename base::ReferentPtr<HolderType>::Type(), callback));
  }

  void RequestPlatformInfo(const InfoCallback<PlatformInfo>::Type& callback);

  void RequestTextureImage(
      GLuint id, const InfoCallback<TextureImageInfo>::Type& callback);

 protected:
  template <typename InfoType>
  struct DataRequest {
    DataRequest(
        GLuint id_in,
        const typename InfoCallback<InfoType>::Type& callback_in)
        : id(id_in), callback(callback_in) {}
    GLuint id;
    typename InfoCallback<InfoType>::Type callback;
  };

  template <typename HolderType, typename InfoType>
  struct ResourceRequest {
    ResourceRequest(
        const typename base::ReferentPtr<HolderType>::Type& holder_in,
        const typename InfoCallback<InfoType>::Type& callback_in)
        : holder(holder_in), callback(callback_in) {}
    typename base::ReferentPtr<HolderType>::Type holder;
    typename InfoCallback<InfoType>::Type callback;
  };

  explicit ResourceManager(const GraphicsManagerPtr& gm);
  ~ResourceManager() override;

  template <typename HolderType, typename InfoType>
  std::vector<ResourceRequest<HolderType, InfoType> >*
      GetResourceRequestVector();

  template <typename InfoType>
  std::vector<DataRequest<InfoType> >* GetDataRequestVector();

  template <typename InfoType>
  void FillInfoFromOpenGL(InfoType* info);

  port::Mutex request_mutex_;

 private:
  GraphicsManagerPtr graphics_manager_;

  std::vector<ResourceRequest<AttributeArray, ArrayInfo> > array_requests_;
  std::vector<ResourceRequest<BufferObject, BufferInfo> > buffer_requests_;
  std::vector<ResourceRequest<FramebufferObject, FramebufferInfo> >
      framebuffer_requests_;
  std::vector<DataRequest<PlatformInfo> > platform_requests_;
  std::vector<ResourceRequest<ShaderProgram, ProgramInfo> >
      program_requests_;
  std::vector<ResourceRequest<Sampler, SamplerInfo> > sampler_requests_;
  std::vector<ResourceRequest<Shader, ShaderInfo> > shader_requests_;
  std::vector<DataRequest<TextureImageInfo> > texture_image_requests_;
  std::vector<ResourceRequest<TextureBase, TextureInfo> > texture_requests_;
};

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_RESOURCEMANAGER_H_