Program.h revision c0ac193b9415680f0a69e20a3f5f22d16f8053be 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_UI_PROGRAM_H
18#define ANDROID_UI_PROGRAM_H
19
20#include <GLES2/gl2.h>
21#include <GLES2/gl2ext.h>
22
23#include <utils/KeyedVector.h>
24#include <utils/RefBase.h>
25
26#include "Matrix.h"
27
28namespace android {
29namespace uirenderer {
30
31/**
32 * A program holds a vertex and a fragment shader. It offers several utility
33 * methods to query attributes and uniforms.
34 */
35class Program: public LightRefBase<Program> {
36public:
37    /**
38     * Creates a new program with the specified vertex and fragment
39     * shaders sources.
40     */
41    Program(const char* vertex, const char* fragment);
42    virtual ~Program();
43
44    /**
45     * Binds this program to the GL context.
46     */
47    virtual void use();
48
49    /**
50     * Marks this program as unused. This will not unbind
51     * the program from the GL context.
52     */
53    virtual void remove();
54
55    /**
56     * Indicates whether this program is currently in use with
57     * the GL context.
58     */
59    inline bool isInUse() const {
60        return mUse;
61    }
62
63protected:
64    /**
65     * Adds an attribute with the specified name.
66     *
67     * @return The OpenGL name of the attribute.
68     */
69    int addAttrib(const char* name);
70    /**
71     * Returns the OpenGL name of the specified attribute.
72     */
73    int getAttrib(const char* name);
74
75    /**
76     * Adds a uniform with the specified name.
77     *
78     * @return The OpenGL name of the uniform.
79     */
80    int addUniform(const char* name);
81    /**
82     * Returns the OpenGL name of the specified uniform.
83     */
84    int getUniform(const char* name);
85
86private:
87    /**
88     * Compiles the specified shader of the specified type.
89     *
90     * @return The name of the compiled shader.
91     */
92    GLuint buildShader(const char* source, GLenum type);
93
94    // Name of the OpenGL program
95    GLuint id;
96
97    // Name of the shaders
98    GLuint vertexShader;
99    GLuint fragmentShader;
100
101    // Keeps track of attributes and uniforms slots
102    KeyedVector<const char*, int> attributes;
103    KeyedVector<const char*, int> uniforms;
104
105    bool mUse;
106}; // class Program
107
108/**
109 * Program used to draw vertices with a simple color. The shaders must
110 * specify the following attributes:
111 *      vec4 position, position of the vertex
112 *      vec4 color, RGBA color of the vertex
113 *
114 * And the following uniforms:
115 *      mat4 projection, the projection matrix
116 *      mat4 modelView, the modelView matrix
117 *      mat4 transform, an extra transformation matrix
118 */
119class DrawColorProgram: public Program {
120public:
121    DrawColorProgram();
122    DrawColorProgram(const char* vertex, const char* fragment);
123
124    /**
125     * Binds the program with the specified projection, modelView and
126     * transform matrices.
127     */
128    void set(const mat4& projectionMatrix, const mat4& modelViewMatrix,
129             const mat4& transformMatrix);
130
131    /**
132     * Binds this program to the GL context.
133     */
134    virtual void use();
135
136    /**
137     * Marks this program as unused. This will not unbind
138     * the program from the GL context.
139     */
140    virtual void remove();
141
142    /**
143     * Name of the position attribute.
144     */
145    int position;
146
147    /**
148     * Name of the color uniform.
149     */
150    int color;
151
152    /**
153     * Name of the transform uniform.
154     */
155    int transform;
156
157protected:
158    void getAttribsAndUniforms();
159};
160
161/**
162 * Program used to draw textured vertices. In addition to everything that the
163 * DrawColorProgram supports, the following two attributes must be specified:
164 *      sampler2D sampler, the texture sampler
165 *      vec2 texCoords, the texture coordinates of the vertex
166 */
167class DrawTextureProgram: public DrawColorProgram {
168public:
169    DrawTextureProgram();
170
171    /**
172     * Binds this program to the GL context.
173     */
174    virtual void use();
175
176    /**
177     * Marks this program as unused. This will not unbind
178     * the program from the GL context.
179     */
180    virtual void remove();
181
182    /**
183     * Name of the texture sampler uniform.
184     */
185    int sampler;
186
187    /**
188     * Name of the texture coordinates attribute.
189     */
190    int texCoords;
191};
192
193/**
194 * Program used to draw linear gradients. In addition to everything that the
195 * DrawColorProgram supports, the following two attributes must be specified:
196 *      vec2 gradient, the vector describing the linear gradient
197 *      float gradientLength, the invert of the magnitude of the gradient vector
198 *      sampler2D sampler, the texture sampler
199 */
200class DrawLinearGradientProgram: public DrawColorProgram {
201public:
202    DrawLinearGradientProgram();
203
204    /**
205     * Binds this program to the GL context.
206     */
207    virtual void use();
208
209    /**
210     * Marks this program as unused. This will not unbind
211     * the program from the GL context.
212     */
213    virtual void remove();
214
215    /**
216     * Name of the matrix used to compute the screen space coordinates
217     * of the vertices.
218     */
219    int screenSpace;
220
221    /**
222     * Name of the linear gradient start point.
223     */
224    int start;
225
226    /**
227     * Name of the linear gradient vector.
228     */
229    int gradient;
230
231    /**
232     * Name of the inverse of linear gradient vector's magnitude.
233     */
234    int gradientLength;
235
236    /**
237     * Name of the texture sampler uniform.
238     */
239    int sampler;
240};
241
242}; // namespace uirenderer
243}; // namespace android
244
245#endif // ANDROID_UI_PROGRAM_H
246