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
|
// Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file is here so other GLES2 related files can have a common set of
// includes where appropriate.
#include <GLES2/gl2.h>
#include "gpu/command_buffer/client/gles2_demo_cc.h"
namespace {
int g_width = 512;
int g_height = 512;
GLuint g_texture = 0;
int g_textureLoc = -1;
GLuint g_programObject = 0;
GLuint g_vbo = 0;
GLsizei g_texCoordOffset = 0;
void CheckGLError() {
GLenum error = glGetError();
if (error != GL_NO_ERROR) {
DLOG(ERROR) << "GL Error: " << error;
}
}
GLuint LoadShader(GLenum type, const char* shaderSrc) {
GLuint shader = glCreateShader(type);
if (shader == 0) {
return 0;
}
// Load the shader source
glShaderSource(shader, 1, &shaderSrc, NULL);
// Compile the shader
glCompileShader(shader);
// Check the compile status
GLint value;
glGetShaderiv(shader, GL_COMPILE_STATUS, &value);
if (value == 0) {
char buffer[1024];
GLsizei length;
glGetShaderInfoLog(shader, sizeof(buffer), &length, buffer);
std::string log(buffer, length);
DLOG(ERROR) << "Error compiling shader:" << log;
glDeleteShader(shader);
return 0;
}
return shader;
}
void InitShaders() {
static const char* vShaderStr =
"attribute vec3 g_Position;\n"
"attribute vec2 g_TexCoord0;\n"
"varying vec2 texCoord;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(g_Position.x, g_Position.y, g_Position.z, 1.0);\n"
" texCoord = g_TexCoord0;\n"
"}\n";
static const char* fShaderStr =
"uniform sampler2D tex;\n"
"varying vec2 texCoord;\n"
"void main()\n"
"{\n"
" gl_FragColor = texture2D(tex, texCoord);\n"
"}\n";
GLuint vertexShader = LoadShader(GL_VERTEX_SHADER, vShaderStr);
GLuint fragmentShader = LoadShader(GL_FRAGMENT_SHADER, fShaderStr);
// Create the program object
GLuint programObject = glCreateProgram();
if (programObject == 0) {
DLOG(ERROR) << "Creating program failed";
return;
}
glAttachShader(programObject, vertexShader);
glAttachShader(programObject, fragmentShader);
// Bind g_Position to attribute 0
// Bind g_TexCoord0 to attribute 1
glBindAttribLocation(programObject, 0, "g_Position");
glBindAttribLocation(programObject, 1, "g_TexCoord0");
// Link the program
glLinkProgram(programObject);
// Check the link status
GLint linked;
glGetProgramiv(programObject, GL_LINK_STATUS, &linked);
if (linked == 0) {
char buffer[1024];
GLsizei length;
glGetProgramInfoLog(programObject, sizeof(buffer), &length, buffer);
std::string log(buffer, length);
DLOG(ERROR) << "Error linking program:" << log;
glDeleteProgram(programObject);
return;
}
g_programObject = programObject;
g_textureLoc = glGetUniformLocation(g_programObject, "tex");
glGenBuffers(1, &g_vbo);
glBindBuffer(GL_ARRAY_BUFFER, g_vbo);
static float vertices[] = {
0.25, 0.75, 0.0,
-0.75, 0.75, 0.0,
-0.75, -0.25, 0.0,
0.25, 0.75, 0.0,
-0.75, -0.25, 0.0,
0.25, -0.25, 0.0,
};
static float texCoords[] = {
1.0, 1.0,
0.0, 1.0,
0.0, 0.0,
1.0, 1.0,
0.0, 0.0,
1.0, 0.0,
};
g_texCoordOffset = sizeof(vertices);
glBufferData(GL_ARRAY_BUFFER,
sizeof(vertices) + sizeof(texCoords),
NULL,
GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
glBufferSubData(GL_ARRAY_BUFFER, g_texCoordOffset,
sizeof(texCoords), texCoords);
CheckGLError();
}
void Draw() {
// Note: the viewport is automatically set up to cover the entire Canvas.
// Clear the color buffer
glClear(GL_COLOR_BUFFER_BIT);
CheckGLError();
// Use the program object
glUseProgram(g_programObject);
CheckGLError();
// Load the vertex data
glBindBuffer(GL_ARRAY_BUFFER, g_vbo);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0,
reinterpret_cast<const void*>(g_texCoordOffset));
CheckGLError();
// Bind the texture to texture unit 0
glBindTexture(GL_TEXTURE_2D, g_texture);
CheckGLError();
// Point the uniform sampler to texture unit 0
glUniform1i(g_textureLoc, 0);
CheckGLError();
glDrawArrays(GL_TRIANGLES, 0, 6);
CheckGLError();
glFlush();
}
GLuint CreateCheckerboardTexture() {
static unsigned char pixels[] = {
255, 255, 255,
0, 0, 0,
0, 0, 0,
255, 255, 255,
};
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE,
pixels);
return texture;
}
void Init() {
glClearColor(0.f, 0.f, .7f, 1.f);
g_texture = CreateCheckerboardTexture();
InitShaders();
}
} // anonymous namespace.
void GLFromCPPTestFunction() {
static bool initialized = false;
if (!initialized) {
initialized = true;
Init();
}
Draw();
}
|
