← Back to branch summary

~townsend/compiz/fix-lp1244754-0.9.10

« back to all changes in this revision

Viewing changes to plugins/opengl/src/program.cpp

  • Committer: smspillaz
  • Date: 2012-05-16 17:40:13 UTC
  • mfrom: (0.1.96 trunk)
  • Revision ID: sam.spilsbury@canonical.com-20120516174013-0rsxq2ka7zm2ypp0
Merge lp:compiz-scaleaddon-plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/opengl/src/program.cpp
1
 
/*
2
 
 * Copyright © 2011 Linaro Ltd.
3
 
 *
4
 
 * Permission to use, copy, modify, distribute, and sell this software
5
 
 * and its documentation for any purpose is hereby granted without
6
 
 * fee, provided that the above copyright notice appear in all copies
7
 
 * and that both that copyright notice and this permission notice
8
 
 * appear in supporting documentation, and that the name of
9
 
 * Linaro Ltd. not be used in advertising or publicity pertaining to
10
 
 * distribution of the software without specific, written prior permission.
11
 
 * Linaro Ltd. makes no representations about the suitability of this
12
 
 * software for any purpose. It is provided "as is" without express or
13
 
 * implied warranty.
14
 
 *
15
 
 * LINARO LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
16
 
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
17
 
 * NO EVENT SHALL LINARO LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
18
 
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
19
 
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
20
 
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
21
 
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22
 
 *
23
 
 * Authors: Travis Watkins <travis.watkins@linaro.org>
24
 
 */
25
 
 
26
 
#include <iostream>
27
 
#include <fstream>
28
 
#include <opengl/opengl.h>
29
 
 
30
 
class PrivateProgram
31
 
{
32
 
    public:
33
 
        GLuint program;
34
 
        bool valid;
35
 
};
36
 
 
37
 
 
38
 
void printShaderInfoLog (GLuint shader)
39
 
{
40
 
    GLint   length = 0;
41
 
    GLint   chars  = 0;
42
 
 
43
 
    (*GL::getShaderiv) (shader, GL::INFO_LOG_LENGTH, &length);
44
 
 
45
 
    if (length > 0)
46
 
    {
47
 
        GLchar *infoLog;
48
 
        infoLog = new GLchar[length];
49
 
        (*GL::getShaderInfoLog) (shader, length, &chars, infoLog);
50
 
        std::cout << infoLog << std::endl;
51
 
        delete[] infoLog;
52
 
    }
53
 
}
54
 
 
55
 
void printProgramInfoLog(GLuint program)
56
 
{
57
 
    GLint   length = 0;
58
 
    GLint   chars  = 0;
59
 
 
60
 
    (*GL::getProgramiv) (program, GL::INFO_LOG_LENGTH, &length);
61
 
 
62
 
    if (length > 0)
63
 
    {
64
 
        GLchar *infoLog;
65
 
        infoLog = new GLchar[length];
66
 
        (*GL::getProgramInfoLog) (program, length, &chars, infoLog);
67
 
        std::cout << infoLog << std::endl;
68
 
        delete[] infoLog;
69
 
    }
70
 
}
71
 
 
72
 
static bool compileShader (GLuint *shader, GLenum type, CompString &source)
73
 
{
74
 
    const GLchar *data;
75
 
    GLint         status;
76
 
 
77
 
    data = (GLchar *)source.c_str ();
78
 
 
79
 
    *shader = (*GL::createShader) (type);
80
 
    (*GL::shaderSource) (*shader, 1, &data, NULL);
81
 
    (*GL::compileShader) (*shader);
82
 
 
83
 
    (*GL::getShaderiv) (*shader, GL::COMPILE_STATUS, &status);
84
 
    return (status == GL_TRUE);
85
 
}
86
 
 
87
 
GLProgram::GLProgram (CompString &vertexShader, CompString &fragmentShader) :
88
 
    priv (new PrivateProgram ())
89
 
{
90
 
    GLuint vertex, fragment;
91
 
    GLint status;
92
 
 
93
 
    priv->valid = false;
94
 
    priv->program = (*GL::createProgram) ();
95
 
 
96
 
    if (!compileShader (&vertex, GL::VERTEX_SHADER, vertexShader))
97
 
    {
98
 
        printShaderInfoLog (vertex);
99
 
        std::cout << vertexShader << std::endl << std::endl;
100
 
        return;
101
 
    }
102
 
 
103
 
    if (!compileShader (&fragment, GL::FRAGMENT_SHADER, fragmentShader))
104
 
    {
105
 
        printShaderInfoLog (fragment);
106
 
        std::cout << fragmentShader << std::endl << std::endl;
107
 
        return;
108
 
    }
109
 
 
110
 
    (*GL::attachShader) (priv->program, vertex);
111
 
    (*GL::attachShader) (priv->program, fragment);
112
 
 
113
 
    (*GL::linkProgram) (priv->program);
114
 
    (*GL::validateProgram) (priv->program);
115
 
 
116
 
    (*GL::getProgramiv) (priv->program, GL::LINK_STATUS, &status);
117
 
    if (status == GL_FALSE)
118
 
    {
119
 
        printProgramInfoLog (priv->program);
120
 
        return;
121
 
    }
122
 
 
123
 
    (*GL::deleteShader) (vertex);
124
 
    (*GL::deleteShader) (fragment);
125
 
 
126
 
    priv->valid = true;
127
 
}
128
 
 
129
 
GLProgram::~GLProgram ()
130
 
{
131
 
    (*GL::deleteProgram) (priv->program);
132
 
    delete priv;
133
 
}
134
 
 
135
 
bool GLProgram::valid ()
136
 
{
137
 
    return priv->valid;
138
 
}
139
 
 
140
 
void GLProgram::bind ()
141
 
{
142
 
    (*GL::useProgram) (priv->program);
143
 
}
144
 
 
145
 
void GLProgram::unbind ()
146
 
{
147
 
    (*GL::useProgram) (0);
148
 
}
149
 
 
150
 
bool GLProgram::setUniform (const char *name, GLfloat value)
151
 
{
152
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
153
 
    if (location == -1)
154
 
        return false;
155
 
 
156
 
    (*GL::uniform1f) (location, value);
157
 
    return true;
158
 
}
159
 
 
160
 
bool GLProgram::setUniform (const char *name, GLint value)
161
 
{
162
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
163
 
    if (location == -1)
164
 
        return false;
165
 
 
166
 
    (*GL::uniform1i) (location, value);
167
 
    return true;
168
 
}
169
 
 
170
 
bool GLProgram::setUniform (const char *name, const GLMatrix &value)
171
 
{
172
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
173
 
    if (location == -1)
174
 
        return false;
175
 
 
176
 
    (*GL::uniformMatrix4fv) (location, 1, GL_FALSE, value.getMatrix ());
177
 
    return true;
178
 
}
179
 
 
180
 
bool GLProgram::setUniform2f (const char *name,
181
 
                              GLfloat x,
182
 
                              GLfloat y)
183
 
{
184
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
185
 
    if (location == -1)
186
 
        return false;
187
 
 
188
 
    (*GL::uniform2f) (location, x, y);
189
 
    return true;
190
 
}
191
 
 
192
 
bool GLProgram::setUniform3f (const char *name,
193
 
                              GLfloat x,
194
 
                              GLfloat y,
195
 
                              GLfloat z)
196
 
{
197
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
198
 
    if (location == -1)
199
 
        return false;
200
 
 
201
 
    (*GL::uniform3f) (location, x, y, z);
202
 
    return true;
203
 
}
204
 
 
205
 
bool GLProgram::setUniform4f (const char *name,
206
 
                              GLfloat x,
207
 
                              GLfloat y,
208
 
                              GLfloat z,
209
 
                              GLfloat w)
210
 
{
211
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
212
 
    if (location == -1)
213
 
        return false;
214
 
 
215
 
    (*GL::uniform4f) (location, x, y, z, w);
216
 
    return true;
217
 
}
218
 
 
219
 
bool GLProgram::setUniform2i (const char *name,
220
 
                              GLint x,
221
 
                              GLint y)
222
 
{
223
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
224
 
    if (location == -1)
225
 
        return false;
226
 
 
227
 
    (*GL::uniform2i) (location, x, y);
228
 
    return true;
229
 
}
230
 
 
231
 
bool GLProgram::setUniform3i (const char *name,
232
 
                              GLint x,
233
 
                              GLint y,
234
 
                              GLint z)
235
 
{
236
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
237
 
    if (location == -1)
238
 
        return false;
239
 
 
240
 
    (*GL::uniform3i) (location, x, y, z);
241
 
    return true;
242
 
}
243
 
 
244
 
bool GLProgram::setUniform4i (const char *name,
245
 
                              GLint x,
246
 
                              GLint y,
247
 
                              GLint z,
248
 
                              GLint w)
249
 
{
250
 
    GLint location = (*GL::getUniformLocation) (priv->program, name);
251
 
    if (location == -1)
252
 
        return false;
253
 
 
254
 
    (*GL::uniform4i) (location, x, y, z, w);
255
 
    return true;
256
 
}
257
 
 
258
 
GLuint GLProgram::attributeLocation (const char *name)
259
 
{
260
 
    return (*GL::getAttribLocation) (priv->program, name);
261
 
}
262