The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-

  * This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #ifndef MOZILLA_GFX_COMPOSITINGRENDERTARGETOGL_H

 #define MOZILLA_GFX_COMPOSITINGRENDERTARGETOGL_H

 #include "GLContextTypes.h"             // for GLContext

 #include "GLDefs.h"                     // for GLenum, LOCAL_GL_FRAMEBUFFER, etc

 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc

 #include "mozilla/Attributes.h"         // for MOZ_OVERRIDE

 #include "mozilla/RefPtr.h"             // for RefPtr, TemporaryRef

 #include "mozilla/gfx/Point.h"          // for IntSize, IntSizeTyped

 #include "mozilla/gfx/Types.h"          // for SurfaceFormat, etc

 #include "mozilla/layers/Compositor.h"  // for SurfaceInitMode, etc

 #include "mozilla/layers/TextureHost.h" // for CompositingRenderTarget

 #include "mozilla/layers/CompositorOGL.h"  // for CompositorOGL

 #include "mozilla/mozalloc.h"           // for operator new

 #include "nsAString.h"

 #include "nsCOMPtr.h"                   // for already_AddRefed

 #include "nsDebug.h"                    // for NS_ERROR, NS_WARNING

 #include "nsString.h"                   // for nsAutoCString

 namespace mozilla {

 namespace gl {

   class BindableTexture;

 }

 namespace gfx {

   class DataSourceSurface;

 }

 namespace layers {

 class TextureSource;

 class CompositingRenderTargetOGL : public CompositingRenderTarget

 {

   typedef mozilla::gl::GLContext GLContext;

   // For lazy initialisation of the GL stuff

   struct InitParams

   {

     InitParams() : mStatus(NO_PARAMS) {}

     InitParams(const gfx::IntSize& aSize,

                GLenum aFBOTextureTarget,

                SurfaceInitMode aInit)

       : mStatus(READY)

       , mSize(aSize)

       , mFBOTextureTarget(aFBOTextureTarget)

       , mInit(aInit)

     {}

     enum {

       NO_PARAMS,

       READY,

       INITIALIZED

     } mStatus;

     gfx::IntSize mSize;

     GLenum mFBOTextureTarget;

     SurfaceInitMode mInit;

   };

 public:

   CompositingRenderTargetOGL(CompositorOGL* aCompositor, const gfx::IntPoint& aOrigin,

                              GLuint aTexure, GLuint aFBO)

     : CompositingRenderTarget(aOrigin)

     , mInitParams()

     , mTransform()

     , mCompositor(aCompositor)

     , mGL(aCompositor->gl())

     , mTextureHandle(aTexure)

     , mFBO(aFBO)

   {}

   ~CompositingRenderTargetOGL();

   /**

    * Create a render target around the default FBO, for rendering straight to

    * the window.

    */

   static TemporaryRef<CompositingRenderTargetOGL>

   RenderTargetForWindow(CompositorOGL* aCompositor,

                         const gfx::IntSize& aSize,

                         const gfx::Matrix& aTransform)

   {

     RefPtr<CompositingRenderTargetOGL> result

       = new CompositingRenderTargetOGL(aCompositor, gfx::IntPoint(0, 0), 0, 0);

     result->mTransform = aTransform;

     result->mInitParams = InitParams(aSize, 0, INIT_MODE_NONE);

     result->mInitParams.mStatus = InitParams::INITIALIZED;

     return result.forget();

   }

   /**

    * Some initialisation work on the backing FBO and texture.

    * We do this lazily so that when we first set this render target on the

    * compositor we do not have to re-bind the FBO after unbinding it, or

    * alternatively leave the FBO bound after creation.

    */

   void Initialize(const gfx::IntSize& aSize,

                   GLenum aFBOTextureTarget,

                   SurfaceInitMode aInit)

   {

     MOZ_ASSERT(mInitParams.mStatus == InitParams::NO_PARAMS, "Initialized twice?");

     // postpone initialization until we actually want to use this render target

     mInitParams = InitParams(aSize, aFBOTextureTarget, aInit);

   }

   void BindTexture(GLenum aTextureUnit, GLenum aTextureTarget);

   /**

    * Call when we want to draw into our FBO

    */

   void BindRenderTarget();

   GLuint GetFBO() const

   {

     MOZ_ASSERT(mInitParams.mStatus == InitParams::INITIALIZED);

     return mFBO;

   }

   GLuint GetTextureHandle() const

   {

     MOZ_ASSERT(mInitParams.mStatus == InitParams::INITIALIZED);

     return mTextureHandle;

   }

   // TextureSourceOGL

   TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE

   {

     // XXX - Bug 900770

     MOZ_ASSERT(false, "CompositingRenderTargetOGL should not be used as a TextureSource");

     return nullptr;

   }

   gfx::IntSize GetSize() const MOZ_OVERRIDE

   {

     // XXX - Bug 900770

     MOZ_ASSERT(false, "CompositingRenderTargetOGL should not be used as a TextureSource");

     return gfx::IntSize(0, 0);

   }

   gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE

   {

     // XXX - Should it be implemented ? is the above assert true ?

     MOZ_ASSERT(false, "Not implemented");

     return gfx::SurfaceFormat::UNKNOWN;

   }

   const gfx::Matrix& GetTransform() {

     return mTransform;

   }

 #ifdef MOZ_DUMP_PAINTING

   virtual TemporaryRef<gfx::DataSourceSurface> Dump(Compositor* aCompositor);

 #endif

 private:

   /**

    * Actually do the initialisation. Note that we leave our FBO bound, and so

    * calling this method is only suitable when about to use this render target.

    */

   void InitializeImpl();

   InitParams mInitParams;

   gfx::Matrix mTransform;

   CompositorOGL* mCompositor;

   GLContext* mGL;

   GLuint mTextureHandle;

   GLuint mFBO;

 };

 }

 }

 #endif /* MOZILLA_GFX_SURFACEOGL_H */