renderutils.cc

Go to the documentation of this file.

#include "ion/image/renderutils.h"

#include <string>

#include "base/integral_types.h"
#include "ion/base/allocationmanager.h"
#include "ion/base/datacontainer.h"
#include "ion/gfx/framebufferobject.h"
#include "ion/gfx/node.h"
#include "ion/gfx/sampler.h"
#include "ion/gfx/shader.h"
#include "ion/gfx/shaderinputregistry.h"
#include "ion/gfx/shaderprogram.h"
#include "ion/gfx/shape.h"
#include "ion/gfx/statetable.h"
#include "ion/gfx/texture.h"
#include "ion/gfxutils/shapeutils.h"
#include "ion/math/range.h"
#include "ion/math/vector.h"

namespace ion {
namespace image {

namespace {




static const char kVertexShaderString[] =
    "attribute vec3 aVertex;\n"
    "attribute vec2 aTexCoords;\n"
    "varying vec2 vTextureCoords;\n"
    "\n"
    "void main(void) {\n"
    "  vTextureCoords = aTexCoords;\n"
    "  gl_Position = vec4(aVertex, 1.);\n"
    "}\n";

static const char kTextureFragmentShaderString[] =
    "#ifdef GL_ES\n"
    "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
    "precision highp float;\n"
    "#else\n"
    "precision mediump float;\n"
    "#endif\n"
    "#endif\n"
    "\n"
    "uniform sampler2D uTexture;\n"
    "varying vec2 vTextureCoords;\n"
    "\n"
    "void main(void) {\n"
    "  gl_FragColor = texture2D(uTexture, vTextureCoords);\n"
    "}\n";

static const char kCubeMapFragmentShaderString[] =
    "#ifdef GL_ES\n"
    "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
    "precision highp float;\n"
    "#else\n"
    "precision mediump float;\n"
    "#endif\n"
    "#endif\n"
    "\n"
    "uniform int uCubeMapFace;\n"
    "uniform samplerCube uCubeMap;\n"
    "varying vec2 vTextureCoords;\n"
    "\n"
    "void main(void) {\n"
    "  /* Put coords in range (-1, 1). */\n"
    "  float s = -1. + 2. * vTextureCoords.s;\n"
    "  float t = -1. + 2. * vTextureCoords.t;\n"
    "  vec3 tc;\n"
    "  if (uCubeMapFace == 0) {         /* Left   */\n"
    "    tc = vec3(-1., t, s);\n"
    "  } else if (uCubeMapFace == 1) {  /* Bottom */\n"
    "    tc = vec3(s, -1., t);\n"
    "  } else if (uCubeMapFace == 2) {  /* Back   */\n"
    "    tc = vec3(s, -t, -1.);\n"
    "  } else if (uCubeMapFace == 3) {  /* Right  */\n"
    "    tc = vec3(1., t, -s);\n"
    "  } else if (uCubeMapFace == 4) {  /* Top    */\n"
    "    tc = vec3(s, 1., -t);\n"
    "  } else                        {  /* Front  */\n"
    "    tc = vec3(s, t, 1.);\n"
    "  }\n"
    "  gl_FragColor = textureCube(uCubeMap, tc);\n"
    "}\n";




static const base::AllocatorPtr& GetShortTermAllocator(
    const base::AllocatorPtr& allocator) {
  return allocator.Get() ?
      allocator->GetAllocatorForLifetime(base::kShortTerm) :
      base::AllocationManager::GetDefaultAllocatorForLifetime(
          base::kShortTerm);
}

static const gfx::ShaderInputRegistryPtr BuildRegistry(
    bool is_cubemap, const base::AllocatorPtr& allocator) {
  gfx::ShaderInputRegistryPtr reg(new(allocator) gfx::ShaderInputRegistry);
  reg->IncludeGlobalRegistry();
  if (is_cubemap) {
    reg->Add(gfx::ShaderInputRegistry::UniformSpec(
        "uCubeMap", gfx::kCubeMapTextureUniform, "CubeMapTexture"));
    reg->Add(gfx::ShaderInputRegistry::UniformSpec(
        "uCubeMapFace", gfx::kIntUniform, "Face of cubemap"));
  } else {
    reg->Add(gfx::ShaderInputRegistry::UniformSpec(
        "uTexture", gfx::kTextureUniform, "Texture"));
  }
  return reg;
}

static const gfx::NodePtr BuildNode(
    const gfx::TexturePtr& texture,
    const gfx::CubeMapTexturePtr& cubemap, int face,
    const math::Vector2i& viewport_size, const base::AllocatorPtr& allocator) {
  gfx::NodePtr node(new(allocator) gfx::Node);

  const bool is_cubemap = cubemap.Get();

  gfx::StateTablePtr state_table(
      new(allocator) gfx::StateTable(viewport_size[0], viewport_size[1]));
  state_table->SetViewport(
      math::Range2i::BuildWithSize(math::Point2i::Zero(), viewport_size));
  node->SetStateTable(state_table);

  gfxutils::RectangleSpec rect_spec;
  rect_spec.allocator = allocator;
  rect_spec.size.Set(2.f, 2.f);  // -1 to +1.
  rect_spec.vertex_type = gfxutils::ShapeSpec::kPositionTexCoords;
  gfx::ShapePtr rect_shape = gfxutils::BuildRectangleShape(rect_spec);
  node->AddShape(rect_shape);

  gfx::ShaderInputRegistryPtr reg = BuildRegistry(is_cubemap, allocator);
  node->SetShaderProgram(
      gfx::ShaderProgram::BuildFromStrings(
      "Ion image renderutils", reg, kVertexShaderString,
      is_cubemap ? kCubeMapFragmentShaderString : kTextureFragmentShaderString,
      allocator));

  if (is_cubemap) {
    node->AddUniform(reg->Create<gfx::Uniform>("uCubeMap", cubemap));
    node->AddUniform(reg->Create<gfx::Uniform>("uCubeMapFace",
                                               static_cast<int>(face)));
  } else {
    node->AddUniform(reg->Create<gfx::Uniform>("uTexture", texture));
  }

  return node;
}

static const gfx::ImagePtr RenderToImage(
    const gfx::RendererPtr& renderer, const gfx::NodePtr& node,
    const math::Vector2i& image_size, const base::AllocatorPtr& allocator) {
  DCHECK(renderer.Get());
  DCHECK(node.Get());
  DCHECK_GT(image_size[0], 0);
  DCHECK_GT(image_size[1], 0);

  DCHECK(renderer->GetGraphicsManager().Get());
  const gfx::GraphicsManager& gm = *renderer->GetGraphicsManager();
  const gfx::Image::Format target_format =
      (gm.GetGlApiStandard() == gfx::GraphicsManager::kEs &&
       gm.GetGlVersion() == 20) ? gfx::Image::kRgb565Byte : gfx::Image::kRgb8;

  const base::AllocatorPtr& st_alloc = GetShortTermAllocator(allocator);
  const gfx::FramebufferObjectPtr fbo(
      new (st_alloc) gfx::FramebufferObject(image_size[0], image_size[1]));
  fbo->SetColorAttachment(0U,
                          gfx::FramebufferObject::Attachment(target_format));
  renderer->BindFramebuffer(fbo);
  renderer->DrawScene(node);

  gfx::ImagePtr image = renderer->ReadImage(
      math::Range2i::BuildWithSize(math::Point2i::Zero(), image_size),
      gfx::Image::kRgb888, allocator);

  renderer->BindFramebuffer(gfx::FramebufferObjectPtr());

  return image;
}

static const gfx::ImagePtr RenderTextureOrCubeMapTextureToImage(
    const gfx::TexturePtr& texture,
    const gfx::CubeMapTexturePtr& cubemap, gfx::CubeMapTexture::CubeFace face,
    const math::Vector2i& size, const gfx::RendererPtr& renderer,
    const base::AllocatorPtr& allocator) {
  gfx::ImagePtr output_image;
  if ((texture.Get() || cubemap.Get()) &&
      renderer.Get() && size[0] && size[1]) {
    gfx::NodePtr node = BuildNode(texture, cubemap, face, size,
                                  GetShortTermAllocator(allocator));
    output_image = RenderToImage(renderer, node, size, allocator);
  }
  return output_image;
}

}  // anonymous namespace




const gfx::ImagePtr RenderTextureImage(
    const gfx::TexturePtr& texture, uint32 width, uint32 height,
    const gfx::RendererPtr& renderer, const base::AllocatorPtr& allocator) {
  return RenderTextureOrCubeMapTextureToImage(
      texture, gfx::CubeMapTexturePtr(), gfx::CubeMapTexture::kNegativeX,
      math::Vector2i(width, height), renderer, allocator);
}

const gfx::ImagePtr RenderCubeMapTextureFaceImage(
    const gfx::CubeMapTexturePtr& cubemap, gfx::CubeMapTexture::CubeFace face,
    uint32 width, uint32 height,
    const gfx::RendererPtr& renderer, const base::AllocatorPtr& allocator) {
  return RenderTextureOrCubeMapTextureToImage(
      gfx::TexturePtr(), cubemap, face,
      math::Vector2i(width, height), renderer, allocator);
}

}  // namespace image
}  // namespace ion