text: //
  // Copyright (c) 2008-2015 the Urho3D project.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a copy
  // of this software and associated documentation files (the "Software"), to deal
  // in the Software without restriction, including without limitation the rights
  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  // copies of the Software, and to permit persons to whom the Software is
  // furnished to do so, subject to the following conditions:
  //
  // The above copyright notice and this permission notice shall be included in
  // all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  // THE SOFTWARE.
  //
  
  #pragma once
  
  #include "../../Container/ArrayPtr.h"
  #include "../../Math/Color.h"
  #include "../../Graphics/GraphicsDefs.h"
  #include "../../Resource/Image.h"
  #include "../../Core/Mutex.h"
  #include "../../Core/Object.h"
  #include "../../Math/Plane.h"
  #include "../../Math/Rect.h"
  
  namespace Urho3D
  {
  
  class ConstantBuffer;
  class File;
  class Image;
  class IndexBuffer;
  class GPUObject;
  class GraphicsImpl;
  class RenderSurface;
  class Shader;
  class ShaderPrecache;
  class ShaderProgram;
  class ShaderVariation;
  class Texture;
  class Texture2D;
  class TextureCube;
  class Vector3;
  class Vector4;
  class VertexBuffer;
  
  typedef HashMap<Pair<ShaderVariation*, ShaderVariation*>, SharedPtr<ShaderProgram> > ShaderProgramMap;
  
  static const unsigned NUM_SCREEN_BUFFERS = 2;
  
  /// CPU-side scratch buffer for vertex data updates.
  struct ScratchBuffer
  {
      ScratchBuffer() :
          size_(0),
          reserved_(false)
      {
      }
      
      /// Buffer data.
      SharedArrayPtr<unsigned char> data_;
      /// Data size.
      unsigned size_;
      /// Reserved flag.
      bool reserved_;
  };
  
  /// %Graphics subsystem. Manages the application window, rendering state and GPU resources.
  class URHO3D_API Graphics : public Object
  {
      OBJECT(Graphics);
      
  public:
      /// Construct.
      Graphics(Context* context_);
      /// Destruct. Release the OpenGL context and close the window.
      virtual ~Graphics();
  
      /// Set external window handle. Only effective before setting the initial screen mode. On Windows it is necessary to set up OpenGL pixel format manually for the window.
      void SetExternalWindow(void* window);
      /// Set window icon.
      void SetWindowIcon(Image* windowIcon);
      /// Set window title.
      void SetWindowTitle(const String& windowTitle);
      /// Set window position.
      void SetWindowPosition(const IntVector2& position);
      /// Set window position.
      void SetWindowPosition(int x, int y);
      /// Set screen mode. Return true if successful.
      bool SetMode(int width, int height, bool fullscreen, bool borderless, bool resizable, bool vsync, bool tripleBuffer, int multiSample);
      /// Set screen resolution only. Return true if successful.
      bool SetMode(int width, int height);
      /// Set whether the main window uses sRGB conversion on write.
      void SetSRGB(bool enable);
      /// Set whether to flush the GPU command buffer to prevent multiple frames being queued and uneven frame timesteps. Not yet implemented on OpenGL.
      void SetFlushGPU(bool enable);
      /// Set forced use of OpenGL 2 even if OpenGL 3 is available. Must be called before setting the screen mode for the first time. Default false.
      void SetForceGL2(bool enable);
      /// Set allowed screen orientations as a space-separated list of "LandscapeLeft", "LandscapeRight", "Portrait" and "PortraitUpsideDown". Affects currently only iOS platform.
      void SetOrientations(const String& orientations);
      /// Toggle between full screen and windowed mode. Return true if successful.
      bool ToggleFullscreen();
      /// Close the window.
      void Close();
      /// Take a screenshot. Return true if successful.
      bool TakeScreenShot(Image& destImage);
      /// Begin frame rendering. Return true if device available and can render.
      bool BeginFrame();
      /// End frame rendering and swap buffers.
      void EndFrame();
      /// Clear any or all of rendertarget, depth buffer and stencil buffer.
      void Clear(unsigned flags, const Color& color = Color(0.0f, 0.0f, 0.0f, 0.0f), float depth = 1.0f, unsigned stencil = 0);
      /// Resolve multisampled backbuffer to a texture rendertarget. The texture's size should match the viewport size.
      bool ResolveToTexture(Texture2D* destination, const IntRect& viewport);
      /// Draw non-indexed geometry.
      void Draw(PrimitiveType type, unsigned vertexStart, unsigned vertexCount);
      /// Draw indexed geometry.
      void Draw(PrimitiveType type, unsigned indexStart, unsigned indexCount, unsigned minVertex, unsigned vertexCount);
      /// Draw indexed, instanced geometry.
      void DrawInstanced(PrimitiveType type, unsigned indexStart, unsigned indexCount, unsigned minVertex, unsigned vertexCount, unsigned instanceCount);
      /// Set vertex buffer.
      void SetVertexBuffer(VertexBuffer* buffer);
      /// Set multiple vertex buffers.
      bool SetVertexBuffers(const PODVector<VertexBuffer*>& buffers, const PODVector<unsigned>& elementMasks, unsigned instanceOffset = 0);
      /// Set multiple vertex buffers.
      bool SetVertexBuffers(const Vector<SharedPtr<VertexBuffer> >& buffers, const PODVector<unsigned>& elementMasks, unsigned instanceOffset = 0);
      /// Set index buffer.
      void SetIndexBuffer(IndexBuffer* buffer);
      /// Set shaders.
      void SetShaders(ShaderVariation* vs, ShaderVariation* ps);
      /// Set shader float constants.
      void SetShaderParameter(StringHash param, const float* data, unsigned count);
      /// Set shader float constant.
      void SetShaderParameter(StringHash param, float value);
      /// Set shader color constant.
      void SetShaderParameter(StringHash param, const Color& color);
      /// Set shader 2D vector constant.
      void SetShaderParameter(StringHash param, const Vector2& vector);
      /// Set shader 3x3 matrix constant.
      void SetShaderParameter(StringHash param, const Matrix3& matrix);
      /// Set shader 3D vector constant.
      void SetShaderParameter(StringHash param, const Vector3& vector);
      /// Set shader 4x4 matrix constant.
      void SetShaderParameter(StringHash param, const Matrix4& matrix);
      /// Set shader 4D vector constant.
      void SetShaderParameter(StringHash param, const Vector4& vector);
      /// Set shader 4x3 matrix constant.
      void SetShaderParameter(StringHash param, const Matrix3x4& matrix);
      /// Set shader constant from a variant. Supported variant types: bool, float, vector2, vector3, vector4, color.
      void SetShaderParameter(StringHash param, const Variant& value);
      /// Check whether a shader parameter group needs update. Does not actually check whether parameters exist in the shaders.
      bool NeedParameterUpdate(ShaderParameterGroup group, const void* source);
      /// Check whether a shader parameter exists on the currently set shaders.
      bool HasShaderParameter(StringHash param);
      /// Check whether the current pixel shader uses a texture unit.
      bool HasTextureUnit(TextureUnit unit);
      /// Clear remembered shader parameter source group.
      void ClearParameterSource(ShaderParameterGroup group);
      /// Clear remembered shader parameter sources.
      void ClearParameterSources();
      /// Clear remembered transform shader parameter sources.
      void ClearTransformSources();
      /// Set texture.
      void SetTexture(unsigned index, Texture* texture);
      /// Bind texture unit 0 for update. Called by Texture.
      void SetTextureForUpdate(Texture* texture);
      /// Set default texture filtering mode.
      void SetDefaultTextureFilterMode(TextureFilterMode mode);
      /// Set texture anisotropy.
      void SetTextureAnisotropy(unsigned level);
      /// Dirty texture parameters of all textures (when global settings change.)
      void SetTextureParametersDirty();
      /// Reset all rendertargets, depth-stencil surface and viewport.
      void ResetRenderTargets();
      /// Reset specific rendertarget.
      void ResetRenderTarget(unsigned index);
      /// Reset depth-stencil surface.
      void ResetDepthStencil();
      /// Set rendertarget.
      void SetRenderTarget(unsigned index, RenderSurface* renderTarget);
      /// Set rendertarget.
      void SetRenderTarget(unsigned index, Texture2D* texture);
      /// Set depth-stencil surface.
      void SetDepthStencil(RenderSurface* depthStencil);
      /// Set depth-stencil surface.
      void SetDepthStencil(Texture2D* texture);
      /// Set viewport.
      void SetViewport(const IntRect& rect);
      /// Set blending mode.
      void SetBlendMode(BlendMode mode);
      /// Set color write on/off.
      void SetColorWrite(bool enable);
      /// Set hardware culling mode.
      void SetCullMode(CullMode mode);
      /// Set depth bias.
      void SetDepthBias(float constantBias, float slopeScaledBias);
      /// Set depth compare.
      void SetDepthTest(CompareMode mode);
      /// Set depth write on/off.
      void SetDepthWrite(bool enable);
      /// Set polygon fill mode.
      void SetFillMode(FillMode mode);
      /// Set scissor test.
      void SetScissorTest(bool enable, const Rect& rect = Rect::FULL, bool borderInclusive = true);
      /// Set scissor test.
      void SetScissorTest(bool enable, const IntRect& rect);
      /// Set stencil test.
      void SetStencilTest(bool enable, CompareMode mode = CMP_ALWAYS, StencilOp pass = OP_KEEP, StencilOp fail = OP_KEEP, StencilOp zFail = OP_KEEP, unsigned stencilRef = 0, unsigned compareMask = M_MAX_UNSIGNED, unsigned writeMask = M_MAX_UNSIGNED);
      /// Set a custom clipping plane. The plane is specified in world space, but is dependent on the view and projection matrices.
      void SetClipPlane(bool enable, const Plane& clipPlane = Plane::UP, const Matrix3x4& view = Matrix3x4::IDENTITY, const Matrix4& projection = Matrix4::IDENTITY);
      /// Begin dumping shader variation names to an XML file for precaching.
      void BeginDumpShaders(const String& fileName);
      /// End dumping shader variations names.
      void EndDumpShaders();
      /// Precache shader variations from an XML file generated with BeginDumpShaders().
      void PrecacheShaders(Deserializer& source);
  
      /// Return whether rendering initialized.
      bool IsInitialized() const;
      /// Return graphics implementation, which holds the actual API-specific resources.
      GraphicsImpl* GetImpl() const { return impl_; }
      /// Return OS-specific external window handle. Null if not in use.
      void* GetExternalWindow() const { return externalWindow_; }
      /// Return window title.
      const String& GetWindowTitle() const { return windowTitle_; }
      /// Return graphics API name.
      const String& GetApiName() const { return apiName_; }
      /// Return window position.
      IntVector2 GetWindowPosition() const;
      /// Return window width.
      int GetWidth() const { return width_; }
      /// Return window height.
      int GetHeight() const { return height_; }
      /// Return multisample mode (1 = no multisampling.)
      int GetMultiSample() const { return multiSample_; }
      /// Return whether window is fullscreen.
      bool GetFullscreen() const { return fullscreen_; }
      /// Return whether window is borderless.
      bool GetBorderless() const { return borderless_; }
      /// Return whether window is resizable.
      bool GetResizable() const { return resizable_; }
      /// Return whether vertical sync is on.
      bool GetVSync() const { return vsync_; }
      /// Return whether triple buffering is enabled.
      bool GetTripleBuffer() const { return tripleBuffer_; }
      /// Return whether the main window is using sRGB conversion on write.
      bool GetSRGB() const { return sRGB_; }
      /// Return whether the GPU command buffer is flushed each frame. Not yet implemented on OpenGL.
      bool GetFlushGPU() const { return false; }
      /// Return whether OpenGL 2 use is forced.
      bool GetForceGL2() const { return forceGL2_; }
      /// Return allowed screen orientations.
      const String& GetOrientations() const { return orientations_; }
      /// Return whether device is lost, and can not yet render.
      bool IsDeviceLost() const;
      /// Return number of primitives drawn this frame.
      unsigned GetNumPrimitives() const { return numPrimitives_; }
      /// Return number of batches drawn this frame.
      unsigned GetNumBatches() const { return numBatches_; }
      /// Return dummy color texture format for shadow maps. 0 if not needed, may be nonzero on OS X to work around an Intel driver issue.
      unsigned GetDummyColorFormat() const { return dummyColorFormat_; }
      /// Return shadow map depth texture format, or 0 if not supported.
      unsigned GetShadowMapFormat() const { return shadowMapFormat_; }
      /// Return 24-bit shadow map depth texture format, or 0 if not supported.
      unsigned GetHiresShadowMapFormat() const { return hiresShadowMapFormat_; }
      /// Return whether hardware instancing is supported.
      bool GetInstancingSupport() const { return instancingSupport_; }
      /// Return whether light pre-pass rendering is supported.
      bool GetLightPrepassSupport() const { return lightPrepassSupport_; }
      /// Return whether deferred rendering is supported.
      bool GetDeferredSupport() const { return deferredSupport_; }
      /// Return whether anisotropic texture filtering is supported.
      bool GetAnisotropySupport() const { return anisotropySupport_; }
      /// Return whether shadow map depth compare is done in hardware. Always true on OpenGL.
      bool GetHardwareShadowSupport() const { return true; }
      /// Return whether a readable hardware depth format is available.
      bool GetReadableDepthSupport() const { return GetReadableDepthFormat() != 0; }
      /// Return whether sRGB conversion on texture sampling is supported.
      bool GetSRGBSupport() const { return sRGBSupport_; }
      /// Return whether sRGB conversion on rendertarget writing is supported.
      bool GetSRGBWriteSupport() const { return sRGBWriteSupport_; }
      /// Return supported fullscreen resolutions.
      PODVector<IntVector2> GetResolutions() const;
      /// Return supported multisampling levels.
      PODVector<int> GetMultiSampleLevels() const;
      /// Return the desktop resolution.
      IntVector2 GetDesktopResolution() const;
      /// Return hardware format for a compressed image format, or 0 if unsupported.
      unsigned GetFormat(CompressedFormat format) const;
      /// Return a shader variation by name and defines.
      ShaderVariation* GetShader(ShaderType type, const String& name, const String& defines = String::EMPTY) const;
      /// Return a shader variation by name and defines.
      ShaderVariation* GetShader(ShaderType type, const char* name, const char* defines) const;
      /// Return current vertex buffer by index.
      VertexBuffer* GetVertexBuffer(unsigned index) const;
      /// Return index buffer.
      IndexBuffer* GetIndexBuffer() const { return indexBuffer_; }
      /// Return vertex shader.
      ShaderVariation* GetVertexShader() const { return vertexShader_; }
      /// Return pixel shader.
      ShaderVariation* GetPixelShader() const { return pixelShader_; }
      /// Return shader program.
      ShaderProgram* GetShaderProgram() const { return shaderProgram_; }
      /// Return texture unit index by name.
      TextureUnit GetTextureUnit(const String& name);
      /// Return texture unit name by index.
      const String& GetTextureUnitName(TextureUnit unit);
      /// Return texture by texture unit index.
      Texture* GetTexture(unsigned index) const;
      /// Return default texture filtering mode.
      TextureFilterMode GetDefaultTextureFilterMode() const { return defaultTextureFilterMode_; }
      /// Return rendertarget by index.
      RenderSurface* GetRenderTarget(unsigned index) const;
      /// Return depth-stencil surface.
      RenderSurface* GetDepthStencil() const { return depthStencil_; }
      /// Return readable depth-stencil texture. Not created automatically on OpenGL.
      Texture2D* GetDepthTexture() const { return 0; }
      /// Return the viewport coordinates.
      IntRect GetViewport() const { return viewport_; }
      /// Return texture anisotropy.
      unsigned GetTextureAnisotropy() const { return textureAnisotropy_; }
      /// Return blending mode.
      BlendMode GetBlendMode() const { return blendMode_; }
      /// Return whether color write is enabled.
      bool GetColorWrite() const { return colorWrite_; }
      /// Return hardware culling mode.
      CullMode GetCullMode() const { return cullMode_; }
      /// Return depth constant bias.
      float GetDepthConstantBias() const { return constantDepthBias_; }
      /// Return depth slope scaled bias.
      float GetDepthSlopeScaledBias() const { return slopeScaledDepthBias_; }
      /// Return depth compare mode.
      CompareMode GetDepthTest() const { return depthTestMode_; }
      /// Return whether depth write is enabled.
      bool GetDepthWrite() const { return depthWrite_; }
      /// Return polygon fill mode.
      FillMode GetFillMode() const { return fillMode_; }
      /// Return whether stencil test is enabled.
      bool GetStencilTest() const { return stencilTest_; }
      /// Return whether scissor test is enabled.
      bool GetScissorTest() const { return scissorTest_; }
      /// Return scissor rectangle coordinates.
      const IntRect& GetScissorRect() const { return scissorRect_; }
      /// Return stencil compare mode.
      CompareMode GetStencilTestMode() const { return stencilTestMode_; }
      /// Return stencil operation to do if stencil test passes.
      StencilOp GetStencilPass() const { return stencilPass_; }
      /// Return stencil operation to do if stencil test fails.
      StencilOp GetStencilFail() const { return stencilFail_; }
      /// Return stencil operation to do if depth compare fails.
      StencilOp GetStencilZFail() const { return stencilZFail_; }
      /// Return stencil reference value.
      unsigned GetStencilRef() const { return stencilRef_; }
      /// Return stencil compare bitmask.
      unsigned GetStencilCompareMask() const { return stencilCompareMask_; }
      /// Return stencil write bitmask.
      unsigned GetStencilWriteMask() const { return stencilWriteMask_; }
      /// Return whether a custom clipping plane is in use.
      bool GetUseClipPlane() const { return useClipPlane_; }
      /// Return rendertarget width and height.
      IntVector2 GetRenderTargetDimensions() const;
  
      /// Window was resized through user interaction. Called by Input subsystem.
      void WindowResized();
      /// Window was moved through user interaction. Called by Input subsystem.
      void WindowMoved();
      /// Add a GPU object to keep track of. Called by GPUObject.
      void AddGPUObject(GPUObject* object);
      /// Remove a GPU object. Called by GPUObject.
      void RemoveGPUObject(GPUObject* object);
      /// Reserve a CPU-side scratch buffer.
      void* ReserveScratchBuffer(unsigned size);
      /// Free a CPU-side scratch buffer.
      void FreeScratchBuffer(void* buffer);
      /// Clean up too large scratch buffers.
      void CleanupScratchBuffers();
      /// Clean up a render surface from all FBOs.
      void CleanupRenderSurface(RenderSurface* surface);
      /// Clean up shader programs when a shader variation is released or destroyed.
      void CleanupShaderPrograms(ShaderVariation* variation);
      /// Reserve a constant buffer.
      ConstantBuffer* GetOrCreateConstantBuffer(unsigned bindingIndex, unsigned size);
      /// Release/clear GPU objects and optionally close the window.
      void Release(bool clearGPUObjects, bool closeWindow);
      /// Restore GPU objects and reinitialize state. Requires an open window.
      void Restore();
      /// Maximize the Window.
      void Maximize();
      /// Minimize the Window.
      void Minimize();
      /// Mark the FBO needing an update.
      void MarkFBODirty();
      /// Bind a VBO, avoiding redundant operation.
      void SetVBO(unsigned object);
      /// Bind a UBO, avoiding redundant operation.
      void SetUBO(unsigned object);
      
      /// Return the API-specific alpha texture format.
      static unsigned GetAlphaFormat();
      /// Return the API-specific luminance texture format.
      static unsigned GetLuminanceFormat();
      /// Return the API-specific luminance alpha texture format.
      static unsigned GetLuminanceAlphaFormat();
      /// Return the API-specific RGB texture format.
      static unsigned GetRGBFormat();
      /// Return the API-specific RGBA texture format.
      static unsigned GetRGBAFormat();
      /// Return the API-specific RGBA 16-bit texture format.
      static unsigned GetRGBA16Format();
      /// Return the API-specific RGBA 16-bit float texture format.
      static unsigned GetRGBAFloat16Format();
      /// Return the API-specific RGBA 32-bit float texture format.
      static unsigned GetRGBAFloat32Format();
      /// Return the API-specific RG 16-bit texture format.
      static unsigned GetRG16Format();
      /// Return the API-specific RG 16-bit float texture format.
      static unsigned GetRGFloat16Format();
      /// Return the API-specific RG 32-bit float texture format.
      static unsigned GetRGFloat32Format();
      /// Return the API-specific single channel 16-bit float texture format.
      static unsigned GetFloat16Format();
      /// Return the API-specific single channel 32-bit float texture format.
      static unsigned GetFloat32Format();
      /// Return the API-specific linear depth texture format.
      static unsigned GetLinearDepthFormat();
      /// Return the API-specific hardware depth-stencil texture format.
      static unsigned GetDepthStencilFormat();
      /// Return the API-specific readable hardware depth format, or 0 if not supported.
      static unsigned GetReadableDepthFormat();
      /// Return the API-specific texture format from a textual description, for example "rgb".
      static unsigned GetFormat(const String& formatName);
      /// Return UV offset required for pixel perfect rendering.
      static const Vector2& GetPixelUVOffset() { return pixelUVOffset; }
      /// Return maximum number of supported bones for skinning.
      static unsigned GetMaxBones();
      /// Return whether is using an OpenGL 3 context.
      static bool GetGL3Support() { return gl3Support; }
  
  private:
      /// Create the application window icon.
      void CreateWindowIcon();
      /// Check supported rendering features.
      void CheckFeatureSupport();
      /// Prepare for draw call. Update constant buffers and setup the FBO.
      void PrepareDraw();
      /// Clean up all framebuffers. Called when destroying the context.
      void CleanupFramebuffers();
      /// Reset cached rendering state.
      void ResetCachedState();
      /// Initialize texture unit mappings.
      void SetTextureUnitMappings();
      /// Create a framebuffer using either extension or core functionality.
      unsigned CreateFramebuffer();
      /// Delete a framebuffer using either extension or core functionality.
      void DeleteFramebuffer(unsigned fbo);
      /// Bind a framebuffer using either extension or core functionality.
      void BindFramebuffer(unsigned fbo);
      /// Bind a framebuffer color attachment using either extension or core functionality.
      void BindColorAttachment(unsigned index, unsigned target, unsigned object);
      /// Bind a framebuffer depth attachment using either extension or core functionality.
      void BindDepthAttachment(unsigned object, bool isRenderBuffer);
      /// Bind a framebuffer stencil attachment using either extension or core functionality.
      void BindStencilAttachment(unsigned object, bool isRenderBuffer);
      /// Check FBO completeness using either extension or core functionality.
      bool CheckFramebuffer();
      
      /// Mutex for accessing the GPU objects vector from several threads.
      Mutex gpuObjectMutex_;
      /// Implementation.
      GraphicsImpl* impl_;
      /// Window title.
      String windowTitle_;
      /// Window Icon File Name
      Image* windowIcon_;
      /// External window, null if not in use (default.)
      void* externalWindow_;
      /// Window width.
      int width_;
      /// Window height.
      int height_;
      /// Window position.
      IntVector2 position_;
      /// Multisampling mode.
      int multiSample_;
      /// Fullscreen flag.
      bool fullscreen_;
      /// Borderless flag.
      bool borderless_;
      /// Resizable flag.
      bool resizable_;
      /// Vertical sync flag.
      bool vsync_;
      /// Triple buffering flag.
      bool tripleBuffer_;
      /// sRGB conversion on write flag for the main window.
      bool sRGB_;
      /// Force OpenGL 2 use flag.
      bool forceGL2_;
      /// Instancing support flag.
      bool instancingSupport_;
      /// Light prepass support flag.
      bool lightPrepassSupport_;
      /// Deferred rendering support flag.
      bool deferredSupport_;
      /// Anisotropic filtering support flag.
      bool anisotropySupport_;
      /// DXT format support flag.
      bool dxtTextureSupport_;
      /// ETC1 format support flag.
      bool etcTextureSupport_;
      /// PVRTC formats support flag.
      bool pvrtcTextureSupport_;
      /// sRGB conversion on read support flag.
      bool sRGBSupport_;
      /// sRGB conversion on write support flag.
      bool sRGBWriteSupport_;
      /// Number of primitives this frame.
      unsigned numPrimitives_;
      /// Number of batches this frame.
      unsigned numBatches_;
      /// Largest scratch buffer request this frame.
      unsigned maxScratchBufferRequest_;
      /// GPU objects.
      PODVector<GPUObject*> gpuObjects_;
      /// Scratch buffers.
      Vector<ScratchBuffer> scratchBuffers_;
      /// Shadow map dummy color texture format.
      unsigned dummyColorFormat_;
      /// Shadow map depth texture format.
      unsigned shadowMapFormat_;
      /// Shadow map 24-bit depth texture format.
      unsigned hiresShadowMapFormat_;
      /// Vertex buffers in use.
      VertexBuffer* vertexBuffers_[MAX_VERTEX_STREAMS];
      /// Element mask in use.
      unsigned elementMasks_[MAX_VERTEX_STREAMS];
      /// Index buffer in use.
      IndexBuffer* indexBuffer_;
      /// Vertex shader in use.
      ShaderVariation* vertexShader_;
      /// Pixel shader in use.
      ShaderVariation* pixelShader_;
      /// Shader program in use.
      ShaderProgram* shaderProgram_;
      /// Linked shader programs.
      ShaderProgramMap shaderPrograms_;
      /// Textures in use.
      Texture* textures_[MAX_TEXTURE_UNITS];
      /// OpenGL texture types in use.
      unsigned textureTypes_[MAX_TEXTURE_UNITS];
      /// Texture unit mappings.
      HashMap<String, TextureUnit> textureUnits_;
      /// All constant buffers.
      HashMap<unsigned, SharedPtr<ConstantBuffer> > constantBuffers_;
      /// Currently bound constant buffers.
      ConstantBuffer* currentConstantBuffers_[MAX_SHADER_PARAMETER_GROUPS * 2];
      /// Dirty constant buffers.
      PODVector<ConstantBuffer*> dirtyConstantBuffers_;
      /// Rendertargets in use.
      RenderSurface* renderTargets_[MAX_RENDERTARGETS];
      /// Depth-stencil surface in use.
      RenderSurface* depthStencil_;
      /// Viewport coordinates.
      IntRect viewport_;
      /// Texture anisotropy level.
      unsigned textureAnisotropy_;
      /// Blending mode.
      BlendMode blendMode_;
      /// Color write enable.
      bool colorWrite_;
      /// Hardware culling mode.
      CullMode cullMode_;
      /// Depth constant bias.
      float constantDepthBias_;
      /// Depth slope scaled bias.
      float slopeScaledDepthBias_;
      /// Depth compare mode.
      CompareMode depthTestMode_;
      /// Depth write enable flag.
      bool depthWrite_;
      /// Polygon fill mode.
      FillMode fillMode_;
      /// Scissor test rectangle.
      IntRect scissorRect_;
      /// Scissor test enable flag.
      bool scissorTest_;
      /// Current custom clip plane in post-projection space.
      Vector4 clipPlane_;
      /// Stencil test compare mode.
      CompareMode stencilTestMode_;
      /// Stencil operation on pass.
      StencilOp stencilPass_;
      /// Stencil operation on fail.
      StencilOp stencilFail_;
      /// Stencil operation on depth fail.
      StencilOp stencilZFail_;
      /// Stencil test reference value.
      unsigned stencilRef_;
      /// Stencil compare bitmask.
      unsigned stencilCompareMask_;
      /// Stencil write bitmask.
      unsigned stencilWriteMask_;
      /// Stencil test enable flag.
      bool stencilTest_;
      /// Custom clip plane enable flag.
      bool useClipPlane_;
      /// Last used instance data offset.
      unsigned lastInstanceOffset_;
      /// Default texture filtering mode.
      TextureFilterMode defaultTextureFilterMode_;
      /// Map for additional depth textures, to emulate Direct3D9 ability to mix render texture and backbuffer rendering.
      HashMap<int, SharedPtr<Texture2D> > depthTextures_;
      /// Base directory for shaders.
      String shaderPath_;
      /// File extension for shaders.
      String shaderExtension_;
      /// Last used shader in shader variation query.
      mutable WeakPtr<Shader> lastShader_;
      /// Last used shader name in shader variation query.
      mutable String lastShaderName_;
      /// Shader precache utility.
      SharedPtr<ShaderPrecache> shaderPrecache_;
      /// Allowed screen orientations.
      String orientations_;
      /// Graphics API name.
      String apiName_;
  
      /// Pixel perfect UV offset.
      static const Vector2 pixelUVOffset;
      /// Flag for OpenGL 3 support.
      static bool gl3Support;
  };
  
  /// Register Graphics library objects.
  void URHO3D_API RegisterGraphicsLibrary(Context* context_);
  
  }
  