resourcemanager.cc

Go to the documentation of this file.

#include "ion/gfx/resourcemanager.h"

#include <algorithm>
#include <memory>

#include "base/integral_types.h"
#include "ion/base/scopedallocation.h"
#include "ion/base/stringutils.h"
#include "ion/gfx/attributearray.h"
#include "ion/gfx/bufferobject.h"
#include "ion/gfx/framebufferobject.h"
#include "ion/gfx/graphicsmanager.h"
#include "ion/gfx/sampler.h"
#include "ion/gfx/shader.h"
#include "ion/gfx/shaderprogram.h"
#include "ion/gfx/texture.h"
#include "ion/math/matrixutils.h"

namespace ion {
namespace gfx {

namespace {



static void FillArrayInfo(const GraphicsManagerPtr& gm,
                          ResourceManager::ArrayInfo* info) {
  GLint attrib_count;
  gm->GetIntegerv(GL_MAX_VERTEX_ATTRIBS, &attrib_count);
  info->attributes.resize(attrib_count);
  GLint boolean_value = GL_FALSE;
  for (GLint i = 0; i < attrib_count; ++i) {
    gm->GetVertexAttribiv(
        static_cast<GLuint>(i), GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
        reinterpret_cast<GLint*>(&info->attributes[i].buffer));
    gm->GetVertexAttribiv(
        static_cast<GLuint>(i), GL_VERTEX_ATTRIB_ARRAY_ENABLED, &boolean_value);
    info->attributes[i].enabled = static_cast<GLboolean>(boolean_value);
    gm->GetVertexAttribiv(
        static_cast<GLuint>(i), GL_VERTEX_ATTRIB_ARRAY_SIZE,
        reinterpret_cast<GLint*>(&info->attributes[i].size));
    gm->GetVertexAttribiv(
        static_cast<GLuint>(i), GL_VERTEX_ATTRIB_ARRAY_STRIDE,
        reinterpret_cast<GLint*>(&info->attributes[i].stride));
    gm->GetVertexAttribiv(
        static_cast<GLuint>(i), GL_VERTEX_ATTRIB_ARRAY_TYPE,
        reinterpret_cast<GLint*>(&info->attributes[i].type));
    gm->GetVertexAttribiv(
        static_cast<GLuint>(i), GL_VERTEX_ATTRIB_ARRAY_NORMALIZED,
        &boolean_value);
    info->attributes[i].normalized = static_cast<GLboolean>(boolean_value);
    gm->GetVertexAttribfv(
        static_cast<GLuint>(i), GL_CURRENT_VERTEX_ATTRIB,
        &info->attributes[i].value[0]);
    gm->GetVertexAttribPointerv(
        static_cast<GLuint>(i), GL_VERTEX_ATTRIB_ARRAY_POINTER,
        &info->attributes[i].pointer);
    if (gm->IsFunctionGroupAvailable(GraphicsManager::kInstancedDrawing)) {
      gm->GetVertexAttribiv(
          static_cast<GLuint>(i), GL_VERTEX_ATTRIB_ARRAY_DIVISOR,
          reinterpret_cast<GLint*>(&info->attributes[i].divisor));
    }
  }
}



static void FillBufferInfo(const GraphicsManagerPtr& gm,
                           ResourceManager::BufferInfo* info) {
  GLint size = 0;
  gm->GetBufferParameteriv(info->target, GL_BUFFER_SIZE, &size);
  info->size = size;
  gm->GetBufferParameteriv(
      info->target, GL_BUFFER_USAGE, reinterpret_cast<GLint*>(&info->usage));
  if (gm->IsFunctionGroupAvailable(GraphicsManager::kMapBufferBase)) {
    void* data = NULL;
    gm->GetBufferPointerv(info->target, GL_BUFFER_MAP_POINTER, &data);
    info->mapped_data = data;
  }
}



static void FillFramebufferAttachmentInfo(
    const GraphicsManagerPtr& gm,
    ResourceManager::FramebufferInfo::Attachment* info,
    ResourceManager::RenderbufferInfo* rb_info,
    GLenum attachment) {
  gm->GetFramebufferAttachmentParameteriv(
      GL_FRAMEBUFFER, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
      reinterpret_cast<GLint*>(&info->type));

  if ((info->type == GL_RENDERBUFFER) && (rb_info->id == 0U)) {
    info->type = GL_NONE;
  }

  if (info->type != GL_NONE)
    gm->GetFramebufferAttachmentParameteriv(
        GL_FRAMEBUFFER, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
        reinterpret_cast<GLint*>(&info->value));
  if (info->type == GL_TEXTURE) {
    gm->GetFramebufferAttachmentParameteriv(
        GL_FRAMEBUFFER, attachment, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
        reinterpret_cast<GLint*>(&info->level));
    gm->GetFramebufferAttachmentParameteriv(
        GL_FRAMEBUFFER, attachment,
        GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE,
        reinterpret_cast<GLint*>(&info->cube_face));
  }

  if (info->type == GL_RENDERBUFFER) {
    gm->BindRenderbuffer(GL_RENDERBUFFER, rb_info->id);
    gm->GetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH,
                                   reinterpret_cast<GLint*>(&rb_info->width));
    gm->GetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT,
                                   reinterpret_cast<GLint*>(&rb_info->height));
    gm->GetRenderbufferParameteriv(
        GL_RENDERBUFFER, GL_RENDERBUFFER_INTERNAL_FORMAT,
        reinterpret_cast<GLint*>(&rb_info->internal_format));
    gm->GetRenderbufferParameteriv(
        GL_RENDERBUFFER, GL_RENDERBUFFER_RED_SIZE,
        reinterpret_cast<GLint*>(&rb_info->red_size));
    gm->GetRenderbufferParameteriv(
        GL_RENDERBUFFER, GL_RENDERBUFFER_GREEN_SIZE,
        reinterpret_cast<GLint*>(&rb_info->green_size));
    gm->GetRenderbufferParameteriv(
        GL_RENDERBUFFER, GL_RENDERBUFFER_BLUE_SIZE,
        reinterpret_cast<GLint*>(&rb_info->blue_size));
    gm->GetRenderbufferParameteriv(
        GL_RENDERBUFFER, GL_RENDERBUFFER_ALPHA_SIZE,
        reinterpret_cast<GLint*>(&rb_info->alpha_size));
    gm->GetRenderbufferParameteriv(
        GL_RENDERBUFFER, GL_RENDERBUFFER_DEPTH_SIZE,
        reinterpret_cast<GLint*>(&rb_info->depth_size));
    gm->GetRenderbufferParameteriv(
        GL_RENDERBUFFER, GL_RENDERBUFFER_STENCIL_SIZE,
        reinterpret_cast<GLint*>(&rb_info->stencil_size));
  }
}

static void FillFramebufferInfo(const GraphicsManagerPtr& gm,
                                ResourceManager::FramebufferInfo* info) {
  FillFramebufferAttachmentInfo(
      gm, &info->color0, &info->color0_renderbuffer, GL_COLOR_ATTACHMENT0);
  FillFramebufferAttachmentInfo(
      gm, &info->depth, &info->depth_renderbuffer, GL_DEPTH_ATTACHMENT);
  FillFramebufferAttachmentInfo(
      gm, &info->stencil, &info->stencil_renderbuffer, GL_STENCIL_ATTACHMENT);
}



static void FillSamplerInfo(const GraphicsManagerPtr& gm,
                           ResourceManager::SamplerInfo* info) {
  if (gm->IsFunctionGroupAvailable(GraphicsManager::kSamplerObjects)) {
    gm->GetSamplerParameteriv(info->id, GL_TEXTURE_COMPARE_FUNC,
                              reinterpret_cast<GLint*>(&info->compare_func));
    gm->GetSamplerParameteriv(info->id, GL_TEXTURE_COMPARE_MODE,
                              reinterpret_cast<GLint*>(&info->compare_mode));
    gm->GetSamplerParameterfv(
        info->id, GL_TEXTURE_MAX_ANISOTROPY_EXT,
        reinterpret_cast<GLfloat*>(&info->max_anisotropy));
    gm->GetSamplerParameteriv(info->id, GL_TEXTURE_MAG_FILTER,
                              reinterpret_cast<GLint*>(&info->mag_filter));
    gm->GetSamplerParameterfv(info->id, GL_TEXTURE_MAX_LOD,
                              reinterpret_cast<GLfloat*>(&info->max_lod));
    gm->GetSamplerParameteriv(info->id, GL_TEXTURE_MIN_FILTER,
                              reinterpret_cast<GLint*>(&info->min_filter));
    gm->GetSamplerParameterfv(info->id, GL_TEXTURE_MIN_LOD,
                              reinterpret_cast<GLfloat*>(&info->min_lod));
    gm->GetSamplerParameteriv(
        info->id, GL_TEXTURE_WRAP_R, reinterpret_cast<GLint*>(&info->wrap_r));
    gm->GetSamplerParameteriv(
        info->id, GL_TEXTURE_WRAP_S, reinterpret_cast<GLint*>(&info->wrap_s));
    gm->GetSamplerParameteriv(
        info->id, GL_TEXTURE_WRAP_T, reinterpret_cast<GLint*>(&info->wrap_t));
  }
}



static void FillShaderInfo(const GraphicsManagerPtr& gm,
                           ResourceManager::ShaderInfo* info) {
  GLint boolean_value = GL_FALSE;
  gm->GetShaderiv(
      info->id, GL_SHADER_TYPE, reinterpret_cast<GLint*>(&info->type));
  gm->GetShaderiv(info->id, GL_DELETE_STATUS, &boolean_value);
  info->delete_status = static_cast<GLboolean>(boolean_value);
  gm->GetShaderiv(info->id, GL_COMPILE_STATUS, &boolean_value);
  info->compile_status = static_cast<GLboolean>(boolean_value);

  GLint length = 0;
  gm->GetShaderiv(info->id, GL_SHADER_SOURCE_LENGTH, &length);
  length = std::max(1, length);
  {
    base::ScopedAllocation<char> buffer(base::kShortTerm, length);
    buffer.Get()[0] = 0;
    gm->GetShaderSource(info->id, length, &length, buffer.Get());
    info->source = buffer.Get();
  }

  length = 0;
  gm->GetShaderiv(info->id, GL_INFO_LOG_LENGTH, &length);
  length = std::max(1, length);
  {
    base::ScopedAllocation<char> buffer(base::kShortTerm, length);
    buffer.Get()[0] = 0;
    gm->GetShaderInfoLog(info->id, length, &length, buffer.Get());
    info->info_log = buffer.Get();
  }
}



template <typename T>
void FillShaderInputs(
    const GraphicsManagerPtr& gm, GLuint id, GLenum active_enum,
    GLenum length_enum,
    const std::function<void(GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*,
                             GLchar*)>& GetInput,
    const std::function<GLint(GLuint, const GLchar*)>& GetLocation,
    std::vector<T>* infos) {
  GLint count = 0;
  gm->GetProgramiv(id, active_enum, &count);
  infos->resize(count);
  if (count) {
    char name[2048];
    for (GLint i = 0; i < count; ++i) {
      GLsizei length = 0;
      name[0] = 0;
      GetInput(id, static_cast<GLuint>(i), 2047, &length, &(*infos)[i].size,
               &(*infos)[i].type, name);
      (*infos)[i].name = name;
      (*infos)[i].index = GetLocation(id, name);
      if ((*infos)[i].size > 1) {
        for (GLint j = 0; j < (*infos)[i].size; ++j) {
          std::ostringstream str;
          str << name << "[" << j << "]";
          const std::string array_name = str.str();
          (*infos)[i].array_indices.push_back(
              GetLocation(id, array_name.c_str()));
        }
      }
    }
  }
}

template <typename T>
static void FillUniformValue(T* values,
                             ResourceManager::ProgramInfo::Uniform* uniform,
                             const base::AllocatorPtr& allocator) {
  if (uniform->size > 1) {
    uniform->value.InitArray<T>(allocator, uniform->size);
    for (GLint i = 0; i < uniform->size; i++)
      uniform->value.SetValueAt(i, values[i]);
  } else {
    uniform->value.Set(values[0]);
  }
}

template <int Dimension, typename T>
static void FillUniformValue(math::Matrix<Dimension, T>* values,
                             ResourceManager::ProgramInfo::Uniform* uniform,
                             const base::AllocatorPtr& allocator) {
  if (uniform->size > 1) {
    uniform->value.InitArray<math::Matrix<Dimension, T>>(allocator,
                                                         uniform->size);
    for (GLint i = 0; i < uniform->size; i++)
      uniform->value.SetValueAt(i, math::Transpose(values[i]));
  } else {
    uniform->value.Set(math::Transpose(values[0]));
  }
}

template <typename T>
static void GetGlUniformValue(const GraphicsManagerPtr& gm, GLuint id,
                              GLuint stride,
                              ResourceManager::ProgramInfo::Uniform* uniform,
                              void (GraphicsManager::*Getv)(GLuint, GLint, T*),
                              T* gl_values) {
  if (uniform->size == 1) {
    ((*gm).*Getv)(id, uniform->index, gl_values);
  } else {
    uint8* ptr = reinterpret_cast<uint8*>(gl_values);
    for (GLint i = 0; i < uniform->size; ++i) {
      T* values = reinterpret_cast<T*>(&ptr[i * stride]);
      ((*gm).*Getv)(id, uniform->array_indices[i], values);
    }
  }
}

template <typename T>
static void FillFloatUniformValue(
    const GraphicsManagerPtr& gm, GLuint id,
    ResourceManager::ProgramInfo::Uniform* uniform, T* values,
    GLfloat* gl_values, const base::AllocatorPtr& allocator) {
  GetGlUniformValue(gm, id, sizeof(T), uniform, &GraphicsManager::GetUniformfv,
                    gl_values);
  FillUniformValue(values, uniform, allocator);
}

template <typename T>
static void FillIntUniformValue(const GraphicsManagerPtr& gm, GLuint id,
                                ResourceManager::ProgramInfo::Uniform* uniform,
                                T* values, GLint* gl_values,
                                const base::AllocatorPtr& allocator) {
  GetGlUniformValue(gm, id, sizeof(T), uniform, &GraphicsManager::GetUniformiv,
                    gl_values);
  FillUniformValue(values, uniform, allocator);
}

template <typename T>
static void FillUintUniformValue(const GraphicsManagerPtr& gm, GLuint id,
                                 ResourceManager::ProgramInfo::Uniform* uniform,
                                 T* values, GLuint* gl_values,
                                 const base::AllocatorPtr& allocator) {
  GetGlUniformValue(gm, id, sizeof(T), uniform, &GraphicsManager::GetUniformuiv,
                    gl_values);
  FillUniformValue(values, uniform, allocator);
}

static void FillUniformValues(
    const GraphicsManagerPtr& gm, GLuint id,
    std::vector<ResourceManager::ProgramInfo::Uniform>* uniforms) {
  base::AllocatorPtr allocator =
      base::AllocationManager::GetDefaultAllocatorForLifetime(
          base::kMediumTerm);
  const size_t count = uniforms->size();
  for (size_t i = 0; i < count; ++i) {
    ResourceManager::ProgramInfo::Uniform& u = (*uniforms)[i];
    switch (u.type) {
      case GL_FLOAT: {
        base::ScopedAllocation<float> value(allocator, u.size);
        FillFloatUniformValue<float>(gm, id, &u, value.Get(), value.Get(),
                                     allocator);
        break;
      }
      case GL_FLOAT_VEC2: {
        base::ScopedAllocation<math::Vector2f> value(allocator, u.size);
        FillFloatUniformValue<math::Vector2f>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0], allocator);
        break;
      }
      case GL_FLOAT_VEC3: {
        base::ScopedAllocation<math::Vector3f> value(allocator, u.size);
        FillFloatUniformValue<math::Vector3f>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0], allocator);
        break;
      }
      case GL_FLOAT_VEC4: {
        base::ScopedAllocation<math::Vector4f> value(allocator, u.size);
        FillFloatUniformValue<math::Vector4f>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0], allocator);
        break;
      }
      case GL_INT:
      case GL_INT_SAMPLER_1D:
      case GL_INT_SAMPLER_1D_ARRAY:
      case GL_INT_SAMPLER_2D:
      case GL_INT_SAMPLER_2D_ARRAY:
      case GL_INT_SAMPLER_3D:
      case GL_INT_SAMPLER_CUBE:
      case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
      case GL_SAMPLER_1D:
      case GL_SAMPLER_1D_ARRAY:
      case GL_SAMPLER_1D_ARRAY_SHADOW:
      case GL_SAMPLER_1D_SHADOW:
      case GL_SAMPLER_2D:
      case GL_SAMPLER_2D_ARRAY:
      case GL_SAMPLER_2D_ARRAY_SHADOW:
      case GL_SAMPLER_2D_MULTISAMPLE:
      case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
      case GL_SAMPLER_2D_SHADOW:
      case GL_SAMPLER_3D:
      case GL_SAMPLER_CUBE:
      case GL_SAMPLER_CUBE_MAP_ARRAY:
      case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
      case GL_SAMPLER_CUBE_SHADOW:
      case GL_SAMPLER_EXTERNAL_OES:
      case GL_UNSIGNED_INT_SAMPLER_1D:
      case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
      case GL_UNSIGNED_INT_SAMPLER_2D:
      case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
      case GL_UNSIGNED_INT_SAMPLER_3D:
      case GL_UNSIGNED_INT_SAMPLER_CUBE:
      case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: {
        base::ScopedAllocation<int> value(allocator, u.size);
        FillIntUniformValue<int>(gm, id, &u, value.Get(), value.Get(),
                                 allocator);
        break;
      }
      case GL_INT_VEC2: {
        base::ScopedAllocation<math::Vector2i> value(allocator, u.size);
        FillIntUniformValue<math::Vector2i>(gm, id, &u, value.Get(),
                                            &(*value.Get())[0], allocator);
        break;
      }
      case GL_INT_VEC3: {
        base::ScopedAllocation<math::Vector3i> value(allocator, u.size);
        FillIntUniformValue<math::Vector3i>(gm, id, &u, value.Get(),
                                            &(*value.Get())[0], allocator);
        break;
      }
      case GL_INT_VEC4: {
        base::ScopedAllocation<math::Vector4i> value(allocator, u.size);
        FillIntUniformValue<math::Vector4i>(gm, id, &u, value.Get(),
                                            &(*value.Get())[0], allocator);
        break;
      }
      case GL_UNSIGNED_INT: {
        base::ScopedAllocation<uint32> value(allocator, u.size);
        FillUintUniformValue<uint32>(gm, id, &u, value.Get(), value.Get(),
                                     allocator);
        break;
      }
      case GL_UNSIGNED_INT_VEC2: {
        base::ScopedAllocation<math::Vector2ui> value(allocator, u.size);
        FillUintUniformValue<math::Vector2ui>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0], allocator);
        break;
      }
      case GL_UNSIGNED_INT_VEC3: {
        base::ScopedAllocation<math::Vector3ui> value(allocator, u.size);
        FillUintUniformValue<math::Vector3ui>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0], allocator);
        break;
      }
      case GL_UNSIGNED_INT_VEC4: {
        base::ScopedAllocation<math::Vector4ui> value(allocator, u.size);
        FillUintUniformValue<math::Vector4ui>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0], allocator);
        break;
      }
      case GL_FLOAT_MAT2: {
        base::ScopedAllocation<math::Matrix2f> value(allocator, u.size);
        FillFloatUniformValue<math::Matrix2f>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0][0], allocator);
        break;
      }
      case GL_FLOAT_MAT3: {
        base::ScopedAllocation<math::Matrix3f> value(allocator, u.size);
        FillFloatUniformValue<math::Matrix3f>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0][0], allocator);
        break;
      }
      case GL_FLOAT_MAT4: {
        base::ScopedAllocation<math::Matrix4f> value(allocator, u.size);
        FillFloatUniformValue<math::Matrix4f>(gm, id, &u, value.Get(),
                                              &(*value.Get())[0][0], allocator);
        break;
      }
#if !defined(ION_COVERAGE)  // COV_NF_START
      default:
        break;
#endif  // COV_NF_END
    }
  }
}

static void FillProgramInfo(const GraphicsManagerPtr& gm,
                            ResourceManager::ProgramInfo* info) {
  using std::bind;
  using std::placeholders::_1;
  using std::placeholders::_2;
  using std::placeholders::_3;
  using std::placeholders::_4;
  using std::placeholders::_5;
  using std::placeholders::_6;
  using std::placeholders::_7;

  GLint boolean_value = GL_FALSE;
  gm->GetProgramiv(info->id, GL_DELETE_STATUS, &boolean_value);
  info->delete_status = static_cast<GLboolean>(boolean_value);
  gm->GetProgramiv(info->id, GL_LINK_STATUS, &boolean_value);
  info->link_status = static_cast<GLboolean>(boolean_value);
  gm->GetProgramiv(info->id, GL_VALIDATE_STATUS, &boolean_value);
  info->validate_status = static_cast<GLboolean>(boolean_value);

  GLint info_log_length = 0;
  gm->GetProgramiv(info->id, GL_INFO_LOG_LENGTH, &info_log_length);
  info_log_length = std::max(1, info_log_length);
  {
    base::ScopedAllocation<char> buffer(base::kShortTerm, info_log_length);
    buffer.Get()[0] = 0;
    gm->GetProgramInfoLog(
        info->id, info_log_length, &info_log_length, buffer.Get());
    info->info_log = buffer.Get();
  }
  info->info_log.resize(info_log_length);

  FillShaderInputs(
      gm, info->id, GL_ACTIVE_ATTRIBUTES, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
      bind(&GraphicsManager::GetActiveAttrib, gm.Get(),
           _1, _2, _3, _4, _5, _6, _7),
      bind(&GraphicsManager::GetAttribLocation, gm.Get(), _1, _2),
      &info->attributes);
  FillShaderInputs(
      gm, info->id, GL_ACTIVE_UNIFORMS, GL_ACTIVE_UNIFORM_MAX_LENGTH,
      bind(&GraphicsManager::GetActiveUniform, gm.Get(),
           _1, _2, _3, _4, _5, _6, _7),
      bind(&GraphicsManager::GetUniformLocation, gm.Get(), _1, _2),
      &info->uniforms);
  FillUniformValues(gm, info->id, &info->uniforms);
}



static void FillStringsAndVersions(const GraphicsManagerPtr& gm,
                                   ResourceManager::PlatformInfo* info) {
  info->renderer = reinterpret_cast<const char*>(gm->GetString(GL_RENDERER));
  info->vendor = reinterpret_cast<const char*>(gm->GetString(GL_VENDOR));
  info->version_string =
      reinterpret_cast<const char*>(gm->GetString(GL_VERSION));

  const size_t dot_pos = info->version_string.find('.');
  info->major_version = 0;
  info->minor_version = 0;
  info->glsl_version = 0;
  if (dot_pos != std::string::npos && dot_pos > 0 &&
      dot_pos < info->version_string.length() - 1) {
    info->major_version = info->version_string[dot_pos - 1] - '0';
    info->minor_version = info->version_string[dot_pos + 1] - '0';
  }
  const char* glsl_version_string =
      reinterpret_cast<const char*>(gm->GetString(GL_SHADING_LANGUAGE_VERSION));
  const std::vector<std::string> strings = base::SplitString(
      glsl_version_string, " ");
  const size_t count = strings.size();
  for (size_t i = 0; i < count; ++i) {
    size_t pos = strings[i].find(".");
    if (pos != std::string::npos) {
      const std::vector<std::string> numbers = base::SplitString(strings[i],
                                                                 ".");
      if (numbers.size() == 2)
        info->glsl_version = 100 * base::StringToInt32(numbers[0]) +
                             base::StringToInt32(numbers[1]);
    }
  }

  if (const char* extensions =
          reinterpret_cast<const char*>(gm->GetString(GL_EXTENSIONS))) {
    info->extensions = extensions;
  }
}

static void FillPlatformInfo(const GraphicsManagerPtr& gm,
                             ResourceManager::PlatformInfo* info) {
  gm->GetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, info->aliased_line_width_range);
  if (gm->GetGlApiStandard() == GraphicsManager::kDesktop &&
      gm->GetGlVersion() >= 30)
    gm->GetFloatv(GL_POINT_SIZE_RANGE, info->aliased_point_size_range);
  else
    gm->GetFloatv(GL_ALIASED_POINT_SIZE_RANGE, info->aliased_point_size_range);

  info->max_color_attachments = -1;
  gm->GetIntegerv(GL_MAX_COLOR_ATTACHMENTS,
                  &info->max_color_attachments);
  info->max_combined_texture_image_units = -1;
  gm->GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                  &info->max_combined_texture_image_units);
  info->max_combined_texture_image_units = -1;
  gm->GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                  &info->max_combined_texture_image_units);
  info->max_cube_map_texture_size = -1;
  gm->GetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE,
                  &info->max_cube_map_texture_size);
  info->max_draw_buffers = -1;
  gm->GetIntegerv(GL_MAX_DRAW_BUFFERS,
                  &info->max_draw_buffers);
  info->max_fragment_uniform_vectors = -1;
  gm->GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS,
                  &info->max_fragment_uniform_vectors);
  info->max_renderbuffer_size = -1;
  gm->GetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &info->max_renderbuffer_size);
  info->max_texture_image_units = -1;
  gm->GetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &info->max_texture_image_units);
  info->max_texture_size = -1;
  gm->GetIntegerv(GL_MAX_TEXTURE_SIZE, &info->max_texture_size);
  info->max_varying_vectors = -1;
  gm->GetIntegerv(GL_MAX_VARYING_VECTORS, &info->max_varying_vectors);
  info->max_vertex_attribs = -1;
  gm->GetIntegerv(GL_MAX_VERTEX_ATTRIBS, &info->max_vertex_attribs);
  info->max_vertex_texture_image_units = -1;
  gm->GetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,
                  &info->max_vertex_texture_image_units);
  info->max_vertex_uniform_vectors = -1;
  gm->GetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS,
                  &info->max_vertex_uniform_vectors);
  info->max_viewport_dims[0] = -1;
  info->max_viewport_dims[1] = -1;
  gm->GetIntegerv(GL_MAX_VIEWPORT_DIMS, info->max_viewport_dims);

  info->max_transform_feedback_buffers = -1;
  info->max_transform_feedback_interleaved_components = -1;
  info->max_transform_feedback_separate_attribs = -1;
  info->max_transform_feedback_separate_components = -1;
  info->transform_feedback_varying_max_length = -1;
  if (gm->IsFunctionGroupAvailable(GraphicsManager::kTransformFeedback)) {
    gm->GetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_BUFFERS,
                    &info->max_transform_feedback_buffers);
    gm->GetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
                    &info->max_transform_feedback_interleaved_components);
    gm->GetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
                    &info->max_transform_feedback_separate_attribs);
    gm->GetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,
                    &info->max_transform_feedback_separate_components);
    gm->GetIntegerv(GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH,
                    &info->transform_feedback_varying_max_length);
  }

  GLint count = 0;
  gm->GetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &count);
  info->compressed_texture_formats.resize(count);
  if (count)
    gm->GetIntegerv(
        GL_COMPRESSED_TEXTURE_FORMATS,
        reinterpret_cast<GLint*>(&info->compressed_texture_formats[0]));

  count = 0;
  gm->GetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &count);
  info->shader_binary_formats.resize(count);
  if (count)
    gm->GetIntegerv(
        GL_SHADER_BINARY_FORMATS,
        reinterpret_cast<GLint*>(&info->shader_binary_formats[0]));

  FillStringsAndVersions(gm, info);
}



static void FillTextureInfo(const GraphicsManagerPtr& gm,
                            ResourceManager::TextureInfo* info) {
  gm->ActiveTexture(info->unit);
  gm->GetTexParameterfv(info->target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                        reinterpret_cast<GLfloat*>(&info->max_anisotropy));
  gm->GetTexParameteriv(info->target, GL_TEXTURE_MAG_FILTER,
                        reinterpret_cast<GLint*>(&info->mag_filter));
  gm->GetTexParameteriv(info->target, GL_TEXTURE_MIN_FILTER,
                        reinterpret_cast<GLint*>(&info->min_filter));
  gm->GetTexParameteriv(info->target, GL_TEXTURE_WRAP_S,
                        reinterpret_cast<GLint*>(&info->wrap_s));
  gm->GetTexParameteriv(info->target, GL_TEXTURE_WRAP_T,
                        reinterpret_cast<GLint*>(&info->wrap_t));
  if (gm->GetGlVersion() > 20) {
    gm->GetIntegerv(GL_SAMPLER_BINDING,
                    reinterpret_cast<GLint*>(&info->sampler));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_BASE_LEVEL,
                          reinterpret_cast<GLint*>(&info->base_level));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_COMPARE_FUNC,
                          reinterpret_cast<GLint*>(&info->compare_func));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_COMPARE_MODE,
                          reinterpret_cast<GLint*>(&info->compare_mode));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_MAX_LEVEL,
                          reinterpret_cast<GLint*>(&info->max_level));
    gm->GetTexParameterfv(info->target, GL_TEXTURE_MAX_LOD,
                          reinterpret_cast<GLfloat*>(&info->max_lod));
    gm->GetTexParameterfv(info->target, GL_TEXTURE_MIN_LOD,
                          reinterpret_cast<GLfloat*>(&info->min_lod));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_SWIZZLE_R,
                          reinterpret_cast<GLint*>(&info->swizzle_r));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_SWIZZLE_G,
                          reinterpret_cast<GLint*>(&info->swizzle_g));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_SWIZZLE_B,
                          reinterpret_cast<GLint*>(&info->swizzle_b));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_SWIZZLE_A,
                          reinterpret_cast<GLint*>(&info->swizzle_a));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_WRAP_R,
                          reinterpret_cast<GLint*>(&info->wrap_r));
  }
  if (gm->IsFunctionGroupAvailable(GraphicsManager::kTextureMultisample)) {
    gm->GetTexParameteriv(info->target, GL_TEXTURE_SAMPLES,
                          reinterpret_cast<GLint*>(&info->samples));
    gm->GetTexParameteriv(info->target, GL_TEXTURE_FIXED_SAMPLE_LOCATIONS,
                          reinterpret_cast<GLint*>(
                              &info->fixed_sample_locations));
  }
}

}  // anonymous namespace

ResourceManager::ResourceManager(const GraphicsManagerPtr& gm)
    : graphics_manager_(gm) {
}

ResourceManager::~ResourceManager() {
}

template <> ION_API
std::vector<ResourceManager::ResourceRequest<AttributeArray,
                                             ResourceManager::ArrayInfo> >*
ResourceManager::GetResourceRequestVector<AttributeArray,
                                          ResourceManager::ArrayInfo>() {
  return &array_requests_;
}

template <> ION_API
std::vector<ResourceManager::ResourceRequest<BufferObject,
                                             ResourceManager::BufferInfo> >*
ResourceManager::GetResourceRequestVector<BufferObject,
                                          ResourceManager::BufferInfo>() {
  return &buffer_requests_;
}

template <> ION_API std::vector<
    ResourceManager::ResourceRequest<FramebufferObject,
                                     ResourceManager::FramebufferInfo> >*
ResourceManager::GetResourceRequestVector<FramebufferObject,
                                          ResourceManager::FramebufferInfo>() {
  return &framebuffer_requests_;
}

template <> ION_API
std::vector<ResourceManager::DataRequest<ResourceManager::PlatformInfo> >*
ResourceManager::GetDataRequestVector<ResourceManager::PlatformInfo>() {
  return &platform_requests_;
}

template <> ION_API
std::vector<ResourceManager::ResourceRequest<ShaderProgram,
                                             ResourceManager::ProgramInfo> >*
ResourceManager::GetResourceRequestVector<ShaderProgram,
                                          ResourceManager::ProgramInfo>() {
  return &program_requests_;
}

template <> ION_API std::vector<
    ResourceManager::ResourceRequest<Sampler, ResourceManager::SamplerInfo> >*
ResourceManager::GetResourceRequestVector<Sampler,
                                          ResourceManager::SamplerInfo>() {
  return &sampler_requests_;
}

template <> ION_API std::vector<
    ResourceManager::ResourceRequest<Shader, ResourceManager::ShaderInfo> >*
ResourceManager::GetResourceRequestVector<Shader,
                                          ResourceManager::ShaderInfo>() {
  return &shader_requests_;
}

template <> ION_API
std::vector<ResourceManager::ResourceRequest<TextureBase,
                                             ResourceManager::TextureInfo> >*
ResourceManager::GetResourceRequestVector<TextureBase,
                                          ResourceManager::TextureInfo>() {
  return &texture_requests_;
}

template <> ION_API
std::vector<ResourceManager::DataRequest<ResourceManager::TextureImageInfo> >*
ResourceManager::GetDataRequestVector<ResourceManager::TextureImageInfo>() {
  return &texture_image_requests_;
}

void ResourceManager::RequestPlatformInfo(
    const InfoCallback<PlatformInfo>::Type& callback) {
  base::LockGuard lock_guard(&this->request_mutex_);
  GetDataRequestVector<PlatformInfo>()->push_back(
      DataRequest<PlatformInfo>(0, callback));
}

void ResourceManager::RequestTextureImage(
    GLuint id, const InfoCallback<TextureImageInfo>::Type& callback) {
  GetDataRequestVector<TextureImageInfo>()->push_back(
      DataRequest<TextureImageInfo>(id, callback));
}

template <>
void ResourceManager::FillInfoFromOpenGL(ResourceManager::ArrayInfo* info) {
  FillArrayInfo(graphics_manager_, info);
}

template <>
void ResourceManager::FillInfoFromOpenGL(ResourceManager::BufferInfo* info) {
  FillBufferInfo(graphics_manager_, info);
}

template <>
void ResourceManager::FillInfoFromOpenGL(
    ResourceManager::FramebufferInfo* info) {
  FillFramebufferInfo(graphics_manager_, info);
}

template <>
void ResourceManager::FillInfoFromOpenGL(ResourceManager::ProgramInfo* info) {
  FillProgramInfo(graphics_manager_, info);
}

template <>
void ResourceManager::FillInfoFromOpenGL(ResourceManager::SamplerInfo* info) {
  FillSamplerInfo(graphics_manager_, info);
}

template <>
void ResourceManager::FillInfoFromOpenGL(ResourceManager::ShaderInfo* info) {
  FillShaderInfo(graphics_manager_, info);
}

template <>
void ResourceManager::FillInfoFromOpenGL(ResourceManager::PlatformInfo* info) {
  FillPlatformInfo(graphics_manager_, info);
}

template <>
void ResourceManager::FillInfoFromOpenGL(ResourceManager::TextureInfo* info) {
  FillTextureInfo(graphics_manager_, info);
}

template <> void ResourceManager::FillInfoFromOpenGL(
    ResourceManager::TextureImageInfo* info) {}

}  // namespace gfx
}  // namespace ion