renderer.h

Go to the documentation of this file.

#ifndef ION_GFX_RENDERER_H_
#define ION_GFX_RENDERER_H_

#include <bitset>
#include <memory>

#include "base/integral_types.h"
#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocunorderedmap.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/framebufferobject.h"
#include "ion/gfx/graphicsmanager.h"
#include "ion/gfx/image.h"
#include "ion/gfx/node.h"
#include "ion/gfx/resourcemanager.h"
#include "ion/gfx/shaderprogram.h"
#include "ion/gfx/statetable.h"
#include "ion/gfx/uniform.h"
#include "ion/math/range.h"

namespace ion {
namespace portgfx {
class Visual;
}  // namespace portgfx
namespace gfx {

class IndexBuffer;
class Shape;

class ION_API Renderer : public base::Referent {
 public:
  enum Flag {
    kProcessInfoRequests,
    kProcessReleases,

    kClearActiveTexture,  // Sets the active image unit to unit 0.
    kClearArrayBuffer,
    kClearCubemaps,  // Clears cubemaps from _all_ image units.
    kClearElementArrayBuffer,
    kClearFramebuffer,
    kClearSamplers,  // Clears samplers from _all_ image units.
    kClearShaderProgram,
    kClearTextures,  // Clears textures from _all_ image units.
    kClearVertexArray,

    kRestoreActiveTexture,
    kRestoreArrayBuffer,
    kRestoreElementArrayBuffer,
    kRestoreFramebuffer,
    kRestoreShaderProgram,
    kRestoreStateTable,
    kRestoreVertexArray,

    kSaveActiveTexture,
    kSaveArrayBuffer,
    kSaveElementArrayBuffer,
    kSaveFramebuffer,
    kSaveShaderProgram,
    kSaveStateTable,
    kSaveVertexArray,
  };
  static const int kNumFlags = kSaveVertexArray + 1;
  typedef std::bitset<kNumFlags> Flags;

  enum ResourceType {
    kAttributeArray,
    kBufferObject,
    kFramebufferObject,
    kSampler,
    kShaderInputRegistry,
    kShaderProgram,
    kShader,
    kTexture,
  };
  static const int kNumResourceTypes = kTexture + 1;

  enum BufferObjectDataMapMode {
    kReadOnly,
    kReadWrite,
    kWriteOnly
  };

  explicit Renderer(const GraphicsManagerPtr& gm);

  const Flags& GetFlags() const { return flags_; }
  void ClearFlag(Flag flag) { flags_.reset(flag); }
  void ClearFlags(const Flags& flags) { flags_ &= ~flags; }
  void SetFlag(Flag flag) { flags_.set(flag); }
  void SetFlags(const Flags& flags) { flags_ |= flags; }

  static const Flags& AllFlags();
  static const Flags& AllClearFlags();
  static const Flags& AllProcessFlags();
  static const Flags& AllRestoreFlags();
  static const Flags& AllSaveFlags();

  const GraphicsManagerPtr& GetGraphicsManager() const;

  gfx::ResourceManager* GetResourceManager() const;

  void BindFramebuffer(const FramebufferObjectPtr& fbo);

  const FramebufferObjectPtr GetCurrentFramebuffer() const;

  template <typename T>
  void BindResource(T* holder);

  template <typename T>
  void CreateOrUpdateResource(T* holder);
  void CreateOrUpdateResources(const NodePtr& node);
  void CreateOrUpdateShapeResources(const ShapePtr& shape);

  template <typename T>
  void RequestForcedUpdate(T* holder);
  void RequestForcedUpdates(const NodePtr& node);
  void RequestForcedShapeUpdates(const ShapePtr& shape);

  void ProcessStateTable(const StateTablePtr& state_table);

  template <typename T>
  void CreateResourceWithExternallyManagedId(T* holder, uint32 gl_id);

  void SetInitialUniformValue(const Uniform& u);

  void ResolveMultisampleFramebuffer(const FramebufferObjectPtr& ms_fbo,
                                     const FramebufferObjectPtr& dest_fbo);

  virtual void DrawScene(const NodePtr& node);
  void ProcessResourceInfoRequests();

  template <typename T>
  uint32 GetResourceGlId(T* holder);

  void SetTextureImageUnitRange(const math::Range1i& units);

  void MapBufferObjectData(const BufferObjectPtr& buffer,
                           BufferObjectDataMapMode mode);
  void MapBufferObjectDataRange(const BufferObjectPtr& buffer,
                                BufferObjectDataMapMode mode,
                                const math::Range1ui& range);
  void UnmapBufferObjectData(const BufferObjectPtr& buffer);

  const ShaderProgramPtr& GetDefaultShaderProgram() const {
    return default_shader_;
  }

  void UpdateStateFromOpenGL(int window_width, int window_height);

  void UpdateStateFromStateTable(const StateTablePtr& state_to_clear);

  const StateTable& GetStateTable() const;

  void UpdateDefaultFramebufferFromOpenGL();

  void ClearCachedBindings();

  const ImagePtr ReadImage(const math::Range2i& range, Image::Format format,
                           const base::AllocatorPtr& allocator);

  void PushDebugMarker(const std::string& marker);
  void PopDebugMarker();

  template <typename HolderType>
  void ClearResources(const HolderType* holder);

  void ClearAllResources();

  void ReleaseResources();

  void ClearTypedResources(ResourceType type);

  static void DestroyStateCache(const portgfx::Visual* visual);

  static void DestroyCurrentStateCache();

  size_t GetGpuMemoryUsage(ResourceType type) const;

 protected:
  ~Renderer() override;

 private:
  template <int NumModifiedBits> class Resource;
  class BufferResource;
  class FramebufferResource;
  class ResourceBinder;
  class ResourceManager;
  class SamplerResource;
  class ScopedLabel;
  class ShaderInputRegistryResource;
  class ShaderProgramResource;
  class ShaderResource;
  class TextureResource;
  class VertexArrayResource;
  class VertexArrayEmulatorResource;

  template <typename T>
  struct HolderToResource;

  typedef base::AllocUnorderedMap<size_t, std::shared_ptr<ResourceBinder> >
      ResourceBinderMap;
  static ResourceBinderMap& GetResourceBinderMap();
  ResourceBinder* GetOrCreateInternalResourceBinder(int line) const;
  ResourceBinder* GetInternalResourceBinder(size_t* visual_id) const;

  static const ShaderProgramPtr CreateDefaultShaderProgram(
      const base::AllocatorPtr& allocator);
  static void SetResourceHolderBit(const ResourceHolder* holder, int bit);

  Flags flags_;

  std::unique_ptr<ResourceManager> resource_manager_;

  ShaderProgramPtr default_shader_;
};

typedef base::ReferentPtr<Renderer>::Type RendererPtr;

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_RENDERER_H_