1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGLProgram_DEFINED
#define GrGLProgram_DEFINED
#include "builders/GrGLProgramBuilder.h"
#include "GrDrawState.h"
#include "GrGLContext.h"
#include "GrGLProgramDesc.h"
#include "GrGLSL.h"
#include "GrGLTexture.h"
#include "GrGLProgramDataManager.h"
#include "SkString.h"
#include "SkXfermode.h"
class GrGLEffect;
class GrGLProgramEffects;
class GrGLProgramBuilder;
/**
* This class manages a GPU program and records per-program information.
* We can specify the attribute locations so that they are constant
* across our shaders. But the driver determines the uniform locations
* at link time. We don't need to remember the sampler uniform location
* because we will bind a texture slot to it and never change it
* Uniforms are program-local so we can't rely on fHWState to hold the
* previous uniform state after a program change.
*/
class GrGLProgram : public SkRefCnt {
public:
SK_DECLARE_INST_COUNT(GrGLProgram)
typedef GrGLProgramBuilder::BuiltinUniformHandles BuiltinUniformHandles;
static GrGLProgram* Create(GrGpuGL* gpu,
const GrGLProgramDesc& desc,
const GrEffectStage* colorStages[],
const GrEffectStage* coverageStages[]);
virtual ~GrGLProgram();
/**
* Call to abandon GL objects owned by this program.
*/
void abandon();
/**
* The shader may modify the blend coefficients. Params are in/out.
*/
void overrideBlend(GrBlendCoeff* srcCoeff, GrBlendCoeff* dstCoeff) const;
const GrGLProgramDesc& getDesc() { return fDesc; }
/**
* Gets the GL program ID for this program.
*/
GrGLuint programID() const { return fProgramID; }
bool hasVertexShader() const { return fHasVertexShader; }
/**
* Some GL state that is relevant to programs is not stored per-program. In particular color
* and coverage attributes can be global state. This struct is read and updated by
* GrGLProgram::setColor and GrGLProgram::setCoverage to allow us to avoid setting this state
* redundantly.
*/
struct SharedGLState {
GrColor fConstAttribColor;
int fConstAttribColorIndex;
GrColor fConstAttribCoverage;
int fConstAttribCoverageIndex;
SharedGLState() { this->invalidate(); }
void invalidate() {
fConstAttribColor = GrColor_ILLEGAL;
fConstAttribColorIndex = -1;
fConstAttribCoverage = GrColor_ILLEGAL;
fConstAttribCoverageIndex = -1;
}
};
/**
* The GrDrawState's view matrix along with the aspects of the render target determine the
* matrix sent to GL. The size of the render target affects the GL matrix because we must
* convert from Skia device coords to GL's normalized coords. Also the origin of the render
* target may require us to perform a mirror-flip.
*/
struct MatrixState {
SkMatrix fViewMatrix;
SkISize fRenderTargetSize;
GrSurfaceOrigin fRenderTargetOrigin;
MatrixState() { this->invalidate(); }
void invalidate() {
fViewMatrix = SkMatrix::InvalidMatrix();
fRenderTargetSize.fWidth = -1;
fRenderTargetSize.fHeight = -1;
fRenderTargetOrigin = (GrSurfaceOrigin) -1;
}
/**
* Gets a matrix that goes from local coords to Skia's device coordinates.
*/
template<int Size> void getGLMatrix(GrGLfloat* destMatrix) {
GrGLGetMatrix<Size>(destMatrix, fViewMatrix);
}
/**
* Gets a matrix that goes from local coordinates to GL normalized device coords.
*/
template<int Size> void getRTAdjustedGLMatrix(GrGLfloat* destMatrix) {
SkMatrix combined;
if (kBottomLeft_GrSurfaceOrigin == fRenderTargetOrigin) {
combined.setAll(SkIntToScalar(2) / fRenderTargetSize.fWidth, 0, -SK_Scalar1,
0, -SkIntToScalar(2) / fRenderTargetSize.fHeight, SK_Scalar1,
0, 0, 1);
} else {
combined.setAll(SkIntToScalar(2) / fRenderTargetSize.fWidth, 0, -SK_Scalar1,
0, SkIntToScalar(2) / fRenderTargetSize.fHeight, -SK_Scalar1,
0, 0, 1);
}
combined.preConcat(fViewMatrix);
GrGLGetMatrix<Size>(destMatrix, combined);
}
/**
* Gets a vec4 that adjusts the position from Skia device coords to GL's normalized device
* coords. Assuming the transformed position, pos, is a homogeneous vec3, the vec, v, is
* applied as such:
* pos.x = dot(v.xy, pos.xz)
* pos.y = dot(v.zq, pos.yz)
*/
void getRTAdjustmentVec(GrGLfloat* destVec) {
destVec[0] = 2.f / fRenderTargetSize.fWidth;
destVec[1] = -1.f;
if (kBottomLeft_GrSurfaceOrigin == fRenderTargetOrigin) {
destVec[2] = -2.f / fRenderTargetSize.fHeight;
destVec[3] = 1.f;
} else {
destVec[2] = 2.f / fRenderTargetSize.fHeight;
destVec[3] = -1.f;
}
}
};
/**
* This function uploads uniforms and calls each GrGLEffect's setData. It is called before a
* draw occurs using the program after the program has already been bound. It also uses the
* GrGpuGL object to bind the textures required by the GrGLEffects. The color and coverage
* stages come from GrGLProgramDesc::Build().
*/
void setData(GrDrawState::BlendOptFlags,
const GrEffectStage* colorStages[],
const GrEffectStage* coverageStages[],
const GrDeviceCoordTexture* dstCopy, // can be NULL
SharedGLState*);
private:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
GrGLProgram(GrGpuGL*,
const GrGLProgramDesc&,
const GrGLProgramBuilder&);
// Sets the texture units for samplers.
void initSamplerUniforms();
// Helper for setData(). Makes GL calls to specify the initial color when there is not
// per-vertex colors.
void setColor(const GrDrawState&, GrColor color, SharedGLState*);
// Helper for setData(). Makes GL calls to specify the initial coverage when there is not
// per-vertex coverages.
void setCoverage(const GrDrawState&, GrColor coverage, SharedGLState*);
// Helper for setData() that sets the view matrix and loads the render target height uniform
void setMatrixAndRenderTargetHeight(const GrDrawState&);
// these reflect the current values of uniforms (GL uniform values travel with program)
MatrixState fMatrixState;
GrColor fColor;
GrColor fCoverage;
int fDstCopyTexUnit;
BuiltinUniformHandles fBuiltinUniformHandles;
SkAutoTUnref<GrGLProgramEffects> fColorEffects;
SkAutoTUnref<GrGLProgramEffects> fCoverageEffects;
GrGLuint fProgramID;
bool fHasVertexShader;
int fTexCoordSetCnt;
GrGLProgramDesc fDesc;
GrGpuGL* fGpu;
GrGLProgramDataManager fProgramDataManager;
typedef SkRefCnt INHERITED;
};
#endif
|
