tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

ClientWebGLExtensions.h (15842B)

      1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      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/. */
      5 
      6 #ifndef CLIENTWEBGLEXTENSIONS_H_
      7 #define CLIENTWEBGLEXTENSIONS_H_
      8 
      9 #include "ClientWebGLContext.h"
     10 #include "WebGLExtensions.h"
     11 
     12 namespace mozilla {
     13 
     14 class ClientWebGLExtensionBase : public nsWrapperCache {
     15  friend ClientWebGLContext;
     16 
     17 protected:
     18  WeakPtr<ClientWebGLContext> mContext;
     19 
     20 public:
     21  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(ClientWebGLExtensionBase)
     22  NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(ClientWebGLExtensionBase)
     23 
     24 protected:
     25  explicit ClientWebGLExtensionBase(ClientWebGLContext& context)
     26      : mContext(&context) {}
     27  virtual ~ClientWebGLExtensionBase() = default;
     28 
     29 public:
     30  ClientWebGLContext* GetParentObject() const { return mContext.get(); }
     31 };
     32 
     33 // -
     34 
     35 // To be used for implementations of ClientWebGLExtensionBase
     36 #define DEFINE_WEBGL_EXTENSION_GOOP(_WebGLBindingType, _Extension)             \
     37  JSObject* Client##_Extension::WrapObject(JSContext* cx,                      \
     38                                           JS::Handle<JSObject*> givenProto) { \
     39    return dom::_WebGLBindingType##_Binding::Wrap(cx, this, givenProto);       \
     40  }                                                                            \
     41  Client##_Extension::Client##_Extension(ClientWebGLContext& aClient)          \
     42      : ClientWebGLExtensionBase(aClient) {}
     43 
     44 // Many extensions have no methods.  This is a shorthand for declaring client
     45 // versions of such classes.
     46 #define DECLARE_SIMPLE_WEBGL_EXTENSION(_Extension)                           \
     47  class Client##_Extension : public ClientWebGLExtensionBase {               \
     48   public:                                                                   \
     49    virtual JSObject* WrapObject(JSContext* cx,                              \
     50                                 JS::Handle<JSObject*> givenProto) override; \
     51    explicit Client##_Extension(ClientWebGLContext&);                        \
     52  };
     53 
     54 ////
     55 
     56 class ClientWebGLExtensionCompressedTextureASTC
     57    : public ClientWebGLExtensionBase {
     58 public:
     59  virtual JSObject* WrapObject(JSContext* cx,
     60                               JS::Handle<JSObject*> givenProto) override;
     61  explicit ClientWebGLExtensionCompressedTextureASTC(ClientWebGLContext&);
     62 
     63  void GetSupportedProfiles(dom::Nullable<nsTArray<nsString>>& retval) const {
     64    if (MOZ_UNLIKELY(!mContext)) {
     65      AutoJsWarning("getSupportedProfiles: Extension is `invalidated`.");
     66      return;
     67    }
     68    mContext->GetSupportedProfilesASTC(retval);
     69  }
     70 };
     71 
     72 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionFloatBlend)
     73 
     74 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionCompressedTextureBPTC)
     75 
     76 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionCompressedTextureES3)
     77 
     78 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionCompressedTextureETC1)
     79 
     80 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionCompressedTexturePVRTC)
     81 
     82 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionCompressedTextureRGTC)
     83 
     84 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionFBORenderMipmap)
     85 
     86 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionCompressedTextureS3TC)
     87 
     88 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionCompressedTextureS3TC_SRGB)
     89 
     90 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionDebugRendererInfo)
     91 
     92 class ClientWebGLExtensionDebugShaders : public ClientWebGLExtensionBase {
     93 public:
     94  virtual JSObject* WrapObject(JSContext* cx,
     95                               JS::Handle<JSObject*> givenProto) override;
     96  explicit ClientWebGLExtensionDebugShaders(ClientWebGLContext&);
     97 
     98  void GetTranslatedShaderSource(const WebGLShaderJS& shader,
     99                                 nsAString& retval) const {
    100    if (MOZ_UNLIKELY(!mContext)) {
    101      AutoJsWarning("getTranslatedShaderSource: Extension is `invalidated`.");
    102      return;
    103    }
    104    mContext->GetTranslatedShaderSource(shader, retval);
    105  }
    106 };
    107 
    108 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionDepthClamp)
    109 
    110 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionDepthTexture)
    111 
    112 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionElementIndexUint)
    113 
    114 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionEXTColorBufferFloat)
    115 
    116 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionFragDepth)
    117 
    118 class ClientWebGLExtensionLoseContext : public ClientWebGLExtensionBase {
    119 public:
    120  virtual JSObject* WrapObject(JSContext* cx,
    121                               JS::Handle<JSObject*> givenProto) override;
    122  explicit ClientWebGLExtensionLoseContext(ClientWebGLContext&);
    123 
    124  void LoseContext() {
    125    if (MOZ_UNLIKELY(!mContext)) {
    126      AutoJsWarning("loseContext: Extension is `invalidated`.");
    127      return;
    128    }
    129    mContext->EmulateLoseContext();
    130  }
    131  void RestoreContext() {
    132    if (MOZ_UNLIKELY(!mContext)) {
    133      AutoJsWarning("restoreContext: Extension is `invalidated`.");
    134      return;
    135    }
    136    mContext->RestoreContext(webgl::LossStatus::LostManually);
    137  }
    138 };
    139 
    140 class ClientWebGLExtensionProvokingVertex : public ClientWebGLExtensionBase {
    141 public:
    142  virtual JSObject* WrapObject(JSContext* cx,
    143                               JS::Handle<JSObject*> givenProto) override;
    144  explicit ClientWebGLExtensionProvokingVertex(ClientWebGLContext&);
    145 
    146  void ProvokingVertexWEBGL(const GLenum mode) const {
    147    if (MOZ_UNLIKELY(!mContext)) {
    148      AutoJsWarning("provokingVertexWEBGL: Extension is `invalidated`.");
    149      return;
    150    }
    151    mContext->ProvokingVertex(mode);
    152  }
    153 };
    154 
    155 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionSRGB)
    156 
    157 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionStandardDerivatives)
    158 
    159 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionShaderTextureLod)
    160 
    161 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureFilterAnisotropic)
    162 
    163 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureFloat)
    164 
    165 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureFloatLinear)
    166 
    167 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureHalfFloat)
    168 
    169 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureHalfFloatLinear)
    170 
    171 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureNorm16)
    172 
    173 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionColorBufferFloat)
    174 
    175 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionColorBufferHalfFloat)
    176 
    177 class ClientWebGLExtensionDrawBuffers : public ClientWebGLExtensionBase {
    178 public:
    179  virtual JSObject* WrapObject(JSContext* cx,
    180                               JS::Handle<JSObject*> givenProto) override;
    181  explicit ClientWebGLExtensionDrawBuffers(ClientWebGLContext&);
    182 
    183  void DrawBuffersWEBGL(const dom::Sequence<GLenum>& buffers) {
    184    if (MOZ_UNLIKELY(!mContext)) {
    185      AutoJsWarning("drawBuffersWEBGL: Extension is `invalidated`.");
    186      return;
    187    }
    188    mContext->DrawBuffers(buffers);
    189  }
    190 };
    191 
    192 class ClientWebGLExtensionVertexArray : public ClientWebGLExtensionBase {
    193 public:
    194  virtual JSObject* WrapObject(JSContext* cx,
    195                               JS::Handle<JSObject*> givenProto) override;
    196  explicit ClientWebGLExtensionVertexArray(ClientWebGLContext&);
    197 
    198  already_AddRefed<WebGLVertexArrayJS> CreateVertexArrayOES() {
    199    RefPtr<WebGLVertexArrayJS> ret;
    200    if (MOZ_UNLIKELY(!mContext)) {
    201      AutoJsWarning("createVertexArrayOES: Extension is `invalidated`.");
    202      ret = new WebGLVertexArrayJS(nullptr);
    203    } else {
    204      ret = mContext->CreateVertexArray();
    205    }
    206    return ret.forget();
    207  }
    208  void DeleteVertexArrayOES(WebGLVertexArrayJS* array) {
    209    if (MOZ_UNLIKELY(!mContext)) {
    210      AutoJsWarning("deleteVertexArrayOES: Extension is `invalidated`.");
    211      return;
    212    }
    213    mContext->DeleteVertexArray(array);
    214  }
    215  bool IsVertexArrayOES(const WebGLVertexArrayJS* array) {
    216    if (MOZ_UNLIKELY(!mContext)) {
    217      AutoJsWarning("isVertexArrayOES: Extension is `invalidated`.");
    218      return false;
    219    }
    220    return mContext->IsVertexArray(array);
    221  }
    222  void BindVertexArrayOES(WebGLVertexArrayJS* array) {
    223    if (MOZ_UNLIKELY(!mContext)) {
    224      AutoJsWarning("bindVertexArrayOES: Extension is `invalidated`.");
    225      return;
    226    }
    227    mContext->BindVertexArray(array);
    228  }
    229 };
    230 
    231 class ClientWebGLExtensionInstancedArrays : public ClientWebGLExtensionBase {
    232 public:
    233  virtual JSObject* WrapObject(JSContext* cx,
    234                               JS::Handle<JSObject*> givenProto) override;
    235  explicit ClientWebGLExtensionInstancedArrays(ClientWebGLContext&);
    236 
    237  void DrawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count,
    238                                GLsizei primcount) {
    239    if (MOZ_UNLIKELY(!mContext)) {
    240      AutoJsWarning("drawArraysInstancedANGLE: Extension is `invalidated`.");
    241      return;
    242    }
    243    mContext->DrawArraysInstanced(mode, first, count, primcount);
    244  }
    245  void DrawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type,
    246                                  WebGLintptr offset, GLsizei primcount) {
    247    if (MOZ_UNLIKELY(!mContext)) {
    248      AutoJsWarning("drawElementsInstancedANGLE: Extension is `invalidated`.");
    249      return;
    250    }
    251    mContext->DrawElementsInstanced(mode, count, type, offset, primcount);
    252  }
    253  void VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
    254    if (MOZ_UNLIKELY(!mContext)) {
    255      AutoJsWarning("vertexAttribDivisorANGLE: Extension is `invalidated`.");
    256      return;
    257    }
    258    mContext->VertexAttribDivisor(index, divisor);
    259  }
    260 };
    261 
    262 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionBlendMinMax)
    263 
    264 class ClientWebGLExtensionDisjointTimerQuery : public ClientWebGLExtensionBase {
    265 public:
    266  virtual JSObject* WrapObject(JSContext* cx,
    267                               JS::Handle<JSObject*> givenProto) override;
    268  explicit ClientWebGLExtensionDisjointTimerQuery(ClientWebGLContext&);
    269 
    270  already_AddRefed<WebGLQueryJS> CreateQueryEXT() const {
    271    RefPtr<WebGLQueryJS> ret;
    272    if (MOZ_UNLIKELY(!mContext)) {
    273      AutoJsWarning("createQueryEXT: Extension is `invalidated`.");
    274      ret = new WebGLQueryJS(nullptr);
    275    } else {
    276      ret = mContext->CreateQuery();
    277    }
    278    return ret.forget();
    279  }
    280  void DeleteQueryEXT(WebGLQueryJS* query) const {
    281    if (MOZ_UNLIKELY(!mContext)) {
    282      AutoJsWarning("deleteQueryEXT: Extension is `invalidated`.");
    283      return;
    284    }
    285    mContext->DeleteQuery(query);
    286  }
    287  bool IsQueryEXT(const WebGLQueryJS* query) const {
    288    if (MOZ_UNLIKELY(!mContext)) {
    289      AutoJsWarning("isQueryEXT: Extension is `invalidated`.");
    290      return false;
    291    }
    292    return mContext->IsQuery(query);
    293  }
    294  void BeginQueryEXT(GLenum target, WebGLQueryJS& query) const {
    295    if (MOZ_UNLIKELY(!mContext)) {
    296      AutoJsWarning("beginQueryEXT: Extension is `invalidated`.");
    297      return;
    298    }
    299    mContext->BeginQuery(target, query);
    300  }
    301  void EndQueryEXT(GLenum target) const {
    302    if (MOZ_UNLIKELY(!mContext)) {
    303      AutoJsWarning("endQueryEXT: Extension is `invalidated`.");
    304      return;
    305    }
    306    mContext->EndQuery(target);
    307  }
    308  void QueryCounterEXT(WebGLQueryJS& query, GLenum target) const {
    309    if (MOZ_UNLIKELY(!mContext)) {
    310      AutoJsWarning("queryCounterEXT: Extension is `invalidated`.");
    311      return;
    312    }
    313    mContext->QueryCounter(query, target);
    314  }
    315  void GetQueryEXT(JSContext* cx, GLenum target, GLenum pname,
    316                   JS::MutableHandle<JS::Value> retval) const {
    317    if (MOZ_UNLIKELY(!mContext)) {
    318      AutoJsWarning("getQueryEXT: Extension is `invalidated`.");
    319      return;
    320    }
    321    mContext->GetQuery(cx, target, pname, retval);
    322  }
    323  void GetQueryObjectEXT(JSContext* cx, WebGLQueryJS& query, GLenum pname,
    324                         JS::MutableHandle<JS::Value> retval) const {
    325    if (MOZ_UNLIKELY(!mContext)) {
    326      AutoJsWarning("getQueryObjectEXT: Extension is `invalidated`.");
    327      return;
    328    }
    329    mContext->GetQueryParameter(cx, query, pname, retval);
    330  }
    331 };
    332 
    333 class ClientWebGLExtensionExplicitPresent : public ClientWebGLExtensionBase {
    334 public:
    335  virtual JSObject* WrapObject(JSContext* cx,
    336                               JS::Handle<JSObject*> givenProto) override;
    337  explicit ClientWebGLExtensionExplicitPresent(ClientWebGLContext&);
    338 
    339  void Present() const {
    340    if (MOZ_UNLIKELY(!mContext)) {
    341      AutoJsWarning("present: Extension is `invalidated`.");
    342      return;
    343    }
    344    mContext->OnBeforePaintTransaction();
    345  }
    346 };
    347 
    348 class ClientWebGLExtensionMOZDebug : public ClientWebGLExtensionBase {
    349 public:
    350  virtual JSObject* WrapObject(JSContext* cx,
    351                               JS::Handle<JSObject*> givenProto) override;
    352  explicit ClientWebGLExtensionMOZDebug(ClientWebGLContext&);
    353 
    354  void GetParameter(JSContext* cx, GLenum pname,
    355                    JS::MutableHandle<JS::Value> retval,
    356                    ErrorResult& er) const {
    357    if (MOZ_UNLIKELY(!mContext)) {
    358      AutoJsWarning("getParameter: Extension is `invalidated`.");
    359      return;
    360    }
    361    mContext->MOZDebugGetParameter(cx, pname, retval, er);
    362  }
    363 };
    364 
    365 class ClientWebGLExtensionMultiview : public ClientWebGLExtensionBase {
    366 public:
    367  virtual JSObject* WrapObject(JSContext* cx,
    368                               JS::Handle<JSObject*> givenProto) override;
    369  explicit ClientWebGLExtensionMultiview(ClientWebGLContext&);
    370 
    371  void FramebufferTextureMultiviewOVR(const GLenum target,
    372                                      const GLenum attachment,
    373                                      WebGLTextureJS* const texture,
    374                                      const GLint level,
    375                                      const GLint baseViewIndex,
    376                                      const GLsizei numViews) const {
    377    if (MOZ_UNLIKELY(!mContext)) {
    378      AutoJsWarning(
    379          "framebufferTextureMultiviewOVR: Extension is `invalidated`.");
    380      return;
    381    }
    382    mContext->FramebufferTextureMultiview(target, attachment, texture, level,
    383                                          baseViewIndex, numViews);
    384  }
    385 };
    386 
    387 class ClientWebGLExtensionDrawBuffersIndexed : public ClientWebGLExtensionBase {
    388 public:
    389  virtual JSObject* WrapObject(JSContext* cx,
    390                               JS::Handle<JSObject*> givenProto) override;
    391  explicit ClientWebGLExtensionDrawBuffersIndexed(ClientWebGLContext&);
    392 
    393  void EnableiOES(const GLenum target, const GLuint buf) const {
    394    if (MOZ_UNLIKELY(!mContext)) {
    395      AutoJsWarning("enableiOES: Extension is `invalidated`.");
    396      return;
    397    }
    398    mContext->SetEnabledI(target, Some(buf), true);
    399  }
    400 
    401  void DisableiOES(const GLenum target, const GLuint buf) const {
    402    if (MOZ_UNLIKELY(!mContext)) {
    403      AutoJsWarning("disableiOES: Extension is `invalidated`.");
    404      return;
    405    }
    406    mContext->SetEnabledI(target, Some(buf), false);
    407  }
    408 
    409  void BlendEquationiOES(const GLuint buf, const GLenum mode) const {
    410    BlendEquationSeparateiOES(buf, mode, mode);
    411  }
    412 
    413  void BlendEquationSeparateiOES(const GLuint buf, const GLenum modeRgb,
    414                                 const GLenum modeAlpha) const {
    415    if (MOZ_UNLIKELY(!mContext)) {
    416      AutoJsWarning("blendEquationSeparateiOES: Extension is `invalidated`.");
    417      return;
    418    }
    419    mContext->BlendEquationSeparateI(Some(buf), modeRgb, modeAlpha);
    420  }
    421 
    422  void BlendFunciOES(const GLuint buf, const GLenum src,
    423                     const GLenum dst) const {
    424    BlendFuncSeparateiOES(buf, src, dst, src, dst);
    425  }
    426 
    427  void BlendFuncSeparateiOES(const GLuint buf, const GLenum srcRgb,
    428                             const GLenum dstRgb, const GLenum srcAlpha,
    429                             const GLenum dstAlpha) const {
    430    if (MOZ_UNLIKELY(!mContext)) {
    431      AutoJsWarning("blendFuncSeparateiOES: Extension is `invalidated`.");
    432      return;
    433    }
    434    mContext->BlendFuncSeparateI(Some(buf), srcRgb, dstRgb, srcAlpha, dstAlpha);
    435  }
    436 
    437  void ColorMaskiOES(const GLuint buf, const bool r, const bool g, const bool b,
    438                     const bool a) const {
    439    if (MOZ_UNLIKELY(!mContext)) {
    440      AutoJsWarning("colorMaskiOES: Extension is `invalidated`.");
    441      return;
    442    }
    443    mContext->ColorMaskI(Some(buf), r, g, b, a);
    444  }
    445 };
    446 
    447 }  // namespace mozilla
    448 
    449 #endif  // CLIENTWEBGLEXTENSIONS_H_