1 // Copyright 2016 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <GLES2/gl2.h>
6 #include <GLES2/gl2ext.h>
7 #include <GLES2/gl2extchromium.h>
8 #include <GLES3/gl3.h>
9 #include <stdint.h>
10
11 #include "gpu/command_buffer/service/context_group.h"
12 #include "gpu/command_buffer/tests/gl_manager.h"
13 #include "gpu/command_buffer/tests/gl_test_utils.h"
14 #include "gpu/config/gpu_test_config.h"
15 #include "testing/gmock/include/gmock/gmock.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17
18 #define SHADER(Src) #Src
19
20 namespace gpu {
21
22 class ES3MapBufferRangeTest : public testing::Test {
23 protected:
24 static const GLsizei kCanvasSize = 4;
25
SetUp()26 void SetUp() override {
27 GLManager::Options options;
28 options.size = gfx::Size(kCanvasSize, kCanvasSize);
29 options.context_type = CONTEXT_TYPE_OPENGLES3;
30
31 gl_.Initialize(options);
32 }
33
ShouldSkipTest() const34 bool ShouldSkipTest() const {
35 // If a driver isn't capable of supporting ES3 context, creating
36 // ContextGroup will fail.
37 // See crbug.com/654709.
38 return (!gl_.decoder() || !gl_.decoder()->GetContextGroup());
39 }
40
TearDown()41 void TearDown() override { gl_.Destroy(); }
42
SetupSimpleProgram(GLint * ret_position_loc)43 GLuint SetupSimpleProgram(GLint* ret_position_loc) {
44 static const char* v_shader_src =
45 SHADER(attribute vec2 a_position;
46 void main() { gl_Position = vec4(a_position, 0.0, 1.0); });
47 static const char* f_shader_src =
48 SHADER(precision mediump float;
49 void main() { gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); });
50 GLuint program = GLTestHelper::LoadProgram(v_shader_src, f_shader_src);
51 EXPECT_LT(0u, program);
52 glUseProgram(program);
53 *ret_position_loc = glGetAttribLocation(program, "a_position");
54 EXPECT_LE(0, *ret_position_loc);
55 return program;
56 }
57
SetupTransformFeedbackProgram(GLint * ret_position_loc)58 GLuint SetupTransformFeedbackProgram(GLint* ret_position_loc) {
59 static const char* v_shader_src =
60 "#version 300 es\n"
61 "in vec2 a_position;\n"
62 "out vec3 var0;\n"
63 "out vec2 var1;\n"
64 "void main() {\n"
65 " var0 = vec3(a_position, 0.5);\n"
66 " var1 = a_position;\n"
67 " gl_Position = vec4(a_position, 0.0, 1.0);\n"
68 "}";
69 static const char* f_shader_src =
70 "#version 300 es\n"
71 "precision mediump float;\n"
72 "out vec4 color;\n"
73 "in vec3 var0;\n"
74 "in vec2 var1;\n"
75 "void main() {\n"
76 " color = vec4(0.0, 1.0, 0.0, 1.0);\n"
77 "}";
78 static const char* varyings[] = {"var0", "var1"};
79 GLuint program = GLTestHelper::LoadProgram(v_shader_src, f_shader_src);
80 EXPECT_LT(0u, program);
81 glTransformFeedbackVaryings(program, 2, varyings, GL_SEPARATE_ATTRIBS);
82 glLinkProgram(program);
83 GLint link_status = GL_FALSE;
84 glGetProgramiv(program, GL_LINK_STATUS, &link_status);
85 EXPECT_EQ(GL_TRUE, link_status);
86 glUseProgram(program);
87 *ret_position_loc = glGetAttribLocation(program, "a_position");
88 EXPECT_LE(0, *ret_position_loc);
89 return program;
90 }
91
92 GLManager gl_;
93 };
94
TEST_F(ES3MapBufferRangeTest,DrawArraysAndInstanced)95 TEST_F(ES3MapBufferRangeTest, DrawArraysAndInstanced) {
96 if (ShouldSkipTest())
97 return;
98
99 const uint8_t kRedColor[] = {255, 0, 0, 255};
100 const uint8_t kBlackColor[] = {0, 0, 0, 255};
101 const GLsizei kPrimCount = 4;
102
103 GLint position_loc = 0;
104 SetupSimpleProgram(&position_loc);
105 GLTestHelper::CheckGLError("no errors", __LINE__);
106
107 GLuint buffer = GLTestHelper::SetupUnitQuad(position_loc);
108 GLTestHelper::CheckGLError("no errors", __LINE__);
109 EXPECT_LT(0u, buffer);
110
111 glClearColor(0.0, 0.0, 0.0, 1.0);
112 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
113 glDrawArrays(GL_TRIANGLES, 0, 6);
114 GLTestHelper::CheckGLError("no errors", __LINE__);
115 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
116 kRedColor, nullptr));
117
118 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
119 glDrawArraysInstancedANGLE(GL_TRIANGLES, 0, 6, kPrimCount);
120 GLTestHelper::CheckGLError("no errors", __LINE__);
121 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
122 kRedColor, nullptr));
123
124 glMapBufferRange(GL_ARRAY_BUFFER, 0, 6, GL_MAP_READ_BIT);
125 GLTestHelper::CheckGLError("no errors", __LINE__);
126
127 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
128 glDrawArrays(GL_TRIANGLES, 0, 6);
129 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
130 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
131 kBlackColor, nullptr));
132
133 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
134 glDrawArraysInstancedANGLE(GL_TRIANGLES, 0, 6, kPrimCount);
135 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
136 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
137 kBlackColor, nullptr));
138
139 // The following test is necessary to make sure draw calls do not just check
140 // bound buffers, but actual buffers that are attached to the enabled vertex
141 // attribs.
142 glBindBuffer(GL_ARRAY_BUFFER, 0);
143
144 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
145 glDrawArrays(GL_TRIANGLES, 0, 6);
146 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
147 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
148 kBlackColor, nullptr));
149
150 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
151 glDrawArraysInstancedANGLE(GL_TRIANGLES, 0, 6, kPrimCount);
152 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
153 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
154 kBlackColor, nullptr));
155
156 glBindBuffer(GL_ARRAY_BUFFER, buffer);
157 glUnmapBuffer(GL_ARRAY_BUFFER);
158 GLTestHelper::CheckGLError("no errors", __LINE__);
159
160 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
161 glDrawArrays(GL_TRIANGLES, 0, 6);
162 GLTestHelper::CheckGLError("no errors", __LINE__);
163 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
164 kRedColor, nullptr));
165
166 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
167 glDrawArraysInstancedANGLE(GL_TRIANGLES, 0, 6, kPrimCount);
168 GLTestHelper::CheckGLError("no errors", __LINE__);
169 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
170 kRedColor, nullptr));
171 }
172
TEST_F(ES3MapBufferRangeTest,DrawElementsAndInstanced)173 TEST_F(ES3MapBufferRangeTest, DrawElementsAndInstanced) {
174 if (ShouldSkipTest())
175 return;
176
177 const uint8_t kRedColor[] = {255, 0, 0, 255};
178 const uint8_t kBlackColor[] = {0, 0, 0, 255};
179 const GLsizei kPrimCount = 4;
180
181 GLint position_loc = 0;
182 SetupSimpleProgram(&position_loc);
183 GLTestHelper::CheckGLError("no errors", __LINE__);
184
185 std::vector<GLuint> buffers =
186 GLTestHelper::SetupIndexedUnitQuad(position_loc);
187 GLTestHelper::CheckGLError("no errors", __LINE__);
188 EXPECT_EQ(2u, buffers.size());
189 EXPECT_LT(0u, buffers[0]);
190 EXPECT_LT(0u, buffers[1]);
191
192 glClearColor(0.0, 0.0, 0.0, 1.0);
193 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
194 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
195 GLTestHelper::CheckGLError("no errors", __LINE__);
196 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
197 kRedColor, nullptr));
198
199 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
200 glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
201 kPrimCount);
202 GLTestHelper::CheckGLError("no errors", __LINE__);
203 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
204 kRedColor, nullptr));
205
206 glMapBufferRange(GL_ARRAY_BUFFER, 0, 6, GL_MAP_READ_BIT);
207 GLTestHelper::CheckGLError("no errors", __LINE__);
208
209 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
210 glDrawArrays(GL_TRIANGLES, 0, 6);
211 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
212 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
213 kBlackColor, nullptr));
214
215 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
216 glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
217 kPrimCount);
218 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
219 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
220 kBlackColor, nullptr));
221
222 // The following test is necessary to make sure draw calls do not just check
223 // bound buffers, but actual buffers that are attached to the enabled vertex
224 // attribs.
225 glBindBuffer(GL_ARRAY_BUFFER, 0);
226
227 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
228 glDrawArrays(GL_TRIANGLES, 0, 6);
229 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
230 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
231 kBlackColor, nullptr));
232
233 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
234 glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
235 kPrimCount);
236 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
237 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
238 kBlackColor, nullptr));
239
240 glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
241
242 glUnmapBuffer(GL_ARRAY_BUFFER);
243 GLTestHelper::CheckGLError("no errors", __LINE__);
244
245 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
246 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
247 GLTestHelper::CheckGLError("no errors", __LINE__);
248 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
249 kRedColor, nullptr));
250
251 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
252 glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
253 kPrimCount);
254 GLTestHelper::CheckGLError("no errors", __LINE__);
255 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
256 kRedColor, nullptr));
257
258 glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, 6, GL_MAP_READ_BIT);
259 GLTestHelper::CheckGLError("no errors", __LINE__);
260
261 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
262 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
263 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
264 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
265 kBlackColor, nullptr));
266
267 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
268 glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
269 kPrimCount);
270 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
271 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
272 kBlackColor, nullptr));
273
274 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
275 GLTestHelper::CheckGLError("no errors", __LINE__);
276
277 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
278 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
279 GLTestHelper::CheckGLError("no errors", __LINE__);
280 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
281 kRedColor, nullptr));
282
283 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
284 glDrawElementsInstancedANGLE(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0,
285 kPrimCount);
286 GLTestHelper::CheckGLError("no errors", __LINE__);
287 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kCanvasSize, kCanvasSize, 1,
288 kRedColor, nullptr));
289 }
290
TEST_F(ES3MapBufferRangeTest,ReadPixels)291 TEST_F(ES3MapBufferRangeTest, ReadPixels) {
292 if (ShouldSkipTest())
293 return;
294
295 // TODO(crbug.com/angleproject/5213) consistent driver errors on this config.
296 if (GPUTestBotConfig::CurrentConfigMatches("Linux AMD"))
297 return;
298
299 GLuint buffer = 0;
300 glGenBuffers(1, &buffer);
301 EXPECT_LT(0u, buffer);
302 glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer);
303 glBufferData(GL_PIXEL_PACK_BUFFER, 4 * kCanvasSize * kCanvasSize, 0,
304 GL_STATIC_READ);
305
306 glReadPixels(0, 0, kCanvasSize, kCanvasSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
307 GLTestHelper::CheckGLError("no errors", __LINE__);
308
309 glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, 6, GL_MAP_WRITE_BIT);
310 GLTestHelper::CheckGLError("no errors", __LINE__);
311
312 glReadPixels(0, 0, kCanvasSize, kCanvasSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
313 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
314
315 glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
316 GLTestHelper::CheckGLError("no errors", __LINE__);
317
318 glReadPixels(0, 0, kCanvasSize, kCanvasSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
319 GLTestHelper::CheckGLError("no errors", __LINE__);
320 }
321
TEST_F(ES3MapBufferRangeTest,TexImageAndSubImage2D)322 TEST_F(ES3MapBufferRangeTest, TexImageAndSubImage2D) {
323 if (ShouldSkipTest())
324 return;
325
326 const GLsizei kTextureSize = 4;
327 GLuint buffer = 0;
328 glGenBuffers(1, &buffer);
329 EXPECT_LT(0u, buffer);
330 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
331 glBufferData(GL_PIXEL_UNPACK_BUFFER, 4 * kTextureSize * kTextureSize, 0,
332 GL_STATIC_READ);
333
334 GLuint tex = 0;
335 glGenTextures(1, &tex);
336 EXPECT_LT(0u, tex);
337 glBindTexture(GL_TEXTURE_2D, tex);
338 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kTextureSize, kTextureSize, 0,
339 GL_RGBA, GL_UNSIGNED_BYTE, 0);
340 GLTestHelper::CheckGLError("no errors", __LINE__);
341 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextureSize, kTextureSize, GL_RGBA,
342 GL_UNSIGNED_BYTE, 0);
343 GLTestHelper::CheckGLError("no errors", __LINE__);
344
345 glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, 6, GL_MAP_READ_BIT);
346 GLTestHelper::CheckGLError("no errors", __LINE__);
347
348 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kTextureSize, kTextureSize, 0,
349 GL_RGBA, GL_UNSIGNED_BYTE, 0);
350 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
351 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextureSize, kTextureSize, GL_RGBA,
352 GL_UNSIGNED_BYTE, 0);
353 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
354
355 glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
356 GLTestHelper::CheckGLError("no errors", __LINE__);
357
358 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kTextureSize, kTextureSize, 0,
359 GL_RGBA, GL_UNSIGNED_BYTE, 0);
360 GLTestHelper::CheckGLError("no errors", __LINE__);
361 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextureSize, kTextureSize, GL_RGBA,
362 GL_UNSIGNED_BYTE, 0);
363 GLTestHelper::CheckGLError("no errors", __LINE__);
364 }
365
TEST_F(ES3MapBufferRangeTest,TexImageAndSubImage3D)366 TEST_F(ES3MapBufferRangeTest, TexImageAndSubImage3D) {
367 if (ShouldSkipTest())
368 return;
369
370 const GLsizei kTextureSize = 4;
371 GLuint buffer = 0;
372 glGenBuffers(1, &buffer);
373 EXPECT_LT(0u, buffer);
374 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
375 glBufferData(GL_PIXEL_UNPACK_BUFFER,
376 4 * kTextureSize * kTextureSize * kTextureSize, 0,
377 GL_STATIC_READ);
378
379 GLuint tex = 0;
380 glGenTextures(1, &tex);
381 EXPECT_LT(0u, tex);
382 glBindTexture(GL_TEXTURE_3D, tex);
383 glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, kTextureSize, kTextureSize,
384 kTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
385 GLTestHelper::CheckGLError("no errors", __LINE__);
386 glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, kTextureSize, kTextureSize,
387 kTextureSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
388 GLTestHelper::CheckGLError("no errors", __LINE__);
389
390 glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, 6, GL_MAP_READ_BIT);
391 GLTestHelper::CheckGLError("no errors", __LINE__);
392
393 glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, kTextureSize, kTextureSize,
394 kTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
395 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
396 glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, kTextureSize, kTextureSize,
397 kTextureSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
398 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
399
400 glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
401 GLTestHelper::CheckGLError("no errors", __LINE__);
402
403 glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, kTextureSize, kTextureSize,
404 kTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
405 GLTestHelper::CheckGLError("no errors", __LINE__);
406 glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, kTextureSize, kTextureSize,
407 kTextureSize, GL_RGBA, GL_UNSIGNED_BYTE, 0);
408 GLTestHelper::CheckGLError("no errors", __LINE__);
409 }
410
411 // TODO(zmo): Add tests for CompressedTex* functions.
412
TEST_F(ES3MapBufferRangeTest,TransformFeedback)413 TEST_F(ES3MapBufferRangeTest, TransformFeedback) {
414 if (ShouldSkipTest())
415 return;
416
417 GLuint transform_feedback = 0;
418 glGenTransformFeedbacks(1, &transform_feedback);
419 glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transform_feedback);
420 GLTestHelper::CheckGLError("no errors", __LINE__);
421
422 GLuint transform_feedback_buffer[2];
423 glGenBuffers(2, transform_feedback_buffer);
424 EXPECT_LT(0u, transform_feedback_buffer[0]);
425 EXPECT_LT(0u, transform_feedback_buffer[1]);
426 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0,
427 transform_feedback_buffer[0]);
428 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 3 * 6 * sizeof(float), 0,
429 GL_STATIC_READ);
430 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1,
431 transform_feedback_buffer[1]);
432 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 2 * 6 * sizeof(float), 0,
433 GL_STATIC_READ);
434 GLTestHelper::CheckGLError("no errors", __LINE__);
435
436 GLint position_loc = 0;
437 SetupTransformFeedbackProgram(&position_loc);
438 GLTestHelper::CheckGLError("no errors", __LINE__);
439
440 GLuint buffer = GLTestHelper::SetupUnitQuad(position_loc);
441 GLTestHelper::CheckGLError("no errors", __LINE__);
442 EXPECT_LT(0u, buffer);
443
444 glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 6, GL_MAP_WRITE_BIT);
445 GLTestHelper::CheckGLError("no errors", __LINE__);
446
447 glBeginTransformFeedback(GL_TRIANGLES);
448 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
449
450 glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
451 GLTestHelper::CheckGLError("no errors", __LINE__);
452
453 glBeginTransformFeedback(GL_TRIANGLES);
454 GLTestHelper::CheckGLError("no errors", __LINE__);
455
456 glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 6, GL_MAP_WRITE_BIT);
457 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
458
459 // Bind the used buffer to another binding target and try to map it using
460 // that target - should still fail.
461 glBindBuffer(GL_PIXEL_PACK_BUFFER, transform_feedback_buffer[0]);
462 GLTestHelper::CheckGLError("no errors", __LINE__);
463
464 glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, 6, GL_MAP_READ_BIT);
465 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
466
467 glEndTransformFeedback();
468 GLTestHelper::CheckGLError("no errors", __LINE__);
469
470 glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 6, GL_MAP_WRITE_BIT);
471 GLTestHelper::CheckGLError("no errors", __LINE__);
472
473 glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
474 GLTestHelper::CheckGLError("no errors", __LINE__);
475 }
476
TEST_F(ES3MapBufferRangeTest,GetBufferParameteriv)477 TEST_F(ES3MapBufferRangeTest, GetBufferParameteriv) {
478 if (ShouldSkipTest())
479 return;
480
481 GLuint buffer;
482 glGenBuffers(1, &buffer);
483 EXPECT_LT(0u, buffer);
484 glBindBuffer(GL_ARRAY_BUFFER, buffer);
485 glBufferData(GL_ARRAY_BUFFER, 64, 0, GL_STATIC_READ);
486
487 GLbitfield access = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT;
488 glMapBufferRange(GL_ARRAY_BUFFER, 16, 32, access);
489 GLint param = 0;
490 glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_ACCESS_FLAGS, ¶m);
491 EXPECT_EQ(access, static_cast<GLbitfield>(param));
492 glUnmapBuffer(GL_ARRAY_BUFFER);
493 param = 0;
494 glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_ACCESS_FLAGS, ¶m);
495 EXPECT_EQ(0u, static_cast<GLbitfield>(param));
496
497 GLTestHelper::CheckGLError("no errors", __LINE__);
498 }
499
TEST_F(ES3MapBufferRangeTest,CopyBufferSubData)500 TEST_F(ES3MapBufferRangeTest, CopyBufferSubData) {
501 if (ShouldSkipTest())
502 return;
503
504 const GLsizeiptr kSize = 64;
505 const GLsizeiptr kHalfSize = kSize / 2;
506 const GLintptr kReadOffset = 0;
507 const GLintptr kWriteOffset = kHalfSize;
508 const GLsizeiptr kCopySize = 5;
509 const uint8_t kValue0 = 3;
510 const uint8_t kValue1 = 21;
511
512 GLuint buffer;
513 glGenBuffers(1, &buffer);
514 EXPECT_NE(0u, buffer);
515 glBindBuffer(GL_ARRAY_BUFFER, buffer);
516 glBufferData(GL_ARRAY_BUFFER, kSize, nullptr, GL_STREAM_DRAW);
517
518 std::array<uint8_t, kHalfSize> data0;
519 data0.fill(kValue0);
520 glBufferSubData(GL_ARRAY_BUFFER, 0, kHalfSize, data0.data());
521
522 std::array<uint8_t, kHalfSize> data1;
523 data1.fill(kValue1);
524 glBufferSubData(GL_ARRAY_BUFFER, kHalfSize, kHalfSize, data1.data());
525
526 GLTestHelper::CheckGLError("no errors", __LINE__);
527
528 // Verify the data is initialized.
529 const uint8_t* map_ptr = static_cast<uint8_t*>(
530 glMapBufferRange(GL_ARRAY_BUFFER, 0, kSize, GL_MAP_READ_BIT));
531 ASSERT_NE(nullptr, map_ptr);
532
533 EXPECT_EQ(0, memcmp(map_ptr, data0.data(), kHalfSize));
534 EXPECT_EQ(0, memcmp(map_ptr + kHalfSize, data1.data(), kHalfSize));
535
536 glUnmapBuffer(GL_ARRAY_BUFFER);
537
538 glCopyBufferSubData(GL_ARRAY_BUFFER, GL_ARRAY_BUFFER, kReadOffset,
539 kWriteOffset, kCopySize);
540 GLTestHelper::CheckGLError("no errors", __LINE__);
541
542 // Verify the data is copied.
543 map_ptr = static_cast<uint8_t*>(
544 glMapBufferRange(GL_ARRAY_BUFFER, 0, kSize, GL_MAP_READ_BIT));
545 ASSERT_NE(nullptr, map_ptr);
546
547 for (GLsizeiptr ii = 0; ii < kHalfSize; ++ii) {
548 EXPECT_EQ(kValue0, map_ptr[ii]);
549 }
550 for (GLsizeiptr ii = kHalfSize; ii < kSize; ++ii) {
551 if (ii >= kWriteOffset && ii < kWriteOffset + kCopySize) {
552 EXPECT_EQ(kValue0, map_ptr[ii]);
553 } else {
554 EXPECT_EQ(kValue1, map_ptr[ii]);
555 }
556 }
557 }
558
TEST_F(ES3MapBufferRangeTest,Delete)559 TEST_F(ES3MapBufferRangeTest, Delete) {
560 // Test that we can unbind a mapped buffer and deleting it still unmaps it.
561 if (ShouldSkipTest())
562 return;
563
564 const int kNumBuffers = 3;
565 const int kSize = sizeof(GLuint);
566
567 GLuint buffers[kNumBuffers];
568 glGenBuffers(kNumBuffers, buffers);
569 // Set each buffer to contain its name.
570 for (int i = 0; i < kNumBuffers; ++i) {
571 EXPECT_NE(0u, buffers[i]);
572 glBindBuffer(GL_ARRAY_BUFFER, buffers[i]);
573 glBufferData(GL_ARRAY_BUFFER, sizeof(GLuint), &buffers[i], GL_STREAM_DRAW);
574 glBindBuffer(GL_ARRAY_BUFFER, 0);
575 }
576
577 GLTestHelper::CheckGLError("no errors", __LINE__);
578
579 glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
580
581 // Use a different binding point to map the buffer than we originally used,
582 // to test if we are improperly using Buffer::initial_target() anywhere.
583 glBindBuffer(GL_COPY_READ_BUFFER, buffers[0]);
584 const GLuint* map_ptr_0 = static_cast<GLuint*>(
585 glMapBufferRange(GL_COPY_READ_BUFFER, 0, kSize, GL_MAP_READ_BIT));
586 ASSERT_NE(nullptr, map_ptr_0);
587 EXPECT_EQ(buffers[0], *map_ptr_0);
588 glBindBuffer(GL_COPY_READ_BUFFER, buffers[1]);
589
590 // The buffer is no longer bound. Delete it.
591 glDeleteBuffers(1, &buffers[0]);
592
593 GLint copy_read_buffer = 0;
594 glGetIntegerv(GL_COPY_READ_BUFFER_BINDING, ©_read_buffer);
595 EXPECT_EQ(copy_read_buffer, (GLint)buffers[1]);
596 GLint array_buffer = 0;
597 glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &array_buffer);
598 EXPECT_EQ(array_buffer, (GLint)buffers[2]);
599
600 // Make sure buffers[1] [2] are truly still bound by mapping them and
601 // checking the contents.
602 const GLuint* map_ptr_1 = static_cast<GLuint*>(
603 glMapBufferRange(GL_COPY_READ_BUFFER, 0, kSize, GL_MAP_READ_BIT));
604 ASSERT_NE(nullptr, map_ptr_1);
605 EXPECT_EQ(buffers[1], *map_ptr_1);
606 glUnmapBuffer(GL_COPY_READ_BUFFER);
607
608 const GLuint* map_ptr_2 = static_cast<GLuint*>(
609 glMapBufferRange(GL_ARRAY_BUFFER, 0, kSize, GL_MAP_READ_BIT));
610 ASSERT_NE(nullptr, map_ptr_2);
611 EXPECT_EQ(buffers[2], *map_ptr_2);
612 glUnmapBuffer(GL_ARRAY_BUFFER);
613
614 GLTestHelper::CheckGLError("no errors", __LINE__);
615 }
616
617 // TODO(zmo): add tests for uniform buffer mapping.
618
619 } // namespace gpu
620