dom/canvas/ClientWebGLExtensions.h

   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 "WebGLExtensions.h"
  10 #include "ClientWebGLContext.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(WebGLExtensionDepthTexture)
 109
 110 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionElementIndexUint)
 111
 112 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionEXTColorBufferFloat)
 113
 114 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionFragDepth)
 115
 116 class ClientWebGLExtensionLoseContext : public ClientWebGLExtensionBase {
 117  public:
 118   virtual JSObject* WrapObject(JSContext* cx,
 119                                JS::Handle<JSObject*> givenProto) override;
 120   explicit ClientWebGLExtensionLoseContext(ClientWebGLContext&);
 121
 122   void LoseContext() {
 123     if (MOZ_UNLIKELY(!mContext)) {
 124       AutoJsWarning("loseContext: Extension is `invalidated`.");
 125       return;
 126     }
 127     mContext->EmulateLoseContext();
 128   }
 129   void RestoreContext() {
 130     if (MOZ_UNLIKELY(!mContext)) {
 131       AutoJsWarning("restoreContext: Extension is `invalidated`.");
 132       return;
 133     }
 134     mContext->RestoreContext(webgl::LossStatus::LostManually);
 135   }
 136 };
 137
 138 class ClientWebGLExtensionProvokingVertex : public ClientWebGLExtensionBase {
 139  public:
 140   virtual JSObject* WrapObject(JSContext* cx,
 141                                JS::Handle<JSObject*> givenProto) override;
 142   explicit ClientWebGLExtensionProvokingVertex(ClientWebGLContext&);
 143
 144   void ProvokingVertexWEBGL(const GLenum mode) const {
 145     if (MOZ_UNLIKELY(!mContext)) {
 146       AutoJsWarning("provokingVertexWEBGL: Extension is `invalidated`.");
 147       return;
 148     }
 149     mContext->ProvokingVertex(mode);
 150   }
 151 };
 152
 153 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionSRGB)
 154
 155 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionStandardDerivatives)
 156
 157 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionShaderTextureLod)
 158
 159 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureFilterAnisotropic)
 160
 161 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureFloat)
 162
 163 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureFloatLinear)
 164
 165 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureHalfFloat)
 166
 167 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureHalfFloatLinear)
 168
 169 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionTextureNorm16)
 170
 171 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionColorBufferFloat)
 172
 173 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionColorBufferHalfFloat)
 174
 175 class ClientWebGLExtensionDrawBuffers : public ClientWebGLExtensionBase {
 176  public:
 177   virtual JSObject* WrapObject(JSContext* cx,
 178                                JS::Handle<JSObject*> givenProto) override;
 179   explicit ClientWebGLExtensionDrawBuffers(ClientWebGLContext&);
 180
 181   void DrawBuffersWEBGL(const dom::Sequence<GLenum>& buffers) {
 182     if (MOZ_UNLIKELY(!mContext)) {
 183       AutoJsWarning("drawBuffersWEBGL: Extension is `invalidated`.");
 184       return;
 185     }
 186     mContext->DrawBuffers(buffers);
 187   }
 188 };
 189
 190 class ClientWebGLExtensionVertexArray : public ClientWebGLExtensionBase {
 191  public:
 192   virtual JSObject* WrapObject(JSContext* cx,
 193                                JS::Handle<JSObject*> givenProto) override;
 194   explicit ClientWebGLExtensionVertexArray(ClientWebGLContext&);
 195
 196   already_AddRefed<WebGLVertexArrayJS> CreateVertexArrayOES() {
 197     if (MOZ_UNLIKELY(!mContext)) {
 198       AutoJsWarning("createVertexArrayOES: Extension is `invalidated`.");
 199       return nullptr;
 200     }
 201     return mContext->CreateVertexArray();
 202   }
 203   void DeleteVertexArrayOES(WebGLVertexArrayJS* array) {
 204     if (MOZ_UNLIKELY(!mContext)) {
 205       AutoJsWarning("deleteVertexArrayOES: Extension is `invalidated`.");
 206       return;
 207     }
 208     mContext->DeleteVertexArray(array);
 209   }
 210   bool IsVertexArrayOES(const WebGLVertexArrayJS* array) {
 211     if (MOZ_UNLIKELY(!mContext)) {
 212       AutoJsWarning("isVertexArrayOES: Extension is `invalidated`.");
 213       return false;
 214     }
 215     return mContext->IsVertexArray(array);
 216   }
 217   void BindVertexArrayOES(WebGLVertexArrayJS* array) {
 218     if (MOZ_UNLIKELY(!mContext)) {
 219       AutoJsWarning("bindVertexArrayOES: Extension is `invalidated`.");
 220       return;
 221     }
 222     mContext->BindVertexArray(array);
 223   }
 224 };
 225
 226 class ClientWebGLExtensionInstancedArrays : public ClientWebGLExtensionBase {
 227  public:
 228   virtual JSObject* WrapObject(JSContext* cx,
 229                                JS::Handle<JSObject*> givenProto) override;
 230   explicit ClientWebGLExtensionInstancedArrays(ClientWebGLContext&);
 231
 232   void DrawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count,
 233                                 GLsizei primcount) {
 234     if (MOZ_UNLIKELY(!mContext)) {
 235       AutoJsWarning("drawArraysInstancedANGLE: Extension is `invalidated`.");
 236       return;
 237     }
 238     mContext->DrawArraysInstanced(mode, first, count, primcount);
 239   }
 240   void DrawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type,
 241                                   WebGLintptr offset, GLsizei primcount) {
 242     if (MOZ_UNLIKELY(!mContext)) {
 243       AutoJsWarning("drawElementsInstancedANGLE: Extension is `invalidated`.");
 244       return;
 245     }
 246     mContext->DrawElementsInstanced(mode, count, type, offset, primcount);
 247   }
 248   void VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
 249     if (MOZ_UNLIKELY(!mContext)) {
 250       AutoJsWarning("vertexAttribDivisorANGLE: Extension is `invalidated`.");
 251       return;
 252     }
 253     mContext->VertexAttribDivisor(index, divisor);
 254   }
 255 };
 256
 257 DECLARE_SIMPLE_WEBGL_EXTENSION(WebGLExtensionBlendMinMax)
 258
 259 class ClientWebGLExtensionDisjointTimerQuery : public ClientWebGLExtensionBase {
 260  public:
 261   virtual JSObject* WrapObject(JSContext* cx,
 262                                JS::Handle<JSObject*> givenProto) override;
 263   explicit ClientWebGLExtensionDisjointTimerQuery(ClientWebGLContext&);
 264
 265   already_AddRefed<WebGLQueryJS> CreateQueryEXT() const {
 266     if (MOZ_UNLIKELY(!mContext)) {
 267       AutoJsWarning("createQueryEXT: Extension is `invalidated`.");
 268       return nullptr;
 269     }
 270     return mContext->CreateQuery();
 271   }
 272   void DeleteQueryEXT(WebGLQueryJS* query) const {
 273     if (MOZ_UNLIKELY(!mContext)) {
 274       AutoJsWarning("deleteQueryEXT: Extension is `invalidated`.");
 275       return;
 276     }
 277     mContext->DeleteQuery(query);
 278   }
 279   bool IsQueryEXT(const WebGLQueryJS* query) const {
 280     if (MOZ_UNLIKELY(!mContext)) {
 281       AutoJsWarning("isQueryEXT: Extension is `invalidated`.");
 282       return false;
 283     }
 284     return mContext->IsQuery(query);
 285   }
 286   void BeginQueryEXT(GLenum target, WebGLQueryJS& query) const {
 287     if (MOZ_UNLIKELY(!mContext)) {
 288       AutoJsWarning("beginQueryEXT: Extension is `invalidated`.");
 289       return;
 290     }
 291     mContext->BeginQuery(target, query);
 292   }
 293   void EndQueryEXT(GLenum target) const {
 294     if (MOZ_UNLIKELY(!mContext)) {
 295       AutoJsWarning("endQueryEXT: Extension is `invalidated`.");
 296       return;
 297     }
 298     mContext->EndQuery(target);
 299   }
 300   void QueryCounterEXT(WebGLQueryJS& query, GLenum target) const {
 301     if (MOZ_UNLIKELY(!mContext)) {
 302       AutoJsWarning("queryCounterEXT: Extension is `invalidated`.");
 303       return;
 304     }
 305     mContext->QueryCounter(query, target);
 306   }
 307   void GetQueryEXT(JSContext* cx, GLenum target, GLenum pname,
 308                    JS::MutableHandle<JS::Value> retval) const {
 309     if (MOZ_UNLIKELY(!mContext)) {
 310       AutoJsWarning("getQueryEXT: Extension is `invalidated`.");
 311       return;
 312     }
 313     mContext->GetQuery(cx, target, pname, retval);
 314   }
 315   void GetQueryObjectEXT(JSContext* cx, WebGLQueryJS& query, GLenum pname,
 316                          JS::MutableHandle<JS::Value> retval) const {
 317     if (MOZ_UNLIKELY(!mContext)) {
 318       AutoJsWarning("getQueryObjectEXT: Extension is `invalidated`.");
 319       return;
 320     }
 321     mContext->GetQueryParameter(cx, query, pname, retval);
 322   }
 323 };
 324
 325 class ClientWebGLExtensionExplicitPresent : public ClientWebGLExtensionBase {
 326  public:
 327   virtual JSObject* WrapObject(JSContext* cx,
 328                                JS::Handle<JSObject*> givenProto) override;
 329   explicit ClientWebGLExtensionExplicitPresent(ClientWebGLContext&);
 330
 331   void Present() const {
 332     if (MOZ_UNLIKELY(!mContext)) {
 333       AutoJsWarning("present: Extension is `invalidated`.");
 334       return;
 335     }
 336     mContext->OnBeforePaintTransaction();
 337   }
 338 };
 339
 340 class ClientWebGLExtensionMOZDebug : public ClientWebGLExtensionBase {
 341  public:
 342   virtual JSObject* WrapObject(JSContext* cx,
 343                                JS::Handle<JSObject*> givenProto) override;
 344   explicit ClientWebGLExtensionMOZDebug(ClientWebGLContext&);
 345
 346   void GetParameter(JSContext* cx, GLenum pname,
 347                     JS::MutableHandle<JS::Value> retval,
 348                     ErrorResult& er) const {
 349     if (MOZ_UNLIKELY(!mContext)) {
 350       AutoJsWarning("getParameter: Extension is `invalidated`.");
 351       return;
 352     }
 353     mContext->MOZDebugGetParameter(cx, pname, retval, er);
 354   }
 355 };
 356
 357 class ClientWebGLExtensionMultiview : public ClientWebGLExtensionBase {
 358  public:
 359   virtual JSObject* WrapObject(JSContext* cx,
 360                                JS::Handle<JSObject*> givenProto) override;
 361   explicit ClientWebGLExtensionMultiview(ClientWebGLContext&);
 362
 363   void FramebufferTextureMultiviewOVR(const GLenum target,
 364                                       const GLenum attachment,
 365                                       WebGLTextureJS* const texture,
 366                                       const GLint level,
 367                                       const GLint baseViewIndex,
 368                                       const GLsizei numViews) const {
 369     if (MOZ_UNLIKELY(!mContext)) {
 370       AutoJsWarning(
 371           "framebufferTextureMultiviewOVR: Extension is `invalidated`.");
 372       return;
 373     }
 374     mContext->FramebufferTextureMultiview(target, attachment, texture, level,
 375                                           baseViewIndex, numViews);
 376   }
 377 };
 378
 379 class ClientWebGLExtensionDrawBuffersIndexed : public ClientWebGLExtensionBase {
 380  public:
 381   virtual JSObject* WrapObject(JSContext* cx,
 382                                JS::Handle<JSObject*> givenProto) override;
 383   explicit ClientWebGLExtensionDrawBuffersIndexed(ClientWebGLContext&);
 384
 385   void EnableiOES(const GLenum target, const GLuint buf) const {
 386     if (MOZ_UNLIKELY(!mContext)) {
 387       AutoJsWarning("enableiOES: Extension is `invalidated`.");
 388       return;
 389     }
 390     mContext->SetEnabledI(target, Some(buf), true);
 391   }
 392
 393   void DisableiOES(const GLenum target, const GLuint buf) const {
 394     if (MOZ_UNLIKELY(!mContext)) {
 395       AutoJsWarning("disableiOES: Extension is `invalidated`.");
 396       return;
 397     }
 398     mContext->SetEnabledI(target, Some(buf), false);
 399   }
 400
 401   void BlendEquationiOES(const GLuint buf, const GLenum mode) const {
 402     BlendEquationSeparateiOES(buf, mode, mode);
 403   }
 404
 405   void BlendEquationSeparateiOES(const GLuint buf, const GLenum modeRgb,
 406                                  const GLenum modeAlpha) const {
 407     if (MOZ_UNLIKELY(!mContext)) {
 408       AutoJsWarning("blendEquationSeparateiOES: Extension is `invalidated`.");
 409       return;
 410     }
 411     mContext->BlendEquationSeparateI(Some(buf), modeRgb, modeAlpha);
 412   }
 413
 414   void BlendFunciOES(const GLuint buf, const GLenum src,
 415                      const GLenum dst) const {
 416     BlendFuncSeparateiOES(buf, src, dst, src, dst);
 417   }
 418
 419   void BlendFuncSeparateiOES(const GLuint buf, const GLenum srcRgb,
 420                              const GLenum dstRgb, const GLenum srcAlpha,
 421                              const GLenum dstAlpha) const {
 422     if (MOZ_UNLIKELY(!mContext)) {
 423       AutoJsWarning("blendFuncSeparateiOES: Extension is `invalidated`.");
 424       return;
 425     }
 426     mContext->BlendFuncSeparateI(Some(buf), srcRgb, dstRgb, srcAlpha, dstAlpha);
 427   }
 428
 429   void ColorMaskiOES(const GLuint buf, const bool r, const bool g, const bool b,
 430                      const bool a) const {
 431     if (MOZ_UNLIKELY(!mContext)) {
 432       AutoJsWarning("colorMaskiOES: Extension is `invalidated`.");
 433       return;
 434     }
 435     mContext->ColorMaskI(Some(buf), r, g, b, a);
 436   }
 437 };
 438
 439 }  // namespace mozilla
 440
 441 #endif  // CLIENTWEBGLEXTENSIONS_H_