OptState owns program descriptor

src/gpu/GrProgramDesc.h

 /*
- * Copyright 2013 Google Inc.
+ * 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 GrGLProgramDesc_DEFINED
-#define GrGLProgramDesc_DEFINED
+#ifndef GrProgramDesc_DEFINED
+#define GrProgramDesc_DEFINED
 
-#include "GrGLProcessor.h"
-#include "GrDrawState.h"
+#include "GrColor.h"
 #include "GrGpu.h"
-#include "GrOptDrawState.h"
+#include "GrTypesPriv.h"
 
 class GrGpuGL;
 
 /** This class describes a program to generate. It also serves as a program cache key. Very little
     of this is GL-specific. The GL-specific parts could be factored out into a subclass. */
-class GrGLProgramDesc {
+class GrProgramDesc {
 public:
-    GrGLProgramDesc() {}
-    GrGLProgramDesc(const GrGLProgramDesc& desc) { *this = desc; }
-
     // Returns this as a uint32_t array to be used as a key in the program cache.
     const uint32_t* asKey() const {
         return reinterpret_cast<const uint32_t*>(fKey.begin());
     }
 
     // Gets the number of bytes in asKey(). It will be a 4-byte aligned value. When comparing two
     // keys the size of either key can be used with memcmp() since the lengths themselves begin the
     // keys and thus the memcmp will exit early if the keys are of different lengths.
     uint32_t keyLength() const { return *this->atOffset<uint32_t, kLengthOffset>(); }
 
     // Gets the a checksum of the key. Can be used as a hash value for a fast lookup in a cache.
     uint32_t getChecksum() const { return *this->atOffset<uint32_t, kChecksumOffset>(); }
 
-    /**
-     * Builds a program descriptor from a GrOptDrawState. Whether the primitive type is points, and
-     * the caps of the GrGpuGL are also inputs. It also outputs the color and coverage stages
-     * referenced by the generated descriptor. Coverage stages from the drawState may be treated as
-     * color stages in the output.
-     */
-    static bool Build(const GrOptDrawState&,
-                      GrGpu::DrawType,
-                      GrGpuGL*,
-                      const GrDeviceCoordTexture*,
-                      GrGLProgramDesc*);
+    GrProgramDesc& operator= (const GrProgramDesc& other) {
+        size_t keyLength = other.keyLength();
+        fKey.reset(keyLength);
+        memcpy(fKey.begin(), other.fKey.begin(), keyLength);
+        return *this;
+    }
+
+    bool operator== (const GrProgramDesc& other) const {
+        // The length is masked as a hint to the compiler that the address will be 4 byte aligned.
+        return 0 == memcmp(this->asKey(), other.asKey(), this->keyLength() & ~0x3);
+    }
+
+    bool operator!= (const GrProgramDesc& other) const {
+        return !(*this == other);
+    }
+
+    static bool Less(const GrProgramDesc& a, const GrProgramDesc& b) {
+        return memcmp(a.asKey(), b.asKey(), a.keyLength() & ~0x3) < 0;
+    }
 
     bool hasGeometryProcessor() const {
-        return SkToBool(this->getHeader().fHasGeometryProcessor);
+        return SkToBool(this->baseHeader().fHasGeometryProcessor);
     }
 
     int numColorEffects() const {
-        return this->getHeader().fColorEffectCnt;
+        return this->baseHeader().fColorEffectCnt;
     }
 
     int numCoverageEffects() const {
-        return this->getHeader().fCoverageEffectCnt;
+        return this->baseHeader().fCoverageEffectCnt;
     }
 
     int numTotalEffects() const { return this->numColorEffects() + this->numCoverageEffects(); }
 
-    GrGLProgramDesc& operator= (const GrGLProgramDesc& other);
+    /*
+     * Helper to downcast to derived type
+     */
+    template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
 
-    bool operator== (const GrGLProgramDesc& other) const {
-        // The length is masked as a hint to the compiler that the address will be 4 byte aligned.
-        return 0 == memcmp(this->asKey(), other.asKey(), this->keyLength() & ~0x3);
-    }
+    ///////////////////////////////////////////////////////////////////////////
+    /// @name Stage Output Types
+    ////
 
-    bool operator!= (const GrGLProgramDesc& other) const {
-        return !(*this == other);
-    }
+    enum PrimaryOutputType {
+        // Modulate color and coverage, write result as the color output.
+        kModulate_PrimaryOutputType,
+        // Combines the coverage, dst, and color as coverage * color + (1 - coverage) * dst. This
+        // can only be set if fDstReadKey is non-zero.
+        kCombineWithDst_PrimaryOutputType,
 
-    static bool Less(const GrGLProgramDesc& a, const GrGLProgramDesc& b) {
-        return memcmp(a.asKey(), b.asKey(), a.keyLength() & ~0x3) < 0;
-    }
+        kPrimaryOutputTypeCnt,
+    };
 
-private:
+    enum SecondaryOutputType {
+        // There is no secondary output
+        kNone_SecondaryOutputType,
+        // Writes coverage as the secondary output. Only set if dual source blending is supported
+        // and primary output is kModulate.
+        kCoverage_SecondaryOutputType,
+        // Writes coverage * (1 - colorA) as the secondary output. Only set if dual source blending
+        // is supported and primary output is kModulate.
+        kCoverageISA_SecondaryOutputType,
+        // Writes coverage * (1 - colorRGBA) as the secondary output. Only set if dual source
+        // blending is supported and primary output is kModulate.
+        kCoverageISC_SecondaryOutputType,
+
+        kSecondaryOutputTypeCnt,
+    };
+
+protected:
+    GrProgramDesc() {}
+
     // Specifies where the initial color comes from before the stages are applied.
     enum ColorInput {
         kAllOnes_ColorInput,
         kAttribute_ColorInput,
         kUniform_ColorInput,
 
         kColorInputCnt
     };
 
     struct KeyHeader {
         uint8_t                          fDstReadKey;   // set by GrGLShaderBuilder if there
                                                         // are effects that must read the dst.
                                                         // Otherwise, 0.
         uint8_t                          fFragPosKey;   // set by GrGLShaderBuilder if there are
                                                         // effects that read the fragment position.
                                                         // Otherwise, 0.
 
-        SkBool8                     fUseFragShaderOnly;
         SkBool8                     fEmitsPointSize;
 
         ColorInput                       fColorInput : 8;
         ColorInput                       fCoverageInput : 8;
 
-        GrOptDrawState::PrimaryOutputType    fPrimaryOutputType : 8;
-        GrOptDrawState::SecondaryOutputType  fSecondaryOutputType : 8;
+        PrimaryOutputType    fPrimaryOutputType : 8;
+        SecondaryOutputType  fSecondaryOutputType : 8;
 
         int8_t                      fPositionAttributeIndex;
         int8_t                      fLocalCoordAttributeIndex;
         int8_t                      fColorAttributeIndex;
         int8_t                      fCoverageAttributeIndex;
 
         SkBool8                     fHasGeometryProcessor;
         int8_t                      fColorEffectCnt;
         int8_t                      fCoverageEffectCnt;
     };
 
-    // The key, stored in fKey, is composed of five parts:
-    // 1. uint32_t for total key length.
-    // 2. uint32_t for a checksum.
-    // 3. Header struct defined above.
-    // 4. An array of offsets to effect keys and their sizes (see 5). uint16_t for each
-    //    offset and size.
-    // 5. per-effect keys. Each effect's key is a variable length array of uint32_t.
-    enum {
-        // Part 1.
-        kLengthOffset = 0,
-        // Part 2.
-        kChecksumOffset = kLengthOffset + sizeof(uint32_t),
-        // Part 3.
-        kHeaderOffset = kChecksumOffset + sizeof(uint32_t),
-        kHeaderSize = SkAlign4(sizeof(KeyHeader)),
-        // Part 4.
-        // This is the offset in the overall key to the array of per-effect offset,length pairs.
-        kEffectKeyOffsetsAndLengthOffset = kHeaderOffset + kHeaderSize,
-    };
-
     template<typename T, size_t OFFSET> T* atOffset() {
         return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
     }
 
     template<typename T, size_t OFFSET> const T* atOffset() const {
         return reinterpret_cast<const T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
     }
 
-    KeyHeader* header() { return this->atOffset<KeyHeader, kHeaderOffset>(); }
+    // This should really only be used internally, base classes should return their own headers
+    const KeyHeader& baseHeader() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
 
-    // a helper class to handle getting an individual processor's key
-    template <class ProcessorKeyBuilder>
-    static bool BuildStagedProcessorKey(const typename ProcessorKeyBuilder::StagedProcessor& stage,
-                                        const GrGLCaps& caps,
-                                        bool requiresLocalCoordAttrib,
-                                        GrGLProgramDesc* desc,
-                                        int* offsetAndSizeIndex);
-    void finalize();
 
-    const KeyHeader& getHeader() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
+    // The key, stored in fKey, is composed of five parts:
+    // 1. uint32_t for total key length.
+    // 2. uint32_t for a checksum.
+    // 3. Header struct defined above., also room for derived class headers.
+    // 4. An array of offsets to effect keys and their sizes (see 5). uint16_t for each
+    //    offset and size.
+    // 5. per-effect keys. Each effect's key is a variable length array of uint32_t.
+    enum KeyOffsets {
+        // Part 1.
+        kLengthOffset = 0,
+        // Part 2.
+        kChecksumOffset = kLengthOffset + sizeof(uint32_t),
+        // Part 3.
+        kHeaderOffset = kChecksumOffset + sizeof(uint32_t),
+        kHeaderSize = SkAlign4(2 * sizeof(KeyHeader)),
+        // Part 4.
+        // This is the offset in the overall key to the array of per-effect offset,length pairs.
+        kEffectKeyOffsetsAndLengthOffset = kHeaderOffset + kHeaderSize,
+    };
+
 
     /** Used to provide effects' keys to their emitCode() function. */
     class ProcKeyProvider {
     public:
         enum ProcessorType {
             kGeometry_ProcessorType,
             kFragment_ProcessorType,
         };
 
-        ProcKeyProvider(const GrGLProgramDesc* desc, ProcessorType type)
-            : fDesc(desc), fBaseIndex(0) {
+        ProcKeyProvider(const GrProgramDesc* desc, ProcessorType type, int effectOffset)
+            : fDesc(desc), fBaseIndex(0), fEffectOffset(effectOffset) {
             switch (type) {
                 case kGeometry_ProcessorType:
                     // there can be only one
                     fBaseIndex = 0;
                     break;
                 case kFragment_ProcessorType:
                     fBaseIndex = desc->hasGeometryProcessor() ? 1 : 0;
                     break;
             }
         }
 
         GrProcessorKey get(int index) const {
             const uint16_t* offsetsAndLengths = reinterpret_cast<const uint16_t*>(
-                fDesc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset);
+                fDesc->fKey.begin() + fEffectOffset);
             // We store two uint16_ts per effect, one for the offset to the effect's key and one for
             // its length. Here we just need the offset.
             uint16_t offset = offsetsAndLengths[2 * (fBaseIndex + index) + 0];
             uint16_t length = offsetsAndLengths[2 * (fBaseIndex + index) + 1];
             // Currently effects must add to the key in units of uint32_t.
             SkASSERT(0 == (length % sizeof(uint32_t)));
             return GrProcessorKey(reinterpret_cast<const uint32_t*>(fDesc->fKey.begin() + offset),
                                length / sizeof(uint32_t));
         }
     private:
-        const GrGLProgramDesc*  fDesc;
-        int                     fBaseIndex;
+        const GrProgramDesc*  fDesc;
+        int                   fBaseIndex;
+        int                   fEffectOffset;
     };
 
     enum {
         kMaxPreallocEffects = 8,
         kIntsPerEffect      = 4,    // This is an overestimate of the average effect key size.
         kPreAllocSize = kEffectKeyOffsetsAndLengthOffset +
                         kMaxPreallocEffects * sizeof(uint32_t) * kIntsPerEffect,
     };
 
     SkSTArray<kPreAllocSize, uint8_t, true> fKey;
 
-    // GrGLProgram and GrGLShaderBuilder read the private fields to generate code. TODO: Split out
-    // part of GrGLShaderBuilder that is used by effects so that this header doesn't need to be
-    // visible to GrGLProcessors. Then make public accessors as necessary and remove friends.
-    friend class GrGLProgram;
-    friend class GrGLProgramBuilder;
-    friend class GrGLLegacyNvprProgramBuilder;
-    friend class GrGLVertexBuilder;
-    friend class GrGLFragmentShaderBuilder;
-    friend class GrGLGeometryBuilder;
+    friend class GrGLProgramDesc;
+    friend class GrOptDrawState;
 };
 
 #endif