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(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_