/* * Copyright 2014 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #ifndef GrXferProcessor_DEFINED #define GrXferProcessor_DEFINED #include "include/core/SkRefCnt.h" #include "include/private/base/SkAssert.h" #include "include/private/base/SkMacros.h" #include "include/private/base/SkTo.h" #include "src/gpu/Blend.h" #include "src/gpu/Swizzle.h" #include "src/gpu/ganesh/GrCaps.h" #include "src/gpu/ganesh/GrNonAtomicRef.h" #include "src/gpu/ganesh/GrProcessor.h" #include "src/gpu/ganesh/GrProcessorAnalysis.h" #include "src/gpu/ganesh/glsl/GrGLSLUniformHandler.h" #include <memory> class GrGLSLProgramDataManager; class GrGLSLXPFragmentBuilder; enum GrSurfaceOrigin : int; enum class GrClampType; enum class SkBlendMode; namespace skgpu { class KeyBuilder; } struct GrShaderCaps; /** * Barriers for blending. When a shader reads the dst directly, an Xfer barrier is sometimes * required after a pixel has been written, before it can be safely read again. */ enum GrXferBarrierType { … }; /** Should be able to treat kNone as false in boolean expressions */ static_assert …; // Flag version of the above enum. enum class GrXferBarrierFlags { … }; SK_MAKE_BITFIELD_CLASS_OPS(GrXferBarrierFlags) /** * GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst * color, and for applying any coverage. It does this by emitting fragment shader code and * controlling the fixed-function blend state. When dual-source blending is available, it may also * write a secondary fragment shader output color. GrXferProcessor has two modes of operation: * * Dst read: When allowed by the backend API, or when supplied a texture of the destination, the * GrXferProcessor may read the destination color. While operating in this mode, the subclass only * provides shader code that blends the src and dst colors, and the base class applies coverage. * * No dst read: When not performing a dst read, the subclass is given full control of the fixed- * function blend state and/or secondary output, and is responsible to apply coverage on its own. * * A GrXferProcessor is never installed directly into our draw state, but instead is created from a * GrXPFactory once we have finalized the state of our draw. */ class GrXferProcessor : public GrProcessor, public GrNonAtomicRef<GrXferProcessor> { … }; /** * We install a GrXPFactory (XPF) early on in the pipeline before all the final draw information is * known (e.g. whether there is fractional pixel coverage, will coverage be 1 or 4 channel, is the * draw opaque, etc.). Once the state of the draw is finalized, we use the XPF along with all the * draw information to create a GrXferProcessor (XP) which can implement the desired blending for * the draw. * * Before the XP is created, the XPF is able to answer queries about what functionality the XPs it * creates will have. For example, can it create an XP that supports RGB coverage or will the XP * blend with the destination color. * * GrXPFactories are intended to be static immutable objects. We pass them around as raw pointers * and expect the pointers to always be valid and for the factories to be reusable and thread safe. * Equality is tested for using pointer comparison. GrXPFactory destructors must be no-ops. */ // In order to construct GrXPFactory subclass instances as constexpr the subclass, and therefore // GrXPFactory, must be a literal type. One requirement is having a trivial destructor. This is ok // since these objects have no need for destructors. However, GCC and clang throw a warning when a // class has virtual functions and a non-virtual destructor. We suppress that warning here and // for the subclasses. #if defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wnon-virtual-dtor" #endif #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wnon-virtual-dtor" #endif class GrXPFactory { … }; #if defined(__GNUC__) #pragma GCC diagnostic pop #endif #if defined(__clang__) #pragma clang diagnostic pop #endif SK_MAKE_BITFIELD_CLASS_OPS(GrXPFactory::AnalysisProperties) ////////////////////////////////////////////////////////////////////////////// class GrXferProcessor::ProgramImpl { … }; #endif