Home | History | Annotate | Download | only in gpu 
      1 /*
      2  * Copyright 2015 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 GrPipelineBuilder_DEFINED
      9 #define GrPipelineBuilder_DEFINED
     10 
     11 #include "GrGpuResourceRef.h"
     12 #include "GrPipeline.h"
     13 #include "GrProcessorSet.h"
     14 #include "GrRenderTarget.h"
     15 #include "GrUserStencilSettings.h"
     16 #include "GrXferProcessor.h"
     17 
     18 class GrCaps;
     19 class GrDrawOp;
     20 class GrPaint;
     21 class GrTexture;
     22 
     23 class GrPipelineBuilder : private SkNoncopyable {
     24 public:
     25     /**
     26      * Initializes the GrPipelineBuilder based on a GrPaint and MSAA availability. Note
     27      * that GrPipelineBuilder encompasses more than GrPaint. Aspects of GrPipelineBuilder that have
     28      * no GrPaint equivalents are set to default values with the exception of vertex attribute state
     29      * which is unmodified by this function and clipping which will be enabled.
     30      */
     31     GrPipelineBuilder(GrPaint&& paint, GrAAType aaType)
     32             : fFlags(0x0)
     33             , fDrawFace(GrDrawFace::kBoth)
     34             , fUserStencilSettings(&GrUserStencilSettings::kUnused)
     35             , fProcessors(std::move(paint)) {
     36         if (GrAATypeIsHW(aaType)) {
     37             fFlags |= GrPipeline::kHWAntialias_Flag;
     38         }
     39     }
     40 
     41     ///////////////////////////////////////////////////////////////////////////
     42     /// @name Fragment Processors
     43     ///
     44     /// GrFragmentProcessors are used to compute per-pixel color and per-pixel fractional coverage.
     45     /// There are two chains of FPs, one for color and one for coverage. The first FP in each
     46     /// chain gets the initial color/coverage from the GrPrimitiveProcessor. It computes an output
     47     /// color/coverage which is fed to the next FP in the chain. The last color and coverage FPs
     48     /// feed their output to the GrXferProcessor which controls blending.
     49     ////
     50 
     51     int numColorFragmentProcessors() const { return fProcessors.numColorFragmentProcessors(); }
     52     int numCoverageFragmentProcessors() const {
     53         return fProcessors.numCoverageFragmentProcessors();
     54     }
     55     int numFragmentProcessors() const { return fProcessors.numFragmentProcessors(); }
     56 
     57     const GrFragmentProcessor* getColorFragmentProcessor(int idx) const {
     58         return fProcessors.colorFragmentProcessor(idx);
     59     }
     60     const GrFragmentProcessor* getCoverageFragmentProcessor(int idx) const {
     61         return fProcessors.coverageFragmentProcessor(idx);
     62     }
     63 
     64     const GrProcessorSet& processors() const { return fProcessors; }
     65 
     66     /// @}
     67 
     68     ///////////////////////////////////////////////////////////////////////////
     69     /// @name Blending
     70     ////
     71 
     72     /**
     73      * Checks whether the xp will need destination in a texture to correctly blend.
     74      */
     75     bool willXPNeedDstTexture(const GrCaps& caps,
     76                               const GrProcessorSet::FragmentProcessorAnalysis& analysis) const {
     77         return GrXPFactory::WillNeedDstTexture(fProcessors.xpFactory(), caps, analysis);
     78     }
     79 
     80     /// @}
     81 
     82 
     83     ///////////////////////////////////////////////////////////////////////////
     84     /// @name Stencil
     85     ////
     86 
     87     bool hasUserStencilSettings() const { return !fUserStencilSettings->isUnused(); }
     88 
     89     /**
     90      * Sets the user stencil settings for the next draw.
     91      * This class only stores pointers to stencil settings objects.
     92      * The caller guarantees the pointer will remain valid until it
     93      * changes or goes out of scope.
     94      * @param settings  the stencil settings to use.
     95      */
     96     void setUserStencil(const GrUserStencilSettings* settings) { fUserStencilSettings = settings; }
     97 
     98     /// @}
     99 
    100     ///////////////////////////////////////////////////////////////////////////
    101     /// @name State Flags
    102     ////
    103 
    104     bool isHWAntialias() const { return SkToBool(fFlags & GrPipeline::kHWAntialias_Flag); }
    105 
    106     void setSnapVerticesToPixelCenters(bool enable) {
    107         if (enable) {
    108             fFlags |= GrPipeline::kSnapVerticesToPixelCenters_Flag;
    109         } else {
    110             fFlags &= ~GrPipeline::kSnapVerticesToPixelCenters_Flag;
    111         }
    112     }
    113 
    114     /// @}
    115 
    116     ///////////////////////////////////////////////////////////////////////////
    117     /// @name Face Culling
    118     ////
    119 
    120     /**
    121      * Controls whether clockwise, counterclockwise, or both faces are drawn.
    122      * @param face  the face(s) to draw.
    123      */
    124     void setDrawFace(GrDrawFace face) {
    125         SkASSERT(GrDrawFace::kInvalid != face);
    126         fDrawFace = face;
    127     }
    128 
    129     /// @}
    130 
    131     void getPipelineInitArgs(GrPipeline::InitArgs* args) const {
    132         args->fFlags = fFlags;
    133         args->fUserStencil = fUserStencilSettings;
    134         args->fDrawFace = fDrawFace;
    135         args->fProcessors = &fProcessors;
    136     }
    137 
    138 private:
    139     uint32_t fFlags;
    140     GrDrawFace fDrawFace;
    141     const GrUserStencilSettings* fUserStencilSettings;
    142     GrProcessorSet fProcessors;
    143 };
    144 
    145 #endif
    146