Program.cpp revision 5a4690bf26932c0d6940e4af8516d920e09ae81a 
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#include <utils/Trace.h>
18
19#include "Program.h"
20#include "Vertex.h"
21
22namespace android {
23namespace uirenderer {
24
25///////////////////////////////////////////////////////////////////////////////
26// Base program
27///////////////////////////////////////////////////////////////////////////////
28
29Program::Program(const ProgramDescription& description, const char* vertex, const char* fragment) {
30    mInitialized = false;
31    mHasColorUniform = false;
32    mHasSampler = false;
33    mUse = false;
34
35    // No need to cache compiled shaders, rely instead on Android's
36    // persistent shaders cache
37    mVertexShader = buildShader(vertex, GL_VERTEX_SHADER);
38    if (mVertexShader) {
39        mFragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
40        if (mFragmentShader) {
41            mProgramId = glCreateProgram();
42
43            glAttachShader(mProgramId, mVertexShader);
44            glAttachShader(mProgramId, mFragmentShader);
45
46            bindAttrib("position", kBindingPosition);
47            if (description.hasTexture || description.hasExternalTexture) {
48                texCoords = bindAttrib("texCoords", kBindingTexCoords);
49            } else {
50                texCoords = -1;
51            }
52
53            ATRACE_BEGIN("linkProgram");
54            glLinkProgram(mProgramId);
55            ATRACE_END();
56
57            GLint status;
58            glGetProgramiv(mProgramId, GL_LINK_STATUS, &status);
59            if (status != GL_TRUE) {
60                GLint infoLen = 0;
61                glGetProgramiv(mProgramId, GL_INFO_LOG_LENGTH, &infoLen);
62                if (infoLen > 1) {
63                    GLchar log[infoLen];
64                    glGetProgramInfoLog(mProgramId, infoLen, nullptr, &log[0]);
65                    ALOGE("%s", log);
66                }
67                LOG_ALWAYS_FATAL("Error while linking shaders");
68            } else {
69                mInitialized = true;
70            }
71        } else {
72            glDeleteShader(mVertexShader);
73        }
74    }
75
76    if (mInitialized) {
77        transform = addUniform("transform");
78        projection = addUniform("projection");
79    }
80}
81
82Program::~Program() {
83    if (mInitialized) {
84        // This would ideally happen after linking the program
85        // but Tegra drivers, especially when perfhud is enabled,
86        // sometimes crash if we do so
87        glDetachShader(mProgramId, mVertexShader);
88        glDetachShader(mProgramId, mFragmentShader);
89
90        glDeleteShader(mVertexShader);
91        glDeleteShader(mFragmentShader);
92
93        glDeleteProgram(mProgramId);
94    }
95}
96
97int Program::addAttrib(const char* name) {
98    int slot = glGetAttribLocation(mProgramId, name);
99    mAttributes.add(name, slot);
100    return slot;
101}
102
103int Program::bindAttrib(const char* name, ShaderBindings bindingSlot) {
104    glBindAttribLocation(mProgramId, bindingSlot, name);
105    mAttributes.add(name, bindingSlot);
106    return bindingSlot;
107}
108
109int Program::getAttrib(const char* name) {
110    ssize_t index = mAttributes.indexOfKey(name);
111    if (index >= 0) {
112        return mAttributes.valueAt(index);
113    }
114    return addAttrib(name);
115}
116
117int Program::addUniform(const char* name) {
118    int slot = glGetUniformLocation(mProgramId, name);
119    mUniforms.add(name, slot);
120    return slot;
121}
122
123int Program::getUniform(const char* name) {
124    ssize_t index = mUniforms.indexOfKey(name);
125    if (index >= 0) {
126        return mUniforms.valueAt(index);
127    }
128    return addUniform(name);
129}
130
131GLuint Program::buildShader(const char* source, GLenum type) {
132    ATRACE_NAME("Build GL Shader");
133
134    GLuint shader = glCreateShader(type);
135    glShaderSource(shader, 1, &source, nullptr);
136    glCompileShader(shader);
137
138    GLint status;
139    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
140    if (status != GL_TRUE) {
141        ALOGE("Error while compiling this shader:\n===\n%s\n===", source);
142        // Some drivers return wrong values for GL_INFO_LOG_LENGTH
143        // use a fixed size instead
144        GLchar log[512];
145        glGetShaderInfoLog(shader, sizeof(log), nullptr, &log[0]);
146        LOG_ALWAYS_FATAL("Shader info log: %s", log);
147        return 0;
148    }
149
150    return shader;
151}
152
153void Program::set(const mat4& projectionMatrix, const mat4& modelViewMatrix,
154        const mat4& transformMatrix, bool offset) {
155    if (projectionMatrix != mProjection || offset != mOffset) {
156        if (CC_LIKELY(!offset)) {
157            glUniformMatrix4fv(projection, 1, GL_FALSE, &projectionMatrix.data[0]);
158        } else {
159            mat4 p(projectionMatrix);
160            // offset screenspace xy by an amount that compensates for typical precision
161            // issues in GPU hardware that tends to paint hor/vert lines in pixels shifted
162            // up and to the left.
163            // This offset value is based on an assumption that some hardware may use as
164            // little as 12.4 precision, so we offset by slightly more than 1/16.
165            p.translate(Vertex::GeometryFudgeFactor(), Vertex::GeometryFudgeFactor());
166            glUniformMatrix4fv(projection, 1, GL_FALSE, &p.data[0]);
167        }
168        mProjection = projectionMatrix;
169        mOffset = offset;
170    }
171
172    mat4 t(transformMatrix);
173    t.multiply(modelViewMatrix);
174    glUniformMatrix4fv(transform, 1, GL_FALSE, &t.data[0]);
175}
176
177void Program::setColor(FloatColor color) {
178    if (!mHasColorUniform) {
179        mColorUniform = getUniform("color");
180        mHasColorUniform = true;
181    }
182    glUniform4f(mColorUniform, color.r, color.g, color.b, color.a);
183}
184
185void Program::use() {
186    glUseProgram(mProgramId);
187    if (texCoords >= 0 && !mHasSampler) {
188        glUniform1i(getUniform("baseSampler"), 0);
189        mHasSampler = true;
190    }
191    mUse = true;
192}
193
194void Program::remove() {
195    mUse = false;
196}
197
198}; // namespace uirenderer
199}; // namespace android
200