diff options
Diffstat (limited to 'dom/canvas/WebGLContext.h')
| -rw-r--r-- | dom/canvas/WebGLContext.h | 1430 |
1 files changed, 1430 insertions, 0 deletions
diff --git a/dom/canvas/WebGLContext.h b/dom/canvas/WebGLContext.h new file mode 100644 index 0000000000..5d4ca6a68b --- /dev/null +++ b/dom/canvas/WebGLContext.h @@ -0,0 +1,1430 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 <bitset> +#include <memory> +#include <stdarg.h> + +#include "GLContextTypes.h" +#include "GLDefs.h" +#include "GLScreenBuffer.h" +#include "js/ScalarType.h" // js::Scalar::Type +#include "mozilla/Attributes.h" +#include "mozilla/Atomics.h" +#include "mozilla/CheckedInt.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/HTMLCanvasElement.h" +#include "mozilla/dom/Nullable.h" +#include "mozilla/dom/TypedArray.h" +#include "mozilla/EnumeratedArray.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/Mutex.h" +#include "mozilla/StaticMutex.h" +#include "mozilla/StaticPrefs_webgl.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/WeakPtr.h" +#include "nsICanvasRenderingContextInternal.h" +#include "nsTArray.h" +#include "SurfaceTypes.h" +#include "ScopedGLHelpers.h" +#include "TexUnpackBlob.h" + +// Local +#include "CacheInvalidator.h" +#include "WebGLContextLossHandler.h" +#include "WebGLExtensions.h" +#include "WebGLObjectModel.h" +#include "WebGLStrongTypes.h" +#include "WebGLTypes.h" + +// Generated +#include "mozilla/dom/WebGLRenderingContextBinding.h" +#include "mozilla/dom/WebGL2RenderingContextBinding.h" + +#include <list> + +class nsIDocShell; + +// WebGL-only GLenums +// clang-format off +#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 +// clang-format on + +namespace mozilla { +class HostWebGLContext; +class ScopedCopyTexImageSource; +class ScopedDrawCallWrapper; +class ScopedResolveTexturesForDraw; +class WebGLBuffer; +class WebGLExtensionBase; +class WebGLFramebuffer; +class WebGLProgram; +class WebGLQuery; +class WebGLRenderbuffer; +class WebGLSampler; +class WebGLShader; +class WebGLSync; +class WebGLTexture; +class WebGLTransformFeedback; +class WebGLVertexArray; + +namespace dom { +class Document; +class Element; +class ImageData; +class OwningHTMLCanvasElementOrOffscreenCanvas; +struct WebGLContextAttributes; +} // namespace dom + +namespace gfx { +class SourceSurface; +class VRLayerChild; +} // namespace gfx + +namespace gl { +class GLScreenBuffer; +class MozFramebuffer; +class SharedSurface; +class Texture; +} // namespace gl + +namespace layers { +class CompositableHost; +class RemoteTextureOwnerClient; +class SurfaceDescriptor; +} // namespace layers + +namespace webgl { +class AvailabilityRunnable; +struct CachedDrawFetchLimits; +struct FbAttachInfo; +struct FormatInfo; +class FormatUsageAuthority; +struct FormatUsageInfo; +struct ImageInfo; +struct LinkedProgramInfo; +struct SamplerUniformInfo; +struct SamplingState; +class ScopedPrepForResourceClear; +class ShaderValidator; +class TexUnpackBlob; +struct UniformInfo; +struct UniformBlockInfo; +struct VertAttribPointerDesc; +} // namespace webgl + +struct WebGLTexImageData { + TexImageTarget mTarget; + int32_t mRowLength; + uint32_t mWidth; + uint32_t mHeight; + uint32_t mDepth; + gfxAlphaType mSrcAlphaType; +}; + +struct WebGLTexPboOffset { + TexImageTarget mTarget; + uint32_t mWidth; + uint32_t mHeight; + uint32_t mDepth; + WebGLsizeiptr mPboOffset; + bool mHasExpectedImageSize; + GLsizei mExpectedImageSize; +}; + +WebGLTexelFormat GetWebGLTexelFormat(TexInternalFormat format); + +void AssertUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint shadow); + +// 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 { + RefPtr<WebGLBuffer> mBufferBinding; + uint64_t mRangeStart; + uint64_t mRangeSize; + + IndexedBufferBinding(); + + uint64_t ByteCount() const; +}; + +//////////////////////////////////// + +namespace webgl { + +class AvailabilityRunnable final : public DiscardableRunnable { + public: + const WeakPtr<const ClientWebGLContext> mWebGL; + std::vector<WeakPtr<WebGLQueryJS>> mQueries; + std::vector<WeakPtr<WebGLSyncJS>> mSyncs; + + explicit AvailabilityRunnable(const ClientWebGLContext* webgl); + ~AvailabilityRunnable(); + + NS_IMETHOD Run() override; +}; + +struct BufferAndIndex final { + const WebGLBuffer* buffer = nullptr; + uint32_t id = -1; +}; + +} // namespace webgl + +//////////////////////////////////////////////////////////////////////////////// + +class WebGLContext : public VRefCounted, public SupportsWeakPtr { + friend class ScopedDrawCallWrapper; + friend class ScopedDrawWithTransformFeedback; + friend class ScopedFakeVertexAttrib0; + friend class ScopedFBRebinder; + friend class WebGL2Context; + friend class WebGLContextUserData; + friend class WebGLExtensionCompressedTextureASTC; + friend class WebGLExtensionCompressedTextureBPTC; + friend class WebGLExtensionCompressedTextureES3; + friend class WebGLExtensionCompressedTextureETC1; + friend class WebGLExtensionCompressedTexturePVRTC; + friend class WebGLExtensionCompressedTextureRGTC; + friend class WebGLExtensionCompressedTextureS3TC; + friend class WebGLExtensionCompressedTextureS3TC_SRGB; + friend class WebGLExtensionDepthTexture; + friend class WebGLExtensionDisjointTimerQuery; + friend class WebGLExtensionDrawBuffers; + friend class WebGLExtensionLoseContext; + friend class WebGLExtensionMOZDebug; + friend class WebGLExtensionVertexArray; + friend class WebGLMemoryTracker; + friend class webgl::AvailabilityRunnable; + friend struct webgl::LinkedProgramInfo; + friend struct webgl::SamplerUniformInfo; + friend class webgl::ScopedPrepForResourceClear; + friend struct webgl::UniformBlockInfo; + + friend const webgl::CachedDrawFetchLimits* ValidateDraw(WebGLContext*, GLenum, + uint32_t); + friend RefPtr<const webgl::LinkedProgramInfo> QueryProgramInfo( + WebGLProgram* prog, gl::GLContext* gl); + + MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(WebGLContext, override) + + enum { + UNPACK_FLIP_Y_WEBGL = 0x9240, + UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241, + // We throw InvalidOperation in TexImage if we fail to use GPU fast-path + // for texture copy when it is set to true, only for debug purpose. + UNPACK_REQUIRE_FASTPATH = 0x10001, + CONTEXT_LOST_WEBGL = 0x9242, + UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243, + BROWSER_DEFAULT_WEBGL = 0x9244, + UNMASKED_VENDOR_WEBGL = 0x9245, + UNMASKED_RENDERER_WEBGL = 0x9246 + }; + + private: + class LruPosition final { + std::list<WebGLContext*>::iterator mItr; + + LruPosition(const LruPosition&) = delete; + LruPosition(LruPosition&&) = delete; + LruPosition& operator=(const LruPosition&) = delete; + LruPosition& operator=(LruPosition&&) = delete; + + public: + void AssignLocked(WebGLContext& aContext) MOZ_REQUIRES(sLruMutex); + void Reset(); + void ResetLocked() MOZ_REQUIRES(sLruMutex); + bool IsInsertedLocked() const MOZ_REQUIRES(sLruMutex); + + LruPosition(); + explicit LruPosition(WebGLContext&); + + ~LruPosition() { Reset(); } + }; + + mutable LruPosition mLruPosition MOZ_GUARDED_BY(sLruMutex); + + void BumpLruLocked() MOZ_REQUIRES(sLruMutex); + + public: + void BumpLru(); + void LoseLruContextIfLimitExceeded(); + + // - + + // We've had issues in the past with nulling `gl` without actually releasing + // all of our resources. This construction ensures that we are aware that we + // should only null `gl` in DestroyResourcesAndContext. + RefPtr<gl::GLContext> mGL_OnlyClearInDestroyResourcesAndContext; + + public: + // Grab a const reference so we can see changes, but can't make changes. + const decltype(mGL_OnlyClearInDestroyResourcesAndContext)& gl; + + public: + void CheckForInactivity(); + + protected: + const WeakPtr<HostWebGLContext> mHost; + const bool mResistFingerprinting; + WebGLContextOptions mOptions; + const uint32_t mPrincipalKey; + Maybe<webgl::Limits> mLimits; + const uint32_t mMaxVertIdsPerDraw = + StaticPrefs::webgl_max_vert_ids_per_draw(); + + bool mIsContextLost = false; + Atomic<bool> mPendingContextLoss; + webgl::ContextLossReason mPendingContextLossReason = + webgl::ContextLossReason::None; + const uint32_t mMaxPerfWarnings; + mutable uint64_t mNumPerfWarnings = 0; + const uint32_t mMaxAcceptableFBStatusInvals; + bool mWarnOnce_DepthTexCompareFilterable = true; + + uint64_t mNextFenceId = 1; + uint64_t mCompletedFenceId = 0; + + std::unique_ptr<gl::Texture> mIncompleteTexOverride; + + public: + class FuncScope; + + private: + mutable FuncScope* mFuncScope = nullptr; + + public: + static RefPtr<WebGLContext> Create(HostWebGLContext&, + const webgl::InitContextDesc&, + webgl::InitContextResult* out); + + private: + void FinishInit(); + + protected: + WebGLContext(HostWebGLContext&, const webgl::InitContextDesc&); + virtual ~WebGLContext(); + + RefPtr<layers::CompositableHost> mCompositableHost; + + layers::LayersBackend mBackend = layers::LayersBackend::LAYERS_NONE; + + public: + void Resize(uvec2 size); + + void SetCompositableHost(RefPtr<layers::CompositableHost>& aCompositableHost); + + /** + * 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(); + + void OnMemoryPressure(); + + // - + + /* + + Here are the bind calls that are supposed to be fully-validated client side, + so that client's binding state doesn't diverge: + * AttachShader + * DetachShader + * BindFramebuffer + * FramebufferAttach + * BindBuffer + * BindBufferRange + * BindTexture + * UseProgram + * BindSampler + * BindTransformFeedback + * BindVertexArray + * BeginQuery + * EndQuery + * ActiveTexture + + */ + + const auto& CurFuncScope() const { return *mFuncScope; } + const char* FuncName() const; + + class FuncScope final { + public: + const WebGLContext& mWebGL; + const char* const mFuncName; + bool mBindFailureGuard = false; + + public: + FuncScope(const WebGLContext& webgl, const char* funcName); + ~FuncScope(); + }; + + void GenerateErrorImpl(const GLenum err, const nsACString& text) const { + GenerateErrorImpl(err, std::string(text.BeginReading())); + } + void GenerateErrorImpl(const GLenum err, const std::string& text) const; + + void GenerateError(const webgl::ErrorInfo& err) { + GenerateError(err.type, "%s", err.info.c_str()); + } + + template <typename... Args> + void GenerateError(const GLenum err, const char* const fmt, + const Args&... args) const { + MOZ_ASSERT(FuncName()); + + nsCString text; + text.AppendPrintf("WebGL warning: %s: ", FuncName()); + +#ifdef __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wformat-security" +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wformat-security" +#endif + text.AppendPrintf(fmt, args...); +#ifdef __clang__ +# pragma clang diagnostic pop +#elif defined(__GNUC__) +# pragma GCC diagnostic pop +#endif + + GenerateErrorImpl(err, text); + } + + template <typename... Args> + void ErrorInvalidEnum(const char* const fmt, const Args&... args) const { + GenerateError(LOCAL_GL_INVALID_ENUM, fmt, args...); + } + template <typename... Args> + void ErrorInvalidOperation(const char* const fmt, const Args&... args) const { + GenerateError(LOCAL_GL_INVALID_OPERATION, fmt, args...); + } + template <typename... Args> + void ErrorInvalidValue(const char* const fmt, const Args&... args) const { + GenerateError(LOCAL_GL_INVALID_VALUE, fmt, args...); + } + template <typename... Args> + void ErrorInvalidFramebufferOperation(const char* const fmt, + const Args&... args) const { + GenerateError(LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION, fmt, args...); + } + template <typename... Args> + void ErrorOutOfMemory(const char* const fmt, const Args&... args) const { + GenerateError(LOCAL_GL_OUT_OF_MEMORY, fmt, args...); + } + + template <typename... Args> + void ErrorImplementationBug(const char* const fmt, + const Args&... args) const { + const nsPrintfCString newFmt( + "Implementation bug, please file at %s! %s", + "https://bugzilla.mozilla.org/" + "enter_bug.cgi?product=Core&component=Canvas%3A+WebGL", + fmt); + GenerateError(LOCAL_GL_OUT_OF_MEMORY, newFmt.BeginReading(), args...); + MOZ_ASSERT(false, "WebGLContext::ErrorImplementationBug"); + NS_ERROR("WebGLContext::ErrorImplementationBug"); + } + + void ErrorInvalidEnumInfo(const char* info, GLenum enumValue) const; + void ErrorInvalidEnumArg(const char* argName, GLenum val) const; + + static 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(); + + WebGLTexture* GetActiveTex(const GLenum texTarget) const; + + gl::GLContext* GL() const { return gl; } + + bool IsPremultAlpha() const { return mOptions.premultipliedAlpha; } + + bool IsPreservingDrawingBuffer() const { + return mOptions.preserveDrawingBuffer; + } + + // Present to compositor + private: + bool PresentInto(gl::SwapChain& swapChain); + bool PresentIntoXR(gl::SwapChain& swapChain, const gl::MozFramebuffer& xrFb); + + public: + // Present swaps the front and back buffers of the swap chain for compositing. + // This assumes the framebuffer may directly alias with the back buffer, + // dependent on remoting state or other concerns. Framebuffer and swap chain + // surface formats are assumed to be similar to enable this aliasing. As such, + // the back buffer may be invalidated by this swap with the front buffer, + // unless overriden by explicitly setting the preserveDrawingBuffer option, + // which may incur a further copy to preserve the back buffer. + void Present( + WebGLFramebuffer*, layers::TextureType, const bool webvr, + const webgl::SwapChainOptions& options = webgl::SwapChainOptions()); + // CopyToSwapChain forces a copy from the supplied framebuffer into the back + // buffer before swapping the front and back buffers of the swap chain for + // compositing. The formats of the framebuffer and the swap chain buffers + // may differ subject to available format conversion options. Since this + // operation uses an explicit copy, it inherently preserves the framebuffer + // without need to set the preserveDrawingBuffer option. + void CopyToSwapChain( + WebGLFramebuffer*, layers::TextureType, + const webgl::SwapChainOptions& options = webgl::SwapChainOptions()); + // In use cases where a framebuffer is used as an offscreen framebuffer and + // does not need to be committed to the swap chain, it may still be useful + // for the implementation to delineate distinct frames, such as when sharing + // a single WebGLContext amongst many distinct users. EndOfFrame signals that + // frame rendering is complete so that any implementation side-effects such + // as resetting internal profile counters or resource queues may be handled + // appropriately. + void EndOfFrame(); + RefPtr<gfx::DataSourceSurface> GetFrontBufferSnapshot(); + Maybe<uvec2> FrontBufferSnapshotInto( + const Maybe<Range<uint8_t>> dest, + const Maybe<size_t> destStride = Nothing()); + Maybe<uvec2> FrontBufferSnapshotInto( + const std::shared_ptr<gl::SharedSurface>& front, + const Maybe<Range<uint8_t>> dest, + const Maybe<size_t> destStride = Nothing()); + Maybe<uvec2> SnapshotInto(GLuint srcFb, const gfx::IntSize& size, + const Range<uint8_t>& dest, + const Maybe<size_t> destStride = Nothing()); + gl::SwapChain* GetSwapChain(WebGLFramebuffer*, const bool webvr); + Maybe<layers::SurfaceDescriptor> GetFrontBuffer(WebGLFramebuffer*, + const bool webvr); + + void ClearVRSwapChain(); + + void RunContextLossTimer(); + void CheckForContextLoss(); + void HandlePendingContextLoss(); + + bool TryToRestoreContext(); + + void AssertCachedBindings() const; + void AssertCachedGlobalState() const; + + // WebIDL WebGLRenderingContext API + void Commit(); + + uvec2 DrawingBufferSize(); + + public: + void GetContextAttributes(dom::Nullable<dom::WebGLContextAttributes>& retval); + + // This is the entrypoint. Don't test against it directly. + bool IsContextLost() const { + auto* self = const_cast<WebGLContext*>(this); + if (self->mPendingContextLoss.exchange(false)) { + self->HandlePendingContextLoss(); + } + return mIsContextLost; + } + + // - + + RefPtr<WebGLBuffer> CreateBuffer(); + RefPtr<WebGLFramebuffer> CreateFramebuffer(); + RefPtr<WebGLFramebuffer> CreateOpaqueFramebuffer( + const webgl::OpaqueFramebufferOptions& options); + RefPtr<WebGLProgram> CreateProgram(); + RefPtr<WebGLQuery> CreateQuery(); + RefPtr<WebGLRenderbuffer> CreateRenderbuffer(); + RefPtr<WebGLShader> CreateShader(GLenum type); + RefPtr<WebGLTexture> CreateTexture(); + RefPtr<WebGLVertexArray> CreateVertexArray(); + + // - + + void AttachShader(WebGLProgram& prog, WebGLShader& shader); + void BindAttribLocation(WebGLProgram& prog, GLuint location, + const std::string& name) const; + 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 BlendEquationSeparate(Maybe<GLuint> i, GLenum modeRGB, GLenum modeAlpha); + void BlendFuncSeparate(Maybe<GLuint> i, 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(Maybe<GLuint> i, uint8_t mask); + void CompileShader(WebGLShader& shader); + + private: + void CompileShaderANGLE(WebGLShader* shader); + void CompileShaderBypass(WebGLShader* shader, const nsCString& shaderSource); + + public: + void CullFace(GLenum face); + void DepthFunc(GLenum func); + void DepthMask(WebGLboolean b); + void DepthRange(GLclampf zNear, GLclampf zFar); + void DetachShader(WebGLProgram& prog, const WebGLShader& shader); + void DrawBuffers(const std::vector<GLenum>& buffers); + void Flush(); + void Finish(); + + void FramebufferAttach(GLenum target, GLenum attachSlot, + GLenum bindImageTarget, + const webgl::FbAttachInfo& toAttach); + + void FrontFace(GLenum mode); + + Maybe<double> GetBufferParameter(GLenum target, GLenum pname); + webgl::CompileResult GetCompileResult(const WebGLShader&) const; + GLenum GetError(); + GLint GetFragDataLocation(const WebGLProgram&, const std::string& name) const; + + Maybe<double> GetFramebufferAttachmentParameter(WebGLFramebuffer*, + GLenum attachment, + GLenum pname) const; + + Maybe<double> GetRenderbufferParameter(const WebGLRenderbuffer&, + GLenum pname) const; + webgl::LinkResult GetLinkResult(const WebGLProgram&) const; + + Maybe<webgl::ShaderPrecisionFormat> GetShaderPrecisionFormat( + GLenum shadertype, GLenum precisiontype) const; + + webgl::GetUniformData GetUniform(const WebGLProgram&, uint32_t loc) const; + + void Hint(GLenum target, GLenum mode); + + void LineWidth(GLfloat width); + void LinkProgram(WebGLProgram& prog); + void PolygonOffset(GLfloat factor, GLfloat units); + void ProvokingVertex(webgl::ProvokingVertex) const; + + //// + + webgl::PackingInfo ValidImplementationColorReadPI( + const webgl::FormatUsageInfo* usage) const; + + protected: + webgl::ReadPixelsResult ReadPixelsImpl(const webgl::ReadPixelsDesc&, + uintptr_t dest, uint64_t availBytes); + bool DoReadPixelsAndConvert(const webgl::FormatInfo* srcFormat, + const webgl::ReadPixelsDesc&, uintptr_t dest, + uint64_t dataLen, uint32_t rowStride); + + public: + void ReadPixelsPbo(const webgl::ReadPixelsDesc&, uint64_t offset); + webgl::ReadPixelsResult ReadPixelsInto(const webgl::ReadPixelsDesc&, + const Range<uint8_t>& dest); + + //// + + void RenderbufferStorageMultisample(WebGLRenderbuffer&, uint32_t samples, + GLenum internalformat, uint32_t width, + uint32_t height) const; + + public: + void SampleCoverage(GLclampf value, WebGLboolean invert); + void Scissor(GLint x, GLint y, GLsizei width, GLsizei height); + void ShaderSource(WebGLShader& shader, const std::string& source) const; + void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); + void StencilMaskSeparate(GLenum face, GLuint mask); + void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, + GLenum dppass); + + ////////////////////////// + + void UniformData(uint32_t loc, bool transpose, + const Range<const webgl::UniformDataVal>& data) const; + + //////////////////////////////////// + + void UseProgram(WebGLProgram* prog); + + bool ValidateAttribArraySetter(uint32_t count, uint32_t arrayLength); + bool ValidateProgram(const WebGLProgram& prog) const; + void Viewport(GLint x, GLint y, GLsizei width, GLsizei height); + + // ----------------------------------------------------------------------------- + // Buffer Objects (WebGLContextBuffers.cpp) + void BindBuffer(GLenum target, WebGLBuffer* buffer); + void BindBufferRange(GLenum target, GLuint index, WebGLBuffer* buf, + uint64_t offset, uint64_t size); + + void BufferData(GLenum target, uint64_t dataLen, const uint8_t* data, + GLenum usage) const; + // The unsynchronized flag may allow for better performance when + // interleaving buffer updates with draw calls. However, care must + // be taken. This has similar semantics to glMapBufferRange's + // GL_MAP_UNSYNCHRONIZED_BIT: the results of any pending operations + // that reference the region of the buffer being updated are + // undefined. + void BufferSubData(GLenum target, uint64_t dstByteOffset, uint64_t srcDataLen, + const uint8_t* srcData, bool unsynchronized = false) const; + + protected: + // bound buffer state + RefPtr<WebGLBuffer> mBoundArrayBuffer; + RefPtr<WebGLBuffer> mBoundCopyReadBuffer; + RefPtr<WebGLBuffer> mBoundCopyWriteBuffer; + RefPtr<WebGLBuffer> mBoundPixelPackBuffer; + RefPtr<WebGLBuffer> mBoundPixelUnpackBuffer; + RefPtr<WebGLBuffer> mBoundTransformFeedbackBuffer; + RefPtr<WebGLBuffer> mBoundUniformBuffer; + + std::vector<IndexedBufferBinding> mIndexedUniformBufferBindings; + + RefPtr<WebGLBuffer>& GetBufferSlotByTarget(GLenum target); + RefPtr<WebGLBuffer>& GetBufferSlotByTargetIndexed(GLenum target, + GLuint index); + + // - + + void GenErrorIllegalUse(GLenum useTarget, uint32_t useId, GLenum boundTarget, + uint32_t boundId) const; + + bool ValidateBufferForNonTf(const WebGLBuffer&, GLenum nonTfTarget, + uint32_t nonTfId) const; + + bool ValidateBufferForNonTf(const WebGLBuffer* const nonTfBuffer, + const GLenum nonTfTarget, + const uint32_t nonTfId = -1) const { + if (!nonTfBuffer) return true; + return ValidateBufferForNonTf(*nonTfBuffer, nonTfTarget, nonTfId); + } + + bool ValidateBuffersForTf(const WebGLTransformFeedback&, + const webgl::LinkedProgramInfo&) const; + bool ValidateBuffersForTf( + const std::vector<webgl::BufferAndIndex>& tfBuffers) const; + + // ----------------------------------------------------------------------------- + // Queries (WebGL2ContextQueries.cpp) + protected: + RefPtr<WebGLQuery> mQuerySlot_SamplesPassed; + RefPtr<WebGLQuery> mQuerySlot_TFPrimsWritten; + RefPtr<WebGLQuery> mQuerySlot_TimeElapsed; + + RefPtr<WebGLQuery>* ValidateQuerySlotByTarget(GLenum target); + + public: + void BeginQuery(GLenum target, WebGLQuery& query); + void EndQuery(GLenum target); + Maybe<double> GetQueryParameter(const WebGLQuery& query, GLenum pname) const; + void QueryCounter(WebGLQuery&) const; + + // ----------------------------------------------------------------------------- + // State and State Requests (WebGLContextState.cpp) + void SetEnabled(GLenum cap, Maybe<GLuint> i, bool enabled); + bool GetStencilBits(GLint* const out_stencilBits) const; + + virtual Maybe<double> GetParameter(GLenum pname); + Maybe<std::string> GetString(GLenum pname) const; + + bool IsEnabled(GLenum cap); + + private: + static StaticMutex sLruMutex; + static std::list<WebGLContext*> sLru MOZ_GUARDED_BY(sLruMutex); + + // State tracking slots + bool mDitherEnabled = true; + bool mRasterizerDiscardEnabled = false; + bool mScissorTestEnabled = false; + bool mDepthTestEnabled = false; + bool mStencilTestEnabled = false; + GLenum mGenerateMipmapHint = LOCAL_GL_DONT_CARE; + + struct ScissorRect final { + GLint x; + GLint y; + GLsizei w; + GLsizei h; + + void Apply(gl::GLContext&) const; + }; + ScissorRect mScissorRect = {}; + + bool ValidateCapabilityEnum(GLenum cap); + bool* GetStateTrackingSlot(GLenum cap, GLuint i); + + // Allocation debugging variables + mutable uint64_t mDataAllocGLCallCount = 0; + + void OnDataAllocCall() const { mDataAllocGLCallCount++; } + + uint64_t GetNumGLDataAllocCalls() const { return mDataAllocGLCallCount; } + + void OnEndOfFrame(); + + // ----------------------------------------------------------------------------- + // Texture funcions (WebGLContextTextures.cpp) + public: + void ActiveTexture(uint32_t texUnit); + void BindTexture(GLenum texTarget, WebGLTexture* tex); + void GenerateMipmap(GLenum texTarget); + + Maybe<double> GetTexParameter(const WebGLTexture&, GLenum pname) const; + void TexParameter_base(GLenum texTarget, GLenum pname, + const FloatOrInt& param); + + virtual bool IsTexParamValid(GLenum pname) const; + + //////////////////////////////////// + // Uploads + + // CompressedTexSubImage if `sub` + void CompressedTexImage(bool sub, GLenum imageTarget, uint32_t level, + GLenum format, uvec3 offset, uvec3 size, + const Range<const uint8_t>& src, + const uint32_t pboImageSize, + const Maybe<uint64_t>& pboOffset) const; + + // CopyTexSubImage if `!respectFormat` + void CopyTexImage(GLenum imageTarget, uint32_t level, GLenum respecFormat, + uvec3 dstOffset, const ivec2& srcOffset, + const uvec2& size) const; + + // TexSubImage if `!respectFormat` + void TexImage(uint32_t level, GLenum respecFormat, uvec3 offset, + const webgl::PackingInfo& pi, + const webgl::TexUnpackBlobDesc&) const; + + void TexStorage(GLenum texTarget, uint32_t levels, GLenum sizedFormat, + uvec3 size) const; + + UniquePtr<webgl::TexUnpackBlob> ToTexUnpackBytes( + const WebGLTexImageData& imageData); + + UniquePtr<webgl::TexUnpackBytes> ToTexUnpackBytes(WebGLTexPboOffset& aPbo); + + //////////////////////////////////// + // WebGLTextureUpload.cpp + protected: + bool ValidateTexImageSpecification(uint8_t funcDims, GLenum texImageTarget, + GLint level, GLsizei width, GLsizei height, + GLsizei depth, GLint border, + TexImageTarget* const out_target, + WebGLTexture** const out_texture, + webgl::ImageInfo** const out_imageInfo); + bool ValidateTexImageSelection(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, + webgl::ImageInfo** const out_imageInfo); + bool ValidateUnpackInfo(bool usePBOs, GLenum format, GLenum type, + webgl::PackingInfo* const out); + + // ----------------------------------------------------------------------------- + // Vertices Feature (WebGLContextVertices.cpp) + GLenum mPrimRestartTypeBytes = 0; + + public: + void DrawArraysInstanced(GLenum mode, GLint first, GLsizei vertexCount, + GLsizei instanceCount); + void DrawElementsInstanced(GLenum mode, GLsizei vertexCount, GLenum type, + WebGLintptr byteOffset, GLsizei instanceCount); + + void EnableVertexAttribArray(GLuint index); + void DisableVertexAttribArray(GLuint index); + + Maybe<double> GetVertexAttrib(GLuint index, GLenum pname); + + //// + + void VertexAttrib4T(GLuint index, const webgl::TypedQuad&); + + //// + + void VertexAttribPointer(uint32_t index, const webgl::VertAttribPointerDesc&); + + void VertexAttribDivisor(GLuint index, GLuint divisor); + + private: + WebGLBuffer* DrawElements_check(GLsizei indexCount, GLenum type, + WebGLintptr byteOffset, + GLsizei instanceCount); + void Draw_cleanup(); + + 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 BindArrayAttribToLocation0(WebGLProgram* prog); + + // ----------------------------------------------------------------------------- + // PROTECTED + protected: + WebGLVertexAttrib0Status WhatDoesVertexAttrib0Need() const; + bool DoFakeVertexAttrib0(uint64_t fakeVertexCount, + WebGLVertexAttrib0Status whatDoesAttrib0Need); + void UndoFakeVertexAttrib0(); + + bool mResetLayer = true; + bool mOptionsFrozen = false; + bool mIsMesa = false; + bool mLoseContextOnMemoryPressure = false; + bool mCanLoseContextInForeground = true; + bool mShouldPresent = false; + bool mDisableFragHighP = false; + bool mForceResizeOnPresent = false; + bool mVRReady = false; + + template <typename WebGLObjectType> + void DeleteWebGLObjectsArray(nsTArray<WebGLObjectType>& array); + + GLuint mActiveTexture = 0; + GLenum mDefaultFB_DrawBuffer0 = LOCAL_GL_BACK; + GLenum mDefaultFB_ReadBuffer = LOCAL_GL_BACK; + + mutable GLenum mWebGLError = 0; + + std::unique_ptr<webgl::ShaderValidator> CreateShaderValidator( + GLenum shaderType) const; + + // some GL constants + uint32_t mGLMaxFragmentUniformVectors = 0; + uint32_t mGLMaxVertexUniformVectors = 0; + uint32_t mGLMaxVertexOutputVectors = 0; + uint32_t mGLMaxFragmentInputVectors = 0; + + uint32_t mGLMaxVertexTextureImageUnits = 0; + uint32_t mGLMaxFragmentTextureImageUnits = 0; + uint32_t mGLMaxCombinedTextureImageUnits = 0; + + // ES3: + uint32_t mGLMinProgramTexelOffset = 0; + uint32_t mGLMaxProgramTexelOffset = 0; + + public: + auto GLMaxDrawBuffers() const { return mLimits->maxColorDrawBuffers; } + + uint32_t MaxValidDrawBuffers() const { + if (IsWebGL2() || + IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers)) { + return GLMaxDrawBuffers(); + } + return 1; + } + + GLenum LastColorAttachmentEnum() const { + return LOCAL_GL_COLOR_ATTACHMENT0 + MaxValidDrawBuffers() - 1; + } + + const auto& Options() const { return mOptions; } + + protected: + uint32_t mGLMaxRenderbufferSize = 0; + + public: + const auto& Limits() const { return *mLimits; } + auto MaxVertexAttribs() const { return mLimits->maxVertexAttribs; } + auto GLMaxTextureUnits() const { return mLimits->maxTexUnits; } + + bool IsFormatValidForFB(TexInternalFormat format) const; + + protected: + // ------------------------------------------------------------------------- + // WebGL extensions (implemented in WebGLContextExtensions.cpp) + + EnumeratedArray<WebGLExtensionID, WebGLExtensionID::Max, + std::unique_ptr<WebGLExtensionBase>> + mExtensions; + + public: + void RequestExtension(WebGLExtensionID, bool explicitly = true); + + // returns true if the extension has been enabled by calling getExtension. + bool IsExtensionEnabled(const WebGLExtensionID id) const { + return bool(mExtensions[id]); + } + + bool IsExtensionExplicit(WebGLExtensionID) const; + void WarnIfImplicit(WebGLExtensionID) const; + + bool IsExtensionSupported(WebGLExtensionID) const; + + // ------------------------------------------------------------------------- + // WebGL 2 specifics (implemented in WebGL2Context.cpp) + public: + virtual bool IsWebGL2() const { return false; } + + struct FailureReason { + nsCString key; // For reporting. + nsCString info; + + FailureReason() = default; + + 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); + + // ------------------------------------------------------------------------- + // Validation functions (implemented in WebGLContextValidate.cpp) + bool InitAndValidateGL(FailureReason* const out_failReason); + + bool ValidateBlendEquationEnum(GLenum cap, const char* info); + bool ValidateBlendFuncEnumsCompatibility(GLenum sfactor, GLenum dfactor, + const char* info); + bool ValidateStencilOpEnum(GLenum action, const char* info); + bool ValidateFaceEnum(GLenum face); + bool ValidateTexInputData(GLenum type, js::Scalar::Type jsArrayType, + WebGLTexImageFunc func, WebGLTexDimensions dims); + bool ValidateAttribPointer(bool integerMode, GLuint index, GLint size, + GLenum type, WebGLboolean normalized, + GLsizei stride, WebGLintptr byteOffset, + const char* info); + bool ValidateStencilParamsForDrawCall() const; + + 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 HasDrawBuffers() const { + return IsWebGL2() || + IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers); + } + + RefPtr<WebGLBuffer>* ValidateBufferSlot(GLenum target); + + public: + WebGLBuffer* ValidateBufferSelection(GLenum target) const; + + protected: + IndexedBufferBinding* ValidateIndexedBufferSlot(GLenum target, GLuint index); + + bool ValidateIndexedBufferBinding( + GLenum target, GLuint index, + RefPtr<WebGLBuffer>** const out_genericBinding, + IndexedBufferBinding** const out_indexedBinding); + + public: + bool ValidateNonNegative(const char* argName, int64_t val) const { + if (MOZ_UNLIKELY(val < 0)) { + ErrorInvalidValue("`%s` must be non-negative.", argName); + return false; + } + return true; + } + + template <typename T> + bool ValidateNonNull(const char* const argName, + const dom::Nullable<T>& maybe) const { + if (maybe.IsNull()) { + ErrorInvalidValue("%s: Cannot be null.", argName); + return false; + } + return true; + } + + //// + + protected: + void DestroyResourcesAndContext(); + + // 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: + template <typename T> + bool ValidateObject(const char* const argName, const T& object) const { + // Todo: Remove all callers. + return true; + } + + template <typename T> + bool ValidateObject(const char* const argName, const T* const object) const { + // Todo: Remove most (all?) callers. + if (!object) { + ErrorInvalidOperation( + "%s: Object argument cannot have been marked for" + " deletion.", + argName); + return false; + } + return true; + } + + //// + + private: + void LoseContextLruLocked(webgl::ContextLossReason reason) + MOZ_REQUIRES(sLruMutex); + + public: + void LoseContext( + webgl::ContextLossReason reason = webgl::ContextLossReason::None); + + protected: + nsTArray<RefPtr<WebGLTexture>> mBound2DTextures; + nsTArray<RefPtr<WebGLTexture>> mBoundCubeMapTextures; + nsTArray<RefPtr<WebGLTexture>> mBound3DTextures; + nsTArray<RefPtr<WebGLTexture>> mBound2DArrayTextures; + nsTArray<RefPtr<WebGLSampler>> mBoundSamplers; + + void ResolveTexturesForDraw() const; + + RefPtr<WebGLProgram> mCurrentProgram; + RefPtr<const webgl::LinkedProgramInfo> mActiveProgramLinkInfo; + + bool ValidateFramebufferTarget(GLenum target) const; + bool ValidateInvalidateFramebuffer(GLenum target, + const Range<const GLenum>& attachments, + std::vector<GLenum>* const scopedVector, + GLsizei* const out_glNumAttachments, + const GLenum** const out_glAttachments); + + RefPtr<WebGLFramebuffer> mBoundDrawFramebuffer; + RefPtr<WebGLFramebuffer> mBoundReadFramebuffer; + RefPtr<WebGLTransformFeedback> mBoundTransformFeedback; + RefPtr<WebGLVertexArray> mBoundVertexArray; + + public: + const auto& BoundReadFb() const { return mBoundReadFramebuffer; } + + protected: + RefPtr<WebGLTransformFeedback> mDefaultTransformFeedback; + RefPtr<WebGLVertexArray> mDefaultVertexArray; + + //////////////////////////////////// + + protected: + GLuint mEmptyTFO = 0; + + // 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. + std::vector<webgl::AttribBaseType> mGenericVertexAttribTypes; + CacheInvalidator mGenericVertexAttribTypeInvalidator; + + GLuint mFakeVertexAttrib0BufferObject = 0; + intptr_t mFakeVertexAttrib0BufferObjectSize = 0; + bool mFakeVertexAttrib0DataDefined = false; + alignas(alignof(float)) uint8_t + mGenericVertexAttrib0Data[sizeof(float) * 4] = {}; + alignas(alignof(float)) uint8_t + mFakeVertexAttrib0Data[sizeof(float) * 4] = {}; + + GLint mStencilRefFront = 0; + GLint mStencilRefBack = 0; + GLuint mStencilValueMaskFront = 0; + GLuint mStencilValueMaskBack = 0; + GLuint mStencilWriteMaskFront = 0; + GLuint mStencilWriteMaskBack = 0; + uint8_t mColorWriteMask0 = 0xf; // bitmask + mutable uint8_t mDriverColorMask0 = 0xf; + bool mDepthWriteMask = true; + GLfloat mColorClearValue[4] = {0, 0, 0, 0}; + GLint mStencilClearValue = 0; + GLfloat mDepthClearValue = 1.0f; + + std::bitset<webgl::kMaxDrawBuffers> mColorWriteMaskNonzero = -1; + std::bitset<webgl::kMaxDrawBuffers> mBlendEnabled = 0; + + GLint mViewportX = 0; + GLint mViewportY = 0; + GLsizei mViewportWidth = 0; + GLsizei mViewportHeight = 0; + bool mAlreadyWarnedAboutViewportLargerThanDest = false; + + GLfloat mLineWidth = 1.0; + + WebGLContextLossHandler mContextLossHandler; + + // Used for some hardware (particularly Tegra 2 and 4) that likes to + // be Flushed while doing hundreds of draw calls. + mutable uint64_t mDrawCallsSinceLastFlush = 0; + + mutable uint64_t mWarningCount = 0; + const uint64_t mMaxWarnings; + bool mAlreadyWarnedAboutFakeVertexAttrib0 = false; + + bool ShouldGenerateWarnings() const { return mWarningCount < mMaxWarnings; } + + bool ShouldGeneratePerfWarnings() const { + return mNumPerfWarnings < mMaxPerfWarnings; + } + + bool mNeedsFakeNoAlpha = false; + bool mNeedsFakeNoDepth = false; + bool mNeedsFakeNoStencil = false; + bool mNeedsFakeNoStencil_UserFBs = false; + + bool mDriverDepthTest = false; + bool mDriverStencilTest = false; + + bool mNeedsLegacyVertexAttrib0Handling = false; + bool mMaybeNeedsLegacyVertexAttrib0Handling = false; + bool mNeedsIndexValidation = false; + bool mBug_DrawArraysInstancedUserAttribFetchAffectedByFirst = false; + + const bool mAllowFBInvalidation; + + bool Has64BitTimestamps() const; + + // -- + + const uint8_t mMsaaSamples; + mutable uvec2 mRequestedSize; + mutable UniquePtr<gl::MozFramebuffer> mDefaultFB; + mutable bool mDefaultFB_IsInvalid = false; + mutable UniquePtr<gl::MozFramebuffer> mResolvedDefaultFB; + + gl::SwapChain mSwapChain; + gl::SwapChain mWebVRSwapChain; + + RefPtr<layers::RemoteTextureOwnerClient> mRemoteTextureOwner; + + bool PushRemoteTexture(WebGLFramebuffer*, gl::SwapChain&, + std::shared_ptr<gl::SharedSurface>, + const webgl::SwapChainOptions& options); + + // -- + + bool EnsureDefaultFB(); + bool ValidateAndInitFB( + const WebGLFramebuffer* fb, + GLenum incompleteFbError = LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION); + void DoBindFB(const WebGLFramebuffer* fb, + GLenum target = LOCAL_GL_FRAMEBUFFER) const; + + bool BindCurFBForDraw(); + bool BindCurFBForColorRead( + const webgl::FormatUsageInfo** out_format, uint32_t* out_width, + uint32_t* out_height, + GLenum incompleteFbError = LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION); + void DoColorMask(Maybe<GLuint> i, uint8_t bitmask) const; + void BlitBackbufferToCurDriverFB( + WebGLFramebuffer* const srcAsWebglFb = nullptr, + const gl::MozFramebuffer* const srcAsMozFb = nullptr, + bool srcIsBGRA = false) const; + bool BindDefaultFBForRead(); + + // -- + + public: + // console logging helpers + template <typename... Args> + void GenerateWarning(const char* const fmt, const Args&... args) const { + GenerateError(0, fmt, args...); + } + + template <typename... Args> + void GeneratePerfWarning(const char* const fmt, const Args&... args) const { + GenerateError(webgl::kErrorPerfWarning, fmt, args...); + } + + public: + UniquePtr<webgl::FormatUsageAuthority> mFormatUsage; + + virtual UniquePtr<webgl::FormatUsageAuthority> CreateFormatUsage( + gl::GLContext* gl) const; + + const decltype(mBound2DTextures)* TexListForElemType(GLenum elemType) const; + + // Friend list + friend class ScopedCopyTexImageSource; + friend class ScopedResolveTexturesForDraw; + 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 WebGLVertexArray; + friend class WebGLVertexArrayFake; + friend class WebGLVertexArrayGL; +}; + +// 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; +} + +class ScopedFBRebinder final { + private: + const WebGLContext* const mWebGL; + + public: + explicit ScopedFBRebinder(const WebGLContext* const webgl) : mWebGL(webgl) {} + ~ScopedFBRebinder(); +}; + +// - + +constexpr inline bool IsBufferTargetLazilyBound(const GLenum target) { + return target != LOCAL_GL_ELEMENT_ARRAY_BUFFER; +} + +void DoBindBuffer(gl::GLContext&, GLenum target, const WebGLBuffer*); + +class ScopedLazyBind final { + private: + gl::GLContext& mGL; + const GLenum mTarget; + + public: + ScopedLazyBind(gl::GLContext* const gl, const GLenum target, + const WebGLBuffer* const buf) + : mGL(*gl), mTarget(IsBufferTargetLazilyBound(target) ? target : 0) { + if (mTarget) { + DoBindBuffer(mGL, mTarget, buf); + } + } + + ~ScopedLazyBind() { + if (mTarget) { + DoBindBuffer(mGL, mTarget, nullptr); + } + } +}; + +//// + +bool Intersect(int32_t srcSize, int32_t read0, int32_t readSize, + int32_t* out_intRead0, int32_t* out_intWrite0, + int32_t* out_intSize); + +uint64_t AvailGroups(uint64_t totalAvailItems, uint64_t firstItemOffset, + uint32_t groupSize, uint32_t groupStride); + +//// + +class ScopedDrawCallWrapper final { + public: + WebGLContext& mWebGL; + + explicit ScopedDrawCallWrapper(WebGLContext& webgl); + ~ScopedDrawCallWrapper(); +}; + +namespace webgl { + +class ScopedPrepForResourceClear final { + const WebGLContext& webgl; + + public: + explicit ScopedPrepForResourceClear(const WebGLContext&); + ~ScopedPrepForResourceClear(); +}; + +struct IndexedName final { + std::string name; + uint64_t index; +}; +Maybe<IndexedName> ParseIndexed(const std::string& str); + +} // namespace webgl + +webgl::LinkActiveInfo GetLinkActiveInfo( + gl::GLContext& gl, const GLuint prog, const bool webgl2, + const std::unordered_map<std::string, std::string>& nameUnmap); + +} // namespace mozilla + +#endif |