Home | History | Annotate | Download | only in gpu 
      1 /*
      2  * Copyright 2013 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 GrGeometryProcessor_DEFINED
      9 #define GrGeometryProcessor_DEFINED
     10 
     11 #include "GrPrimitiveProcessor.h"
     12 
     13 /**
     14  * A GrGeometryProcessor is a flexible method for rendering a primitive.  The GrGeometryProcessor
     15  * has complete control over vertex attributes and uniforms(aside from the render target) but it
     16  * must obey the same contract as any GrPrimitiveProcessor, specifically it must emit a color and
     17  * coverage into the fragment shader.  Where this color and coverage come from is completely the
     18  * responsibility of the GrGeometryProcessor.
     19  */
     20 class GrGeometryProcessor : public GrPrimitiveProcessor {
     21 public:
     22     GrGeometryProcessor()
     23         : fWillUseGeoShader(false)
     24         , fLocalCoordsType(kUnused_LocalCoordsType)
     25         , fSampleShading(0.0) {}
     26 
     27     bool willUseGeoShader() const override { return fWillUseGeoShader; }
     28 
     29     bool hasExplicitLocalCoords() const override {
     30         return kHasExplicit_LocalCoordsType == fLocalCoordsType;
     31     }
     32 
     33     /**
     34      * Returns the minimum fraction of samples for which the fragment shader will be run. For
     35      * instance, if sampleShading is 0.5 in MSAA16 mode, the fragment shader will run a minimum of
     36      * 8 times per pixel. The default value is zero.
     37      */
     38     float getSampleShading() const override {
     39         return fSampleShading;
     40     }
     41 
     42 protected:
     43     /**
     44      * Subclasses call this from their constructor to register vertex attributes.  Attributes
     45      * will be padded to the nearest 4 bytes for performance reasons.
     46      * TODO After deferred geometry, we should do all of this inline in GenerateGeometry alongside
     47      * the struct used to actually populate the attributes.  This is all extremely fragile, vertex
     48      * attributes have to be added in the order they will appear in the struct which maps memory.
     49      * The processor key should reflect the vertex attributes, or there lack thereof in the
     50      * GrGeometryProcessor.
     51      */
     52     const Attribute& addVertexAttrib(const char* name, GrVertexAttribType type,
     53                                      GrSLPrecision precision = kDefault_GrSLPrecision) {
     54         fAttribs.emplace_back(name, type, precision);
     55         fVertexStride += fAttribs.back().fOffset;
     56         return fAttribs.back();
     57     }
     58 
     59     void setWillUseGeoShader() { fWillUseGeoShader = true; }
     60 
     61     /**
     62      * If a GrFragmentProcessor in the GrPipeline needs localCoods, we will provide them in one of
     63      * three ways
     64      * 1) LocalCoordTransform * Position - in Shader
     65      * 2) LocalCoordTransform * ExplicitLocalCoords- in Shader
     66      * 3) A transformation on the CPU uploaded via vertex attribute
     67      */
     68     enum LocalCoordsType {
     69         kUnused_LocalCoordsType,
     70         kHasExplicit_LocalCoordsType,
     71         kHasTransformed_LocalCoordsType
     72     };
     73 
     74     void setHasExplicitLocalCoords() {
     75         SkASSERT(kUnused_LocalCoordsType == fLocalCoordsType);
     76         fLocalCoordsType = kHasExplicit_LocalCoordsType;
     77     }
     78     void setHasTransformedLocalCoords() {
     79         SkASSERT(kUnused_LocalCoordsType == fLocalCoordsType);
     80         fLocalCoordsType = kHasTransformed_LocalCoordsType;
     81     }
     82 
     83     void setSampleShading(float sampleShading) {
     84         fSampleShading = sampleShading;
     85     }
     86 
     87 private:
     88     bool fWillUseGeoShader;
     89     LocalCoordsType fLocalCoordsType;
     90     float fSampleShading;
     91 
     92     typedef GrPrimitiveProcessor INHERITED;
     93 };
     94 
     95 #endif
     96