• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2016 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #ifndef GrTextureProducer_DEFINED
9 #define GrTextureProducer_DEFINED
10 
11 #include "GrResourceKey.h"
12 #include "GrSamplerState.h"
13 #include "SkImageInfo.h"
14 #include "SkNoncopyable.h"
15 
16 class GrContext;
17 class GrFragmentProcessor;
18 class GrTexture;
19 class GrTextureProxy;
20 class SkColorSpace;
21 class SkMatrix;
22 struct SkRect;
23 
24 /**
25  * Different GPUs and API extensions have different requirements with respect to what texture
26  * sampling parameters may be used with textures of various types. This class facilitates making
27  * texture compatible with a given GrSamplerState. There are two immediate subclasses defined
28  * below. One is a base class for sources that are inherently texture-backed (e.g. a texture-backed
29  * SkImage). It supports subsetting the original texture. The other is for use cases where the
30  * source can generate a texture that represents some content (e.g. cpu pixels, SkPicture, ...).
31  */
32 class GrTextureProducer : public SkNoncopyable {
33 public:
34     struct CopyParams {
35         GrSamplerState::Filter fFilter;
36         int fWidth;
37         int fHeight;
38     };
39 
40     enum FilterConstraint {
41         kYes_FilterConstraint,
42         kNo_FilterConstraint,
43     };
44 
45     /**
46      * Helper for creating a fragment processor to sample the texture with a given filtering mode.
47      * It attempts to avoid making texture copies or using domains whenever possible.
48      *
49      * @param textureMatrix                    Matrix used to access the texture. It is applied to
50      *                                         the local coords. The post-transformed coords should
51      *                                         be in texel units (rather than normalized) with
52      *                                         respect to this Producer's bounds (width()/height()).
53      * @param constraintRect                   A rect that represents the area of the texture to be
54      *                                         sampled. It must be contained in the Producer's
55      *                                         bounds as defined by width()/height().
56      * @param filterConstriant                 Indicates whether filtering is limited to
57      *                                         constraintRect.
58      * @param coordsLimitedToConstraintRect    Is it known that textureMatrix*localCoords is bound
59      *                                         by the portion of the texture indicated by
60      *                                         constraintRect (without consideration of filter
61      *                                         width, just the raw coords).
62      * @param filterOrNullForBicubic           If non-null indicates the filter mode. If null means
63      *                                         use bicubic filtering.
64      **/
65     virtual std::unique_ptr<GrFragmentProcessor> createFragmentProcessor(
66             const SkMatrix& textureMatrix,
67             const SkRect& constraintRect,
68             FilterConstraint filterConstraint,
69             bool coordsLimitedToConstraintRect,
70             const GrSamplerState::Filter* filterOrNullForBicubic) = 0;
71 
72     /**
73      *  Returns a texture that is safe for use with the params.
74      *
75      * If the size of the returned texture does not match width()/height() then the contents of the
76      * original may have been scaled to fit the texture or the original may have been copied into
77      * a subrect of the copy. 'scaleAdjust' must be  applied to the normalized texture coordinates
78      * in order to correct for the latter case.
79      *
80      * If the GrSamplerState is known to clamp and use kNearest or kBilerp filter mode then the
81      * proxy will always be unscaled and nullptr can be passed for scaleAdjust. There is a weird
82      * contract that if scaleAdjust is not null it must be initialized to {1, 1} before calling
83      * this method. (TODO: Fix this and make this function always initialize scaleAdjust).
84      */
85     sk_sp<GrTextureProxy> refTextureProxyForParams(const GrSamplerState&,
86                                                    SkScalar scaleAdjust[2]);
87 
refTextureProxyForParams(GrSamplerState::Filter filter,SkScalar scaleAdjust[2])88     sk_sp<GrTextureProxy> refTextureProxyForParams(GrSamplerState::Filter filter,
89                                                    SkScalar scaleAdjust[2]) {
90         return this->refTextureProxyForParams(
91                 GrSamplerState(GrSamplerState::WrapMode::kClamp, filter), scaleAdjust);
92     }
93 
94     /**
95      * Returns a texture. If willNeedMips is true then the returned texture is guaranteed to have
96      * allocated mip map levels. This can be a performance win if future draws with the texture
97      * require mip maps.
98      */
99     // TODO: Once we remove support for npot textures, we should add a flag for must support repeat
100     // wrap mode. To support that flag now would require us to support scaleAdjust array like in
101     // refTextureProxyForParams, however the current public API that uses this call does not expose
102     // that array.
103     sk_sp<GrTextureProxy> refTextureProxy(GrMipMapped willNeedMips);
104 
~GrTextureProducer()105     virtual ~GrTextureProducer() {}
106 
width()107     int width() const { return fWidth; }
height()108     int height() const { return fHeight; }
isAlphaOnly()109     bool isAlphaOnly() const { return fIsAlphaOnly; }
110     virtual SkAlphaType alphaType() const = 0;
111     virtual SkColorSpace* colorSpace() const = 0;
targetColorSpace()112     virtual SkColorSpace* targetColorSpace() const { return nullptr; }
113 
114 protected:
115     friend class GrTextureProducer_TestAccess;
116 
GrTextureProducer(GrContext * context,int width,int height,bool isAlphaOnly)117     GrTextureProducer(GrContext* context, int width, int height, bool isAlphaOnly)
118         : fContext(context)
119         , fWidth(width)
120         , fHeight(height)
121         , fIsAlphaOnly(isAlphaOnly) {}
122 
123     /** Helper for creating a key for a copy from an original key. */
MakeCopyKeyFromOrigKey(const GrUniqueKey & origKey,const CopyParams & copyParams,GrUniqueKey * copyKey)124     static void MakeCopyKeyFromOrigKey(const GrUniqueKey& origKey,
125                                        const CopyParams& copyParams,
126                                        GrUniqueKey* copyKey) {
127         SkASSERT(!copyKey->isValid());
128         if (origKey.isValid()) {
129             static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
130             GrUniqueKey::Builder builder(copyKey, origKey, kDomain, 3);
131             builder[0] = static_cast<uint32_t>(copyParams.fFilter);
132             builder[1] = copyParams.fWidth;
133             builder[2] = copyParams.fHeight;
134         }
135     }
136 
137     /**
138     *  If we need to make a copy in order to be compatible with GrTextureParams producer is asked to
139     *  return a key that identifies its original content + the CopyParms parameter. If the producer
140     *  does not want to cache the stretched version (e.g. the producer is volatile), this should
141     *  simply return without initializing the copyKey. If the texture generated by this producer
142     *  depends on the destination color space, then that information should also be incorporated
143     *  in the key.
144     */
145     virtual void makeCopyKey(const CopyParams&, GrUniqueKey* copyKey) = 0;
146 
147     /**
148     *  If a stretched version of the texture is generated, it may be cached (assuming that
149     *  makeCopyKey() returns true). In that case, the maker is notified in case it
150     *  wants to note that for when the maker is destroyed.
151     */
152     virtual void didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) = 0;
153 
154     enum DomainMode {
155         kNoDomain_DomainMode,
156         kDomain_DomainMode,
157         kTightCopy_DomainMode
158     };
159 
160     static sk_sp<GrTextureProxy> CopyOnGpu(GrContext*, sk_sp<GrTextureProxy> inputProxy,
161                                            const CopyParams& copyParams,
162                                            bool dstWillRequireMipMaps);
163 
164     static DomainMode DetermineDomainMode(const SkRect& constraintRect,
165                                           FilterConstraint filterConstraint,
166                                           bool coordsLimitedToConstraintRect,
167                                           GrTextureProxy*,
168                                           const GrSamplerState::Filter* filterModeOrNullForBicubic,
169                                           SkRect* domainRect);
170 
171     static std::unique_ptr<GrFragmentProcessor> CreateFragmentProcessorForDomainAndFilter(
172             sk_sp<GrTextureProxy> proxy,
173             const SkMatrix& textureMatrix,
174             DomainMode,
175             const SkRect& domain,
176             const GrSamplerState::Filter* filterOrNullForBicubic);
177 
178     GrContext* fContext;
179 
180 private:
181     virtual sk_sp<GrTextureProxy> onRefTextureProxyForParams(const GrSamplerState&,
182                                                              bool willBeMipped,
183                                                              SkScalar scaleAdjust[2]) = 0;
184 
185     const int   fWidth;
186     const int   fHeight;
187     const bool  fIsAlphaOnly;
188 
189     typedef SkNoncopyable INHERITED;
190 };
191 
192 #endif
193