diff options
Diffstat (limited to 'dom/canvas/WebGLContext.h')
| -rw-r--r-- | dom/canvas/WebGLContext.h | 2201 |
1 files changed, 2201 insertions, 0 deletions
diff --git a/dom/canvas/WebGLContext.h b/dom/canvas/WebGLContext.h new file mode 100644 index 000000000..b4d416a33 --- /dev/null +++ b/dom/canvas/WebGLContext.h @@ -0,0 +1,2201 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef WEBGLCONTEXT_H_ +#define WEBGLCONTEXT_H_ + +#include <stdarg.h> + +#include "GLContextTypes.h" +#include "GLDefs.h" +#include "mozilla/Attributes.h" +#include "mozilla/CheckedInt.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/HTMLCanvasElement.h" +#include "mozilla/dom/TypedArray.h" +#include "mozilla/EnumeratedArray.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/LinkedList.h" +#include "mozilla/UniquePtr.h" +#include "nsCycleCollectionNoteChild.h" +#include "nsICanvasRenderingContextInternal.h" +#include "nsLayoutUtils.h" +#include "nsTArray.h" +#include "nsWrapperCache.h" +#include "SurfaceTypes.h" +#include "ScopedGLHelpers.h" +#include "TexUnpackBlob.h" + +#ifdef XP_MACOSX +#include "ForceDiscreteGPUHelperCGL.h" +#endif + +// Local +#include "WebGLContextLossHandler.h" +#include "WebGLContextUnchecked.h" +#include "WebGLFormats.h" +#include "WebGLObjectModel.h" +#include "WebGLStrongTypes.h" +#include "WebGLTexture.h" + +// Generated +#include "nsIDOMEventListener.h" +#include "nsIDOMWebGLRenderingContext.h" +#include "nsICanvasRenderingContextInternal.h" +#include "nsIObserver.h" +#include "mozilla/dom/HTMLCanvasElement.h" +#include "nsWrapperCache.h" +#include "nsLayoutUtils.h" +#include "mozilla/dom/WebGLRenderingContextBinding.h" +#include "mozilla/dom/WebGL2RenderingContextBinding.h" + +class nsIDocShell; + +/* + * Minimum value constants defined in 6.2 State Tables of OpenGL ES - 2.0.25 + * https://bugzilla.mozilla.org/show_bug.cgi?id=686732 + * + * Exceptions: some of the following values are set to higher values than in the spec because + * the values in the spec are ridiculously low. They are explicitly marked below + */ +#define MINVALUE_GL_MAX_TEXTURE_SIZE 1024 // Different from the spec, which sets it to 64 on page 162 +#define MINVALUE_GL_MAX_CUBE_MAP_TEXTURE_SIZE 512 // Different from the spec, which sets it to 16 on page 162 +#define MINVALUE_GL_MAX_VERTEX_ATTRIBS 8 // Page 164 +#define MINVALUE_GL_MAX_FRAGMENT_UNIFORM_VECTORS 16 // Page 164 +#define MINVALUE_GL_MAX_VERTEX_UNIFORM_VECTORS 128 // Page 164 +#define MINVALUE_GL_MAX_VARYING_VECTORS 8 // Page 164 +#define MINVALUE_GL_MAX_TEXTURE_IMAGE_UNITS 8 // Page 164 +#define MINVALUE_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0 // Page 164 +#define MINVALUE_GL_MAX_RENDERBUFFER_SIZE 1024 // Different from the spec, which sets it to 1 on page 164 +#define MINVALUE_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 8 // Page 164 + +/* + * Minimum value constants define in 6.2 State Tables of OpenGL ES - 3.0.4 + */ +#define MINVALUE_GL_MAX_3D_TEXTURE_SIZE 256 +#define MINVALUE_GL_MAX_ARRAY_TEXTURE_LAYERS 256 + +/* + * WebGL-only GLenums + */ +#define LOCAL_GL_BROWSER_DEFAULT_WEBGL 0x9244 +#define LOCAL_GL_CONTEXT_LOST_WEBGL 0x9242 +#define LOCAL_GL_MAX_CLIENT_WAIT_TIMEOUT_WEBGL 0x9247 +#define LOCAL_GL_UNPACK_COLORSPACE_CONVERSION_WEBGL 0x9243 +#define LOCAL_GL_UNPACK_FLIP_Y_WEBGL 0x9240 +#define LOCAL_GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL 0x9241 + +namespace mozilla { +class ScopedCopyTexImageSource; +class ScopedResolveTexturesForDraw; +class ScopedUnpackReset; +class WebGLActiveInfo; +class WebGLBuffer; +class WebGLExtensionBase; +class WebGLFramebuffer; +class WebGLProgram; +class WebGLQuery; +class WebGLRenderbuffer; +class WebGLSampler; +class WebGLShader; +class WebGLShaderPrecisionFormat; +class WebGLSync; +class WebGLTexture; +class WebGLTransformFeedback; +class WebGLUniformLocation; +class WebGLVertexArray; + +namespace dom { +class Element; +class ImageData; +class OwningHTMLCanvasElementOrOffscreenCanvas; +struct WebGLContextAttributes; +template<typename> struct Nullable; +} // namespace dom + +namespace gfx { +class SourceSurface; +class VRLayerChild; +} // namespace gfx + +namespace webgl { +struct LinkedProgramInfo; +class ShaderValidator; +class TexUnpackBlob; +struct UniformInfo; +struct UniformBlockInfo; +} // namespace webgl + +WebGLTexelFormat GetWebGLTexelFormat(TexInternalFormat format); + +void AssertUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint shadow); + +struct WebGLContextOptions +{ + // these are defaults + WebGLContextOptions(); + + bool operator==(const WebGLContextOptions& other) const { + return + alpha == other.alpha && + depth == other.depth && + stencil == other.stencil && + premultipliedAlpha == other.premultipliedAlpha && + antialias == other.antialias && + preserveDrawingBuffer == other.preserveDrawingBuffer; + } + + bool operator!=(const WebGLContextOptions& other) const { + return !operator==(other); + } + + bool alpha; + bool depth; + bool stencil; + bool premultipliedAlpha; + bool antialias; + bool preserveDrawingBuffer; + bool failIfMajorPerformanceCaveat; +}; + +// From WebGLContextUtils +TexTarget TexImageTargetToTexTarget(TexImageTarget texImageTarget); + +struct WebGLIntOrFloat { + const enum { + Int, + Float, + Uint + } mType; + + union { + GLint i; + GLfloat f; + GLuint u; + } mValue; + + explicit WebGLIntOrFloat(GLint i) : mType(Int) { mValue.i = i; } + explicit WebGLIntOrFloat(GLfloat f) : mType(Float) { mValue.f = f; } + + GLint AsInt() const { return (mType == Int) ? mValue.i : NS_lroundf(mValue.f); } + GLfloat AsFloat() const { return (mType == Float) ? mValue.f : GLfloat(mValue.i); } +}; + +struct IndexedBufferBinding +{ + WebGLRefPtr<WebGLBuffer> mBufferBinding; + uint64_t mRangeStart; + uint64_t mRangeSize; + + IndexedBufferBinding(); + + uint64_t ByteCount() const; +}; + +//// + +struct FloatOrInt final // For TexParameter[fi] and friends. +{ + const bool isFloat; + const GLfloat f; + const GLint i; + + explicit FloatOrInt(GLint x) + : isFloat(false) + , f(x) + , i(x) + { } + + explicit FloatOrInt(GLfloat x) + : isFloat(true) + , f(x) + , i(roundf(x)) + { } + + FloatOrInt& operator =(const FloatOrInt& x) { + memcpy(this, &x, sizeof(x)); + return *this; + } +}; + +//////////////////////////////////// + +struct TexImageSource +{ + const dom::ArrayBufferView* mView; + GLuint mViewElemOffset; + GLuint mViewElemLengthOverride; + + const WebGLsizeiptr* mPboOffset; + + const dom::ImageBitmap* mImageBitmap; + const dom::ImageData* mImageData; + + const dom::Element* mDomElem; + ErrorResult* mOut_error; + +protected: + TexImageSource() { + memset(this, 0, sizeof(*this)); + } +}; + +//// + +struct TexImageSourceAdapter final : public TexImageSource +{ + TexImageSourceAdapter(const dom::Nullable<dom::ArrayBufferView>* maybeView, + ErrorResult*) + { + if (!maybeView->IsNull()) { + mView = &(maybeView->Value()); + } + } + + TexImageSourceAdapter(const dom::ArrayBufferView* view, ErrorResult*) { + mView = view; + } + + TexImageSourceAdapter(const dom::ArrayBufferView* view, GLuint viewElemOffset, + GLuint viewElemLengthOverride = 0) + { + mView = view; + mViewElemOffset = viewElemOffset; + mViewElemLengthOverride = viewElemLengthOverride; + } + + TexImageSourceAdapter(const WebGLsizeiptr* pboOffset, GLuint ignored1, GLuint ignored2 = 0) { + mPboOffset = pboOffset; + } + + TexImageSourceAdapter(const WebGLsizeiptr* pboOffset, ErrorResult* ignored) { + mPboOffset = pboOffset; + } + + TexImageSourceAdapter(const dom::ImageBitmap* imageBitmap, ErrorResult*) { + mImageBitmap = imageBitmap; + } + + TexImageSourceAdapter(const dom::ImageData* imageData, ErrorResult*) { + mImageData = imageData; + } + + TexImageSourceAdapter(const dom::Element* domElem, ErrorResult* const out_error) { + mDomElem = domElem; + mOut_error = out_error; + } +}; + +//////////////////////////////////////////////////////////////////////////////// + +class WebGLContext + : public nsIDOMWebGLRenderingContext + , public nsICanvasRenderingContextInternal + , public nsSupportsWeakReference + , public WebGLContextUnchecked + , public WebGLRectangleObject + , public nsWrapperCache +{ + friend class ScopedDrawHelper; + friend class ScopedDrawWithTransformFeedback; + friend class ScopedFBRebinder; + friend class WebGL2Context; + friend class WebGLContextUserData; + friend class WebGLExtensionCompressedTextureATC; + friend class WebGLExtensionCompressedTextureES3; + friend class WebGLExtensionCompressedTextureETC1; + friend class WebGLExtensionCompressedTexturePVRTC; + friend class WebGLExtensionCompressedTextureS3TC; + friend class WebGLExtensionDepthTexture; + friend class WebGLExtensionDisjointTimerQuery; + friend class WebGLExtensionDrawBuffers; + friend class WebGLExtensionLoseContext; + friend class WebGLExtensionVertexArray; + friend class WebGLMemoryTracker; + friend struct webgl::UniformBlockInfo; + + enum { + UNPACK_FLIP_Y_WEBGL = 0x9240, + UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241, + CONTEXT_LOST_WEBGL = 0x9242, + UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243, + BROWSER_DEFAULT_WEBGL = 0x9244, + UNMASKED_VENDOR_WEBGL = 0x9245, + UNMASKED_RENDERER_WEBGL = 0x9246 + }; + + static const uint32_t kMinMaxColorAttachments; + static const uint32_t kMinMaxDrawBuffers; + +public: + WebGLContext(); + +protected: + virtual ~WebGLContext(); + +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(WebGLContext, + nsIDOMWebGLRenderingContext) + + virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> givenProto) override = 0; + + NS_DECL_NSIDOMWEBGLRENDERINGCONTEXT + + virtual void OnVisibilityChange() override; + virtual void OnMemoryPressure() override; + + // nsICanvasRenderingContextInternal + virtual int32_t GetWidth() const override; + virtual int32_t GetHeight() const override; + + NS_IMETHOD SetDimensions(int32_t width, int32_t height) override; + NS_IMETHOD InitializeWithDrawTarget(nsIDocShell*, + NotNull<gfx::DrawTarget*>) override + { + return NS_ERROR_NOT_IMPLEMENTED; + } + + NS_IMETHOD Reset() override { + /* (InitializeWithSurface) */ + return NS_ERROR_NOT_IMPLEMENTED; + } + + virtual UniquePtr<uint8_t[]> GetImageBuffer(int32_t* out_format) override; + NS_IMETHOD GetInputStream(const char* mimeType, + const char16_t* encoderOptions, + nsIInputStream** out_stream) override; + + already_AddRefed<mozilla::gfx::SourceSurface> + GetSurfaceSnapshot(bool* out_premultAlpha) override; + + NS_IMETHOD SetIsOpaque(bool) override { return NS_OK; }; + bool GetIsOpaque() override { return false; } + NS_IMETHOD SetContextOptions(JSContext* cx, + JS::Handle<JS::Value> options, + ErrorResult& aRvForDictionaryInit) override; + + NS_IMETHOD SetIsIPC(bool) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + /** + * An abstract base class to be implemented by callers wanting to be notified + * that a refresh has occurred. Callers must ensure an observer is removed + * before it is destroyed. + */ + virtual void DidRefresh() override; + + NS_IMETHOD Redraw(const gfxRect&) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + void SynthesizeGLError(GLenum err); + void SynthesizeGLError(GLenum err, const char* fmt, ...); + + void ErrorInvalidEnum(const char* fmt = 0, ...); + void ErrorInvalidOperation(const char* fmt = 0, ...); + void ErrorInvalidValue(const char* fmt = 0, ...); + void ErrorInvalidFramebufferOperation(const char* fmt = 0, ...); + void ErrorInvalidEnumInfo(const char* info, GLenum enumValue); + void ErrorInvalidEnumInfo(const char* info, const char* funcName, + GLenum enumValue); + void ErrorOutOfMemory(const char* fmt = 0, ...); + void ErrorImplementationBug(const char* fmt = 0, ...); + + void ErrorInvalidEnumArg(const char* funcName, const char* argName, GLenum val); + + const char* ErrorName(GLenum error); + + /** + * Return displayable name for GLenum. + * This version is like gl::GLenumToStr but with out the GL_ prefix to + * keep consistency with how errors are reported from WebGL. + * Returns hex formatted version of glenum if glenum is unknown. + */ + static void EnumName(GLenum val, nsCString* out_name); + + void DummyReadFramebufferOperation(const char* funcName); + + WebGLTexture* ActiveBoundTextureForTarget(const TexTarget texTarget) const { + switch (texTarget.get()) { + case LOCAL_GL_TEXTURE_2D: + return mBound2DTextures[mActiveTexture]; + case LOCAL_GL_TEXTURE_CUBE_MAP: + return mBoundCubeMapTextures[mActiveTexture]; + case LOCAL_GL_TEXTURE_3D: + return mBound3DTextures[mActiveTexture]; + case LOCAL_GL_TEXTURE_2D_ARRAY: + return mBound2DArrayTextures[mActiveTexture]; + default: + MOZ_CRASH("GFX: bad target"); + } + } + + /* Use this function when you have the texture image target, for example: + * GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_[POSITIVE|NEGATIVE]_[X|Y|Z], and + * not the actual texture binding target: GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP. + */ + WebGLTexture* + ActiveBoundTextureForTexImageTarget(const TexImageTarget texImgTarget) const + { + const TexTarget texTarget = TexImageTargetToTexTarget(texImgTarget); + return ActiveBoundTextureForTarget(texTarget); + } + + void InvalidateResolveCacheForTextureWithTexUnit(const GLuint); + + already_AddRefed<Layer> + GetCanvasLayer(nsDisplayListBuilder* builder, Layer* oldLayer, + LayerManager* manager, + bool aMirror = false) override; + + // Note that 'clean' here refers to its invalidation state, not the + // contents of the buffer. + void MarkContextClean() override { mInvalidated = false; } + + void MarkContextCleanForFrameCapture() override { mCapturedFrameInvalidated = false; } + + bool IsContextCleanForFrameCapture() override { return !mCapturedFrameInvalidated; } + + gl::GLContext* GL() const { return gl; } + + bool IsPremultAlpha() const { return mOptions.premultipliedAlpha; } + + bool IsPreservingDrawingBuffer() const { return mOptions.preserveDrawingBuffer; } + + bool PresentScreenBuffer(); + + // Prepare the context for capture before compositing + void BeginComposition(); + // Clean up the context after captured for compositing + void EndComposition(); + + // a number that increments every time we have an event that causes + // all context resources to be lost. + uint32_t Generation() const { return mGeneration.value(); } + + // This is similar to GLContext::ClearSafely, but tries to minimize the + // amount of work it does. + // It only clears the buffers we specify, and can reset its state without + // first having to query anything, as WebGL knows its state at all times. + void ForceClearFramebufferWithDefaultValues(GLbitfield bufferBits, bool fakeNoAlpha); + + // Calls ForceClearFramebufferWithDefaultValues() for the Context's 'screen'. + void ClearScreen(); + void ClearBackbufferIfNeeded(); + + bool MinCapabilityMode() const { return mMinCapability; } + + void RunContextLossTimer(); + void UpdateContextLossStatus(); + void EnqueueUpdateContextLossStatus(); + + bool TryToRestoreContext(); + + void AssertCachedBindings(); + void AssertCachedGlobalState(); + + dom::HTMLCanvasElement* GetCanvas() const { return mCanvasElement; } + + // WebIDL WebGLRenderingContext API + void Commit(); + void GetCanvas(Nullable<dom::OwningHTMLCanvasElementOrOffscreenCanvas>& retval); + GLsizei DrawingBufferWidth() const { return IsContextLost() ? 0 : mWidth; } + GLsizei DrawingBufferHeight() const { + return IsContextLost() ? 0 : mHeight; + } + + layers::LayersBackend GetCompositorBackendType() const; + + void + GetContextAttributes(dom::Nullable<dom::WebGLContextAttributes>& retval); + + bool IsContextLost() const { return mContextStatus != ContextNotLost; } + void GetSupportedExtensions(dom::Nullable< nsTArray<nsString> >& retval, + dom::CallerType callerType); + void GetExtension(JSContext* cx, const nsAString& name, + JS::MutableHandle<JSObject*> retval, + dom::CallerType callerType, ErrorResult& rv); + void AttachShader(WebGLProgram& prog, WebGLShader& shader); + void BindAttribLocation(WebGLProgram& prog, GLuint location, + const nsAString& name); + void BindFramebuffer(GLenum target, WebGLFramebuffer* fb); + void BindRenderbuffer(GLenum target, WebGLRenderbuffer* fb); + void BindVertexArray(WebGLVertexArray* vao); + void BlendColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a); + void BlendEquation(GLenum mode); + void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); + void BlendFunc(GLenum sfactor, GLenum dfactor); + void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, + GLenum srcAlpha, GLenum dstAlpha); + GLenum CheckFramebufferStatus(GLenum target); + void Clear(GLbitfield mask); + void ClearColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a); + void ClearDepth(GLclampf v); + void ClearStencil(GLint v); + void ColorMask(WebGLboolean r, WebGLboolean g, WebGLboolean b, WebGLboolean a); + void CompileShader(WebGLShader& shader); + void CompileShaderANGLE(WebGLShader* shader); + void CompileShaderBypass(WebGLShader* shader, const nsCString& shaderSource); + already_AddRefed<WebGLFramebuffer> CreateFramebuffer(); + already_AddRefed<WebGLProgram> CreateProgram(); + already_AddRefed<WebGLRenderbuffer> CreateRenderbuffer(); + already_AddRefed<WebGLShader> CreateShader(GLenum type); + already_AddRefed<WebGLVertexArray> CreateVertexArray(); + void CullFace(GLenum face); + void DeleteFramebuffer(WebGLFramebuffer* fb); + void DeleteProgram(WebGLProgram* prog); + void DeleteRenderbuffer(WebGLRenderbuffer* rb); + void DeleteShader(WebGLShader* shader); + void DeleteVertexArray(WebGLVertexArray* vao); + void DepthFunc(GLenum func); + void DepthMask(WebGLboolean b); + void DepthRange(GLclampf zNear, GLclampf zFar); + void DetachShader(WebGLProgram& prog, const WebGLShader& shader); + void DrawBuffers(const dom::Sequence<GLenum>& buffers); + void Flush(); + void Finish(); + void FramebufferRenderbuffer(GLenum target, GLenum attachment, + GLenum rbTarget, WebGLRenderbuffer* rb); + void FramebufferTexture2D(GLenum target, GLenum attachment, + GLenum texImageTarget, WebGLTexture* tex, + GLint level); + + void FrontFace(GLenum mode); + already_AddRefed<WebGLActiveInfo> GetActiveAttrib(const WebGLProgram& prog, + GLuint index); + already_AddRefed<WebGLActiveInfo> GetActiveUniform(const WebGLProgram& prog, + GLuint index); + + void + GetAttachedShaders(const WebGLProgram& prog, + dom::Nullable<nsTArray<RefPtr<WebGLShader>>>& retval); + + GLint GetAttribLocation(const WebGLProgram& prog, const nsAString& name); + JS::Value GetBufferParameter(GLenum target, GLenum pname); + + void GetBufferParameter(JSContext*, GLenum target, GLenum pname, + JS::MutableHandle<JS::Value> retval) + { + retval.set(GetBufferParameter(target, pname)); + } + + GLenum GetError(); + virtual JS::Value GetFramebufferAttachmentParameter(JSContext* cx, GLenum target, + GLenum attachment, GLenum pname, + ErrorResult& rv); + + void GetFramebufferAttachmentParameter(JSContext* cx, GLenum target, + GLenum attachment, GLenum pname, + JS::MutableHandle<JS::Value> retval, + ErrorResult& rv) + { + retval.set(GetFramebufferAttachmentParameter(cx, target, attachment, + pname, rv)); + } + + JS::Value GetProgramParameter(const WebGLProgram& prog, GLenum pname); + + void GetProgramParameter(JSContext*, const WebGLProgram& prog, GLenum pname, + JS::MutableHandle<JS::Value> retval) + { + retval.set(GetProgramParameter(prog, pname)); + } + + void GetProgramInfoLog(const WebGLProgram& prog, nsACString& retval); + void GetProgramInfoLog(const WebGLProgram& prog, nsAString& retval); + JS::Value GetRenderbufferParameter(GLenum target, GLenum pname); + + void GetRenderbufferParameter(JSContext*, GLenum target, GLenum pname, + JS::MutableHandle<JS::Value> retval) + { + retval.set(GetRenderbufferParameter(target, pname)); + } + + JS::Value GetShaderParameter(const WebGLShader& shader, GLenum pname); + + void GetShaderParameter(JSContext*, const WebGLShader& shader, GLenum pname, + JS::MutableHandle<JS::Value> retval) + { + retval.set(GetShaderParameter(shader, pname)); + } + + already_AddRefed<WebGLShaderPrecisionFormat> + GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype); + + void GetShaderInfoLog(const WebGLShader& shader, nsACString& retval); + void GetShaderInfoLog(const WebGLShader& shader, nsAString& retval); + void GetShaderSource(const WebGLShader& shader, nsAString& retval); + + JS::Value GetUniform(JSContext* cx, const WebGLProgram& prog, + const WebGLUniformLocation& loc); + + void GetUniform(JSContext* cx, const WebGLProgram& prog, + const WebGLUniformLocation& loc, + JS::MutableHandle<JS::Value> retval) + { + retval.set(GetUniform(cx, prog, loc)); + } + + already_AddRefed<WebGLUniformLocation> + GetUniformLocation(const WebGLProgram& prog, const nsAString& name); + + void Hint(GLenum target, GLenum mode); + bool IsFramebuffer(const WebGLFramebuffer* fb); + bool IsProgram(const WebGLProgram* prog); + bool IsRenderbuffer(const WebGLRenderbuffer* rb); + bool IsShader(const WebGLShader* shader); + bool IsVertexArray(const WebGLVertexArray* vao); + void LineWidth(GLfloat width); + void LinkProgram(WebGLProgram& prog); + void PixelStorei(GLenum pname, GLint param); + void PolygonOffset(GLfloat factor, GLfloat units); + + already_AddRefed<layers::SharedSurfaceTextureClient> GetVRFrame(); + bool StartVRPresentation(); + + //// + + webgl::PackingInfo + ValidImplementationColorReadPI(const webgl::FormatUsageInfo* usage) const; + +protected: + bool ReadPixels_SharedPrecheck(ErrorResult* const out_error); + void ReadPixelsImpl(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, + GLenum type, void* data, uint32_t dataLen); + bool DoReadPixelsAndConvert(const webgl::FormatInfo* srcFormat, GLint x, GLint y, + GLsizei width, GLsizei height, GLenum format, + GLenum destType, void* dest, uint32_t dataLen, + uint32_t rowStride); +public: + void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, + GLenum type, const dom::Nullable<dom::ArrayBufferView>& maybeView, + ErrorResult& rv) + { + const char funcName[] = "readPixels"; + if (maybeView.IsNull()) { + ErrorInvalidValue("%s: `pixels` must not be null.", funcName); + return; + } + ReadPixels(x, y, width, height, format, type, maybeView.Value(), 0, rv); + } + + void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, + GLenum type, WebGLsizeiptr offset, ErrorResult& out_error); + + void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, + GLenum type, const dom::ArrayBufferView& dstData, GLuint dstOffset, + ErrorResult& out_error); + + //// + + void RenderbufferStorage(GLenum target, GLenum internalFormat, + GLsizei width, GLsizei height); +protected: + void RenderbufferStorage_base(const char* funcName, GLenum target, + GLsizei samples, GLenum internalformat, + GLsizei width, GLsizei height); +public: + void SampleCoverage(GLclampf value, WebGLboolean invert); + void Scissor(GLint x, GLint y, GLsizei width, GLsizei height); + void ShaderSource(WebGLShader& shader, const nsAString& source); + void StencilFunc(GLenum func, GLint ref, GLuint mask); + void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); + void StencilMask(GLuint mask); + void StencilMaskSeparate(GLenum face, GLuint mask); + void StencilOp(GLenum sfail, GLenum dpfail, GLenum dppass); + void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, + GLenum dppass); + + ////// + + void Uniform1f(WebGLUniformLocation* loc, GLfloat x); + void Uniform2f(WebGLUniformLocation* loc, GLfloat x, GLfloat y); + void Uniform3f(WebGLUniformLocation* loc, GLfloat x, GLfloat y, GLfloat z); + void Uniform4f(WebGLUniformLocation* loc, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + + void Uniform1i(WebGLUniformLocation* loc, GLint x); + void Uniform2i(WebGLUniformLocation* loc, GLint x, GLint y); + void Uniform3i(WebGLUniformLocation* loc, GLint x, GLint y, GLint z); + void Uniform4i(WebGLUniformLocation* loc, GLint x, GLint y, GLint z, GLint w); + + void Uniform1ui(WebGLUniformLocation* loc, GLuint v0); + void Uniform2ui(WebGLUniformLocation* loc, GLuint v0, GLuint v1); + void Uniform3ui(WebGLUniformLocation* loc, GLuint v0, GLuint v1, GLuint v2); + void Uniform4ui(WebGLUniformLocation* loc, GLuint v0, GLuint v1, GLuint v2, + GLuint v3); + + ////////////////////////// + + typedef dom::Float32ArrayOrUnrestrictedFloatSequence Float32ListU; + typedef dom::Int32ArrayOrLongSequence Int32ListU; + typedef dom::Uint32ArrayOrUnsignedLongSequence Uint32ListU; + +protected: + template<typename elemT, typename viewT> + struct Arr { + const size_t elemCount; + const elemT* const elemBytes; + + private: + static size_t ComputeAndReturnLength(const viewT& view) { + view.ComputeLengthAndData(); + return view.LengthAllowShared(); + } + + public: + explicit Arr(const viewT& view) + : elemCount(ComputeAndReturnLength(view)) + , elemBytes(view.DataAllowShared()) + { } + + explicit Arr(const dom::Sequence<elemT>& seq) + : elemCount(seq.Length()) + , elemBytes(seq.Elements()) + { } + + Arr(size_t _elemCount, const elemT* _elemBytes) + : elemCount(_elemCount) + , elemBytes(_elemBytes) + { } + + //// + + static Arr From(const Float32ListU& list) { + if (list.IsFloat32Array()) + return Arr(list.GetAsFloat32Array()); + + return Arr(list.GetAsUnrestrictedFloatSequence()); + } + + static Arr From(const Int32ListU& list) { + if (list.IsInt32Array()) + return Arr(list.GetAsInt32Array()); + + return Arr(list.GetAsLongSequence()); + } + + static Arr From(const Uint32ListU& list) { + if (list.IsUint32Array()) + return Arr(list.GetAsUint32Array()); + + return Arr(list.GetAsUnsignedLongSequence()); + } + }; + + typedef Arr<GLfloat, dom::Float32Array> Float32Arr; + typedef Arr<GLint, dom::Int32Array> Int32Arr; + typedef Arr<GLuint, dom::Uint32Array> Uint32Arr; + + //////////////// + + void UniformNfv(const char* funcName, uint8_t N, WebGLUniformLocation* loc, + const Float32Arr& arr, GLuint elemOffset, GLuint elemCountOverride); + void UniformNiv(const char* funcName, uint8_t N, WebGLUniformLocation* loc, + const Int32Arr& arr, GLuint elemOffset, GLuint elemCountOverride); + void UniformNuiv(const char* funcName, uint8_t N, WebGLUniformLocation* loc, + const Uint32Arr& arr, GLuint elemOffset, GLuint elemCountOverride); + + void UniformMatrixAxBfv(const char* funcName, uint8_t A, uint8_t B, + WebGLUniformLocation* loc, bool transpose, + const Float32Arr& arr, GLuint elemOffset, + GLuint elemCountOverride); + + //////////////// + +public: + #define FOO(N) \ + void Uniform ## N ## fv(WebGLUniformLocation* loc, const Float32ListU& list, \ + GLuint elemOffset = 0, GLuint elemCountOverride = 0) \ + { \ + UniformNfv("uniform" #N "fv", N, loc, Float32Arr::From(list), elemOffset, \ + elemCountOverride); \ + } + + FOO(1) + FOO(2) + FOO(3) + FOO(4) + + #undef FOO + + ////// + + #define FOO(N) \ + void Uniform ## N ## iv(WebGLUniformLocation* loc, const Int32ListU& list, \ + GLuint elemOffset = 0, GLuint elemCountOverride = 0) \ + { \ + UniformNiv("uniform" #N "iv", N, loc, Int32Arr::From(list), elemOffset, \ + elemCountOverride); \ + } + + FOO(1) + FOO(2) + FOO(3) + FOO(4) + + #undef FOO + + ////// + + #define FOO(N) \ + void Uniform ## N ## uiv(WebGLUniformLocation* loc, const Uint32ListU& list, \ + GLuint elemOffset = 0, GLuint elemCountOverride = 0) \ + { \ + UniformNuiv("uniform" #N "uiv", N, loc, Uint32Arr::From(list), elemOffset, \ + elemCountOverride); \ + } + + FOO(1) + FOO(2) + FOO(3) + FOO(4) + + #undef FOO + + ////// + + #define FOO(X,A,B) \ + void UniformMatrix ## X ## fv(WebGLUniformLocation* loc, bool transpose, \ + const Float32ListU& list, GLuint elemOffset = 0, \ + GLuint elemCountOverride = 0) \ + { \ + UniformMatrixAxBfv("uniformMatrix" #X "fv", A, B, loc, transpose, \ + Float32Arr::From(list), elemOffset, elemCountOverride); \ + } + + FOO(2,2,2) + FOO(2x3,2,3) + FOO(2x4,2,4) + + FOO(3x2,3,2) + FOO(3,3,3) + FOO(3x4,3,4) + + FOO(4x2,4,2) + FOO(4x3,4,3) + FOO(4,4,4) + + #undef FOO + + //////////////////////////////////// + + void UseProgram(WebGLProgram* prog); + + bool ValidateAttribArraySetter(const char* name, uint32_t count, + uint32_t arrayLength); + bool ValidateUniformLocation(WebGLUniformLocation* loc, const char* funcName); + bool ValidateUniformSetter(WebGLUniformLocation* loc, uint8_t setterSize, + GLenum setterType, const char* funcName); + bool ValidateUniformArraySetter(WebGLUniformLocation* loc, + uint8_t setterElemSize, GLenum setterType, + uint32_t setterArraySize, const char* funcName, + uint32_t* out_numElementsToUpload); + bool ValidateUniformMatrixArraySetter(WebGLUniformLocation* loc, + uint8_t setterCols, + uint8_t setterRows, + GLenum setterType, + uint32_t setterArraySize, + bool setterTranspose, + const char* funcName, + uint32_t* out_numElementsToUpload); + void ValidateProgram(const WebGLProgram& prog); + bool ValidateUniformLocation(const char* info, WebGLUniformLocation* loc); + bool ValidateSamplerUniformSetter(const char* info, + WebGLUniformLocation* loc, GLint value); + void Viewport(GLint x, GLint y, GLsizei width, GLsizei height); +// ----------------------------------------------------------------------------- +// WEBGL_lose_context +public: + void LoseContext(); + void RestoreContext(); + +// ----------------------------------------------------------------------------- +// Buffer Objects (WebGLContextBuffers.cpp) + void BindBuffer(GLenum target, WebGLBuffer* buffer); + void BindBufferBase(GLenum target, GLuint index, WebGLBuffer* buf); + void BindBufferRange(GLenum target, GLuint index, WebGLBuffer* buf, + WebGLintptr offset, WebGLsizeiptr size); + +private: + void BufferDataImpl(GLenum target, size_t dataLen, const uint8_t* data, GLenum usage); + +public: + void BufferData(GLenum target, WebGLsizeiptr size, GLenum usage); + void BufferData(GLenum target, const dom::Nullable<dom::ArrayBuffer>& maybeSrc, + GLenum usage); + void BufferData(GLenum target, const dom::ArrayBufferView& srcData, GLenum usage, + GLuint srcElemOffset = 0, GLuint srcElemCountOverride = 0); + +private: + void BufferSubDataImpl(GLenum target, WebGLsizeiptr dstByteOffset, + size_t srcDataLen, const uint8_t* srcData); + +public: + void BufferSubData(GLenum target, WebGLsizeiptr dstByteOffset, + const dom::ArrayBufferView& src, GLuint srcElemOffset = 0, + GLuint srcElemCountOverride = 0); + void BufferSubData(GLenum target, WebGLsizeiptr dstByteOffset, + const dom::ArrayBuffer& src); + void BufferSubData(GLenum target, WebGLsizeiptr dstByteOffset, + const dom::SharedArrayBuffer& src); + + already_AddRefed<WebGLBuffer> CreateBuffer(); + void DeleteBuffer(WebGLBuffer* buf); + bool IsBuffer(WebGLBuffer* buf); + +protected: + // bound buffer state + WebGLRefPtr<WebGLBuffer> mBoundArrayBuffer; + WebGLRefPtr<WebGLBuffer> mBoundCopyReadBuffer; + WebGLRefPtr<WebGLBuffer> mBoundCopyWriteBuffer; + WebGLRefPtr<WebGLBuffer> mBoundPixelPackBuffer; + WebGLRefPtr<WebGLBuffer> mBoundPixelUnpackBuffer; + WebGLRefPtr<WebGLBuffer> mBoundUniformBuffer; + + std::vector<IndexedBufferBinding> mIndexedUniformBufferBindings; + + WebGLRefPtr<WebGLBuffer>& GetBufferSlotByTarget(GLenum target); + WebGLRefPtr<WebGLBuffer>& GetBufferSlotByTargetIndexed(GLenum target, + GLuint index); + +// ----------------------------------------------------------------------------- +// Queries (WebGL2ContextQueries.cpp) +protected: + WebGLRefPtr<WebGLQuery> mQuerySlot_SamplesPassed; + WebGLRefPtr<WebGLQuery> mQuerySlot_TFPrimsWritten; + WebGLRefPtr<WebGLQuery> mQuerySlot_TimeElapsed; + + WebGLRefPtr<WebGLQuery>* + ValidateQuerySlotByTarget(const char* funcName, GLenum target); + +public: + already_AddRefed<WebGLQuery> CreateQuery(const char* funcName = nullptr); + void DeleteQuery(WebGLQuery* query, const char* funcName = nullptr); + bool IsQuery(const WebGLQuery* query, const char* funcName = nullptr); + void BeginQuery(GLenum target, WebGLQuery& query, const char* funcName = nullptr); + void EndQuery(GLenum target, const char* funcName = nullptr); + void GetQuery(JSContext* cx, GLenum target, GLenum pname, + JS::MutableHandleValue retval, const char* funcName = nullptr); + void GetQueryParameter(JSContext* cx, const WebGLQuery& query, GLenum pname, + JS::MutableHandleValue retval, const char* funcName = nullptr); + + +// ----------------------------------------------------------------------------- +// State and State Requests (WebGLContextState.cpp) +public: + void Disable(GLenum cap); + void Enable(GLenum cap); + bool GetStencilBits(GLint* const out_stencilBits); + bool GetChannelBits(const char* funcName, GLenum pname, GLint* const out_val); + virtual JS::Value GetParameter(JSContext* cx, GLenum pname, ErrorResult& rv); + + void GetParameter(JSContext* cx, GLenum pname, + JS::MutableHandle<JS::Value> retval, ErrorResult& rv) + { + retval.set(GetParameter(cx, pname, rv)); + } + + void GetParameterIndexed(JSContext* cx, GLenum pname, GLuint index, + JS::MutableHandle<JS::Value> retval); + bool IsEnabled(GLenum cap); + +private: + // State tracking slots + realGLboolean mDitherEnabled; + realGLboolean mRasterizerDiscardEnabled; + realGLboolean mScissorTestEnabled; + realGLboolean mDepthTestEnabled; + realGLboolean mStencilTestEnabled; + GLenum mGenerateMipmapHint; + + bool ValidateCapabilityEnum(GLenum cap, const char* info); + realGLboolean* GetStateTrackingSlot(GLenum cap); + +// ----------------------------------------------------------------------------- +// Texture funcions (WebGLContextTextures.cpp) +public: + void ActiveTexture(GLenum texUnit); + void BindTexture(GLenum texTarget, WebGLTexture* tex); + already_AddRefed<WebGLTexture> CreateTexture(); + void DeleteTexture(WebGLTexture* tex); + void GenerateMipmap(GLenum texTarget); + + void GetTexParameter(JSContext*, GLenum texTarget, GLenum pname, + JS::MutableHandle<JS::Value> retval) + { + retval.set(GetTexParameter(texTarget, pname)); + } + + bool IsTexture(WebGLTexture* tex); + + void TexParameterf(GLenum texTarget, GLenum pname, GLfloat param) { + TexParameter_base(texTarget, pname, FloatOrInt(param)); + } + + void TexParameteri(GLenum texTarget, GLenum pname, GLint param) { + TexParameter_base(texTarget, pname, FloatOrInt(param)); + } + +protected: + JS::Value GetTexParameter(GLenum texTarget, GLenum pname); + void TexParameter_base(GLenum texTarget, GLenum pname, const FloatOrInt& param); + + virtual bool IsTexParamValid(GLenum pname) const; + + //////////////////////////////////// + +public: + template<typename T> + void CompressedTexImage2D(GLenum target, GLint level, GLenum internalFormat, + GLsizei width, GLsizei height, GLint border, + const T& anySrc, GLuint viewElemOffset = 0, + GLuint viewElemLengthOverride = 0) + { + const char funcName[] = "compressedTexImage2D"; + const uint8_t funcDims = 2; + const GLsizei depth = 1; + const TexImageSourceAdapter src(&anySrc, viewElemOffset, viewElemLengthOverride); + CompressedTexImage(funcName, funcDims, target, level, internalFormat, width, + height, depth, border, src); + } + + template<typename T> + void CompressedTexSubImage2D(GLenum target, GLint level, GLint xOffset, GLint yOffset, + GLsizei width, GLsizei height, GLenum unpackFormat, + const T& anySrc, GLuint viewElemOffset = 0, + GLuint viewElemLengthOverride = 0) + { + const char funcName[] = "compressedTexSubImage2D"; + const uint8_t funcDims = 2; + const GLint zOffset = 0; + const GLsizei depth = 1; + const TexImageSourceAdapter src(&anySrc, viewElemOffset, viewElemLengthOverride); + CompressedTexSubImage(funcName, funcDims, target, level, xOffset, yOffset, + zOffset, width, height, depth, unpackFormat, src); + } + +protected: + void CompressedTexImage(const char* funcName, uint8_t funcDims, GLenum target, + GLint level, GLenum internalFormat, GLsizei width, + GLsizei height, GLsizei depth, GLint border, + const TexImageSource& src); + + void CompressedTexSubImage(const char* funcName, uint8_t funcDims, GLenum target, + GLint level, GLint xOffset, GLint yOffset, GLint zOffset, + GLsizei width, GLsizei height, GLsizei depth, + GLenum unpackFormat, const TexImageSource& src); + + //////////////////////////////////// + +public: + void CopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, + GLint y, GLsizei width, GLsizei height, GLint border); + + void CopyTexSubImage2D(GLenum target, GLint level, GLint xOffset, + GLint yOffset, GLint x, GLint y, GLsizei width, + GLsizei height) + { + const char funcName[] = "copyTexSubImage2D"; + const uint8_t funcDims = 2; + const GLint zOffset = 0; + CopyTexSubImage(funcName, funcDims, target, level, xOffset, yOffset, zOffset, + x, y, width, height); + } + +protected: + void CopyTexSubImage(const char* funcName, uint8_t funcDims, GLenum target, + GLint level, GLint xOffset, GLint yOffset, GLint zOffset, + GLint x, GLint y, GLsizei width, GLsizei height); + + //////////////////////////////////// + // TexImage + + // Implicit width/height uploads + +public: + template<typename T> + void TexImage2D(GLenum target, GLint level, GLenum internalFormat, + GLenum unpackFormat, GLenum unpackType, const T& src, + ErrorResult& out_error) + { + GLsizei width = 0; + GLsizei height = 0; + GLint border = 0; + TexImage2D(target, level, internalFormat, width, height, border, unpackFormat, + unpackType, src, out_error); + } + + template<typename T> + void TexSubImage2D(GLenum target, GLint level, GLint xOffset, GLint yOffset, + GLenum unpackFormat, GLenum unpackType, const T& src, + ErrorResult& out_error) + { + GLsizei width = 0; + GLsizei height = 0; + TexSubImage2D(target, level, xOffset, yOffset, width, height, unpackFormat, + unpackType, src, out_error); + } + + //// + + template<typename T> + void TexImage2D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, + GLsizei height, GLint border, GLenum unpackFormat, GLenum unpackType, + const T& anySrc, ErrorResult& out_error) + { + const TexImageSourceAdapter src(&anySrc, &out_error); + TexImage2D(target, level, internalFormat, width, height, border, unpackFormat, + unpackType, src); + } + + void TexImage2D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, + GLsizei height, GLint border, GLenum unpackFormat, GLenum unpackType, + const dom::ArrayBufferView& view, GLuint viewElemOffset, + ErrorResult&) + { + const TexImageSourceAdapter src(&view, viewElemOffset); + TexImage2D(target, level, internalFormat, width, height, border, unpackFormat, + unpackType, src); + } + +protected: + void TexImage2D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, + GLsizei height, GLint border, GLenum unpackFormat, + GLenum unpackType, const TexImageSource& src) + { + const char funcName[] = "texImage2D"; + const uint8_t funcDims = 2; + const GLsizei depth = 1; + TexImage(funcName, funcDims, target, level, internalFormat, width, height, depth, + border, unpackFormat, unpackType, src); + } + + void TexImage(const char* funcName, uint8_t funcDims, GLenum target, GLint level, + GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, + GLint border, GLenum unpackFormat, GLenum unpackType, + const TexImageSource& src); + + //// + +public: + template<typename T> + void TexSubImage2D(GLenum target, GLint level, GLint xOffset, GLint yOffset, + GLsizei width, GLsizei height, GLenum unpackFormat, + GLenum unpackType, const T& anySrc, ErrorResult& out_error) + { + const TexImageSourceAdapter src(&anySrc, &out_error); + TexSubImage2D(target, level, xOffset, yOffset, width, height, unpackFormat, + unpackType, src); + } + + void TexSubImage2D(GLenum target, GLint level, GLint xOffset, GLint yOffset, + GLsizei width, GLsizei height, GLenum unpackFormat, + GLenum unpackType, const dom::ArrayBufferView& view, + GLuint viewElemOffset, ErrorResult&) + { + const TexImageSourceAdapter src(&view, viewElemOffset); + TexSubImage2D(target, level, xOffset, yOffset, width, height, unpackFormat, + unpackType, src); + } + +protected: + void TexSubImage2D(GLenum target, GLint level, GLint xOffset, GLint yOffset, + GLsizei width, GLsizei height, GLenum unpackFormat, + GLenum unpackType, const TexImageSource& src) + { + const char funcName[] = "texSubImage2D"; + const uint8_t funcDims = 2; + const GLint zOffset = 0; + const GLsizei depth = 1; + TexSubImage(funcName, funcDims, target, level, xOffset, yOffset, zOffset, width, + height, depth, unpackFormat, unpackType, src); + } + + void TexSubImage(const char* funcName, uint8_t funcDims, GLenum target, GLint level, + GLint xOffset, GLint yOffset, GLint zOffset, GLsizei width, + GLsizei height, GLsizei depth, GLenum unpackFormat, + GLenum unpackType, const TexImageSource& src); + + //////////////////////////////////// + // WebGLTextureUpload.cpp +public: + UniquePtr<webgl::TexUnpackBlob> + From(const char* funcName, TexImageTarget target, GLsizei rawWidth, GLsizei rawHeight, + GLsizei rawDepth, GLint border, const TexImageSource& src, + dom::Uint8ClampedArray* const scopedArr); + +protected: + bool ValidateTexImageSpecification(const char* funcName, uint8_t funcDims, + GLenum texImageTarget, GLint level, + GLsizei width, GLsizei height, GLsizei depth, + GLint border, + TexImageTarget* const out_target, + WebGLTexture** const out_texture, + WebGLTexture::ImageInfo** const out_imageInfo); + bool ValidateTexImageSelection(const char* funcName, uint8_t funcDims, + GLenum texImageTarget, GLint level, GLint xOffset, + GLint yOffset, GLint zOffset, GLsizei width, + GLsizei height, GLsizei depth, + TexImageTarget* const out_target, + WebGLTexture** const out_texture, + WebGLTexture::ImageInfo** const out_imageInfo); + bool ValidateUnpackInfo(const char* funcName, bool usePBOs, GLenum format, + GLenum type, webgl::PackingInfo* const out); + + UniquePtr<webgl::TexUnpackBlob> + FromDomElem(const char* funcName, TexImageTarget target, uint32_t width, + uint32_t height, uint32_t depth, const dom::Element& elem, + ErrorResult* const out_error); + + UniquePtr<webgl::TexUnpackBytes> + FromCompressed(const char* funcName, TexImageTarget target, GLsizei rawWidth, + GLsizei rawHeight, GLsizei rawDepth, GLint border, + const TexImageSource& src); + +// ----------------------------------------------------------------------------- +// Vertices Feature (WebGLContextVertices.cpp) + GLenum mPrimRestartTypeBytes; + +public: + void DrawArrays(GLenum mode, GLint first, GLsizei count); + void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, + GLsizei primcount); + void DrawElements(GLenum mode, GLsizei count, GLenum type, + WebGLintptr byteOffset, const char* funcName = nullptr); + void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, + WebGLintptr byteOffset, GLsizei primcount); + + void EnableVertexAttribArray(GLuint index); + void DisableVertexAttribArray(GLuint index); + + JS::Value GetVertexAttrib(JSContext* cx, GLuint index, GLenum pname, + ErrorResult& rv); + + void GetVertexAttrib(JSContext* cx, GLuint index, GLenum pname, + JS::MutableHandle<JS::Value> retval, ErrorResult& rv) + { + retval.set(GetVertexAttrib(cx, index, pname, rv)); + } + + WebGLsizeiptr GetVertexAttribOffset(GLuint index, GLenum pname); + + //// + + void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w, + const char* funcName = nullptr); + + //// + + void VertexAttrib1f(GLuint index, GLfloat x) { + VertexAttrib4f(index, x, 0, 0, 1, "vertexAttrib1f"); + } + void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y) { + VertexAttrib4f(index, x, y, 0, 1, "vertexAttrib2f"); + } + void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) { + VertexAttrib4f(index, x, y, z, 1, "vertexAttrib3f"); + } + + //// + + void VertexAttrib1fv(GLuint index, const Float32ListU& list) { + const char funcName[] = "vertexAttrib1fv"; + const auto& arr = Float32Arr::From(list); + if (!ValidateAttribArraySetter(funcName, 1, arr.elemCount)) + return; + + VertexAttrib4f(index, arr.elemBytes[0], 0, 0, 1, funcName); + } + + void VertexAttrib2fv(GLuint index, const Float32ListU& list) { + const char funcName[] = "vertexAttrib2fv"; + const auto& arr = Float32Arr::From(list); + if (!ValidateAttribArraySetter(funcName, 2, arr.elemCount)) + return; + + VertexAttrib4f(index, arr.elemBytes[0], arr.elemBytes[1], 0, 1, funcName); + } + + void VertexAttrib3fv(GLuint index, const Float32ListU& list) { + const char funcName[] = "vertexAttrib3fv"; + const auto& arr = Float32Arr::From(list); + if (!ValidateAttribArraySetter(funcName, 3, arr.elemCount)) + return; + + VertexAttrib4f(index, arr.elemBytes[0], arr.elemBytes[1], arr.elemBytes[2], 1, + funcName); + } + + void VertexAttrib4fv(GLuint index, const Float32ListU& list) { + const char funcName[] = "vertexAttrib4fv"; + const auto& arr = Float32Arr::From(list); + if (!ValidateAttribArraySetter(funcName, 4, arr.elemCount)) + return; + + VertexAttrib4f(index, arr.elemBytes[0], arr.elemBytes[1], arr.elemBytes[2], + arr.elemBytes[3], funcName); + } + + //// + + void VertexAttribPointer(GLuint index, GLint size, GLenum type, + WebGLboolean normalized, GLsizei stride, + WebGLintptr byteOffset); + void VertexAttribDivisor(GLuint index, GLuint divisor); + +private: + // Cache the max number of vertices and instances that can be read from + // bound VBOs (result of ValidateBuffers). + bool mBufferFetchingIsVerified; + bool mBufferFetchingHasPerVertex; + uint32_t mMaxFetchedVertices; + uint32_t mMaxFetchedInstances; + bool mBufferFetch_IsAttrib0Active; + + bool DrawArrays_check(const char* funcName, GLenum mode, GLint first, + GLsizei vertCount, GLsizei instanceCount); + bool DrawElements_check(const char* funcName, GLenum mode, GLsizei vertCount, + GLenum type, WebGLintptr byteOffset, + GLsizei instanceCount); + bool DrawInstanced_check(const char* info); + void Draw_cleanup(const char* funcName); + + void VertexAttrib1fv_base(GLuint index, uint32_t arrayLength, + const GLfloat* ptr); + void VertexAttrib2fv_base(GLuint index, uint32_t arrayLength, + const GLfloat* ptr); + void VertexAttrib3fv_base(GLuint index, uint32_t arrayLength, + const GLfloat* ptr); + void VertexAttrib4fv_base(GLuint index, uint32_t arrayLength, + const GLfloat* ptr); + + bool ValidateBufferFetching(const char* info); + bool BindArrayAttribToLocation0(WebGLProgram* prog); + +// ----------------------------------------------------------------------------- +// PROTECTED +protected: + WebGLVertexAttrib0Status WhatDoesVertexAttrib0Need() const; + bool DoFakeVertexAttrib0(const char* funcName, GLuint vertexCount); + void UndoFakeVertexAttrib0(); + + inline void InvalidateBufferFetching() + { + mBufferFetchingIsVerified = false; + mBufferFetchingHasPerVertex = false; + mMaxFetchedVertices = 0; + mMaxFetchedInstances = 0; + } + + CheckedUint32 mGeneration; + + WebGLContextOptions mOptions; + + bool mInvalidated; + bool mCapturedFrameInvalidated; + bool mResetLayer; + bool mLayerIsMirror; + bool mOptionsFrozen; + bool mMinCapability; + bool mDisableExtensions; + bool mIsMesa; + bool mLoseContextOnMemoryPressure; + bool mCanLoseContextInForeground; + bool mRestoreWhenVisible; + bool mShouldPresent; + bool mBackbufferNeedsClear; + bool mDisableFragHighP; + + template<typename WebGLObjectType> + void DeleteWebGLObjectsArray(nsTArray<WebGLObjectType>& array); + + GLuint mActiveTexture; + GLenum mDefaultFB_DrawBuffer0; + + // glGetError sources: + bool mEmitContextLostErrorOnce; + GLenum mWebGLError; + GLenum mUnderlyingGLError; + GLenum GetAndFlushUnderlyingGLErrors(); + + bool mBypassShaderValidation; + + webgl::ShaderValidator* CreateShaderValidator(GLenum shaderType) const; + + // some GL constants + uint32_t mGLMaxVertexAttribs; + int32_t mGLMaxTextureUnits; + int32_t mGLMaxTextureImageUnits; + int32_t mGLMaxVertexTextureImageUnits; + int32_t mGLMaxVaryingVectors; + int32_t mGLMaxFragmentUniformVectors; + int32_t mGLMaxVertexUniformVectors; + uint32_t mGLMaxTransformFeedbackSeparateAttribs; + GLuint mGLMaxUniformBufferBindings; + + // What is supported: + uint32_t mGLMaxColorAttachments; + uint32_t mGLMaxDrawBuffers; + // What we're allowing: + uint32_t mImplMaxColorAttachments; + uint32_t mImplMaxDrawBuffers; + + uint32_t mImplMaxViewportDims[2]; + +public: + GLenum LastColorAttachmentEnum() const { + return LOCAL_GL_COLOR_ATTACHMENT0 + mImplMaxColorAttachments - 1; + } + + const decltype(mOptions)& Options() const { return mOptions; } + +protected: + + // Texture sizes are often not actually the GL values. Let's be explicit that these + // are implementation limits. + uint32_t mImplMaxTextureSize; + uint32_t mImplMaxCubeMapTextureSize; + uint32_t mImplMax3DTextureSize; + uint32_t mImplMaxArrayTextureLayers; + uint32_t mImplMaxRenderbufferSize; + +public: + GLuint MaxVertexAttribs() const { + return mGLMaxVertexAttribs; + } + + GLuint GLMaxTextureUnits() const { + return mGLMaxTextureUnits; + } + + bool IsFormatValidForFB(TexInternalFormat format) const; + +protected: + // Represents current status of the context with respect to context loss. + // That is, whether the context is lost, and what part of the context loss + // process we currently are at. + // This is used to support the WebGL spec's asyncronous nature in handling + // context loss. + enum ContextStatus { + // The context is stable; there either are none or we don't know of any. + ContextNotLost, + // The context has been lost, but we have not yet sent an event to the + // script informing it of this. + ContextLostAwaitingEvent, + // The context has been lost, and we have sent the script an event + // informing it of this. + ContextLost, + // The context is lost, an event has been sent to the script, and the + // script correctly handled the event. We are waiting for the context to + // be restored. + ContextLostAwaitingRestore + }; + + // ------------------------------------------------------------------------- + // WebGL extensions (implemented in WebGLContextExtensions.cpp) + typedef EnumeratedArray<WebGLExtensionID, WebGLExtensionID::Max, + RefPtr<WebGLExtensionBase>> ExtensionsArrayType; + + ExtensionsArrayType mExtensions; + + // enable an extension. the extension should not be enabled before. + void EnableExtension(WebGLExtensionID ext); + + // Enable an extension if it's supported. Return the extension on success. + WebGLExtensionBase* EnableSupportedExtension(dom::CallerType callerType, + WebGLExtensionID ext); + +public: + // returns true if the extension has been enabled by calling getExtension. + bool IsExtensionEnabled(WebGLExtensionID ext) const; + +protected: + // returns true if the extension is supported for this caller type (this decides what getSupportedExtensions exposes) + bool IsExtensionSupported(dom::CallerType callerType, + WebGLExtensionID ext) const; + bool IsExtensionSupported(WebGLExtensionID ext) const; + + static const char* GetExtensionString(WebGLExtensionID ext); + + nsTArray<GLenum> mCompressedTextureFormats; + + // ------------------------------------------------------------------------- + // WebGL 2 specifics (implemented in WebGL2Context.cpp) +public: + virtual bool IsWebGL2() const = 0; + + struct FailureReason { + nsCString key; // For reporting. + nsCString info; + + FailureReason() { } + + template<typename A, typename B> + FailureReason(const A& _key, const B& _info) + : key(nsCString(_key)) + , info(nsCString(_info)) + { } + }; +protected: + bool InitWebGL2(FailureReason* const out_failReason); + + bool CreateAndInitGL(bool forceEnabled, + std::vector<FailureReason>* const out_failReasons); + + bool ResizeBackbuffer(uint32_t width, uint32_t height); + + typedef already_AddRefed<gl::GLContext> FnCreateGL_T(const gl::SurfaceCaps& caps, + gl::CreateContextFlags flags, + WebGLContext* webgl, + std::vector<FailureReason>* const out_failReasons); + + bool CreateAndInitGLWith(FnCreateGL_T fnCreateGL, const gl::SurfaceCaps& baseCaps, + gl::CreateContextFlags flags, + std::vector<FailureReason>* const out_failReasons); + + void ThrowEvent_WebGLContextCreationError(const nsACString& text); + + // ------------------------------------------------------------------------- + // Validation functions (implemented in WebGLContextValidate.cpp) + bool InitAndValidateGL(FailureReason* const out_failReason); + + bool ValidateBlendEquationEnum(GLenum cap, const char* info); + bool ValidateBlendFuncDstEnum(GLenum mode, const char* info); + bool ValidateBlendFuncSrcEnum(GLenum mode, const char* info); + bool ValidateBlendFuncEnumsCompatibility(GLenum sfactor, GLenum dfactor, + const char* info); + bool ValidateComparisonEnum(GLenum target, const char* info); + bool ValidateStencilOpEnum(GLenum action, const char* info); + bool ValidateFaceEnum(GLenum face, const char* info); + bool ValidateTexInputData(GLenum type, js::Scalar::Type jsArrayType, + WebGLTexImageFunc func, WebGLTexDimensions dims); + bool ValidateDrawModeEnum(GLenum mode, const char* info); + bool ValidateAttribIndex(GLuint index, const char* info); + bool ValidateAttribPointer(bool integerMode, GLuint index, GLint size, GLenum type, + WebGLboolean normalized, GLsizei stride, + WebGLintptr byteOffset, const char* info); + bool ValidateStencilParamsForDrawCall(); + + bool ValidateCopyTexImage(TexInternalFormat srcFormat, TexInternalFormat dstformat, + WebGLTexImageFunc func, WebGLTexDimensions dims); + + bool ValidateTexImage(TexImageTarget texImageTarget, + GLint level, GLenum internalFormat, + GLint xoffset, GLint yoffset, GLint zoffset, + GLint width, GLint height, GLint depth, + GLint border, GLenum format, GLenum type, + WebGLTexImageFunc func, WebGLTexDimensions dims); + bool ValidateTexImageFormat(GLenum internalFormat, WebGLTexImageFunc func, + WebGLTexDimensions dims); + bool ValidateTexImageType(GLenum type, WebGLTexImageFunc func, + WebGLTexDimensions dims); + bool ValidateTexImageFormatAndType(GLenum format, GLenum type, + WebGLTexImageFunc func, + WebGLTexDimensions dims); + bool ValidateCompTexImageInternalFormat(GLenum format, + WebGLTexImageFunc func, + WebGLTexDimensions dims); + bool ValidateCopyTexImageInternalFormat(GLenum format, + WebGLTexImageFunc func, + WebGLTexDimensions dims); + bool ValidateTexImageSize(TexImageTarget texImageTarget, GLint level, + GLint width, GLint height, GLint depth, + WebGLTexImageFunc func, WebGLTexDimensions dims); + bool ValidateTexSubImageSize(GLint x, GLint y, GLint z, GLsizei width, + GLsizei height, GLsizei depth, + GLsizei baseWidth, GLsizei baseHeight, + GLsizei baseDepth, WebGLTexImageFunc func, + WebGLTexDimensions dims); + bool ValidateCompTexImageSize(GLint level, GLenum internalFormat, + GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLsizei levelWidth, + GLsizei levelHeight, WebGLTexImageFunc func, + WebGLTexDimensions dims); + bool ValidateCompTexImageDataSize(GLint level, GLenum internalFormat, + GLsizei width, GLsizei height, + uint32_t byteLength, + WebGLTexImageFunc func, + WebGLTexDimensions dims); + + bool ValidateUniformLocationForProgram(WebGLUniformLocation* location, + WebGLProgram* program, + const char* funcName); + + bool ValidateCurFBForRead(const char* funcName, + const webgl::FormatUsageInfo** const out_format, + uint32_t* const out_width, uint32_t* const out_height); + + bool HasDrawBuffers() const { + return IsWebGL2() || + IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers); + } + + WebGLRefPtr<WebGLBuffer>* ValidateBufferSlot(const char* funcName, GLenum target); +public: + WebGLBuffer* ValidateBufferSelection(const char* funcName, GLenum target); +protected: + IndexedBufferBinding* ValidateIndexedBufferSlot(const char* funcName, GLenum target, + GLuint index); + + bool ValidateIndexedBufferBinding(const char* funcName, GLenum target, GLuint index, + WebGLRefPtr<WebGLBuffer>** const out_genericBinding, + IndexedBufferBinding** const out_indexedBinding); + + bool ValidateNonNegative(const char* funcName, const char* argName, int64_t val) { + if (MOZ_UNLIKELY(val < 0)) { + ErrorInvalidValue("%s: `%s` must be non-negative.", funcName, argName); + return false; + } + return true; + } + +public: + template<typename T> + bool ValidateNonNull(const char* funcName, const dom::Nullable<T>& maybe) { + if (maybe.IsNull()) { + ErrorInvalidValue("%s: `null` is invalid.", funcName); + return false; + } + return true; + } + + bool ValidateArrayBufferView(const char* funcName, const dom::ArrayBufferView& view, + GLuint elemOffset, GLuint elemCountOverride, + uint8_t** const out_bytes, size_t* const out_byteLen); + +protected: + //// + + void Invalidate(); + void DestroyResourcesAndContext(); + + void MakeContextCurrent() const; + + // helpers + + bool ConvertImage(size_t width, size_t height, size_t srcStride, + size_t dstStride, const uint8_t* src, uint8_t* dst, + WebGLTexelFormat srcFormat, bool srcPremultiplied, + WebGLTexelFormat dstFormat, bool dstPremultiplied, + size_t dstTexelSize); + + ////// +public: + bool ValidateObjectAllowDeleted(const char* funcName, + const WebGLContextBoundObject& object) + { + if (!object.IsCompatibleWithContext(this)) { + ErrorInvalidOperation("%s: Object from different WebGL context (or older" + " generation of this one) passed as argument.", + funcName); + return false; + } + + return true; + } + + bool ValidateObject(const char* funcName, const WebGLDeletableObject& object, + bool isShaderOrProgram = false) + { + if (!ValidateObjectAllowDeleted(funcName, object)) + return false; + + if (isShaderOrProgram) { + /* GLES 3.0.5 p45: + * "Commands that accept shader or program object names will generate the + * error INVALID_VALUE if the provided name is not the name of either a + * shader or program object[.]" + * Further, shaders and programs appear to be different from other objects, + * in that their lifetimes are better defined. However, they also appear to + * allow use of objects marked for deletion, and only reject + * actually-destroyed objects. + */ + if (object.IsDeleted()) { + ErrorInvalidValue("%s: Shader or program object argument cannot have been" + " deleted.", + funcName); + return false; + } + } else { + if (object.IsDeleteRequested()) { + ErrorInvalidOperation("%s: Object argument cannot have been marked for" + " deletion.", + funcName); + return false; + } + } + + return true; + } + + //// + + bool ValidateObject(const char* funcName, const WebGLProgram& object); + bool ValidateObject(const char* funcName, const WebGLShader& object); + + //// + + bool ValidateIsObject(const char* funcName, + const WebGLDeletableObject* object) const + { + if (IsContextLost()) + return false; + + if (!object) + return false; + + if (!object->IsCompatibleWithContext(this)) + return false; + + if (object->IsDeleted()) + return false; + + return true; + } + + bool ValidateDeleteObject(const char* funcName, const WebGLDeletableObject* object) { + if (IsContextLost()) + return false; + + if (!object) + return false; + + if (!ValidateObjectAllowDeleted(funcName, *object)) + return false; + + if (object->IsDeleteRequested()) + return false; + + return true; + } + + //// + +private: + // ------------------------------------------------------------------------- + // Context customization points + virtual WebGLVertexArray* CreateVertexArrayImpl(); + + virtual bool ValidateAttribPointerType(bool integerMode, GLenum type, uint32_t* alignment, const char* info) = 0; + virtual bool ValidateUniformMatrixTranspose(bool transpose, const char* info) = 0; + +public: + void ForceLoseContext(bool simulateLoss = false); + +protected: + void ForceRestoreContext(); + + nsTArray<WebGLRefPtr<WebGLTexture> > mBound2DTextures; + nsTArray<WebGLRefPtr<WebGLTexture> > mBoundCubeMapTextures; + nsTArray<WebGLRefPtr<WebGLTexture> > mBound3DTextures; + nsTArray<WebGLRefPtr<WebGLTexture> > mBound2DArrayTextures; + nsTArray<WebGLRefPtr<WebGLSampler> > mBoundSamplers; + + void ResolveTexturesForDraw() const; + + WebGLRefPtr<WebGLProgram> mCurrentProgram; + RefPtr<const webgl::LinkedProgramInfo> mActiveProgramLinkInfo; + + bool ValidateFramebufferTarget(GLenum target, const char* const info); + bool ValidateInvalidateFramebuffer(const char* funcName, GLenum target, + const dom::Sequence<GLenum>& attachments, + ErrorResult* const out_rv, + std::vector<GLenum>* const scopedVector, + GLsizei* const out_glNumAttachments, + const GLenum** const out_glAttachments); + + WebGLRefPtr<WebGLFramebuffer> mBoundDrawFramebuffer; + WebGLRefPtr<WebGLFramebuffer> mBoundReadFramebuffer; + WebGLRefPtr<WebGLRenderbuffer> mBoundRenderbuffer; + WebGLRefPtr<WebGLTransformFeedback> mBoundTransformFeedback; + WebGLRefPtr<WebGLVertexArray> mBoundVertexArray; + + LinkedList<WebGLBuffer> mBuffers; + LinkedList<WebGLFramebuffer> mFramebuffers; + LinkedList<WebGLProgram> mPrograms; + LinkedList<WebGLQuery> mQueries; + LinkedList<WebGLRenderbuffer> mRenderbuffers; + LinkedList<WebGLSampler> mSamplers; + LinkedList<WebGLShader> mShaders; + LinkedList<WebGLSync> mSyncs; + LinkedList<WebGLTexture> mTextures; + LinkedList<WebGLTransformFeedback> mTransformFeedbacks; + LinkedList<WebGLVertexArray> mVertexArrays; + + WebGLRefPtr<WebGLTransformFeedback> mDefaultTransformFeedback; + WebGLRefPtr<WebGLVertexArray> mDefaultVertexArray; + + // PixelStore parameters + uint32_t mPixelStore_UnpackImageHeight; + uint32_t mPixelStore_UnpackSkipImages; + uint32_t mPixelStore_UnpackRowLength; + uint32_t mPixelStore_UnpackSkipRows; + uint32_t mPixelStore_UnpackSkipPixels; + uint32_t mPixelStore_UnpackAlignment; + uint32_t mPixelStore_PackRowLength; + uint32_t mPixelStore_PackSkipRows; + uint32_t mPixelStore_PackSkipPixels; + uint32_t mPixelStore_PackAlignment; + + CheckedUint32 GetUnpackSize(bool isFunc3D, uint32_t width, uint32_t height, + uint32_t depth, uint8_t bytesPerPixel); + + bool ValidatePackSize(const char* funcName, uint32_t width, uint32_t height, + uint8_t bytesPerPixel, uint32_t* const out_rowStride, + uint32_t* const out_endOffset); + + GLenum mPixelStore_ColorspaceConversion; + bool mPixelStore_FlipY; + bool mPixelStore_PremultiplyAlpha; + + //////////////////////////////////// + class FakeBlackTexture { + public: + static UniquePtr<FakeBlackTexture> Create(gl::GLContext* gl, + TexTarget target, + FakeBlackType type); + gl::GLContext* const mGL; + const GLuint mGLName; + + ~FakeBlackTexture(); + protected: + explicit FakeBlackTexture(gl::GLContext* gl); + }; + + UniquePtr<FakeBlackTexture> mFakeBlack_2D_0000; + UniquePtr<FakeBlackTexture> mFakeBlack_2D_0001; + UniquePtr<FakeBlackTexture> mFakeBlack_CubeMap_0000; + UniquePtr<FakeBlackTexture> mFakeBlack_CubeMap_0001; + UniquePtr<FakeBlackTexture> mFakeBlack_3D_0000; + UniquePtr<FakeBlackTexture> mFakeBlack_3D_0001; + UniquePtr<FakeBlackTexture> mFakeBlack_2D_Array_0000; + UniquePtr<FakeBlackTexture> mFakeBlack_2D_Array_0001; + + bool BindFakeBlack(uint32_t texUnit, TexTarget target, FakeBlackType fakeBlack); + + //////////////////////////////////// + +protected: + GLuint mEmptyTFO; + + // Generic Vertex Attributes + // Though CURRENT_VERTEX_ATTRIB is listed under "Vertex Shader State" in the spec + // state tables, this isn't vertex shader /object/ state. This array is merely state + // useful to vertex shaders, but is global state. + UniquePtr<GLenum[]> mGenericVertexAttribTypes; + uint8_t mGenericVertexAttrib0Data[sizeof(float) * 4]; + + GLuint mFakeVertexAttrib0BufferObject; + size_t mFakeVertexAttrib0BufferObjectSize; + bool mFakeVertexAttrib0DataDefined; + uint8_t mFakeVertexAttrib0Data[sizeof(float) * 4]; + + JSObject* GetVertexAttribFloat32Array(JSContext* cx, GLuint index); + JSObject* GetVertexAttribInt32Array(JSContext* cx, GLuint index); + JSObject* GetVertexAttribUint32Array(JSContext* cx, GLuint index); + + GLint mStencilRefFront; + GLint mStencilRefBack; + GLuint mStencilValueMaskFront; + GLuint mStencilValueMaskBack; + GLuint mStencilWriteMaskFront; + GLuint mStencilWriteMaskBack; + realGLboolean mColorWriteMask[4]; + realGLboolean mDepthWriteMask; + GLfloat mColorClearValue[4]; + GLint mStencilClearValue; + GLfloat mDepthClearValue; + + GLint mViewportX; + GLint mViewportY; + GLsizei mViewportWidth; + GLsizei mViewportHeight; + bool mAlreadyWarnedAboutViewportLargerThanDest; + + GLfloat mLineWidth; + + WebGLContextLossHandler mContextLossHandler; + bool mAllowContextRestore; + bool mLastLossWasSimulated; + ContextStatus mContextStatus; + bool mContextLostErrorSet; + + // Used for some hardware (particularly Tegra 2 and 4) that likes to + // be Flushed while doing hundreds of draw calls. + int mDrawCallsSinceLastFlush; + + int mAlreadyGeneratedWarnings; + int mMaxWarnings; + bool mAlreadyWarnedAboutFakeVertexAttrib0; + + bool ShouldGenerateWarnings() const; + + uint64_t mLastUseIndex; + + bool mNeedsFakeNoAlpha; + bool mNeedsFakeNoDepth; + bool mNeedsFakeNoStencil; + bool mNeedsEmulatedLoneDepthStencil; + + const bool mAllowFBInvalidation; + + bool Has64BitTimestamps() const; + + struct ScopedDrawCallWrapper final { + WebGLContext& mWebGL; + const bool mFakeNoAlpha; + const bool mFakeNoDepth; + const bool mFakeNoStencil; + + static bool ShouldFakeNoAlpha(WebGLContext& webgl) { + // We should only be doing this if we're about to draw to the backbuffer, but + // the backbuffer needs to have this fake-no-alpha workaround. + return !webgl.mBoundDrawFramebuffer && + webgl.mNeedsFakeNoAlpha && + webgl.mColorWriteMask[3] != false; + } + + static bool ShouldFakeNoDepth(WebGLContext& webgl) { + // We should only be doing this if we're about to draw to the backbuffer. + return !webgl.mBoundDrawFramebuffer && + webgl.mNeedsFakeNoDepth && + webgl.mDepthTestEnabled; + } + + static bool HasDepthButNoStencil(const WebGLFramebuffer* fb); + + static bool ShouldFakeNoStencil(WebGLContext& webgl) { + if (!webgl.mStencilTestEnabled) + return false; + + if (!webgl.mBoundDrawFramebuffer) { + if (webgl.mNeedsFakeNoStencil) + return true; + + if (webgl.mNeedsEmulatedLoneDepthStencil && + webgl.mOptions.depth && !webgl.mOptions.stencil) + { + return true; + } + + return false; + } + + if (webgl.mNeedsEmulatedLoneDepthStencil && + HasDepthButNoStencil(webgl.mBoundDrawFramebuffer)) + { + return true; + } + + return false; + } + + //// + + explicit ScopedDrawCallWrapper(WebGLContext& webgl); + ~ScopedDrawCallWrapper(); + }; + + void OnBeforeReadCall(); + + void LoseOldestWebGLContextIfLimitExceeded(); + void UpdateLastUseIndex(); + + template <typename WebGLObjectType> + JS::Value WebGLObjectAsJSValue(JSContext* cx, const WebGLObjectType*, + ErrorResult& rv) const; + template <typename WebGLObjectType> + JSObject* WebGLObjectAsJSObject(JSContext* cx, const WebGLObjectType*, + ErrorResult& rv) const; + +#ifdef XP_MACOSX + // see bug 713305. This RAII helper guarantees that we're on the discrete GPU, during its lifetime + // Debouncing note: we don't want to switch GPUs too frequently, so try to not create and destroy + // these objects at high frequency. Having WebGLContext's hold one such object seems fine, + // because WebGLContext objects only go away during GC, which shouldn't happen too frequently. + // If in the future GC becomes much more frequent, we may have to revisit then (maybe use a timer). + ForceDiscreteGPUHelperCGL mForceDiscreteGPUHelper; +#endif + +public: + // console logging helpers + void GenerateWarning(const char* fmt, ...); + void GenerateWarning(const char* fmt, va_list ap); + +public: + UniquePtr<webgl::FormatUsageAuthority> mFormatUsage; + + virtual UniquePtr<webgl::FormatUsageAuthority> + CreateFormatUsage(gl::GLContext* gl) const = 0; + + + const decltype(mBound2DTextures)* TexListForElemType(GLenum elemType) const; + + // Friend list + friend class ScopedCopyTexImageSource; + friend class ScopedResolveTexturesForDraw; + friend class ScopedUnpackReset; + friend class webgl::TexUnpackBlob; + friend class webgl::TexUnpackBytes; + friend class webgl::TexUnpackImage; + friend class webgl::TexUnpackSurface; + friend struct webgl::UniformInfo; + friend class WebGLTexture; + friend class WebGLFBAttachPoint; + friend class WebGLFramebuffer; + friend class WebGLRenderbuffer; + friend class WebGLProgram; + friend class WebGLQuery; + friend class WebGLBuffer; + friend class WebGLSampler; + friend class WebGLShader; + friend class WebGLSync; + friend class WebGLTransformFeedback; + friend class WebGLUniformLocation; + friend class WebGLVertexArray; + friend class WebGLVertexArrayFake; + friend class WebGLVertexArrayGL; +}; + +// used by DOM bindings in conjunction with GetParentObject +inline nsISupports* +ToSupports(WebGLContext* webgl) +{ + return static_cast<nsIDOMWebGLRenderingContext*>(webgl); +} + +// Returns `value` rounded to the next highest multiple of `multiple`. +// AKA PadToAlignment, StrideForAlignment. +template<typename V, typename M> +V +RoundUpToMultipleOf(const V& value, const M& multiple) +{ + return ((value + multiple - 1) / multiple) * multiple; +} + +bool +ValidateTexTarget(WebGLContext* webgl, const char* funcName, uint8_t funcDims, + GLenum rawTexTarget, TexTarget* const out_texTarget, + WebGLTexture** const out_tex); +bool +ValidateTexImageTarget(WebGLContext* webgl, const char* funcName, uint8_t funcDims, + GLenum rawTexImageTarget, TexImageTarget* const out_texImageTarget, + WebGLTexture** const out_tex); + +class UniqueBuffer +{ + // Like UniquePtr<>, but for void* and malloc/calloc/free. + void* mBuffer; + +public: + UniqueBuffer() + : mBuffer(nullptr) + { } + + MOZ_IMPLICIT UniqueBuffer(void* buffer) + : mBuffer(buffer) + { } + + ~UniqueBuffer() { + free(mBuffer); + } + + UniqueBuffer(UniqueBuffer&& other) { + this->mBuffer = other.mBuffer; + other.mBuffer = nullptr; + } + + UniqueBuffer& operator =(UniqueBuffer&& other) { + free(this->mBuffer); + this->mBuffer = other.mBuffer; + other.mBuffer = nullptr; + return *this; + } + + UniqueBuffer& operator =(void* newBuffer) { + free(this->mBuffer); + this->mBuffer = newBuffer; + return *this; + } + + explicit operator bool() const { return bool(mBuffer); } + + void* get() const { return mBuffer; } + + UniqueBuffer(const UniqueBuffer& other) = delete; // construct using Move()! + void operator =(const UniqueBuffer& other) = delete; // assign using Move()! +}; + +class ScopedUnpackReset final + : public gl::ScopedGLWrapper<ScopedUnpackReset> +{ + friend struct gl::ScopedGLWrapper<ScopedUnpackReset>; + +private: + WebGLContext* const mWebGL; + +public: + explicit ScopedUnpackReset(WebGLContext* webgl); + +private: + void UnwrapImpl(); +}; + +class ScopedFBRebinder final + : public gl::ScopedGLWrapper<ScopedFBRebinder> +{ + friend struct gl::ScopedGLWrapper<ScopedFBRebinder>; + +private: + WebGLContext* const mWebGL; + +public: + explicit ScopedFBRebinder(WebGLContext* webgl) + : ScopedGLWrapper<ScopedFBRebinder>(webgl->gl) + , mWebGL(webgl) + { } + +private: + void UnwrapImpl(); +}; + +class ScopedLazyBind final + : public gl::ScopedGLWrapper<ScopedLazyBind> +{ + friend struct gl::ScopedGLWrapper<ScopedLazyBind>; + + const GLenum mTarget; + const WebGLBuffer* const mBuf; + +public: + ScopedLazyBind(gl::GLContext* gl, GLenum target, const WebGLBuffer* buf); + +private: + void UnwrapImpl(); +}; + +//// + +bool +Intersect(int32_t srcSize, int32_t read0, int32_t readSize, int32_t* out_intRead0, + int32_t* out_intWrite0, int32_t* out_intSize); + +//// + +void +ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& callback, + const std::vector<IndexedBufferBinding>& field, + const char* name, uint32_t flags = 0); + +void +ImplCycleCollectionUnlink(std::vector<IndexedBufferBinding>& field); + +} // namespace mozilla + +#endif |