/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* 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 MOZILLA_GFX_DRAWTARGETWEBGL_H #define MOZILLA_GFX_DRAWTARGETWEBGL_H #include #include #include #include "GLTypes.h" #include "mozilla/Array.h" #include "mozilla/LinkedList.h" #include "mozilla/WeakPtr.h" #include "mozilla/gfx/2D.h" #include "mozilla/gfx/PathSkia.h" #include "mozilla/ipc/SharedMemoryHandle.h" #include "mozilla/ipc/SharedMemoryMapping.h" #include "mozilla/layers/LayersTypes.h" namespace WGR { struct OutputVertex; struct PathBuilder; } // namespace WGR namespace mozilla { class WebGLContext; class WebGLBuffer; class WebGLFramebuffer; class WebGLProgram; class WebGLRenderbuffer; class WebGLTexture; class WebGLUniformLocation; class WebGLVertexArray; namespace gl { class GLContext; class SharedSurface; } // namespace gl namespace layers { class RemoteTextureOwnerClient; } // namespace layers namespace gfx { class DataSourceSurface; class DrawTargetSkia; class DrawTargetWebgl; class FilterNodeWebgl; class PathSkia; class SourceSurfaceSkia; class SourceSurfaceWebgl; class BackingTexture; class TextureHandle; class SharedTexture; class SharedTextureHandle; class StandaloneTexture; class GlyphCache; class PathCache; class PathCacheEntry; struct PathVertexRange; enum class AAStrokeMode; // SharedContextWebgl stores most of the actual WebGL state that may be used by // any number of DrawTargetWebgl's that use it. Foremost, it holds the actual // WebGL client context, programs, and buffers for mapping to WebGL. // Secondarily, it holds shared caches for surfaces, glyphs, paths, and // shadows so that each DrawTargetWebgl does not require its own cache. It is // important that SetTarget is called to install the current DrawTargetWebgl // before actually using the SharedContext, as the individual framebuffers // and viewport are still maintained in DrawTargetWebgl itself. class SharedContextWebgl : public mozilla::RefCounted, public mozilla::SupportsWeakPtr { friend class DrawTargetWebgl; friend class FilterNodeWebgl; friend class SourceSurfaceWebgl; friend class TextureHandle; friend class SharedTextureHandle; friend class StandaloneTexture; public: MOZ_DECLARE_REFCOUNTED_TYPENAME(SharedContextWebgl) static already_AddRefed Create(); ~SharedContextWebgl(); gl::GLContext* GetGLContext(); void EnterTlsScope(); void ExitTlsScope(); bool IsContextLost() const; void OnMemoryPressure(); void ClearCaches(); std::shared_ptr ExportSharedSurface( layers::TextureType aTextureType, SourceSurface* aSurface); already_AddRefed ImportSurfaceDescriptor( const layers::SurfaceDescriptor& aDesc, const gfx::IntSize& aSize, SurfaceFormat aFormat); private: SharedContextWebgl(); WeakPtr mCurrentTarget; RefPtr mTargetHandle; IntSize mViewportSize; // The current integer-aligned scissor rect. IntRect mClipRect; // The current fractional AA'd clip rect bounds. Rect mClipAARect; RefPtr mWebgl; // Avoid spurious state changes by caching last used state. RefPtr mLastProgram; RefPtr mLastTexture; RefPtr mLastClipMask; // WebGL shader resources RefPtr mPathVertexBuffer; RefPtr mPathVertexArray; // The current insertion offset into the GPU path buffer. uint32_t mPathVertexOffset = 0; // The maximum size of the GPU path buffer. uint32_t mPathVertexCapacity = 0; // The maximum supported type complexity of a GPU path. uint32_t mPathMaxComplexity = 0; // Whether to accelerate stroked paths with AAStroke. bool mPathAAStroke = true; // Whether to accelerate stroked paths with WGR. bool mPathWGRStroke = false; WGR::PathBuilder* mWGRPathBuilder = nullptr; // Temporary buffer for generating WGR output into. UniquePtr mWGROutputBuffer; RefPtr mSolidProgram; Maybe mSolidProgramViewport; Maybe mSolidProgramAA; Maybe mSolidProgramTransform; Maybe mSolidProgramColor; Maybe mSolidProgramClipMask; Maybe mSolidProgramClipBounds; RefPtr mImageProgram; Maybe mImageProgramViewport; Maybe mImageProgramAA; Maybe mImageProgramTransform; Maybe mImageProgramTexMatrix; Maybe mImageProgramTexBounds; Maybe mImageProgramColor; Maybe mImageProgramSwizzle; Maybe mImageProgramSampler; Maybe mImageProgramClipMask; Maybe mImageProgramClipBounds; RefPtr mBlurProgram; Maybe mBlurProgramViewport; Maybe mBlurProgramTransform; Maybe mBlurProgramTexMatrix; Maybe mBlurProgramTexBounds; Maybe mBlurProgramOffsetScale; Maybe mBlurProgramSigma; Maybe mBlurProgramColor; Maybe mBlurProgramSwizzle; Maybe mBlurProgramSampler; Maybe mBlurProgramClipMask; Maybe mBlurProgramClipBounds; RefPtr mFilterProgram; Maybe mFilterProgramViewport; Maybe mFilterProgramTransform; Maybe mFilterProgramTexMatrix; Maybe mFilterProgramTexBounds; Maybe mFilterProgramColorMatrix; Maybe mFilterProgramColorOffset; Maybe mFilterProgramSampler; Maybe mFilterProgramClipMask; Maybe mFilterProgramClipBounds; struct SolidProgramUniformState { Maybe> mViewport; Maybe> mAA; Maybe> mTransform; Maybe> mColor; Maybe> mClipBounds; } mSolidProgramUniformState; struct ImageProgramUniformState { Maybe> mViewport; Maybe> mAA; Maybe> mTransform; Maybe> mTexMatrix; Maybe> mTexBounds; Maybe> mColor; Maybe> mSwizzle; Maybe> mClipBounds; } mImageProgramUniformState; struct BlurProgramUniformState { Maybe> mViewport; Maybe> mTransform; Maybe> mTexMatrix; Maybe> mTexBounds; Maybe> mOffsetScale; Maybe> mSigma; Maybe> mColor; Maybe> mSwizzle; Maybe> mClipBounds; } mBlurProgramUniformState; struct FilterProgramUniformState { Maybe> mViewport; Maybe> mTransform; Maybe> mTexMatrix; Maybe> mTexBounds; Maybe> mColorMatrix; Maybe> mColorOffset; Maybe> mClipBounds; } mFilterProgramUniformState; // Scratch framebuffer used to wrap textures for miscellaneous utility ops. RefPtr mScratchFramebuffer; // Scratch framebuffer used to wrap textures for sub-targets. RefPtr mTargetFramebuffer; // Scratch framebuffer used to wrap textures for export. RefPtr mExportFramebuffer; // Buffer filled with zero data for initializing textures. RefPtr mZeroBuffer; size_t mZeroSize = 0; // 1x1 texture with solid white mask for disabling clipping RefPtr mNoClipMask; uint32_t mMaxTextureSize = 0; bool mRasterizationTruncates = false; // The current blending operation. CompositionOp mLastCompositionOp = CompositionOp::OP_SOURCE; // The constant blend color used for the blending operation. Maybe mLastBlendColor; // The blend stage of the current blending operation. uint8_t mLastBlendStage = 0; // The cached scissor state. Operations that rely on scissor state should // take care to enable or disable the cached scissor state as necessary. bool mScissorEnabled = false; IntRect mLastScissor = {-1, -1, -1, -1}; // A most-recently-used list of allocated texture handles. LinkedList> mTextureHandles; size_t mNumTextureHandles = 0; // User data key linking a SourceSurface with its TextureHandle. UserDataKey mTextureHandleKey = {0}; // User data key linking a ScaledFont with its GlyphCache. UserDataKey mGlyphCacheKey = {0}; // List of all GlyphCaches currently allocated to fonts. LinkedList mGlyphCaches; // Cache of rasterized paths. UniquePtr mPathCache; // Collection of allocated shared texture pages that may be shared amongst // many handles. std::vector> mSharedTextures; // Collection of allocated standalone textures that have a single assigned // handle. std::vector> mStandaloneTextures; size_t mUsedTextureMemory = 0; size_t mTotalTextureMemory = 0; // The total reserved memory for empty texture pages that are kept around // for future allocations. size_t mEmptyTextureMemory = 0; // A memory pressure event may signal from another thread that caches should // be cleared if possible. Atomic mShouldClearCaches; // The total number of DrawTargetWebgls using this shared context. size_t mDrawTargetCount = 0; // Whether we are inside a scoped usage of TLS MakeCurrent, and what previous // value to restore it to when exiting the scope. Maybe mTlsScope; // Cached unit circle path RefPtr mUnitCirclePath; // The total bytes used by pending snapshot PBOs. size_t mUsedSnapshotPBOMemory = 0; // The owning surfaces initiating snapshot PBO readbacks. std::deque> mSnapshotPBOs; bool Initialize(); bool CreateShaders(); void ResetPathVertexBuffer(); void BlendFunc(GLenum aSrcFactor, GLenum aDstFactor); void SetBlendState(CompositionOp aOp, const Maybe& aColor = Nothing(), uint8_t aStage = 0); uint8_t RequiresMultiStageBlend(const DrawOptions& aOptions, DrawTargetWebgl* aDT = nullptr); void SetClipRect(const Rect& aClipRect); void SetClipRect(const IntRect& aClipRect) { SetClipRect(Rect(aClipRect)); } bool SetClipMask(const RefPtr& aTex); bool SetNoClipMask(); bool HasClipMask() const { return mLastClipMask && mLastClipMask != mNoClipMask; } Maybe GetUniformLocation(const RefPtr& prog, const std::string& aName) const; template void UniformData(GLenum aFuncElemType, const Maybe& aLoc, const Array& aData); // Avoids redundant UniformData calls by caching the previously set value. template void MaybeUniformData(GLenum aFuncElemType, const Maybe& aLoc, const Array& aData, Maybe>& aCached); bool IsCurrentTarget(DrawTargetWebgl* aDT) const { return aDT == mCurrentTarget; } bool SetTarget(DrawTargetWebgl* aDT, const RefPtr& aHandle = nullptr, const IntSize& aViewportSize = IntSize()); void RestoreCurrentTarget(const RefPtr& aClipMask = nullptr); // Reset the current target. void ClearTarget() { mCurrentTarget = nullptr; } // Reset the last used texture to force binding next use. void ClearLastTexture(bool aFullClear = false); bool SupportsPattern(const Pattern& aPattern); void EnableScissor(const IntRect& aRect, bool aForce = false); void DisableScissor(bool aForce = false); void SetTexFilter(WebGLTexture* aTex, bool aFilter); void InitTexParameters(WebGLTexture* aTex, bool aFilter = true); bool ReadInto(uint8_t* aDstData, int32_t aDstStride, SurfaceFormat aFormat, const IntRect& aBounds, TextureHandle* aHandle = nullptr, const RefPtr& aBuffer = nullptr); already_AddRefed ReadSnapshot( TextureHandle* aHandle = nullptr, uint8_t* aData = nullptr, int32_t aStride = 0); already_AddRefed WrapSnapshot(const IntSize& aSize, SurfaceFormat aFormat, RefPtr aTex); already_AddRefed CopySnapshot( const IntRect& aRect, TextureHandle* aHandle = nullptr); already_AddRefed ReadSnapshotIntoPBO( SourceSurfaceWebgl* aOwner, TextureHandle* aHandle = nullptr); already_AddRefed ReadSnapshotFromPBO( const RefPtr& aBuffer, SurfaceFormat aFormat, const IntSize& aSize, uint8_t* aData = nullptr, int32_t aStride = 0); void RemoveSnapshotPBO(SourceSurfaceWebgl* aOwner, already_AddRefed aBuffer); void ClearSnapshotPBOs(size_t aMaxMemory = 0); already_AddRefed GetCompatibleSnapshot( SourceSurface* aSurface, RefPtr* aHandle = nullptr, bool aCheckTarget = true) const; bool IsCompatibleSurface(SourceSurface* aSurface) const; bool UploadSurface(DataSourceSurface* aData, SurfaceFormat aFormat, const IntRect& aSrcRect, const IntPoint& aDstOffset, bool aInit, bool aZero = false, const RefPtr& aTex = nullptr); void UploadSurfaceToHandle(const RefPtr& aData, const IntPoint& aSrcOffset, const RefPtr& aHandle); void BindAndInitRenderTex(const RefPtr& aTex, SurfaceFormat aFormat, const IntSize& aSize); void InitRenderTex(BackingTexture* aBacking); void ClearRenderTex(BackingTexture* aBacking); void BindScratchFramebuffer(TextureHandle* aHandle, bool aInit, const IntSize& aViewportSize = IntSize()); already_AddRefed AllocateTextureHandle( SurfaceFormat aFormat, const IntSize& aSize, bool aAllowShared = true, bool aRenderable = false, const WebGLTexture* aAvoid = nullptr); void DrawQuad(); void DrawTriangles(const PathVertexRange& aRange); bool DrawRectAccel(const Rect& aRect, const Pattern& aPattern, const DrawOptions& aOptions, Maybe aMaskColor = Nothing(), RefPtr* aHandle = nullptr, bool aTransformed = true, bool aClipped = true, bool aAccelOnly = false, bool aForceUpdate = false, const StrokeOptions* aStrokeOptions = nullptr, const PathVertexRange* aVertexRange = nullptr, const Matrix* aRectXform = nullptr, uint8_t aBlendStage = 0); already_AddRefed GetFilterInputTexture( const RefPtr& aSurface, const IntRect& aSourceRect, RefPtr* aHandle, IntPoint& aOffset, SurfaceFormat& aFormat, IntRect& aBounds, IntSize& aBackingSize); bool FilterRect(const Rect& aDestRect, const Matrix5x4& aColorMatrix, const RefPtr& aSurface, const IntRect& aSourceRect, const DrawOptions& aOptions, RefPtr* aHandle, RefPtr* aTargetHandle = nullptr); bool BlurRectPass(const Rect& aDestRect, const Point& aSigma, bool aHorizontal, const RefPtr& aSurface, const IntRect& aSourceRect, const DrawOptions& aOptions = DrawOptions(), Maybe aMaskColor = Nothing(), RefPtr* aHandle = nullptr, RefPtr* aTargetHandle = nullptr, bool aFilter = false); bool BlurRectAccel(const Rect& aDestRect, const Point& aSigma, const RefPtr& aSurface, const IntRect& aSourceRect, const DrawOptions& aOptions = DrawOptions(), Maybe aMaskColor = Nothing(), RefPtr* aHandle = nullptr, RefPtr* aTargetHandle = nullptr, RefPtr* aResultHandle = nullptr, bool aFilter = false); already_AddRefed DownscaleBlurInput(SourceSurface* aSurface, const IntRect& aSourceRect, int aIters = 1); already_AddRefed DrawStrokeMask( const PathVertexRange& aVertexRange, const IntSize& aSize); bool DrawWGRPath(const Path* aPath, const IntRect& aIntBounds, const Rect& aQuantBounds, const Matrix& aPathXform, RefPtr& aEntry, const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions, AAStrokeMode aAAStrokeMode, const Pattern& aPattern, const Maybe& aColor); bool DrawPathAccel(const Path* aPath, const Pattern& aPattern, const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions = nullptr, bool aAllowStrokeAlpha = false, const ShadowOptions* aShadow = nullptr, bool aCacheable = true, const Matrix* aPathXform = nullptr); bool DrawCircleAccel(const Point& aCenter, float aRadius, const Pattern& aPattern, const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions = nullptr); bool DrawGlyphsAccel(ScaledFont* aFont, const GlyphBuffer& aBuffer, const Pattern& aPattern, const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions, bool aUseSubpixelAA); already_AddRefed ResolveFilterInputAccel( DrawTargetWebgl* aDT, const Path* aPath, const Pattern& aPattern, const IntRect& aSourceRect, const Matrix& aDestTransform, const DrawOptions& aOptions = DrawOptions(), const StrokeOptions* aStrokeOptions = nullptr, SurfaceFormat aFormat = SurfaceFormat::B8G8R8A8); void PruneTextureHandle(const RefPtr& aHandle); bool PruneTextureMemory(size_t aMargin = 0, bool aPruneUnused = true); bool RemoveSharedTexture(const RefPtr& aTexture); bool RemoveStandaloneTexture(const RefPtr& aTexture); void UnlinkSurfaceTextures(bool aForce = false); void UnlinkSurfaceTexture(const RefPtr& aHandle, bool aForce = false); void UnlinkGlyphCaches(); void AddHeapData(const void* aBuf); void RemoveHeapData(const void* aBuf); void AddUntrackedTextureMemory(size_t aBytes); void RemoveUntrackedTextureMemory(size_t aBytes); template void AddUntrackedTextureMemory(const RefPtr& aObject, size_t aBytes = 0); template void RemoveUntrackedTextureMemory(const RefPtr& aObject, size_t aBytes = 0); void AddTextureMemory(BackingTexture* aTexture); void RemoveTextureMemory(BackingTexture* aTexture); void ClearZeroBuffer(); void ClearAllTextures(); void ClearEmptyTextureMemory(); void ClearCachesIfNecessary(); void CachePrefs(); }; // DrawTargetWebgl implements a subset of the DrawTarget API suitable for use // by CanvasRenderingContext2D. It maps these to a client WebGL context so that // they can be accelerated where possible by WebGL. It manages both routing to // appropriate shaders and texture allocation/caching for surfaces. For commands // that are not feasible to accelerate with WebGL, it mirrors state to a backup // DrawTargetSkia that can be used as a fallback software renderer. Multiple // instances of DrawTargetWebgl within a process will actually share a single // WebGL context so that data can be more easily interchanged between them and // also to enable more reasonable limiting of resource usage. class DrawTargetWebgl : public DrawTarget, public SupportsWeakPtr { friend class FilterNodeWebgl; friend class FilterNodeDeferInputWebgl; friend class SourceSurfaceWebgl; friend class SharedContextWebgl; public: MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetWebgl, override) private: IntSize mSize; RefPtr mFramebuffer; RefPtr mTex; RefPtr mClipMask; // The integer-aligned, scissor-compatible conservative bounds of the clip. IntRect mClipBounds; // The fractional, AA'd bounds of the clip rect, if applicable. Rect mClipAARect; RefPtr mSkia; // Skia DT pointing to the same pixel data, but without any applied clips. RefPtr mSkiaNoClip; // A Shmem read-only handle to the same memory as mShmem, to be consumed by // TakeShmemHandle(). mozilla::ipc::ReadOnlySharedMemoryHandle mShmemHandle; // The Shmem backing the Skia DT, if applicable. mozilla::ipc::SharedMemoryMapping mShmem; // The currently cached snapshot of the WebGL context RefPtr mSnapshot; // Whether the framebuffer is still in the initially clear state. bool mIsClear = true; // Whether or not the Skia target has valid contents and is being drawn to bool mSkiaValid = false; // Whether or not Skia layering over the WebGL context is enabled bool mSkiaLayer = false; // Whether the WebGL target was clear when the Skia layer was established. bool mSkiaLayerClear = false; // Whether or not the WebGL context has valid contents and is being drawn to bool mWebglValid = true; // Whether or not the clip state has changed since last used by // SharedContextWebgl. bool mClipChanged = true; // Whether or not the clip state needs to be refreshed. Sometimes the clip // state may be overwritten and require a refresh later, even though it has // not changed. bool mRefreshClipState = true; // The number of layers currently pushed. int32_t mLayerDepth = 0; RefPtr mSnapshotTexture; // Store a log of clips currently pushed so that they can be used to init // the clip state of temporary DTs. struct ClipStack { Matrix mTransform; Rect mRect; RefPtr mPath; bool operator==(const ClipStack& aOther) const; }; std::vector mClipStack; // The previous state of the clip stack when a mask was generated. std::vector mCachedClipStack; // UsageProfile stores per-frame counters for significant profiling events // that assist in determining whether acceleration should still be used for // a Canvas2D user. struct UsageProfile { uint32_t mFailedFrames = 0; uint32_t mFrameCount = 0; uint32_t mCacheMisses = 0; uint32_t mCacheHits = 0; uint32_t mUncachedDraws = 0; uint32_t mLayers = 0; uint32_t mReadbacks = 0; uint32_t mFallbacks = 0; void BeginFrame(); void EndFrame(); bool RequiresRefresh() const; void OnCacheMiss() { ++mCacheMisses; } void OnCacheHit() { ++mCacheHits; } void OnUncachedDraw() { ++mUncachedDraws; } void OnLayer() { ++mLayers; } void OnReadback() { ++mReadbacks; } void OnFallback() { ++mFallbacks; } }; UsageProfile mProfile; RefPtr mSharedContext; public: DrawTargetWebgl(); ~DrawTargetWebgl(); static bool CanCreate(const IntSize& aSize, SurfaceFormat aFormat); static already_AddRefed Create( const IntSize& aSize, SurfaceFormat aFormat, const RefPtr& aSharedContext); bool Init(const IntSize& aSize, SurfaceFormat aFormat, const RefPtr& aSharedContext); bool IsValid() const override; DrawTargetType GetType() const override { return DrawTargetType::HARDWARE_RASTER; } BackendType GetBackendType() const override { return BackendType::WEBGL; } BackendType GetPathType() const override { return BackendType::SKIA; } IntSize GetSize() const override { return mSize; } const RefPtr& GetSharedContext() const { return mSharedContext; } bool HasDataSnapshot() const; bool EnsureDataSnapshot(); void PrepareShmem(); already_AddRefed GetDataSnapshot(); already_AddRefed Snapshot() override; already_AddRefed GetOptimizedSnapshot(DrawTarget* aTarget); already_AddRefed GetBackingSurface() override; void DetachAllSnapshots() override; void BeginFrame(bool aInvalidContents = false); void EndFrame(); bool RequiresRefresh() const { return mProfile.RequiresRefresh(); } bool LockBits(uint8_t** aData, IntSize* aSize, int32_t* aStride, SurfaceFormat* aFormat, IntPoint* aOrigin = nullptr) override; void ReleaseBits(uint8_t* aData) override; void Flush() override {} void DrawSurface( SourceSurface* aSurface, const Rect& aDest, const Rect& aSource, const DrawSurfaceOptions& aSurfOptions = DrawSurfaceOptions(), const DrawOptions& aOptions = DrawOptions()) override; void DrawFilter(FilterNode* aNode, const Rect& aSourceRect, const Point& aDestPoint, const DrawOptions& aOptions = DrawOptions()) override; void DrawSurfaceWithShadow(SourceSurface* aSurface, const Point& aDest, const ShadowOptions& aShadow, CompositionOp aOperator) override; void DrawShadow(const Path* aPath, const Pattern& aPattern, const ShadowOptions& aShadow, const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions = nullptr) override; void ClearRect(const Rect& aRect) override; void CopySurface(SourceSurface* aSurface, const IntRect& aSourceRect, const IntPoint& aDestination) override; void FillRect(const Rect& aRect, const Pattern& aPattern, const DrawOptions& aOptions = DrawOptions()) override; void StrokeRect(const Rect& aRect, const Pattern& aPattern, const StrokeOptions& aStrokeOptions = StrokeOptions(), const DrawOptions& aOptions = DrawOptions()) override; bool StrokeLineAccel(const Point& aStart, const Point& aEnd, const Pattern& aPattern, const StrokeOptions& aStrokeOptions, const DrawOptions& aOptions, bool aClosed = false); void StrokeLine(const Point& aStart, const Point& aEnd, const Pattern& aPattern, const StrokeOptions& aStrokeOptions = StrokeOptions(), const DrawOptions& aOptions = DrawOptions()) override; void Stroke(const Path* aPath, const Pattern& aPattern, const StrokeOptions& aStrokeOptions = StrokeOptions(), const DrawOptions& aOptions = DrawOptions()) override; void Fill(const Path* aPath, const Pattern& aPattern, const DrawOptions& aOptions = DrawOptions()) override; void FillCircle(const Point& aOrigin, float aRadius, const Pattern& aPattern, const DrawOptions& aOptions = DrawOptions()) override; void StrokeCircle(const Point& aOrigin, float aRadius, const Pattern& aPattern, const StrokeOptions& aStrokeOptions = StrokeOptions(), const DrawOptions& aOptions = DrawOptions()) override; void SetPermitSubpixelAA(bool aPermitSubpixelAA) override; void FillGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer, const Pattern& aPattern, const DrawOptions& aOptions = DrawOptions()) override; void StrokeGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer, const Pattern& aPattern, const StrokeOptions& aStrokeOptions = StrokeOptions(), const DrawOptions& aOptions = DrawOptions()) override; void Mask(const Pattern& aSource, const Pattern& aMask, const DrawOptions& aOptions = DrawOptions()) override; void MaskSurface(const Pattern& aSource, SourceSurface* aMask, Point aOffset, const DrawOptions& aOptions = DrawOptions()) override; bool Draw3DTransformedSurface(SourceSurface* aSurface, const Matrix4x4& aMatrix) override; void PushClip(const Path* aPath) override; void PushClipRect(const Rect& aRect) override; void PushDeviceSpaceClipRects(const IntRect* aRects, uint32_t aCount) override; void PopClip() override; bool RemoveAllClips() override; bool CopyToFallback(DrawTarget* aDT); void PushLayer(bool aOpaque, Float aOpacity, SourceSurface* aMask, const Matrix& aMaskTransform, const IntRect& aBounds = IntRect(), bool aCopyBackground = false) override; void PushLayerWithBlend( bool aOpaque, Float aOpacity, SourceSurface* aMask, const Matrix& aMaskTransform, const IntRect& aBounds = IntRect(), bool aCopyBackground = false, CompositionOp aCompositionOp = CompositionOp::OP_OVER) override; void PopLayer() override; already_AddRefed CreateSourceSurfaceFromData( unsigned char* aData, const IntSize& aSize, int32_t aStride, SurfaceFormat aFormat) const override; already_AddRefed OptimizeSourceSurface( SourceSurface* aSurface) const override; already_AddRefed OptimizeSourceSurfaceForUnknownAlpha( SourceSurface* aSurface) const override; already_AddRefed CreateSourceSurfaceFromNativeSurface( const NativeSurface& aSurface) const override; already_AddRefed CreateSimilarDrawTarget( const IntSize& aSize, SurfaceFormat aFormat) const override; bool CanCreateSimilarDrawTarget(const IntSize& aSize, SurfaceFormat aFormat) const override; RefPtr CreateClippedDrawTarget(const Rect& aBounds, SurfaceFormat aFormat) override; already_AddRefed CreatePathBuilder( FillRule aFillRule = FillRule::FILL_WINDING) const override; already_AddRefed CreateGradientStops( GradientStop* aStops, uint32_t aNumStops, ExtendMode aExtendMode = ExtendMode::CLAMP) const override; already_AddRefed CreateFilter(FilterType aType) override; already_AddRefed DeferFilterInput( const Path* aPath, const Pattern& aPattern, const IntRect& aSourceRect, const IntPoint& aDestOffset, const DrawOptions& aOptions = DrawOptions(), const StrokeOptions* aStrokeOptions = nullptr) override; already_AddRefed ResolveFilterInputAccel( const Path* aPath, const Pattern& aPattern, const IntRect& aSourceRect, const Matrix& aDestTransform, const DrawOptions& aOptions = DrawOptions(), const StrokeOptions* aStrokeOptions = nullptr, SurfaceFormat aFormat = SurfaceFormat::B8G8R8A8); bool FilterSurface(const Matrix5x4& aColorMatrix, SourceSurface* aSurface, const IntRect& aSourceRect, const Point& aDest, const DrawOptions& aOptions = DrawOptions()); bool BlurSurface(float aSigma, SourceSurface* aSurface, const IntRect& aSourceRect, const Point& aDest, const DrawOptions& aOptions = DrawOptions(), const DeviceColor& aColor = DeviceColor(1, 1, 1, 1)); void SetTransform(const Matrix& aTransform) override; void* GetNativeSurface(NativeSurfaceType aType) override; bool CopyToSwapChain( layers::TextureType aTextureType, layers::RemoteTextureId aId, layers::RemoteTextureOwnerId aOwnerId, layers::RemoteTextureOwnerClient* aOwnerClient = nullptr); already_AddRefed ImportSurfaceDescriptor( const layers::SurfaceDescriptor& aDesc, const gfx::IntSize& aSize, SurfaceFormat aFormat) override; void OnMemoryPressure() { mSharedContext->OnMemoryPressure(); } operator std::string() const { std::stringstream stream; stream << "DrawTargetWebgl(" << this << ")"; return stream.str(); } mozilla::ipc::ReadOnlySharedMemoryHandle TakeShmemHandle() { return std::move(mShmemHandle); } private: bool SupportsPattern(const Pattern& aPattern) { return mSharedContext->SupportsPattern(aPattern); } bool SupportsDrawOptions(const DrawOptions& aOptions, const Rect& aRect = Rect()); bool SetSimpleClipRect(); bool GenerateComplexClipMask(); bool PrepareContext(bool aClipped = true, const RefPtr& aHandle = nullptr, const IntSize& aViewportSize = IntSize()); void DrawRectFallback(const Rect& aRect, const Pattern& aPattern, const DrawOptions& aOptions, Maybe aMaskColor = Nothing(), bool aTransform = true, bool aClipped = true, const StrokeOptions* aStrokeOptions = nullptr); bool DrawRect(const Rect& aRect, const Pattern& aPattern, const DrawOptions& aOptions, Maybe aMaskColor = Nothing(), RefPtr* aHandle = nullptr, bool aTransformed = true, bool aClipped = true, bool aAccelOnly = false, bool aForceUpdate = false, const StrokeOptions* aStrokeOptions = nullptr); Maybe LinearGradientToSurface(const RectDouble& aBounds, const Pattern& aPattern); ColorPattern GetClearPattern() const; template RectDouble TransformDouble(const R& aRect) const; Maybe RectClippedToViewport(const RectDouble& aRect) const; bool ShouldAccelPath(const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions, const Rect& aRect = Rect()); void DrawPath(const Path* aPath, const Pattern& aPattern, const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions = nullptr, bool aAllowStrokeAlpha = false); void DrawCircle(const Point& aOrigin, float aRadius, const Pattern& aPattern, const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions = nullptr); bool MarkChanged(); bool ReadIntoSkia(); void FlattenSkia(); bool PrepareSkia(); bool FlushFromSkia(); void MarkSkiaChanged(bool aOverwrite = false); void MarkSkiaChanged(const DrawOptions& aOptions); bool ShouldUseSubpixelAA(ScaledFont* aFont, const DrawOptions& aOptions); bool ReadInto(uint8_t* aDstData, int32_t aDstStride); already_AddRefed ReadSnapshot(uint8_t* aData = nullptr, int32_t aStride = 0); already_AddRefed ReadSnapshotIntoPBO(SourceSurfaceWebgl* aOwner); already_AddRefed CopySnapshot(const IntRect& aRect); already_AddRefed CopySnapshot() { return CopySnapshot(GetRect()); } void ClearSnapshot(bool aCopyOnWrite = true, bool aNeedHandle = false); bool CreateFramebuffer(); void DrawFilterFallback(FilterNode* aNode, const Rect& aSourceRect, const Point& aDestPoint, const DrawOptions& aOptions = DrawOptions()); // PrepareContext may sometimes be used recursively. When this occurs, ensure // that clip state is restored after the context is used. struct AutoRestoreContext { DrawTargetWebgl* mTarget; Rect mClipAARect; RefPtr mLastClipMask; explicit AutoRestoreContext(DrawTargetWebgl* aTarget); ~AutoRestoreContext(); }; }; } // namespace gfx } // namespace mozilla #endif // MOZILLA_GFX_DRAWTARGETWEBGL_H