The Tor Browser: content/canvas/src/WebGLExtensions.h@deefc01c0e14

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

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

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

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

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

     6 #ifndef WEBGLEXTENSIONS_H_

     7 #define WEBGLEXTENSIONS_H_

     9 #include "jsapi.h"

    10 #include "mozilla/Attributes.h"

    11 #include "nsWrapperCache.h"

    12 #include "WebGLObjectModel.h"

    13 #include "WebGLTypes.h"

    15 namespace mozilla {

    17 class WebGLContext;

    18 class WebGLShader;

    19 class WebGLVertexArray;

    21 class WebGLExtensionBase

    22     : public nsWrapperCache

    23     , public WebGLContextBoundObject

    24 {

    25 public:

    26     WebGLExtensionBase(WebGLContext*);

    27     virtual ~WebGLExtensionBase();

    29     WebGLContext *GetParentObject() const {

    30         return Context();

    31     }

    33     void MarkLost();

    35     NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(WebGLExtensionBase)

    36     NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(WebGLExtensionBase)

    38 protected:

    39     bool mIsLost;

    40 };

    42 #define DECL_WEBGL_EXTENSION_GOOP                                           \

    43     virtual JSObject* WrapObject(JSContext *cx) MOZ_OVERRIDE;

    45 #define IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionType) \

    46     JSObject* \

    47     WebGLExtensionType::WrapObject(JSContext *cx) { \

    48         return dom::WebGLExtensionType##Binding::Wrap(cx, this); \

    49     }

    51 class WebGLExtensionCompressedTextureATC

    52     : public WebGLExtensionBase

    53 {

    54 public:

    55     WebGLExtensionCompressedTextureATC(WebGLContext*);

    56     virtual ~WebGLExtensionCompressedTextureATC();

    58     DECL_WEBGL_EXTENSION_GOOP

    59 };

    61 class WebGLExtensionCompressedTextureETC1

    62     : public WebGLExtensionBase

    63 {

    64 public:

    65     WebGLExtensionCompressedTextureETC1(WebGLContext*);

    66     virtual ~WebGLExtensionCompressedTextureETC1();

    68     DECL_WEBGL_EXTENSION_GOOP

    69 };

    71 class WebGLExtensionCompressedTexturePVRTC

    72     : public WebGLExtensionBase

    73 {

    74 public:

    75     WebGLExtensionCompressedTexturePVRTC(WebGLContext*);

    76     virtual ~WebGLExtensionCompressedTexturePVRTC();

    78     DECL_WEBGL_EXTENSION_GOOP

    79 };

    81 class WebGLExtensionCompressedTextureS3TC

    82     : public WebGLExtensionBase

    83 {

    84 public:

    85     WebGLExtensionCompressedTextureS3TC(WebGLContext*);

    86     virtual ~WebGLExtensionCompressedTextureS3TC();

    88     DECL_WEBGL_EXTENSION_GOOP

    89 };

    91 class WebGLExtensionDebugRendererInfo

    92     : public WebGLExtensionBase

    93 {

    94 public:

    95     WebGLExtensionDebugRendererInfo(WebGLContext*);

    96     virtual ~WebGLExtensionDebugRendererInfo();

    98     DECL_WEBGL_EXTENSION_GOOP

    99 };

   101 class WebGLExtensionDebugShaders

   102     : public WebGLExtensionBase

   103 {

   104 public:

   105     WebGLExtensionDebugShaders(WebGLContext*);

   106     virtual ~WebGLExtensionDebugShaders();

   108     void GetTranslatedShaderSource(WebGLShader* shader, nsAString& retval);

   110     DECL_WEBGL_EXTENSION_GOOP

   111 };

   113 class WebGLExtensionDepthTexture

   114     : public WebGLExtensionBase

   115 {

   116 public:

   117     WebGLExtensionDepthTexture(WebGLContext*);

   118     virtual ~WebGLExtensionDepthTexture();

   120     DECL_WEBGL_EXTENSION_GOOP

   121 };

   123 class WebGLExtensionElementIndexUint

   124     : public WebGLExtensionBase

   125 {

   126 public:

   127     WebGLExtensionElementIndexUint(WebGLContext*);

   128     virtual ~WebGLExtensionElementIndexUint();

   130     DECL_WEBGL_EXTENSION_GOOP

   131 };

   133 class WebGLExtensionFragDepth

   134     : public WebGLExtensionBase

   135 {

   136 public:

   137     WebGLExtensionFragDepth(WebGLContext*);

   138     virtual ~WebGLExtensionFragDepth();

   140     static bool IsSupported(const WebGLContext* context);

   142     DECL_WEBGL_EXTENSION_GOOP

   143 };

   145 class WebGLExtensionLoseContext

   146     : public WebGLExtensionBase

   147 {

   148 public:

   149     WebGLExtensionLoseContext(WebGLContext*);

   150     virtual ~WebGLExtensionLoseContext();

   152     void LoseContext();

   153     void RestoreContext();

   155     DECL_WEBGL_EXTENSION_GOOP

   156 };

   158 class WebGLExtensionSRGB

   159     : public WebGLExtensionBase

   160 {

   161 public:

   162     WebGLExtensionSRGB(WebGLContext*);

   163     virtual ~WebGLExtensionSRGB();

   165     static bool IsSupported(const WebGLContext* context);

   167     DECL_WEBGL_EXTENSION_GOOP

   168 };

   170 class WebGLExtensionStandardDerivatives

   171     : public WebGLExtensionBase

   172 {

   173 public:

   174     WebGLExtensionStandardDerivatives(WebGLContext*);

   175     virtual ~WebGLExtensionStandardDerivatives();

   177     DECL_WEBGL_EXTENSION_GOOP

   178 };

   180 class WebGLExtensionTextureFilterAnisotropic

   181     : public WebGLExtensionBase

   182 {

   183 public:

   184     WebGLExtensionTextureFilterAnisotropic(WebGLContext*);

   185     virtual ~WebGLExtensionTextureFilterAnisotropic();

   187     DECL_WEBGL_EXTENSION_GOOP

   188 };

   190 class WebGLExtensionTextureFloat

   191     : public WebGLExtensionBase

   192 {

   193 public:

   194     WebGLExtensionTextureFloat(WebGLContext*);

   195     virtual ~WebGLExtensionTextureFloat();

   197     DECL_WEBGL_EXTENSION_GOOP

   198 };

   200 class WebGLExtensionTextureFloatLinear

   201     : public WebGLExtensionBase

   202 {

   203 public:

   204     WebGLExtensionTextureFloatLinear(WebGLContext*);

   205     virtual ~WebGLExtensionTextureFloatLinear();

   207     DECL_WEBGL_EXTENSION_GOOP

   208 };

   210 class WebGLExtensionTextureHalfFloat

   211     : public WebGLExtensionBase

   212 {

   213 public:

   214     WebGLExtensionTextureHalfFloat(WebGLContext*);

   215     virtual ~WebGLExtensionTextureHalfFloat();

   217     DECL_WEBGL_EXTENSION_GOOP

   218 };

   220 class WebGLExtensionTextureHalfFloatLinear

   221     : public WebGLExtensionBase

   222 {

   223 public:

   224     WebGLExtensionTextureHalfFloatLinear(WebGLContext*);

   225     virtual ~WebGLExtensionTextureHalfFloatLinear();

   227     DECL_WEBGL_EXTENSION_GOOP

   228 };

   230 class WebGLExtensionColorBufferFloat

   231     : public WebGLExtensionBase

   232 {

   233 public:

   234     WebGLExtensionColorBufferFloat(WebGLContext*);

   235     virtual ~WebGLExtensionColorBufferFloat();

   237     static bool IsSupported(const WebGLContext*);

   239     DECL_WEBGL_EXTENSION_GOOP

   240 };

   242 class WebGLExtensionColorBufferHalfFloat

   243     : public WebGLExtensionBase

   244 {

   245 public:

   246     WebGLExtensionColorBufferHalfFloat(WebGLContext*);

   247     virtual ~WebGLExtensionColorBufferHalfFloat();

   249     static bool IsSupported(const WebGLContext*);

   251     DECL_WEBGL_EXTENSION_GOOP

   252 };

   254 class WebGLExtensionDrawBuffers

   255     : public WebGLExtensionBase

   256 {

   257 public:

   258     WebGLExtensionDrawBuffers(WebGLContext*);

   259     virtual ~WebGLExtensionDrawBuffers();

   261     void DrawBuffersWEBGL(const dom::Sequence<GLenum>& buffers);

   263     static bool IsSupported(const WebGLContext*);

   265     static const size_t sMinColorAttachments = 4;

   266     static const size_t sMinDrawBuffers = 4;

   267     /*

   268      WEBGL_draw_buffers does not give a minal value for GL_MAX_DRAW_BUFFERS. But, we request

   269      for GL_MAX_DRAW_BUFFERS = 4 at least to be able to use all requested color attachments.

   270      See DrawBuffersWEBGL in WebGLExtensionDrawBuffers.cpp inner comments for more informations.

   271      */

   273     DECL_WEBGL_EXTENSION_GOOP

   274 };

   276 class WebGLExtensionVertexArray

   277     : public WebGLExtensionBase

   278 {

   279 public:

   280     WebGLExtensionVertexArray(WebGLContext*);

   281     virtual ~WebGLExtensionVertexArray();

   283     already_AddRefed<WebGLVertexArray> CreateVertexArrayOES();

   284     void DeleteVertexArrayOES(WebGLVertexArray* array);

   285     bool IsVertexArrayOES(WebGLVertexArray* array);

   286     void BindVertexArrayOES(WebGLVertexArray* array);

   288     static bool IsSupported(const WebGLContext* context);

   290     DECL_WEBGL_EXTENSION_GOOP

   291 };

   293 class WebGLExtensionInstancedArrays

   294     : public WebGLExtensionBase

   295 {

   296 public:

   297     WebGLExtensionInstancedArrays(WebGLContext* context);

   298     virtual ~WebGLExtensionInstancedArrays();

   300     void DrawArraysInstancedANGLE(GLenum mode, GLint first,

   301                                   GLsizei count, GLsizei primcount);

   302     void DrawElementsInstancedANGLE(GLenum mode, GLsizei count,

   303                                     GLenum type, WebGLintptr offset,

   304                                     GLsizei primcount);

   305     void VertexAttribDivisorANGLE(GLuint index, GLuint divisor);

   307     static bool IsSupported(const WebGLContext* context);

   309     DECL_WEBGL_EXTENSION_GOOP

   310 };

   312 } // namespace mozilla

   314 #endif // WEBGLEXTENSIONS_H_

The Tor Browser / file revision

content/canvas/src/WebGLExtensions.h@deefc01c0e14

content/canvas/src/WebGLExtensions.h