blob: e8f08776aea0b45d7ed58b0bf794c484c04024da [file] [log] [blame]
joshualitt79f8fae2014-10-28 17:59:26 -07001/*
2 * Copyright 2014 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 GrProgramDesc_DEFINED
9#define GrProgramDesc_DEFINED
10
joshualitt79f8fae2014-10-28 17:59:26 -070011#include "GrColor.h"
12#include "GrTypesPriv.h"
mtklein4e976072016-08-08 09:06:27 -070013#include "SkOpts.h"
14#include "SkTArray.h"
Hal Canaryc640d0d2018-06-13 09:59:02 -040015#include "SkTo.h"
Ethan Nicholas38657112017-02-09 17:01:22 -050016#include "glsl/GrGLSLFragmentShaderBuilder.h"
joshualitt79f8fae2014-10-28 17:59:26 -070017
Brian Salomon94efbf52016-11-29 13:43:05 -050018class GrShaderCaps;
egdaniel5d8f69f2016-09-07 07:24:12 -070019class GrPipeline;
20class GrPrimitiveProcessor;
21
22/** This class describes a program to generate. It also serves as a program cache key */
joshualitt79f8fae2014-10-28 17:59:26 -070023class GrProgramDesc {
24public:
25 // Creates an uninitialized key that must be populated by GrGpu::buildProgramDesc()
26 GrProgramDesc() {}
27
egdaniel5d8f69f2016-09-07 07:24:12 -070028 /**
29 * Builds a program descriptor. Before the descriptor can be used, the client must call finalize
30 * on the returned GrProgramDesc.
31 *
32 * @param GrPrimitiveProcessor The geometry
bsalomon2eda5b32016-09-21 10:53:24 -070033 * @param hasPointSize Controls whether the shader will output a point size.
egdaniel5d8f69f2016-09-07 07:24:12 -070034 * @param GrPipeline The optimized drawstate. The descriptor will represent a program
35 * which this optstate can use to draw with. The optstate contains
36 * general draw information, as well as the specific color, geometry,
37 * and coverage stages which will be used to generate the GL Program for
38 * this optstate.
Greg Daniel7a82edf2018-12-04 10:54:34 -050039 * @param GrGpu Ptr to the GrGpu object the program will be used with.
egdaniel5d8f69f2016-09-07 07:24:12 -070040 * @param GrProgramDesc The built and finalized descriptor
41 **/
42 static bool Build(GrProgramDesc*,
43 const GrPrimitiveProcessor&,
bsalomon2eda5b32016-09-21 10:53:24 -070044 bool hasPointSize,
egdaniel5d8f69f2016-09-07 07:24:12 -070045 const GrPipeline&,
Greg Daniel7a82edf2018-12-04 10:54:34 -050046 GrGpu*);
egdaniel5d8f69f2016-09-07 07:24:12 -070047
joshualitt79f8fae2014-10-28 17:59:26 -070048 // Returns this as a uint32_t array to be used as a key in the program cache.
49 const uint32_t* asKey() const {
50 return reinterpret_cast<const uint32_t*>(fKey.begin());
51 }
52
Greg Daniel2d2c09f2019-01-07 16:14:12 -050053 // Gets the number of bytes in asKey(). It will be a 4-byte aligned value.
54 uint32_t keyLength() const {
55 SkASSERT(0 == (fKey.count() % 4));
56 return fKey.count();
57 }
joshualitt79f8fae2014-10-28 17:59:26 -070058
59 GrProgramDesc& operator= (const GrProgramDesc& other) {
bsalomonccb328d2014-12-11 13:31:06 -080060 uint32_t keyLength = other.keyLength();
bsalomonef3fcd82014-12-12 08:51:38 -080061 fKey.reset(SkToInt(keyLength));
joshualitt79f8fae2014-10-28 17:59:26 -070062 memcpy(fKey.begin(), other.fKey.begin(), keyLength);
63 return *this;
64 }
65
bsalomon89d59882015-06-04 15:34:34 -070066 bool operator== (const GrProgramDesc& that) const {
Greg Daniel2d2c09f2019-01-07 16:14:12 -050067 if (this->keyLength() != that.keyLength()) {
68 return false;
69 }
70
bsalomon89d59882015-06-04 15:34:34 -070071 SkASSERT(SkIsAlign4(this->keyLength()));
72 int l = this->keyLength() >> 2;
73 const uint32_t* aKey = this->asKey();
74 const uint32_t* bKey = that.asKey();
75 for (int i = 0; i < l; ++i) {
76 if (aKey[i] != bKey[i]) {
77 return false;
78 }
79 }
80 return true;
joshualitt79f8fae2014-10-28 17:59:26 -070081 }
82
83 bool operator!= (const GrProgramDesc& other) const {
84 return !(*this == other);
85 }
86
Robert Phillips7f861922018-01-30 13:13:42 +000087 void setSurfaceOriginKey(int key) {
Ethan Nicholas38657112017-02-09 17:01:22 -050088 KeyHeader* header = this->atOffset<KeyHeader, kHeaderOffset>();
Robert Phillips7f861922018-01-30 13:13:42 +000089 header->fSurfaceOriginKey = key;
Ethan Nicholas38657112017-02-09 17:01:22 -050090 }
91
joshualitt79f8fae2014-10-28 17:59:26 -070092 struct KeyHeader {
bsalomon7f9b2e42016-01-12 13:29:26 -080093 // Set to uniquely idenitify any swizzling of the shader's output color(s).
Chris Dalton535ba8d2018-02-20 09:51:59 -070094 uint8_t fOutputSwizzle;
95 uint8_t fColorFragmentProcessorCnt; // Can be packed into 4 bits if required.
96 uint8_t fCoverageFragmentProcessorCnt;
bsalomon2eda5b32016-09-21 10:53:24 -070097 // Set to uniquely identify the rt's origin, or 0 if the shader does not require this info.
Chris Dalton535ba8d2018-02-20 09:51:59 -070098 uint8_t fSurfaceOriginKey : 2;
99 bool fSnapVerticesToPixelCenters : 1;
100 bool fHasPointSize : 1;
101 uint8_t fPad : 4;
joshualitt79f8fae2014-10-28 17:59:26 -0700102 };
bsalomon2eda5b32016-09-21 10:53:24 -0700103 GR_STATIC_ASSERT(sizeof(KeyHeader) == 4);
joshualitt79f8fae2014-10-28 17:59:26 -0700104
105 // This should really only be used internally, base classes should return their own headers
106 const KeyHeader& header() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
107
egdaniel5d8f69f2016-09-07 07:24:12 -0700108protected:
109 template<typename T, size_t OFFSET> T* atOffset() {
110 return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
111 }
112
113 template<typename T, size_t OFFSET> const T* atOffset() const {
114 return reinterpret_cast<const T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
115 }
116
Greg Daniel2d2c09f2019-01-07 16:14:12 -0500117 // The key, stored in fKey, is composed of two parts:
118 // 1. Header struct defined above.
119 // 2. A Backend specific payload which includes the per-processor keys.
joshualitt79f8fae2014-10-28 17:59:26 -0700120 enum KeyOffsets {
Greg Daniel2d2c09f2019-01-07 16:14:12 -0500121 kHeaderOffset = 0,
egdaniel5d8f69f2016-09-07 07:24:12 -0700122 kHeaderSize = SkAlign4(sizeof(KeyHeader)),
123 // Part 4.
124 // This is the offset into the backenend specific part of the key, which includes
125 // per-processor keys.
126 kProcessorKeysOffset = kHeaderOffset + kHeaderSize,
joshualitt79f8fae2014-10-28 17:59:26 -0700127 };
128
129 enum {
130 kMaxPreallocProcessors = 8,
131 kIntsPerProcessor = 4, // This is an overestimate of the average effect key size.
132 kPreAllocSize = kHeaderOffset + kHeaderSize +
133 kMaxPreallocProcessors * sizeof(uint32_t) * kIntsPerProcessor,
134 };
135
jvanverthd1e72872015-04-20 12:29:37 -0700136 SkSTArray<kPreAllocSize, uint8_t, true>& key() { return fKey; }
137 const SkSTArray<kPreAllocSize, uint8_t, true>& key() const { return fKey; }
joshualitt79f8fae2014-10-28 17:59:26 -0700138
jvanverthd1e72872015-04-20 12:29:37 -0700139private:
140 SkSTArray<kPreAllocSize, uint8_t, true> fKey;
joshualitt79f8fae2014-10-28 17:59:26 -0700141};
142
143#endif