LCOV - code coverage report
Current view: directory - gfx/layers/opengl - LayerManagerOGL.h (source / functions) Found Hit Coverage
Test: app.info Lines: 104 0 0.0 %
Date: 2012-06-02 Functions: 42 0 0.0 %

       1                 : /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
       2                 :  * ***** BEGIN LICENSE BLOCK *****
       3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       4                 :  *
       5                 :  * The contents of this file are subject to the Mozilla Public License Version
       6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       7                 :  * the License. You may obtain a copy of the License at
       8                 :  * http://www.mozilla.org/MPL/
       9                 :  *
      10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      12                 :  * for the specific language governing rights and limitations under the
      13                 :  * License.
      14                 :  *
      15                 :  * The Original Code is Mozilla Corporation code.
      16                 :  *
      17                 :  * The Initial Developer of the Original Code is Mozilla Foundation.
      18                 :  * Portions created by the Initial Developer are Copyright (C) 2009
      19                 :  * the Initial Developer. All Rights Reserved.
      20                 :  *
      21                 :  * Contributor(s):
      22                 :  *   Bas Schouten <bschouten@mozilla.org>
      23                 :  *   Frederic Plourde <frederic.plourde@collabora.co.uk>
      24                 :  *   Vladimir Vukicevic <vladimir@pobox.com>
      25                 :  *
      26                 :  * Alternatively, the contents of this file may be used under the terms of
      27                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
      28                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      30                 :  * of those above. If you wish to allow use of your version of this file only
      31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      32                 :  * use your version of this file under the terms of the MPL, indicate your
      33                 :  * decision by deleting the provisions above and replace them with the notice
      34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      35                 :  * the provisions above, a recipient may use your version of this file under
      36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      37                 :  *
      38                 :  * ***** END LICENSE BLOCK ***** */
      39                 : 
      40                 : #ifndef GFX_LAYERMANAGEROGL_H
      41                 : #define GFX_LAYERMANAGEROGL_H
      42                 : 
      43                 : #include "Layers.h"
      44                 : 
      45                 : #include "mozilla/layers/ShadowLayers.h"
      46                 : 
      47                 : #include "mozilla/TimeStamp.h"
      48                 : 
      49                 : #ifdef XP_WIN
      50                 : #include <windows.h>
      51                 : #endif
      52                 : 
      53                 : /**
      54                 :  * We don't include GLDefs.h here since we don't want to drag in all defines
      55                 :  * in for all our users.
      56                 :  */
      57                 : typedef unsigned int GLenum;
      58                 : typedef unsigned int GLbitfield;
      59                 : typedef unsigned int GLuint;
      60                 : typedef int GLint;
      61                 : typedef int GLsizei;
      62                 : 
      63                 : #define BUFFER_OFFSET(i) ((char *)NULL + (i))
      64                 : 
      65                 : #include "gfxContext.h"
      66                 : #include "gfx3DMatrix.h"
      67                 : #include "nsIWidget.h"
      68                 : #include "GLContext.h"
      69                 : 
      70                 : #include "LayerManagerOGLProgram.h"
      71                 : 
      72                 : namespace mozilla {
      73                 : namespace layers {
      74                 : 
      75                 : class LayerOGL;
      76                 : class ShadowThebesLayer;
      77                 : class ShadowContainerLayer;
      78                 : class ShadowImageLayer;
      79                 : class ShadowCanvasLayer;
      80                 : class ShadowColorLayer;
      81                 : 
      82                 : /**
      83                 :  * This is the LayerManager used for OpenGL 2.1. For now this will render on
      84                 :  * the main thread.
      85                 :  */
      86                 : class THEBES_API LayerManagerOGL :
      87                 :     public ShadowLayerManager
      88                 : {
      89                 :   typedef mozilla::gl::GLContext GLContext;
      90                 :   typedef mozilla::gl::ShaderProgramType ProgramType;
      91                 : 
      92                 : public:
      93                 :   LayerManagerOGL(nsIWidget *aWidget);
      94                 :   virtual ~LayerManagerOGL();
      95                 : 
      96                 :   void CleanupResources();
      97                 : 
      98                 :   void Destroy();
      99                 : 
     100                 : 
     101                 :   /**
     102                 :    * Initializes the layer manager with a given GLContext. If aContext is null
     103                 :    * then the layer manager will try to create one for the associated widget.
     104                 :    *
     105                 :    * \param aContext an existing GL context to use. Can be created with CreateContext()
     106                 :    *
     107                 :    * \return True is initialization was succesful, false when it was not.
     108                 :    */
     109                 :   bool Initialize(bool force = false) {
     110                 :     return Initialize(CreateContext(), force);
     111                 :   }
     112                 : 
     113                 :   bool Initialize(nsRefPtr<GLContext> aContext, bool force = false);
     114                 : 
     115                 :   /**
     116                 :    * Sets the clipping region for this layer manager. This is important on 
     117                 :    * windows because using OGL we no longer have GDI's native clipping. Therefor
     118                 :    * widget must tell us what part of the screen is being invalidated,
     119                 :    * and we should clip to this.
     120                 :    *
     121                 :    * \param aClippingRegion Region to clip to. Setting an empty region
     122                 :    * will disable clipping.
     123                 :    */
     124                 :   void SetClippingRegion(const nsIntRegion& aClippingRegion);
     125                 : 
     126                 :   /**
     127                 :    * LayerManager implementation.
     128                 :    */
     129               0 :   virtual ShadowLayerManager* AsShadowManager()
     130                 :   {
     131               0 :     return this;
     132                 :   }
     133                 : 
     134                 :   void BeginTransaction();
     135                 : 
     136                 :   void BeginTransactionWithTarget(gfxContext* aTarget);
     137                 : 
     138                 :   void EndConstruction();
     139                 : 
     140                 :   virtual bool EndEmptyTransaction();
     141                 :   virtual void EndTransaction(DrawThebesLayerCallback aCallback,
     142                 :                               void* aCallbackData,
     143                 :                               EndTransactionFlags aFlags = END_DEFAULT);
     144                 : 
     145               0 :   virtual void SetRoot(Layer* aLayer) { mRoot = aLayer; }
     146                 : 
     147               0 :   virtual bool CanUseCanvasLayerForSize(const gfxIntSize &aSize)
     148                 :   {
     149               0 :       if (!mGLContext)
     150               0 :           return false;
     151               0 :       PRInt32 maxSize = mGLContext->GetMaxTextureSize();
     152               0 :       return aSize <= gfxIntSize(maxSize, maxSize);
     153                 :   }
     154                 : 
     155                 :   virtual already_AddRefed<ThebesLayer> CreateThebesLayer();
     156                 : 
     157                 :   virtual already_AddRefed<ContainerLayer> CreateContainerLayer();
     158                 : 
     159                 :   virtual already_AddRefed<ImageLayer> CreateImageLayer();
     160                 : 
     161                 :   virtual already_AddRefed<ColorLayer> CreateColorLayer();
     162                 : 
     163                 :   virtual already_AddRefed<CanvasLayer> CreateCanvasLayer();
     164                 : 
     165                 :   virtual already_AddRefed<ShadowThebesLayer> CreateShadowThebesLayer();
     166                 :   virtual already_AddRefed<ShadowContainerLayer> CreateShadowContainerLayer();
     167                 :   virtual already_AddRefed<ShadowImageLayer> CreateShadowImageLayer();
     168                 :   virtual already_AddRefed<ShadowColorLayer> CreateShadowColorLayer();
     169                 :   virtual already_AddRefed<ShadowCanvasLayer> CreateShadowCanvasLayer();
     170                 : 
     171               0 :   virtual LayersBackend GetBackendType() { return LAYERS_OPENGL; }
     172               0 :   virtual void GetBackendName(nsAString& name) { name.AssignLiteral("OpenGL"); }
     173                 : 
     174                 :   /**
     175                 :    * Helper methods.
     176                 :    */
     177               0 :   void MakeCurrent(bool aForce = false) {
     178               0 :     if (mDestroyed) {
     179               0 :       NS_WARNING("Call on destroyed layer manager");
     180               0 :       return;
     181                 :     }
     182               0 :     mGLContext->MakeCurrent(aForce);
     183                 :   }
     184                 : 
     185               0 :   ColorTextureLayerProgram *GetColorTextureLayerProgram(ProgramType type){
     186               0 :     return static_cast<ColorTextureLayerProgram*>(mPrograms[type]);
     187                 :   }
     188                 : 
     189               0 :   ColorTextureLayerProgram *GetRGBALayerProgram() {
     190               0 :     return static_cast<ColorTextureLayerProgram*>(mPrograms[gl::RGBALayerProgramType]);
     191                 :   }
     192               0 :   ColorTextureLayerProgram *GetBGRALayerProgram() {
     193               0 :     return static_cast<ColorTextureLayerProgram*>(mPrograms[gl::BGRALayerProgramType]);
     194                 :   }
     195               0 :   ColorTextureLayerProgram *GetRGBXLayerProgram() {
     196               0 :     return static_cast<ColorTextureLayerProgram*>(mPrograms[gl::RGBXLayerProgramType]);
     197                 :   }
     198               0 :   ColorTextureLayerProgram *GetBGRXLayerProgram() {
     199               0 :     return static_cast<ColorTextureLayerProgram*>(mPrograms[gl::BGRXLayerProgramType]);
     200                 :   }
     201               0 :   ColorTextureLayerProgram *GetBasicLayerProgram(bool aOpaque, bool aIsRGB)
     202                 :   {
     203               0 :     if (aIsRGB) {
     204                 :       return aOpaque
     205                 :         ? GetRGBXLayerProgram()
     206               0 :         : GetRGBALayerProgram();
     207                 :     } else {
     208                 :       return aOpaque
     209                 :         ? GetBGRXLayerProgram()
     210               0 :         : GetBGRALayerProgram();
     211                 :     }
     212                 :   }
     213                 : 
     214                 :   ColorTextureLayerProgram *GetRGBARectLayerProgram() {
     215                 :     return static_cast<ColorTextureLayerProgram*>(mPrograms[gl::RGBARectLayerProgramType]);
     216                 :   }
     217               0 :   SolidColorLayerProgram *GetColorLayerProgram() {
     218               0 :     return static_cast<SolidColorLayerProgram*>(mPrograms[gl::ColorLayerProgramType]);
     219                 :   }
     220               0 :   YCbCrTextureLayerProgram *GetYCbCrLayerProgram() {
     221               0 :     return static_cast<YCbCrTextureLayerProgram*>(mPrograms[gl::YCbCrLayerProgramType]);
     222                 :   }
     223               0 :   ComponentAlphaTextureLayerProgram *GetComponentAlphaPass1LayerProgram() {
     224                 :     return static_cast<ComponentAlphaTextureLayerProgram*>
     225               0 :              (mPrograms[gl::ComponentAlphaPass1ProgramType]);
     226                 :   }
     227               0 :   ComponentAlphaTextureLayerProgram *GetComponentAlphaPass2LayerProgram() {
     228                 :     return static_cast<ComponentAlphaTextureLayerProgram*>
     229               0 :              (mPrograms[gl::ComponentAlphaPass2ProgramType]);
     230                 :   }
     231               0 :   CopyProgram *GetCopy2DProgram() {
     232               0 :     return static_cast<CopyProgram*>(mPrograms[gl::Copy2DProgramType]);
     233                 :   }
     234               0 :   CopyProgram *GetCopy2DRectProgram() {
     235               0 :     return static_cast<CopyProgram*>(mPrograms[gl::Copy2DRectProgramType]);
     236                 :   }
     237                 : 
     238               0 :   ColorTextureLayerProgram *GetFBOLayerProgram() {
     239               0 :     return static_cast<ColorTextureLayerProgram*>(mPrograms[GetFBOLayerProgramType()]);
     240                 :   }
     241                 : 
     242               0 :   gl::ShaderProgramType GetFBOLayerProgramType() {
     243               0 :     if (mFBOTextureTarget == LOCAL_GL_TEXTURE_RECTANGLE_ARB)
     244               0 :       return gl::RGBARectLayerProgramType;
     245               0 :     return gl::RGBALayerProgramType;
     246                 :   }
     247                 : 
     248               0 :   GLContext *gl() const { return mGLContext; }
     249                 : 
     250               0 :   DrawThebesLayerCallback GetThebesLayerCallback() const
     251               0 :   { return mThebesLayerCallback; }
     252                 : 
     253               0 :   void* GetThebesLayerCallbackData() const
     254               0 :   { return mThebesLayerCallbackData; }
     255                 : 
     256                 :   // This is a GLContext that can be used for resource
     257                 :   // management (creation, destruction).  It is guaranteed
     258                 :   // to be either the same as the gl() context, or a context
     259                 :   // that is in the same share pool.
     260               0 :   GLContext *glForResources() const {
     261               0 :     if (mGLContext->GetSharedContext())
     262               0 :       return mGLContext->GetSharedContext();
     263               0 :     return mGLContext;
     264                 :   }
     265                 : 
     266                 :   /*
     267                 :    * Helper functions for our layers
     268                 :    */
     269                 :   void CallThebesLayerDrawCallback(ThebesLayer* aLayer,
     270                 :                                    gfxContext* aContext,
     271                 :                                    const nsIntRegion& aRegionToDraw)
     272                 :   {
     273                 :     NS_ASSERTION(mThebesLayerCallback,
     274                 :                  "CallThebesLayerDrawCallback without callback!");
     275                 :     mThebesLayerCallback(aLayer, aContext,
     276                 :                          aRegionToDraw, nsIntRegion(),
     277                 :                          mThebesLayerCallbackData);
     278                 :   }
     279                 : 
     280               0 :   GLenum FBOTextureTarget() { return mFBOTextureTarget; }
     281                 : 
     282                 :   /**
     283                 :    * Controls how to initialize the texture / FBO created by
     284                 :    * CreateFBOWithTexture.
     285                 :    *  - InitModeNone: No initialization, contents are undefined.
     286                 :    *  - InitModeClear: Clears the FBO.
     287                 :    *  - InitModeCopy: Copies the contents of the current glReadBuffer into the
     288                 :    *    texture.
     289                 :    */
     290                 :   enum InitMode {
     291                 :     InitModeNone,
     292                 :     InitModeClear,
     293                 :     InitModeCopy
     294                 :   };
     295                 : 
     296                 :   /* Create a FBO backed by a texture; will leave the FBO
     297                 :    * bound.  Note that the texture target type will be
     298                 :    * of the type returned by FBOTextureTarget; different
     299                 :    * shaders are required to sample from the different
     300                 :    * texture types.
     301                 :    */
     302                 :   void CreateFBOWithTexture(const nsIntRect& aRect, InitMode aInit,
     303                 :                             GLuint aCurrentFrameBuffer,
     304                 :                             GLuint *aFBO, GLuint *aTexture);
     305                 : 
     306                 :   GLuint QuadVBO() { return mQuadVBO; }
     307               0 :   GLintptr QuadVBOVertexOffset() { return 0; }
     308               0 :   GLintptr QuadVBOTexCoordOffset() { return sizeof(float)*4*2; }
     309               0 :   GLintptr QuadVBOFlippedTexCoordOffset() { return sizeof(float)*8*2; }
     310                 : 
     311               0 :   void BindQuadVBO() {
     312               0 :     mGLContext->fBindBuffer(LOCAL_GL_ARRAY_BUFFER, mQuadVBO);
     313               0 :   }
     314                 : 
     315               0 :   void QuadVBOVerticesAttrib(GLuint aAttribIndex) {
     316                 :     mGLContext->fVertexAttribPointer(aAttribIndex, 2,
     317                 :                                      LOCAL_GL_FLOAT, LOCAL_GL_FALSE, 0,
     318               0 :                                      (GLvoid*) QuadVBOVertexOffset());
     319               0 :   }
     320                 : 
     321               0 :   void QuadVBOTexCoordsAttrib(GLuint aAttribIndex) {
     322                 :     mGLContext->fVertexAttribPointer(aAttribIndex, 2,
     323                 :                                      LOCAL_GL_FLOAT, LOCAL_GL_FALSE, 0,
     324               0 :                                      (GLvoid*) QuadVBOTexCoordOffset());
     325               0 :   }
     326                 : 
     327               0 :   void QuadVBOFlippedTexCoordsAttrib(GLuint aAttribIndex) {
     328                 :     mGLContext->fVertexAttribPointer(aAttribIndex, 2,
     329                 :                                      LOCAL_GL_FLOAT, LOCAL_GL_FALSE, 0,
     330               0 :                                      (GLvoid*) QuadVBOFlippedTexCoordOffset());
     331               0 :   }
     332                 : 
     333                 :   // Super common
     334                 : 
     335               0 :   void BindAndDrawQuad(GLuint aVertAttribIndex,
     336                 :                        GLuint aTexCoordAttribIndex,
     337                 :                        bool aFlipped = false)
     338                 :   {
     339               0 :     BindQuadVBO();
     340               0 :     QuadVBOVerticesAttrib(aVertAttribIndex);
     341                 : 
     342               0 :     if (aTexCoordAttribIndex != GLuint(-1)) {
     343               0 :       if (aFlipped)
     344               0 :         QuadVBOFlippedTexCoordsAttrib(aTexCoordAttribIndex);
     345                 :       else
     346               0 :         QuadVBOTexCoordsAttrib(aTexCoordAttribIndex);
     347                 : 
     348               0 :       mGLContext->fEnableVertexAttribArray(aTexCoordAttribIndex);
     349                 :     }
     350                 : 
     351               0 :     mGLContext->fEnableVertexAttribArray(aVertAttribIndex);
     352                 : 
     353               0 :     mGLContext->fDrawArrays(LOCAL_GL_TRIANGLE_STRIP, 0, 4);
     354                 : 
     355               0 :     mGLContext->fDisableVertexAttribArray(aVertAttribIndex);
     356                 : 
     357               0 :     if (aTexCoordAttribIndex != GLuint(-1)) {
     358               0 :       mGLContext->fDisableVertexAttribArray(aTexCoordAttribIndex);
     359                 :     }
     360               0 :   }
     361                 : 
     362               0 :   void BindAndDrawQuad(LayerProgram *aProg,
     363                 :                        bool aFlipped = false)
     364                 :   {
     365               0 :     BindAndDrawQuad(aProg->AttribLocation(LayerProgram::VertexAttrib),
     366               0 :                     aProg->AttribLocation(LayerProgram::TexCoordAttrib),
     367               0 :                     aFlipped);
     368               0 :   }
     369                 : 
     370                 :   void BindAndDrawQuadWithTextureRect(LayerProgram *aProg,
     371                 :                                       const nsIntRect& aTexCoordRect,
     372                 :                                       const nsIntSize& aTexSize,
     373                 :                                       GLenum aWrapMode = LOCAL_GL_REPEAT);
     374                 :                                       
     375                 : 
     376                 : #ifdef MOZ_LAYERS_HAVE_LOG
     377               0 :   virtual const char* Name() const { return "OGL"; }
     378                 : #endif // MOZ_LAYERS_HAVE_LOG
     379                 : 
     380                 :   const nsIntSize& GetWigetSize() {
     381                 :     return mWidgetSize;
     382                 :   }
     383                 : 
     384                 :   enum WorldTransforPolicy {
     385                 :     ApplyWorldTransform,
     386                 :     DontApplyWorldTransform
     387                 :   };
     388                 : 
     389                 :   /**
     390                 :    * Setup the viewport and projection matrix for rendering
     391                 :    * to a window of the given dimensions.
     392                 :    */
     393                 :   void SetupPipeline(int aWidth, int aHeight, WorldTransforPolicy aTransformPolicy);
     394                 :   
     395                 :   /**
     396                 :    * Setup World transform matrix.
     397                 :    * Transform will be ignored if it is not PreservesAxisAlignedRectangles
     398                 :    * or has non integer scale
     399                 :    */
     400                 :   void SetWorldTransform(const gfxMatrix& aMatrix);
     401                 :   gfxMatrix& GetWorldTransform(void);
     402                 :   void WorldTransformRect(nsIntRect& aRect);
     403                 : 
     404                 : private:
     405                 :   /** Widget associated with this layer manager */
     406                 :   nsIWidget *mWidget;
     407                 :   nsIntSize mWidgetSize;
     408                 : 
     409                 :   /** 
     410                 :    * Context target, NULL when drawing directly to our swap chain.
     411                 :    */
     412                 :   nsRefPtr<gfxContext> mTarget;
     413                 : 
     414                 :   nsRefPtr<GLContext> mGLContext;
     415                 : 
     416                 :   already_AddRefed<mozilla::gl::GLContext> CreateContext();
     417                 : 
     418                 :   static ProgramType sLayerProgramTypes[];
     419                 : 
     420                 :   /** Backbuffer */
     421                 :   GLuint mBackBufferFBO;
     422                 :   GLuint mBackBufferTexture;
     423                 :   nsIntSize mBackBufferSize;
     424                 : 
     425                 :   /** Shader Programs */
     426                 :   nsTArray<LayerManagerOGLProgram*> mPrograms;
     427                 : 
     428                 :   /** Texture target to use for FBOs */
     429                 :   GLenum mFBOTextureTarget;
     430                 : 
     431                 :   /** VBO that has some basics in it for a textured quad,
     432                 :    *  including vertex coords and texcoords for both
     433                 :    *  flipped and unflipped textures */
     434                 :   GLuint mQuadVBO;
     435                 : 
     436                 :   /** Region we're clipping our current drawing to. */
     437                 :   nsIntRegion mClippingRegion;
     438                 : 
     439                 :   /** Misc */
     440                 :   bool mHasBGRA;
     441                 : 
     442                 :   /** Current root layer. */
     443                 :   LayerOGL *RootLayer() const;
     444                 : 
     445                 :   /**
     446                 :    * Render the current layer tree to the active target.
     447                 :    */
     448                 :   void Render();
     449                 : 
     450                 :   /**
     451                 :    * Setup a backbuffer of the given dimensions.
     452                 :    */
     453                 :   void SetupBackBuffer(int aWidth, int aHeight);
     454                 : 
     455                 :   /**
     456                 :    * Copies the content of our backbuffer to the set transaction target.
     457                 :    */
     458                 :   void CopyToTarget(gfxContext *aTarget);
     459                 : 
     460                 :   /**
     461                 :    * Updates all layer programs with a new projection matrix.
     462                 :    *
     463                 :    * XXX we need a way to be able to delay setting this until
     464                 :    * the program is actually used.  Maybe a DelayedSetUniform
     465                 :    * on Program, that will delay the set until the next Activate?
     466                 :    *
     467                 :    * XXX this is only called once per frame, so it's not awful.
     468                 :    * If we have any more similar updates, then we should delay.
     469                 :    */
     470                 :   void SetLayerProgramProjectionMatrix(const gfx3DMatrix& aMatrix);
     471                 : 
     472                 :   /* Thebes layer callbacks; valid at the end of a transaciton,
     473                 :    * while rendering */
     474                 :   DrawThebesLayerCallback mThebesLayerCallback;
     475                 :   void *mThebesLayerCallbackData;
     476                 :   gfxMatrix mWorldMatrix;
     477                 : 
     478                 :   struct FPSState
     479                 :   {
     480                 :       GLuint texture;
     481                 :       int fps;
     482                 :       bool initialized;
     483                 :       int fcount;
     484                 :       TimeStamp last;
     485                 : 
     486               0 :       FPSState()
     487                 :         : texture(0)
     488                 :         , fps(0)
     489                 :         , initialized(false)
     490               0 :         , fcount(0)
     491                 :       {
     492               0 :         last = TimeStamp::Now();
     493               0 :       }
     494                 :       void DrawFPS(GLContext*, CopyProgram*);
     495                 :   } mFPS;
     496                 : 
     497                 :   static bool sDrawFPS;
     498                 : };
     499                 : 
     500                 : /**
     501                 :  * General information and tree management for OGL layers.
     502                 :  */
     503                 : class LayerOGL
     504                 : {
     505                 : public:
     506               0 :   LayerOGL(LayerManagerOGL *aManager)
     507               0 :     : mOGLManager(aManager), mDestroyed(false)
     508               0 :   { }
     509                 : 
     510               0 :   virtual ~LayerOGL() { }
     511                 : 
     512               0 :   virtual LayerOGL *GetFirstChildOGL() {
     513               0 :     return nsnull;
     514                 :   }
     515                 : 
     516                 :   /* Do NOT call this from the generic LayerOGL destructor.  Only from the
     517                 :    * concrete class destructor
     518                 :    */
     519                 :   virtual void Destroy() = 0;
     520                 : 
     521                 :   virtual Layer* GetLayer() = 0;
     522                 : 
     523                 :   virtual void RenderLayer(int aPreviousFrameBuffer,
     524                 :                            const nsIntPoint& aOffset) = 0;
     525                 : 
     526                 :   typedef mozilla::gl::GLContext GLContext;
     527                 : 
     528               0 :   LayerManagerOGL* OGLManager() const { return mOGLManager; }
     529               0 :   GLContext *gl() const { return mOGLManager->gl(); }
     530                 :   virtual void CleanupResources() = 0;
     531                 : 
     532                 : protected:
     533                 :   LayerManagerOGL *mOGLManager;
     534                 :   bool mDestroyed;
     535                 : };
     536                 : 
     537                 : } /* layers */
     538                 : } /* mozilla */
     539                 : 
     540                 : #endif /* GFX_LAYERMANAGEROGL_H */

Generated by: LCOV version 1.7