1 // Copyright 2014 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 // This file is auto-generated from
6 // gpu/command_buffer/build_gles2_cmd_buffer.py
7 // It's formatted by clang-format using chromium coding style:
8 // clang-format -i -style=chromium filename
9 // DO NOT EDIT!
10
11 // This file is included by gles2_implementation.cc to define the
12 // GL api functions.
13 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_IMPL_AUTOGEN_H_
14 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_IMPL_AUTOGEN_H_
15
AttachShader(GLuint program,GLuint shader)16 void GLES2Implementation::AttachShader(GLuint program, GLuint shader) {
17 GPU_CLIENT_SINGLE_THREAD_CHECK();
18 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glAttachShader(" << program << ", "
19 << shader << ")");
20 helper_->AttachShader(program, shader);
21 CheckGLError();
22 }
23
BindBuffer(GLenum target,GLuint buffer)24 void GLES2Implementation::BindBuffer(GLenum target, GLuint buffer) {
25 GPU_CLIENT_SINGLE_THREAD_CHECK();
26 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindBuffer("
27 << GLES2Util::GetStringBufferTarget(target) << ", "
28 << buffer << ")");
29 if (IsBufferReservedId(buffer)) {
30 SetGLError(GL_INVALID_OPERATION, "BindBuffer", "buffer reserved id");
31 return;
32 }
33 if (BindBufferHelper(target, buffer)) {
34 helper_->BindBuffer(target, buffer);
35 }
36 CheckGLError();
37 }
38
BindFramebuffer(GLenum target,GLuint framebuffer)39 void GLES2Implementation::BindFramebuffer(GLenum target, GLuint framebuffer) {
40 GPU_CLIENT_SINGLE_THREAD_CHECK();
41 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindFramebuffer("
42 << GLES2Util::GetStringFrameBufferTarget(target) << ", "
43 << framebuffer << ")");
44 if (IsFramebufferReservedId(framebuffer)) {
45 SetGLError(
46 GL_INVALID_OPERATION, "BindFramebuffer", "framebuffer reserved id");
47 return;
48 }
49 if (BindFramebufferHelper(target, framebuffer)) {
50 helper_->BindFramebuffer(target, framebuffer);
51 }
52 CheckGLError();
53 }
54
BindRenderbuffer(GLenum target,GLuint renderbuffer)55 void GLES2Implementation::BindRenderbuffer(GLenum target, GLuint renderbuffer) {
56 GPU_CLIENT_SINGLE_THREAD_CHECK();
57 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindRenderbuffer("
58 << GLES2Util::GetStringRenderBufferTarget(target) << ", "
59 << renderbuffer << ")");
60 if (IsRenderbufferReservedId(renderbuffer)) {
61 SetGLError(
62 GL_INVALID_OPERATION, "BindRenderbuffer", "renderbuffer reserved id");
63 return;
64 }
65 if (BindRenderbufferHelper(target, renderbuffer)) {
66 helper_->BindRenderbuffer(target, renderbuffer);
67 }
68 CheckGLError();
69 }
70
BindTexture(GLenum target,GLuint texture)71 void GLES2Implementation::BindTexture(GLenum target, GLuint texture) {
72 GPU_CLIENT_SINGLE_THREAD_CHECK();
73 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindTexture("
74 << GLES2Util::GetStringTextureBindTarget(target) << ", "
75 << texture << ")");
76 if (IsTextureReservedId(texture)) {
77 SetGLError(GL_INVALID_OPERATION, "BindTexture", "texture reserved id");
78 return;
79 }
80 if (BindTextureHelper(target, texture)) {
81 helper_->BindTexture(target, texture);
82 }
83 CheckGLError();
84 }
85
BlendColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)86 void GLES2Implementation::BlendColor(GLclampf red,
87 GLclampf green,
88 GLclampf blue,
89 GLclampf alpha) {
90 GPU_CLIENT_SINGLE_THREAD_CHECK();
91 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBlendColor(" << red << ", "
92 << green << ", " << blue << ", " << alpha << ")");
93 helper_->BlendColor(red, green, blue, alpha);
94 CheckGLError();
95 }
96
BlendEquation(GLenum mode)97 void GLES2Implementation::BlendEquation(GLenum mode) {
98 GPU_CLIENT_SINGLE_THREAD_CHECK();
99 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBlendEquation("
100 << GLES2Util::GetStringEquation(mode) << ")");
101 helper_->BlendEquation(mode);
102 CheckGLError();
103 }
104
BlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha)105 void GLES2Implementation::BlendEquationSeparate(GLenum modeRGB,
106 GLenum modeAlpha) {
107 GPU_CLIENT_SINGLE_THREAD_CHECK();
108 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBlendEquationSeparate("
109 << GLES2Util::GetStringEquation(modeRGB) << ", "
110 << GLES2Util::GetStringEquation(modeAlpha) << ")");
111 helper_->BlendEquationSeparate(modeRGB, modeAlpha);
112 CheckGLError();
113 }
114
BlendFunc(GLenum sfactor,GLenum dfactor)115 void GLES2Implementation::BlendFunc(GLenum sfactor, GLenum dfactor) {
116 GPU_CLIENT_SINGLE_THREAD_CHECK();
117 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBlendFunc("
118 << GLES2Util::GetStringSrcBlendFactor(sfactor) << ", "
119 << GLES2Util::GetStringDstBlendFactor(dfactor) << ")");
120 helper_->BlendFunc(sfactor, dfactor);
121 CheckGLError();
122 }
123
BlendFuncSeparate(GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)124 void GLES2Implementation::BlendFuncSeparate(GLenum srcRGB,
125 GLenum dstRGB,
126 GLenum srcAlpha,
127 GLenum dstAlpha) {
128 GPU_CLIENT_SINGLE_THREAD_CHECK();
129 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBlendFuncSeparate("
130 << GLES2Util::GetStringSrcBlendFactor(srcRGB) << ", "
131 << GLES2Util::GetStringDstBlendFactor(dstRGB) << ", "
132 << GLES2Util::GetStringSrcBlendFactor(srcAlpha) << ", "
133 << GLES2Util::GetStringDstBlendFactor(dstAlpha) << ")");
134 helper_->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
135 CheckGLError();
136 }
137
CheckFramebufferStatus(GLenum target)138 GLenum GLES2Implementation::CheckFramebufferStatus(GLenum target) {
139 GPU_CLIENT_SINGLE_THREAD_CHECK();
140 TRACE_EVENT0("gpu", "GLES2Implementation::CheckFramebufferStatus");
141 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCheckFramebufferStatus("
142 << GLES2Util::GetStringFrameBufferTarget(target) << ")");
143 typedef cmds::CheckFramebufferStatus::Result Result;
144 Result* result = GetResultAs<Result*>();
145 if (!result) {
146 return GL_FRAMEBUFFER_UNSUPPORTED;
147 }
148 *result = 0;
149 helper_->CheckFramebufferStatus(
150 target, GetResultShmId(), GetResultShmOffset());
151 WaitForCmd();
152 GLenum result_value = *result;
153 GPU_CLIENT_LOG("returned " << result_value);
154 CheckGLError();
155 return result_value;
156 }
157
Clear(GLbitfield mask)158 void GLES2Implementation::Clear(GLbitfield mask) {
159 GPU_CLIENT_SINGLE_THREAD_CHECK();
160 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClear(" << mask << ")");
161 helper_->Clear(mask);
162 CheckGLError();
163 }
164
ClearColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)165 void GLES2Implementation::ClearColor(GLclampf red,
166 GLclampf green,
167 GLclampf blue,
168 GLclampf alpha) {
169 GPU_CLIENT_SINGLE_THREAD_CHECK();
170 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClearColor(" << red << ", "
171 << green << ", " << blue << ", " << alpha << ")");
172 helper_->ClearColor(red, green, blue, alpha);
173 CheckGLError();
174 }
175
ClearDepthf(GLclampf depth)176 void GLES2Implementation::ClearDepthf(GLclampf depth) {
177 GPU_CLIENT_SINGLE_THREAD_CHECK();
178 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClearDepthf(" << depth << ")");
179 helper_->ClearDepthf(depth);
180 CheckGLError();
181 }
182
ClearStencil(GLint s)183 void GLES2Implementation::ClearStencil(GLint s) {
184 GPU_CLIENT_SINGLE_THREAD_CHECK();
185 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClearStencil(" << s << ")");
186 helper_->ClearStencil(s);
187 CheckGLError();
188 }
189
ColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)190 void GLES2Implementation::ColorMask(GLboolean red,
191 GLboolean green,
192 GLboolean blue,
193 GLboolean alpha) {
194 GPU_CLIENT_SINGLE_THREAD_CHECK();
195 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glColorMask("
196 << GLES2Util::GetStringBool(red) << ", "
197 << GLES2Util::GetStringBool(green) << ", "
198 << GLES2Util::GetStringBool(blue) << ", "
199 << GLES2Util::GetStringBool(alpha) << ")");
200 helper_->ColorMask(red, green, blue, alpha);
201 CheckGLError();
202 }
203
CompileShader(GLuint shader)204 void GLES2Implementation::CompileShader(GLuint shader) {
205 GPU_CLIENT_SINGLE_THREAD_CHECK();
206 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCompileShader(" << shader
207 << ")");
208 helper_->CompileShader(shader);
209 CheckGLError();
210 }
211
CopyTexImage2D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)212 void GLES2Implementation::CopyTexImage2D(GLenum target,
213 GLint level,
214 GLenum internalformat,
215 GLint x,
216 GLint y,
217 GLsizei width,
218 GLsizei height,
219 GLint border) {
220 GPU_CLIENT_SINGLE_THREAD_CHECK();
221 GPU_CLIENT_LOG(
222 "[" << GetLogPrefix() << "] glCopyTexImage2D("
223 << GLES2Util::GetStringTextureTarget(target) << ", " << level << ", "
224 << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
225 << x << ", " << y << ", " << width << ", " << height << ", " << border
226 << ")");
227 if (width < 0) {
228 SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "width < 0");
229 return;
230 }
231 if (height < 0) {
232 SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "height < 0");
233 return;
234 }
235 if (border != 0) {
236 SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "border GL_INVALID_VALUE");
237 return;
238 }
239 helper_->CopyTexImage2D(target, level, internalformat, x, y, width, height);
240 CheckGLError();
241 }
242
CopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)243 void GLES2Implementation::CopyTexSubImage2D(GLenum target,
244 GLint level,
245 GLint xoffset,
246 GLint yoffset,
247 GLint x,
248 GLint y,
249 GLsizei width,
250 GLsizei height) {
251 GPU_CLIENT_SINGLE_THREAD_CHECK();
252 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCopyTexSubImage2D("
253 << GLES2Util::GetStringTextureTarget(target) << ", "
254 << level << ", " << xoffset << ", " << yoffset << ", " << x
255 << ", " << y << ", " << width << ", " << height << ")");
256 if (width < 0) {
257 SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D", "width < 0");
258 return;
259 }
260 if (height < 0) {
261 SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D", "height < 0");
262 return;
263 }
264 helper_->CopyTexSubImage2D(
265 target, level, xoffset, yoffset, x, y, width, height);
266 CheckGLError();
267 }
268
CreateProgram()269 GLuint GLES2Implementation::CreateProgram() {
270 GPU_CLIENT_SINGLE_THREAD_CHECK();
271 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCreateProgram("
272 << ")");
273 GLuint client_id;
274 GetIdHandler(id_namespaces::kProgramsAndShaders)
275 ->MakeIds(this, 0, 1, &client_id);
276 helper_->CreateProgram(client_id);
277 GPU_CLIENT_LOG("returned " << client_id);
278 CheckGLError();
279 return client_id;
280 }
281
CreateShader(GLenum type)282 GLuint GLES2Implementation::CreateShader(GLenum type) {
283 GPU_CLIENT_SINGLE_THREAD_CHECK();
284 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCreateShader("
285 << GLES2Util::GetStringShaderType(type) << ")");
286 GLuint client_id;
287 GetIdHandler(id_namespaces::kProgramsAndShaders)
288 ->MakeIds(this, 0, 1, &client_id);
289 helper_->CreateShader(type, client_id);
290 GPU_CLIENT_LOG("returned " << client_id);
291 CheckGLError();
292 return client_id;
293 }
294
CullFace(GLenum mode)295 void GLES2Implementation::CullFace(GLenum mode) {
296 GPU_CLIENT_SINGLE_THREAD_CHECK();
297 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCullFace("
298 << GLES2Util::GetStringFaceType(mode) << ")");
299 helper_->CullFace(mode);
300 CheckGLError();
301 }
302
DeleteBuffers(GLsizei n,const GLuint * buffers)303 void GLES2Implementation::DeleteBuffers(GLsizei n, const GLuint* buffers) {
304 GPU_CLIENT_SINGLE_THREAD_CHECK();
305 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteBuffers(" << n << ", "
306 << static_cast<const void*>(buffers) << ")");
307 GPU_CLIENT_LOG_CODE_BLOCK({
308 for (GLsizei i = 0; i < n; ++i) {
309 GPU_CLIENT_LOG(" " << i << ": " << buffers[i]);
310 }
311 });
312 GPU_CLIENT_DCHECK_CODE_BLOCK({
313 for (GLsizei i = 0; i < n; ++i) {
314 DCHECK(buffers[i] != 0);
315 }
316 });
317 if (n < 0) {
318 SetGLError(GL_INVALID_VALUE, "glDeleteBuffers", "n < 0");
319 return;
320 }
321 DeleteBuffersHelper(n, buffers);
322 CheckGLError();
323 }
324
DeleteFramebuffers(GLsizei n,const GLuint * framebuffers)325 void GLES2Implementation::DeleteFramebuffers(GLsizei n,
326 const GLuint* framebuffers) {
327 GPU_CLIENT_SINGLE_THREAD_CHECK();
328 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteFramebuffers(" << n << ", "
329 << static_cast<const void*>(framebuffers) << ")");
330 GPU_CLIENT_LOG_CODE_BLOCK({
331 for (GLsizei i = 0; i < n; ++i) {
332 GPU_CLIENT_LOG(" " << i << ": " << framebuffers[i]);
333 }
334 });
335 GPU_CLIENT_DCHECK_CODE_BLOCK({
336 for (GLsizei i = 0; i < n; ++i) {
337 DCHECK(framebuffers[i] != 0);
338 }
339 });
340 if (n < 0) {
341 SetGLError(GL_INVALID_VALUE, "glDeleteFramebuffers", "n < 0");
342 return;
343 }
344 DeleteFramebuffersHelper(n, framebuffers);
345 CheckGLError();
346 }
347
DeleteProgram(GLuint program)348 void GLES2Implementation::DeleteProgram(GLuint program) {
349 GPU_CLIENT_SINGLE_THREAD_CHECK();
350 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteProgram(" << program
351 << ")");
352 GPU_CLIENT_DCHECK(program != 0);
353 DeleteProgramHelper(program);
354 CheckGLError();
355 }
356
DeleteRenderbuffers(GLsizei n,const GLuint * renderbuffers)357 void GLES2Implementation::DeleteRenderbuffers(GLsizei n,
358 const GLuint* renderbuffers) {
359 GPU_CLIENT_SINGLE_THREAD_CHECK();
360 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteRenderbuffers(" << n
361 << ", " << static_cast<const void*>(renderbuffers) << ")");
362 GPU_CLIENT_LOG_CODE_BLOCK({
363 for (GLsizei i = 0; i < n; ++i) {
364 GPU_CLIENT_LOG(" " << i << ": " << renderbuffers[i]);
365 }
366 });
367 GPU_CLIENT_DCHECK_CODE_BLOCK({
368 for (GLsizei i = 0; i < n; ++i) {
369 DCHECK(renderbuffers[i] != 0);
370 }
371 });
372 if (n < 0) {
373 SetGLError(GL_INVALID_VALUE, "glDeleteRenderbuffers", "n < 0");
374 return;
375 }
376 DeleteRenderbuffersHelper(n, renderbuffers);
377 CheckGLError();
378 }
379
DeleteShader(GLuint shader)380 void GLES2Implementation::DeleteShader(GLuint shader) {
381 GPU_CLIENT_SINGLE_THREAD_CHECK();
382 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteShader(" << shader << ")");
383 GPU_CLIENT_DCHECK(shader != 0);
384 DeleteShaderHelper(shader);
385 CheckGLError();
386 }
387
DeleteTextures(GLsizei n,const GLuint * textures)388 void GLES2Implementation::DeleteTextures(GLsizei n, const GLuint* textures) {
389 GPU_CLIENT_SINGLE_THREAD_CHECK();
390 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteTextures(" << n << ", "
391 << static_cast<const void*>(textures) << ")");
392 GPU_CLIENT_LOG_CODE_BLOCK({
393 for (GLsizei i = 0; i < n; ++i) {
394 GPU_CLIENT_LOG(" " << i << ": " << textures[i]);
395 }
396 });
397 GPU_CLIENT_DCHECK_CODE_BLOCK({
398 for (GLsizei i = 0; i < n; ++i) {
399 DCHECK(textures[i] != 0);
400 }
401 });
402 if (n < 0) {
403 SetGLError(GL_INVALID_VALUE, "glDeleteTextures", "n < 0");
404 return;
405 }
406 DeleteTexturesHelper(n, textures);
407 CheckGLError();
408 }
409
DepthFunc(GLenum func)410 void GLES2Implementation::DepthFunc(GLenum func) {
411 GPU_CLIENT_SINGLE_THREAD_CHECK();
412 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDepthFunc("
413 << GLES2Util::GetStringCmpFunction(func) << ")");
414 helper_->DepthFunc(func);
415 CheckGLError();
416 }
417
DepthMask(GLboolean flag)418 void GLES2Implementation::DepthMask(GLboolean flag) {
419 GPU_CLIENT_SINGLE_THREAD_CHECK();
420 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDepthMask("
421 << GLES2Util::GetStringBool(flag) << ")");
422 helper_->DepthMask(flag);
423 CheckGLError();
424 }
425
DepthRangef(GLclampf zNear,GLclampf zFar)426 void GLES2Implementation::DepthRangef(GLclampf zNear, GLclampf zFar) {
427 GPU_CLIENT_SINGLE_THREAD_CHECK();
428 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDepthRangef(" << zNear << ", "
429 << zFar << ")");
430 helper_->DepthRangef(zNear, zFar);
431 CheckGLError();
432 }
433
DetachShader(GLuint program,GLuint shader)434 void GLES2Implementation::DetachShader(GLuint program, GLuint shader) {
435 GPU_CLIENT_SINGLE_THREAD_CHECK();
436 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDetachShader(" << program << ", "
437 << shader << ")");
438 helper_->DetachShader(program, shader);
439 CheckGLError();
440 }
441
FramebufferRenderbuffer(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)442 void GLES2Implementation::FramebufferRenderbuffer(GLenum target,
443 GLenum attachment,
444 GLenum renderbuffertarget,
445 GLuint renderbuffer) {
446 GPU_CLIENT_SINGLE_THREAD_CHECK();
447 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glFramebufferRenderbuffer("
448 << GLES2Util::GetStringFrameBufferTarget(target) << ", "
449 << GLES2Util::GetStringAttachment(attachment) << ", "
450 << GLES2Util::GetStringRenderBufferTarget(
451 renderbuffertarget) << ", " << renderbuffer << ")");
452 helper_->FramebufferRenderbuffer(
453 target, attachment, renderbuffertarget, renderbuffer);
454 CheckGLError();
455 }
456
FramebufferTexture2D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)457 void GLES2Implementation::FramebufferTexture2D(GLenum target,
458 GLenum attachment,
459 GLenum textarget,
460 GLuint texture,
461 GLint level) {
462 GPU_CLIENT_SINGLE_THREAD_CHECK();
463 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glFramebufferTexture2D("
464 << GLES2Util::GetStringFrameBufferTarget(target) << ", "
465 << GLES2Util::GetStringAttachment(attachment) << ", "
466 << GLES2Util::GetStringTextureTarget(textarget) << ", "
467 << texture << ", " << level << ")");
468 if (level != 0) {
469 SetGLError(
470 GL_INVALID_VALUE, "glFramebufferTexture2D", "level GL_INVALID_VALUE");
471 return;
472 }
473 helper_->FramebufferTexture2D(target, attachment, textarget, texture);
474 CheckGLError();
475 }
476
FrontFace(GLenum mode)477 void GLES2Implementation::FrontFace(GLenum mode) {
478 GPU_CLIENT_SINGLE_THREAD_CHECK();
479 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glFrontFace("
480 << GLES2Util::GetStringFaceMode(mode) << ")");
481 helper_->FrontFace(mode);
482 CheckGLError();
483 }
484
GenBuffers(GLsizei n,GLuint * buffers)485 void GLES2Implementation::GenBuffers(GLsizei n, GLuint* buffers) {
486 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenBuffers(" << n << ", "
487 << static_cast<const void*>(buffers) << ")");
488 if (n < 0) {
489 SetGLError(GL_INVALID_VALUE, "glGenBuffers", "n < 0");
490 return;
491 }
492 GPU_CLIENT_SINGLE_THREAD_CHECK();
493 GetIdHandler(id_namespaces::kBuffers)->MakeIds(this, 0, n, buffers);
494 GenBuffersHelper(n, buffers);
495 helper_->GenBuffersImmediate(n, buffers);
496 if (share_group_->bind_generates_resource())
497 helper_->CommandBufferHelper::Flush();
498 GPU_CLIENT_LOG_CODE_BLOCK({
499 for (GLsizei i = 0; i < n; ++i) {
500 GPU_CLIENT_LOG(" " << i << ": " << buffers[i]);
501 }
502 });
503 CheckGLError();
504 }
505
GenerateMipmap(GLenum target)506 void GLES2Implementation::GenerateMipmap(GLenum target) {
507 GPU_CLIENT_SINGLE_THREAD_CHECK();
508 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenerateMipmap("
509 << GLES2Util::GetStringTextureBindTarget(target) << ")");
510 helper_->GenerateMipmap(target);
511 CheckGLError();
512 }
513
GenFramebuffers(GLsizei n,GLuint * framebuffers)514 void GLES2Implementation::GenFramebuffers(GLsizei n, GLuint* framebuffers) {
515 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenFramebuffers(" << n << ", "
516 << static_cast<const void*>(framebuffers) << ")");
517 if (n < 0) {
518 SetGLError(GL_INVALID_VALUE, "glGenFramebuffers", "n < 0");
519 return;
520 }
521 GPU_CLIENT_SINGLE_THREAD_CHECK();
522 GetIdHandler(id_namespaces::kFramebuffers)->MakeIds(this, 0, n, framebuffers);
523 GenFramebuffersHelper(n, framebuffers);
524 helper_->GenFramebuffersImmediate(n, framebuffers);
525 if (share_group_->bind_generates_resource())
526 helper_->CommandBufferHelper::Flush();
527 GPU_CLIENT_LOG_CODE_BLOCK({
528 for (GLsizei i = 0; i < n; ++i) {
529 GPU_CLIENT_LOG(" " << i << ": " << framebuffers[i]);
530 }
531 });
532 CheckGLError();
533 }
534
GenRenderbuffers(GLsizei n,GLuint * renderbuffers)535 void GLES2Implementation::GenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
536 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenRenderbuffers(" << n << ", "
537 << static_cast<const void*>(renderbuffers) << ")");
538 if (n < 0) {
539 SetGLError(GL_INVALID_VALUE, "glGenRenderbuffers", "n < 0");
540 return;
541 }
542 GPU_CLIENT_SINGLE_THREAD_CHECK();
543 GetIdHandler(id_namespaces::kRenderbuffers)
544 ->MakeIds(this, 0, n, renderbuffers);
545 GenRenderbuffersHelper(n, renderbuffers);
546 helper_->GenRenderbuffersImmediate(n, renderbuffers);
547 if (share_group_->bind_generates_resource())
548 helper_->CommandBufferHelper::Flush();
549 GPU_CLIENT_LOG_CODE_BLOCK({
550 for (GLsizei i = 0; i < n; ++i) {
551 GPU_CLIENT_LOG(" " << i << ": " << renderbuffers[i]);
552 }
553 });
554 CheckGLError();
555 }
556
GenTextures(GLsizei n,GLuint * textures)557 void GLES2Implementation::GenTextures(GLsizei n, GLuint* textures) {
558 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenTextures(" << n << ", "
559 << static_cast<const void*>(textures) << ")");
560 if (n < 0) {
561 SetGLError(GL_INVALID_VALUE, "glGenTextures", "n < 0");
562 return;
563 }
564 GPU_CLIENT_SINGLE_THREAD_CHECK();
565 GetIdHandler(id_namespaces::kTextures)->MakeIds(this, 0, n, textures);
566 GenTexturesHelper(n, textures);
567 helper_->GenTexturesImmediate(n, textures);
568 if (share_group_->bind_generates_resource())
569 helper_->CommandBufferHelper::Flush();
570 GPU_CLIENT_LOG_CODE_BLOCK({
571 for (GLsizei i = 0; i < n; ++i) {
572 GPU_CLIENT_LOG(" " << i << ": " << textures[i]);
573 }
574 });
575 CheckGLError();
576 }
577
GetBooleanv(GLenum pname,GLboolean * params)578 void GLES2Implementation::GetBooleanv(GLenum pname, GLboolean* params) {
579 GPU_CLIENT_SINGLE_THREAD_CHECK();
580 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLboolean, params);
581 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetBooleanv("
582 << GLES2Util::GetStringGLState(pname) << ", "
583 << static_cast<const void*>(params) << ")");
584 TRACE_EVENT0("gpu", "GLES2Implementation::GetBooleanv");
585 if (GetBooleanvHelper(pname, params)) {
586 return;
587 }
588 typedef cmds::GetBooleanv::Result Result;
589 Result* result = GetResultAs<Result*>();
590 if (!result) {
591 return;
592 }
593 result->SetNumResults(0);
594 helper_->GetBooleanv(pname, GetResultShmId(), GetResultShmOffset());
595 WaitForCmd();
596 result->CopyResult(params);
597 GPU_CLIENT_LOG_CODE_BLOCK({
598 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
599 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
600 }
601 });
602 CheckGLError();
603 }
GetBufferParameteriv(GLenum target,GLenum pname,GLint * params)604 void GLES2Implementation::GetBufferParameteriv(GLenum target,
605 GLenum pname,
606 GLint* params) {
607 GPU_CLIENT_SINGLE_THREAD_CHECK();
608 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
609 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetBufferParameteriv("
610 << GLES2Util::GetStringBufferTarget(target) << ", "
611 << GLES2Util::GetStringBufferParameter(pname) << ", "
612 << static_cast<const void*>(params) << ")");
613 TRACE_EVENT0("gpu", "GLES2Implementation::GetBufferParameteriv");
614 if (GetBufferParameterivHelper(target, pname, params)) {
615 return;
616 }
617 typedef cmds::GetBufferParameteriv::Result Result;
618 Result* result = GetResultAs<Result*>();
619 if (!result) {
620 return;
621 }
622 result->SetNumResults(0);
623 helper_->GetBufferParameteriv(
624 target, pname, GetResultShmId(), GetResultShmOffset());
625 WaitForCmd();
626 result->CopyResult(params);
627 GPU_CLIENT_LOG_CODE_BLOCK({
628 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
629 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
630 }
631 });
632 CheckGLError();
633 }
GetFloatv(GLenum pname,GLfloat * params)634 void GLES2Implementation::GetFloatv(GLenum pname, GLfloat* params) {
635 GPU_CLIENT_SINGLE_THREAD_CHECK();
636 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetFloatv("
637 << GLES2Util::GetStringGLState(pname) << ", "
638 << static_cast<const void*>(params) << ")");
639 TRACE_EVENT0("gpu", "GLES2Implementation::GetFloatv");
640 if (GetFloatvHelper(pname, params)) {
641 return;
642 }
643 typedef cmds::GetFloatv::Result Result;
644 Result* result = GetResultAs<Result*>();
645 if (!result) {
646 return;
647 }
648 result->SetNumResults(0);
649 helper_->GetFloatv(pname, GetResultShmId(), GetResultShmOffset());
650 WaitForCmd();
651 result->CopyResult(params);
652 GPU_CLIENT_LOG_CODE_BLOCK({
653 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
654 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
655 }
656 });
657 CheckGLError();
658 }
GetFramebufferAttachmentParameteriv(GLenum target,GLenum attachment,GLenum pname,GLint * params)659 void GLES2Implementation::GetFramebufferAttachmentParameteriv(GLenum target,
660 GLenum attachment,
661 GLenum pname,
662 GLint* params) {
663 GPU_CLIENT_SINGLE_THREAD_CHECK();
664 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
665 GPU_CLIENT_LOG("[" << GetLogPrefix()
666 << "] glGetFramebufferAttachmentParameteriv("
667 << GLES2Util::GetStringFrameBufferTarget(target) << ", "
668 << GLES2Util::GetStringAttachment(attachment) << ", "
669 << GLES2Util::GetStringFrameBufferParameter(pname) << ", "
670 << static_cast<const void*>(params) << ")");
671 TRACE_EVENT0("gpu",
672 "GLES2Implementation::GetFramebufferAttachmentParameteriv");
673 if (GetFramebufferAttachmentParameterivHelper(
674 target, attachment, pname, params)) {
675 return;
676 }
677 typedef cmds::GetFramebufferAttachmentParameteriv::Result Result;
678 Result* result = GetResultAs<Result*>();
679 if (!result) {
680 return;
681 }
682 result->SetNumResults(0);
683 helper_->GetFramebufferAttachmentParameteriv(
684 target, attachment, pname, GetResultShmId(), GetResultShmOffset());
685 WaitForCmd();
686 result->CopyResult(params);
687 GPU_CLIENT_LOG_CODE_BLOCK({
688 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
689 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
690 }
691 });
692 CheckGLError();
693 }
GetIntegerv(GLenum pname,GLint * params)694 void GLES2Implementation::GetIntegerv(GLenum pname, GLint* params) {
695 GPU_CLIENT_SINGLE_THREAD_CHECK();
696 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
697 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetIntegerv("
698 << GLES2Util::GetStringGLState(pname) << ", "
699 << static_cast<const void*>(params) << ")");
700 TRACE_EVENT0("gpu", "GLES2Implementation::GetIntegerv");
701 if (GetIntegervHelper(pname, params)) {
702 return;
703 }
704 typedef cmds::GetIntegerv::Result Result;
705 Result* result = GetResultAs<Result*>();
706 if (!result) {
707 return;
708 }
709 result->SetNumResults(0);
710 helper_->GetIntegerv(pname, GetResultShmId(), GetResultShmOffset());
711 WaitForCmd();
712 result->CopyResult(params);
713 GPU_CLIENT_LOG_CODE_BLOCK({
714 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
715 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
716 }
717 });
718 CheckGLError();
719 }
GetProgramiv(GLuint program,GLenum pname,GLint * params)720 void GLES2Implementation::GetProgramiv(GLuint program,
721 GLenum pname,
722 GLint* params) {
723 GPU_CLIENT_SINGLE_THREAD_CHECK();
724 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
725 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetProgramiv(" << program << ", "
726 << GLES2Util::GetStringProgramParameter(pname) << ", "
727 << static_cast<const void*>(params) << ")");
728 TRACE_EVENT0("gpu", "GLES2Implementation::GetProgramiv");
729 if (GetProgramivHelper(program, pname, params)) {
730 return;
731 }
732 typedef cmds::GetProgramiv::Result Result;
733 Result* result = GetResultAs<Result*>();
734 if (!result) {
735 return;
736 }
737 result->SetNumResults(0);
738 helper_->GetProgramiv(program, pname, GetResultShmId(), GetResultShmOffset());
739 WaitForCmd();
740 result->CopyResult(params);
741 GPU_CLIENT_LOG_CODE_BLOCK({
742 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
743 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
744 }
745 });
746 CheckGLError();
747 }
GetProgramInfoLog(GLuint program,GLsizei bufsize,GLsizei * length,char * infolog)748 void GLES2Implementation::GetProgramInfoLog(GLuint program,
749 GLsizei bufsize,
750 GLsizei* length,
751 char* infolog) {
752 GPU_CLIENT_SINGLE_THREAD_CHECK();
753 GPU_CLIENT_VALIDATE_DESTINATION_OPTIONAL_INITALIZATION(GLsizei, length);
754 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetProgramInfoLog"
755 << "(" << program << ", " << bufsize << ", "
756 << static_cast<void*>(length) << ", "
757 << static_cast<void*>(infolog) << ")");
758 helper_->SetBucketSize(kResultBucketId, 0);
759 helper_->GetProgramInfoLog(program, kResultBucketId);
760 std::string str;
761 GLsizei max_size = 0;
762 if (GetBucketAsString(kResultBucketId, &str)) {
763 if (bufsize > 0) {
764 max_size = std::min(static_cast<size_t>(bufsize) - 1, str.size());
765 memcpy(infolog, str.c_str(), max_size);
766 infolog[max_size] = '\0';
767 GPU_CLIENT_LOG("------\n" << infolog << "\n------");
768 }
769 }
770 if (length != NULL) {
771 *length = max_size;
772 }
773 CheckGLError();
774 }
GetRenderbufferParameteriv(GLenum target,GLenum pname,GLint * params)775 void GLES2Implementation::GetRenderbufferParameteriv(GLenum target,
776 GLenum pname,
777 GLint* params) {
778 GPU_CLIENT_SINGLE_THREAD_CHECK();
779 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
780 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetRenderbufferParameteriv("
781 << GLES2Util::GetStringRenderBufferTarget(target) << ", "
782 << GLES2Util::GetStringRenderBufferParameter(pname) << ", "
783 << static_cast<const void*>(params) << ")");
784 TRACE_EVENT0("gpu", "GLES2Implementation::GetRenderbufferParameteriv");
785 if (GetRenderbufferParameterivHelper(target, pname, params)) {
786 return;
787 }
788 typedef cmds::GetRenderbufferParameteriv::Result Result;
789 Result* result = GetResultAs<Result*>();
790 if (!result) {
791 return;
792 }
793 result->SetNumResults(0);
794 helper_->GetRenderbufferParameteriv(
795 target, pname, GetResultShmId(), GetResultShmOffset());
796 WaitForCmd();
797 result->CopyResult(params);
798 GPU_CLIENT_LOG_CODE_BLOCK({
799 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
800 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
801 }
802 });
803 CheckGLError();
804 }
GetShaderiv(GLuint shader,GLenum pname,GLint * params)805 void GLES2Implementation::GetShaderiv(GLuint shader,
806 GLenum pname,
807 GLint* params) {
808 GPU_CLIENT_SINGLE_THREAD_CHECK();
809 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
810 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetShaderiv(" << shader << ", "
811 << GLES2Util::GetStringShaderParameter(pname) << ", "
812 << static_cast<const void*>(params) << ")");
813 TRACE_EVENT0("gpu", "GLES2Implementation::GetShaderiv");
814 if (GetShaderivHelper(shader, pname, params)) {
815 return;
816 }
817 typedef cmds::GetShaderiv::Result Result;
818 Result* result = GetResultAs<Result*>();
819 if (!result) {
820 return;
821 }
822 result->SetNumResults(0);
823 helper_->GetShaderiv(shader, pname, GetResultShmId(), GetResultShmOffset());
824 WaitForCmd();
825 result->CopyResult(params);
826 GPU_CLIENT_LOG_CODE_BLOCK({
827 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
828 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
829 }
830 });
831 CheckGLError();
832 }
GetShaderInfoLog(GLuint shader,GLsizei bufsize,GLsizei * length,char * infolog)833 void GLES2Implementation::GetShaderInfoLog(GLuint shader,
834 GLsizei bufsize,
835 GLsizei* length,
836 char* infolog) {
837 GPU_CLIENT_SINGLE_THREAD_CHECK();
838 GPU_CLIENT_VALIDATE_DESTINATION_OPTIONAL_INITALIZATION(GLsizei, length);
839 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetShaderInfoLog"
840 << "(" << shader << ", " << bufsize << ", "
841 << static_cast<void*>(length) << ", "
842 << static_cast<void*>(infolog) << ")");
843 helper_->SetBucketSize(kResultBucketId, 0);
844 helper_->GetShaderInfoLog(shader, kResultBucketId);
845 std::string str;
846 GLsizei max_size = 0;
847 if (GetBucketAsString(kResultBucketId, &str)) {
848 if (bufsize > 0) {
849 max_size = std::min(static_cast<size_t>(bufsize) - 1, str.size());
850 memcpy(infolog, str.c_str(), max_size);
851 infolog[max_size] = '\0';
852 GPU_CLIENT_LOG("------\n" << infolog << "\n------");
853 }
854 }
855 if (length != NULL) {
856 *length = max_size;
857 }
858 CheckGLError();
859 }
GetShaderSource(GLuint shader,GLsizei bufsize,GLsizei * length,char * source)860 void GLES2Implementation::GetShaderSource(GLuint shader,
861 GLsizei bufsize,
862 GLsizei* length,
863 char* source) {
864 GPU_CLIENT_SINGLE_THREAD_CHECK();
865 GPU_CLIENT_VALIDATE_DESTINATION_OPTIONAL_INITALIZATION(GLsizei, length);
866 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetShaderSource"
867 << "(" << shader << ", " << bufsize << ", "
868 << static_cast<void*>(length) << ", "
869 << static_cast<void*>(source) << ")");
870 helper_->SetBucketSize(kResultBucketId, 0);
871 helper_->GetShaderSource(shader, kResultBucketId);
872 std::string str;
873 GLsizei max_size = 0;
874 if (GetBucketAsString(kResultBucketId, &str)) {
875 if (bufsize > 0) {
876 max_size = std::min(static_cast<size_t>(bufsize) - 1, str.size());
877 memcpy(source, str.c_str(), max_size);
878 source[max_size] = '\0';
879 GPU_CLIENT_LOG("------\n" << source << "\n------");
880 }
881 }
882 if (length != NULL) {
883 *length = max_size;
884 }
885 CheckGLError();
886 }
GetTexParameterfv(GLenum target,GLenum pname,GLfloat * params)887 void GLES2Implementation::GetTexParameterfv(GLenum target,
888 GLenum pname,
889 GLfloat* params) {
890 GPU_CLIENT_SINGLE_THREAD_CHECK();
891 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetTexParameterfv("
892 << GLES2Util::GetStringGetTexParamTarget(target) << ", "
893 << GLES2Util::GetStringTextureParameter(pname) << ", "
894 << static_cast<const void*>(params) << ")");
895 TRACE_EVENT0("gpu", "GLES2Implementation::GetTexParameterfv");
896 if (GetTexParameterfvHelper(target, pname, params)) {
897 return;
898 }
899 typedef cmds::GetTexParameterfv::Result Result;
900 Result* result = GetResultAs<Result*>();
901 if (!result) {
902 return;
903 }
904 result->SetNumResults(0);
905 helper_->GetTexParameterfv(
906 target, pname, GetResultShmId(), GetResultShmOffset());
907 WaitForCmd();
908 result->CopyResult(params);
909 GPU_CLIENT_LOG_CODE_BLOCK({
910 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
911 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
912 }
913 });
914 CheckGLError();
915 }
GetTexParameteriv(GLenum target,GLenum pname,GLint * params)916 void GLES2Implementation::GetTexParameteriv(GLenum target,
917 GLenum pname,
918 GLint* params) {
919 GPU_CLIENT_SINGLE_THREAD_CHECK();
920 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
921 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetTexParameteriv("
922 << GLES2Util::GetStringGetTexParamTarget(target) << ", "
923 << GLES2Util::GetStringTextureParameter(pname) << ", "
924 << static_cast<const void*>(params) << ")");
925 TRACE_EVENT0("gpu", "GLES2Implementation::GetTexParameteriv");
926 if (GetTexParameterivHelper(target, pname, params)) {
927 return;
928 }
929 typedef cmds::GetTexParameteriv::Result Result;
930 Result* result = GetResultAs<Result*>();
931 if (!result) {
932 return;
933 }
934 result->SetNumResults(0);
935 helper_->GetTexParameteriv(
936 target, pname, GetResultShmId(), GetResultShmOffset());
937 WaitForCmd();
938 result->CopyResult(params);
939 GPU_CLIENT_LOG_CODE_BLOCK({
940 for (int32_t i = 0; i < result->GetNumResults(); ++i) {
941 GPU_CLIENT_LOG(" " << i << ": " << result->GetData()[i]);
942 }
943 });
944 CheckGLError();
945 }
Hint(GLenum target,GLenum mode)946 void GLES2Implementation::Hint(GLenum target, GLenum mode) {
947 GPU_CLIENT_SINGLE_THREAD_CHECK();
948 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glHint("
949 << GLES2Util::GetStringHintTarget(target) << ", "
950 << GLES2Util::GetStringHintMode(mode) << ")");
951 helper_->Hint(target, mode);
952 CheckGLError();
953 }
954
IsBuffer(GLuint buffer)955 GLboolean GLES2Implementation::IsBuffer(GLuint buffer) {
956 GPU_CLIENT_SINGLE_THREAD_CHECK();
957 TRACE_EVENT0("gpu", "GLES2Implementation::IsBuffer");
958 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsBuffer(" << buffer << ")");
959 typedef cmds::IsBuffer::Result Result;
960 Result* result = GetResultAs<Result*>();
961 if (!result) {
962 return GL_FALSE;
963 }
964 *result = 0;
965 helper_->IsBuffer(buffer, GetResultShmId(), GetResultShmOffset());
966 WaitForCmd();
967 GLboolean result_value = *result;
968 GPU_CLIENT_LOG("returned " << result_value);
969 CheckGLError();
970 return result_value;
971 }
972
IsFramebuffer(GLuint framebuffer)973 GLboolean GLES2Implementation::IsFramebuffer(GLuint framebuffer) {
974 GPU_CLIENT_SINGLE_THREAD_CHECK();
975 TRACE_EVENT0("gpu", "GLES2Implementation::IsFramebuffer");
976 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsFramebuffer(" << framebuffer
977 << ")");
978 typedef cmds::IsFramebuffer::Result Result;
979 Result* result = GetResultAs<Result*>();
980 if (!result) {
981 return GL_FALSE;
982 }
983 *result = 0;
984 helper_->IsFramebuffer(framebuffer, GetResultShmId(), GetResultShmOffset());
985 WaitForCmd();
986 GLboolean result_value = *result;
987 GPU_CLIENT_LOG("returned " << result_value);
988 CheckGLError();
989 return result_value;
990 }
991
IsProgram(GLuint program)992 GLboolean GLES2Implementation::IsProgram(GLuint program) {
993 GPU_CLIENT_SINGLE_THREAD_CHECK();
994 TRACE_EVENT0("gpu", "GLES2Implementation::IsProgram");
995 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsProgram(" << program << ")");
996 typedef cmds::IsProgram::Result Result;
997 Result* result = GetResultAs<Result*>();
998 if (!result) {
999 return GL_FALSE;
1000 }
1001 *result = 0;
1002 helper_->IsProgram(program, GetResultShmId(), GetResultShmOffset());
1003 WaitForCmd();
1004 GLboolean result_value = *result;
1005 GPU_CLIENT_LOG("returned " << result_value);
1006 CheckGLError();
1007 return result_value;
1008 }
1009
IsRenderbuffer(GLuint renderbuffer)1010 GLboolean GLES2Implementation::IsRenderbuffer(GLuint renderbuffer) {
1011 GPU_CLIENT_SINGLE_THREAD_CHECK();
1012 TRACE_EVENT0("gpu", "GLES2Implementation::IsRenderbuffer");
1013 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsRenderbuffer(" << renderbuffer
1014 << ")");
1015 typedef cmds::IsRenderbuffer::Result Result;
1016 Result* result = GetResultAs<Result*>();
1017 if (!result) {
1018 return GL_FALSE;
1019 }
1020 *result = 0;
1021 helper_->IsRenderbuffer(renderbuffer, GetResultShmId(), GetResultShmOffset());
1022 WaitForCmd();
1023 GLboolean result_value = *result;
1024 GPU_CLIENT_LOG("returned " << result_value);
1025 CheckGLError();
1026 return result_value;
1027 }
1028
IsShader(GLuint shader)1029 GLboolean GLES2Implementation::IsShader(GLuint shader) {
1030 GPU_CLIENT_SINGLE_THREAD_CHECK();
1031 TRACE_EVENT0("gpu", "GLES2Implementation::IsShader");
1032 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsShader(" << shader << ")");
1033 typedef cmds::IsShader::Result Result;
1034 Result* result = GetResultAs<Result*>();
1035 if (!result) {
1036 return GL_FALSE;
1037 }
1038 *result = 0;
1039 helper_->IsShader(shader, GetResultShmId(), GetResultShmOffset());
1040 WaitForCmd();
1041 GLboolean result_value = *result;
1042 GPU_CLIENT_LOG("returned " << result_value);
1043 CheckGLError();
1044 return result_value;
1045 }
1046
IsTexture(GLuint texture)1047 GLboolean GLES2Implementation::IsTexture(GLuint texture) {
1048 GPU_CLIENT_SINGLE_THREAD_CHECK();
1049 TRACE_EVENT0("gpu", "GLES2Implementation::IsTexture");
1050 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsTexture(" << texture << ")");
1051 typedef cmds::IsTexture::Result Result;
1052 Result* result = GetResultAs<Result*>();
1053 if (!result) {
1054 return GL_FALSE;
1055 }
1056 *result = 0;
1057 helper_->IsTexture(texture, GetResultShmId(), GetResultShmOffset());
1058 WaitForCmd();
1059 GLboolean result_value = *result;
1060 GPU_CLIENT_LOG("returned " << result_value);
1061 CheckGLError();
1062 return result_value;
1063 }
1064
LineWidth(GLfloat width)1065 void GLES2Implementation::LineWidth(GLfloat width) {
1066 GPU_CLIENT_SINGLE_THREAD_CHECK();
1067 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glLineWidth(" << width << ")");
1068 helper_->LineWidth(width);
1069 CheckGLError();
1070 }
1071
PolygonOffset(GLfloat factor,GLfloat units)1072 void GLES2Implementation::PolygonOffset(GLfloat factor, GLfloat units) {
1073 GPU_CLIENT_SINGLE_THREAD_CHECK();
1074 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPolygonOffset(" << factor << ", "
1075 << units << ")");
1076 helper_->PolygonOffset(factor, units);
1077 CheckGLError();
1078 }
1079
ReleaseShaderCompiler()1080 void GLES2Implementation::ReleaseShaderCompiler() {
1081 GPU_CLIENT_SINGLE_THREAD_CHECK();
1082 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glReleaseShaderCompiler("
1083 << ")");
1084 helper_->ReleaseShaderCompiler();
1085 CheckGLError();
1086 }
1087
RenderbufferStorage(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)1088 void GLES2Implementation::RenderbufferStorage(GLenum target,
1089 GLenum internalformat,
1090 GLsizei width,
1091 GLsizei height) {
1092 GPU_CLIENT_SINGLE_THREAD_CHECK();
1093 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glRenderbufferStorage("
1094 << GLES2Util::GetStringRenderBufferTarget(target) << ", "
1095 << GLES2Util::GetStringRenderBufferFormat(internalformat)
1096 << ", " << width << ", " << height << ")");
1097 if (width < 0) {
1098 SetGLError(GL_INVALID_VALUE, "glRenderbufferStorage", "width < 0");
1099 return;
1100 }
1101 if (height < 0) {
1102 SetGLError(GL_INVALID_VALUE, "glRenderbufferStorage", "height < 0");
1103 return;
1104 }
1105 helper_->RenderbufferStorage(target, internalformat, width, height);
1106 CheckGLError();
1107 }
1108
SampleCoverage(GLclampf value,GLboolean invert)1109 void GLES2Implementation::SampleCoverage(GLclampf value, GLboolean invert) {
1110 GPU_CLIENT_SINGLE_THREAD_CHECK();
1111 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glSampleCoverage(" << value << ", "
1112 << GLES2Util::GetStringBool(invert) << ")");
1113 helper_->SampleCoverage(value, invert);
1114 CheckGLError();
1115 }
1116
Scissor(GLint x,GLint y,GLsizei width,GLsizei height)1117 void GLES2Implementation::Scissor(GLint x,
1118 GLint y,
1119 GLsizei width,
1120 GLsizei height) {
1121 GPU_CLIENT_SINGLE_THREAD_CHECK();
1122 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glScissor(" << x << ", " << y
1123 << ", " << width << ", " << height << ")");
1124 if (width < 0) {
1125 SetGLError(GL_INVALID_VALUE, "glScissor", "width < 0");
1126 return;
1127 }
1128 if (height < 0) {
1129 SetGLError(GL_INVALID_VALUE, "glScissor", "height < 0");
1130 return;
1131 }
1132 helper_->Scissor(x, y, width, height);
1133 CheckGLError();
1134 }
1135
StencilFunc(GLenum func,GLint ref,GLuint mask)1136 void GLES2Implementation::StencilFunc(GLenum func, GLint ref, GLuint mask) {
1137 GPU_CLIENT_SINGLE_THREAD_CHECK();
1138 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glStencilFunc("
1139 << GLES2Util::GetStringCmpFunction(func) << ", " << ref
1140 << ", " << mask << ")");
1141 helper_->StencilFunc(func, ref, mask);
1142 CheckGLError();
1143 }
1144
StencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask)1145 void GLES2Implementation::StencilFuncSeparate(GLenum face,
1146 GLenum func,
1147 GLint ref,
1148 GLuint mask) {
1149 GPU_CLIENT_SINGLE_THREAD_CHECK();
1150 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glStencilFuncSeparate("
1151 << GLES2Util::GetStringFaceType(face) << ", "
1152 << GLES2Util::GetStringCmpFunction(func) << ", " << ref
1153 << ", " << mask << ")");
1154 helper_->StencilFuncSeparate(face, func, ref, mask);
1155 CheckGLError();
1156 }
1157
StencilMask(GLuint mask)1158 void GLES2Implementation::StencilMask(GLuint mask) {
1159 GPU_CLIENT_SINGLE_THREAD_CHECK();
1160 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glStencilMask(" << mask << ")");
1161 helper_->StencilMask(mask);
1162 CheckGLError();
1163 }
1164
StencilMaskSeparate(GLenum face,GLuint mask)1165 void GLES2Implementation::StencilMaskSeparate(GLenum face, GLuint mask) {
1166 GPU_CLIENT_SINGLE_THREAD_CHECK();
1167 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glStencilMaskSeparate("
1168 << GLES2Util::GetStringFaceType(face) << ", " << mask
1169 << ")");
1170 helper_->StencilMaskSeparate(face, mask);
1171 CheckGLError();
1172 }
1173
StencilOp(GLenum fail,GLenum zfail,GLenum zpass)1174 void GLES2Implementation::StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
1175 GPU_CLIENT_SINGLE_THREAD_CHECK();
1176 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glStencilOp("
1177 << GLES2Util::GetStringStencilOp(fail) << ", "
1178 << GLES2Util::GetStringStencilOp(zfail) << ", "
1179 << GLES2Util::GetStringStencilOp(zpass) << ")");
1180 helper_->StencilOp(fail, zfail, zpass);
1181 CheckGLError();
1182 }
1183
StencilOpSeparate(GLenum face,GLenum fail,GLenum zfail,GLenum zpass)1184 void GLES2Implementation::StencilOpSeparate(GLenum face,
1185 GLenum fail,
1186 GLenum zfail,
1187 GLenum zpass) {
1188 GPU_CLIENT_SINGLE_THREAD_CHECK();
1189 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glStencilOpSeparate("
1190 << GLES2Util::GetStringFaceType(face) << ", "
1191 << GLES2Util::GetStringStencilOp(fail) << ", "
1192 << GLES2Util::GetStringStencilOp(zfail) << ", "
1193 << GLES2Util::GetStringStencilOp(zpass) << ")");
1194 helper_->StencilOpSeparate(face, fail, zfail, zpass);
1195 CheckGLError();
1196 }
1197
TexParameterf(GLenum target,GLenum pname,GLfloat param)1198 void GLES2Implementation::TexParameterf(GLenum target,
1199 GLenum pname,
1200 GLfloat param) {
1201 GPU_CLIENT_SINGLE_THREAD_CHECK();
1202 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexParameterf("
1203 << GLES2Util::GetStringTextureBindTarget(target) << ", "
1204 << GLES2Util::GetStringTextureParameter(pname) << ", "
1205 << param << ")");
1206 helper_->TexParameterf(target, pname, param);
1207 CheckGLError();
1208 }
1209
TexParameterfv(GLenum target,GLenum pname,const GLfloat * params)1210 void GLES2Implementation::TexParameterfv(GLenum target,
1211 GLenum pname,
1212 const GLfloat* params) {
1213 GPU_CLIENT_SINGLE_THREAD_CHECK();
1214 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexParameterfv("
1215 << GLES2Util::GetStringTextureBindTarget(target) << ", "
1216 << GLES2Util::GetStringTextureParameter(pname) << ", "
1217 << static_cast<const void*>(params) << ")");
1218 GPU_CLIENT_LOG("values: " << params[0]);
1219 helper_->TexParameterfvImmediate(target, pname, params);
1220 CheckGLError();
1221 }
1222
TexParameteri(GLenum target,GLenum pname,GLint param)1223 void GLES2Implementation::TexParameteri(GLenum target,
1224 GLenum pname,
1225 GLint param) {
1226 GPU_CLIENT_SINGLE_THREAD_CHECK();
1227 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexParameteri("
1228 << GLES2Util::GetStringTextureBindTarget(target) << ", "
1229 << GLES2Util::GetStringTextureParameter(pname) << ", "
1230 << param << ")");
1231 helper_->TexParameteri(target, pname, param);
1232 CheckGLError();
1233 }
1234
TexParameteriv(GLenum target,GLenum pname,const GLint * params)1235 void GLES2Implementation::TexParameteriv(GLenum target,
1236 GLenum pname,
1237 const GLint* params) {
1238 GPU_CLIENT_SINGLE_THREAD_CHECK();
1239 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexParameteriv("
1240 << GLES2Util::GetStringTextureBindTarget(target) << ", "
1241 << GLES2Util::GetStringTextureParameter(pname) << ", "
1242 << static_cast<const void*>(params) << ")");
1243 GPU_CLIENT_LOG("values: " << params[0]);
1244 helper_->TexParameterivImmediate(target, pname, params);
1245 CheckGLError();
1246 }
1247
Uniform1f(GLint location,GLfloat x)1248 void GLES2Implementation::Uniform1f(GLint location, GLfloat x) {
1249 GPU_CLIENT_SINGLE_THREAD_CHECK();
1250 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform1f(" << location << ", "
1251 << x << ")");
1252 helper_->Uniform1f(location, x);
1253 CheckGLError();
1254 }
1255
Uniform1fv(GLint location,GLsizei count,const GLfloat * v)1256 void GLES2Implementation::Uniform1fv(GLint location,
1257 GLsizei count,
1258 const GLfloat* v) {
1259 GPU_CLIENT_SINGLE_THREAD_CHECK();
1260 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform1fv(" << location << ", "
1261 << count << ", " << static_cast<const void*>(v) << ")");
1262 GPU_CLIENT_LOG_CODE_BLOCK({
1263 for (GLsizei i = 0; i < count; ++i) {
1264 GPU_CLIENT_LOG(" " << i << ": " << v[0 + i * 1]);
1265 }
1266 });
1267 if (count < 0) {
1268 SetGLError(GL_INVALID_VALUE, "glUniform1fv", "count < 0");
1269 return;
1270 }
1271 helper_->Uniform1fvImmediate(location, count, v);
1272 CheckGLError();
1273 }
1274
Uniform1i(GLint location,GLint x)1275 void GLES2Implementation::Uniform1i(GLint location, GLint x) {
1276 GPU_CLIENT_SINGLE_THREAD_CHECK();
1277 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform1i(" << location << ", "
1278 << x << ")");
1279 helper_->Uniform1i(location, x);
1280 CheckGLError();
1281 }
1282
Uniform1iv(GLint location,GLsizei count,const GLint * v)1283 void GLES2Implementation::Uniform1iv(GLint location,
1284 GLsizei count,
1285 const GLint* v) {
1286 GPU_CLIENT_SINGLE_THREAD_CHECK();
1287 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform1iv(" << location << ", "
1288 << count << ", " << static_cast<const void*>(v) << ")");
1289 GPU_CLIENT_LOG_CODE_BLOCK({
1290 for (GLsizei i = 0; i < count; ++i) {
1291 GPU_CLIENT_LOG(" " << i << ": " << v[0 + i * 1]);
1292 }
1293 });
1294 if (count < 0) {
1295 SetGLError(GL_INVALID_VALUE, "glUniform1iv", "count < 0");
1296 return;
1297 }
1298 helper_->Uniform1ivImmediate(location, count, v);
1299 CheckGLError();
1300 }
1301
Uniform2f(GLint location,GLfloat x,GLfloat y)1302 void GLES2Implementation::Uniform2f(GLint location, GLfloat x, GLfloat y) {
1303 GPU_CLIENT_SINGLE_THREAD_CHECK();
1304 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform2f(" << location << ", "
1305 << x << ", " << y << ")");
1306 helper_->Uniform2f(location, x, y);
1307 CheckGLError();
1308 }
1309
Uniform2fv(GLint location,GLsizei count,const GLfloat * v)1310 void GLES2Implementation::Uniform2fv(GLint location,
1311 GLsizei count,
1312 const GLfloat* v) {
1313 GPU_CLIENT_SINGLE_THREAD_CHECK();
1314 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform2fv(" << location << ", "
1315 << count << ", " << static_cast<const void*>(v) << ")");
1316 GPU_CLIENT_LOG_CODE_BLOCK({
1317 for (GLsizei i = 0; i < count; ++i) {
1318 GPU_CLIENT_LOG(" " << i << ": " << v[0 + i * 2] << ", " << v[1 + i * 2]);
1319 }
1320 });
1321 if (count < 0) {
1322 SetGLError(GL_INVALID_VALUE, "glUniform2fv", "count < 0");
1323 return;
1324 }
1325 helper_->Uniform2fvImmediate(location, count, v);
1326 CheckGLError();
1327 }
1328
Uniform2i(GLint location,GLint x,GLint y)1329 void GLES2Implementation::Uniform2i(GLint location, GLint x, GLint y) {
1330 GPU_CLIENT_SINGLE_THREAD_CHECK();
1331 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform2i(" << location << ", "
1332 << x << ", " << y << ")");
1333 helper_->Uniform2i(location, x, y);
1334 CheckGLError();
1335 }
1336
Uniform2iv(GLint location,GLsizei count,const GLint * v)1337 void GLES2Implementation::Uniform2iv(GLint location,
1338 GLsizei count,
1339 const GLint* v) {
1340 GPU_CLIENT_SINGLE_THREAD_CHECK();
1341 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform2iv(" << location << ", "
1342 << count << ", " << static_cast<const void*>(v) << ")");
1343 GPU_CLIENT_LOG_CODE_BLOCK({
1344 for (GLsizei i = 0; i < count; ++i) {
1345 GPU_CLIENT_LOG(" " << i << ": " << v[0 + i * 2] << ", " << v[1 + i * 2]);
1346 }
1347 });
1348 if (count < 0) {
1349 SetGLError(GL_INVALID_VALUE, "glUniform2iv", "count < 0");
1350 return;
1351 }
1352 helper_->Uniform2ivImmediate(location, count, v);
1353 CheckGLError();
1354 }
1355
Uniform3f(GLint location,GLfloat x,GLfloat y,GLfloat z)1356 void GLES2Implementation::Uniform3f(GLint location,
1357 GLfloat x,
1358 GLfloat y,
1359 GLfloat z) {
1360 GPU_CLIENT_SINGLE_THREAD_CHECK();
1361 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform3f(" << location << ", "
1362 << x << ", " << y << ", " << z << ")");
1363 helper_->Uniform3f(location, x, y, z);
1364 CheckGLError();
1365 }
1366
Uniform3fv(GLint location,GLsizei count,const GLfloat * v)1367 void GLES2Implementation::Uniform3fv(GLint location,
1368 GLsizei count,
1369 const GLfloat* v) {
1370 GPU_CLIENT_SINGLE_THREAD_CHECK();
1371 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform3fv(" << location << ", "
1372 << count << ", " << static_cast<const void*>(v) << ")");
1373 GPU_CLIENT_LOG_CODE_BLOCK({
1374 for (GLsizei i = 0; i < count; ++i) {
1375 GPU_CLIENT_LOG(" " << i << ": " << v[0 + i * 3] << ", " << v[1 + i * 3]
1376 << ", " << v[2 + i * 3]);
1377 }
1378 });
1379 if (count < 0) {
1380 SetGLError(GL_INVALID_VALUE, "glUniform3fv", "count < 0");
1381 return;
1382 }
1383 helper_->Uniform3fvImmediate(location, count, v);
1384 CheckGLError();
1385 }
1386
Uniform3i(GLint location,GLint x,GLint y,GLint z)1387 void GLES2Implementation::Uniform3i(GLint location, GLint x, GLint y, GLint z) {
1388 GPU_CLIENT_SINGLE_THREAD_CHECK();
1389 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform3i(" << location << ", "
1390 << x << ", " << y << ", " << z << ")");
1391 helper_->Uniform3i(location, x, y, z);
1392 CheckGLError();
1393 }
1394
Uniform3iv(GLint location,GLsizei count,const GLint * v)1395 void GLES2Implementation::Uniform3iv(GLint location,
1396 GLsizei count,
1397 const GLint* v) {
1398 GPU_CLIENT_SINGLE_THREAD_CHECK();
1399 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform3iv(" << location << ", "
1400 << count << ", " << static_cast<const void*>(v) << ")");
1401 GPU_CLIENT_LOG_CODE_BLOCK({
1402 for (GLsizei i = 0; i < count; ++i) {
1403 GPU_CLIENT_LOG(" " << i << ": " << v[0 + i * 3] << ", " << v[1 + i * 3]
1404 << ", " << v[2 + i * 3]);
1405 }
1406 });
1407 if (count < 0) {
1408 SetGLError(GL_INVALID_VALUE, "glUniform3iv", "count < 0");
1409 return;
1410 }
1411 helper_->Uniform3ivImmediate(location, count, v);
1412 CheckGLError();
1413 }
1414
Uniform4f(GLint location,GLfloat x,GLfloat y,GLfloat z,GLfloat w)1415 void GLES2Implementation::Uniform4f(GLint location,
1416 GLfloat x,
1417 GLfloat y,
1418 GLfloat z,
1419 GLfloat w) {
1420 GPU_CLIENT_SINGLE_THREAD_CHECK();
1421 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform4f(" << location << ", "
1422 << x << ", " << y << ", " << z << ", " << w << ")");
1423 helper_->Uniform4f(location, x, y, z, w);
1424 CheckGLError();
1425 }
1426
Uniform4fv(GLint location,GLsizei count,const GLfloat * v)1427 void GLES2Implementation::Uniform4fv(GLint location,
1428 GLsizei count,
1429 const GLfloat* v) {
1430 GPU_CLIENT_SINGLE_THREAD_CHECK();
1431 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform4fv(" << location << ", "
1432 << count << ", " << static_cast<const void*>(v) << ")");
1433 GPU_CLIENT_LOG_CODE_BLOCK({
1434 for (GLsizei i = 0; i < count; ++i) {
1435 GPU_CLIENT_LOG(" " << i << ": " << v[0 + i * 4] << ", " << v[1 + i * 4]
1436 << ", " << v[2 + i * 4] << ", " << v[3 + i * 4]);
1437 }
1438 });
1439 if (count < 0) {
1440 SetGLError(GL_INVALID_VALUE, "glUniform4fv", "count < 0");
1441 return;
1442 }
1443 helper_->Uniform4fvImmediate(location, count, v);
1444 CheckGLError();
1445 }
1446
Uniform4i(GLint location,GLint x,GLint y,GLint z,GLint w)1447 void GLES2Implementation::Uniform4i(GLint location,
1448 GLint x,
1449 GLint y,
1450 GLint z,
1451 GLint w) {
1452 GPU_CLIENT_SINGLE_THREAD_CHECK();
1453 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform4i(" << location << ", "
1454 << x << ", " << y << ", " << z << ", " << w << ")");
1455 helper_->Uniform4i(location, x, y, z, w);
1456 CheckGLError();
1457 }
1458
Uniform4iv(GLint location,GLsizei count,const GLint * v)1459 void GLES2Implementation::Uniform4iv(GLint location,
1460 GLsizei count,
1461 const GLint* v) {
1462 GPU_CLIENT_SINGLE_THREAD_CHECK();
1463 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniform4iv(" << location << ", "
1464 << count << ", " << static_cast<const void*>(v) << ")");
1465 GPU_CLIENT_LOG_CODE_BLOCK({
1466 for (GLsizei i = 0; i < count; ++i) {
1467 GPU_CLIENT_LOG(" " << i << ": " << v[0 + i * 4] << ", " << v[1 + i * 4]
1468 << ", " << v[2 + i * 4] << ", " << v[3 + i * 4]);
1469 }
1470 });
1471 if (count < 0) {
1472 SetGLError(GL_INVALID_VALUE, "glUniform4iv", "count < 0");
1473 return;
1474 }
1475 helper_->Uniform4ivImmediate(location, count, v);
1476 CheckGLError();
1477 }
1478
UniformMatrix2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1479 void GLES2Implementation::UniformMatrix2fv(GLint location,
1480 GLsizei count,
1481 GLboolean transpose,
1482 const GLfloat* value) {
1483 GPU_CLIENT_SINGLE_THREAD_CHECK();
1484 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniformMatrix2fv(" << location
1485 << ", " << count << ", "
1486 << GLES2Util::GetStringBool(transpose) << ", "
1487 << static_cast<const void*>(value) << ")");
1488 GPU_CLIENT_LOG_CODE_BLOCK({
1489 for (GLsizei i = 0; i < count; ++i) {
1490 GPU_CLIENT_LOG(" " << i << ": " << value[0 + i * 4] << ", "
1491 << value[1 + i * 4] << ", " << value[2 + i * 4]
1492 << ", " << value[3 + i * 4]);
1493 }
1494 });
1495 if (count < 0) {
1496 SetGLError(GL_INVALID_VALUE, "glUniformMatrix2fv", "count < 0");
1497 return;
1498 }
1499 if (transpose != false) {
1500 SetGLError(
1501 GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose GL_INVALID_VALUE");
1502 return;
1503 }
1504 helper_->UniformMatrix2fvImmediate(location, count, value);
1505 CheckGLError();
1506 }
1507
UniformMatrix3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1508 void GLES2Implementation::UniformMatrix3fv(GLint location,
1509 GLsizei count,
1510 GLboolean transpose,
1511 const GLfloat* value) {
1512 GPU_CLIENT_SINGLE_THREAD_CHECK();
1513 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniformMatrix3fv(" << location
1514 << ", " << count << ", "
1515 << GLES2Util::GetStringBool(transpose) << ", "
1516 << static_cast<const void*>(value) << ")");
1517 GPU_CLIENT_LOG_CODE_BLOCK({
1518 for (GLsizei i = 0; i < count; ++i) {
1519 GPU_CLIENT_LOG(" " << i << ": " << value[0 + i * 9] << ", "
1520 << value[1 + i * 9] << ", " << value[2 + i * 9]
1521 << ", " << value[3 + i * 9] << ", "
1522 << value[4 + i * 9] << ", " << value[5 + i * 9]
1523 << ", " << value[6 + i * 9] << ", "
1524 << value[7 + i * 9] << ", " << value[8 + i * 9]);
1525 }
1526 });
1527 if (count < 0) {
1528 SetGLError(GL_INVALID_VALUE, "glUniformMatrix3fv", "count < 0");
1529 return;
1530 }
1531 if (transpose != false) {
1532 SetGLError(
1533 GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose GL_INVALID_VALUE");
1534 return;
1535 }
1536 helper_->UniformMatrix3fvImmediate(location, count, value);
1537 CheckGLError();
1538 }
1539
UniformMatrix4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)1540 void GLES2Implementation::UniformMatrix4fv(GLint location,
1541 GLsizei count,
1542 GLboolean transpose,
1543 const GLfloat* value) {
1544 GPU_CLIENT_SINGLE_THREAD_CHECK();
1545 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUniformMatrix4fv(" << location
1546 << ", " << count << ", "
1547 << GLES2Util::GetStringBool(transpose) << ", "
1548 << static_cast<const void*>(value) << ")");
1549 GPU_CLIENT_LOG_CODE_BLOCK({
1550 for (GLsizei i = 0; i < count; ++i) {
1551 GPU_CLIENT_LOG(
1552 " " << i << ": " << value[0 + i * 16] << ", " << value[1 + i * 16]
1553 << ", " << value[2 + i * 16] << ", " << value[3 + i * 16] << ", "
1554 << value[4 + i * 16] << ", " << value[5 + i * 16] << ", "
1555 << value[6 + i * 16] << ", " << value[7 + i * 16] << ", "
1556 << value[8 + i * 16] << ", " << value[9 + i * 16] << ", "
1557 << value[10 + i * 16] << ", " << value[11 + i * 16] << ", "
1558 << value[12 + i * 16] << ", " << value[13 + i * 16] << ", "
1559 << value[14 + i * 16] << ", " << value[15 + i * 16]);
1560 }
1561 });
1562 if (count < 0) {
1563 SetGLError(GL_INVALID_VALUE, "glUniformMatrix4fv", "count < 0");
1564 return;
1565 }
1566 if (transpose != false) {
1567 SetGLError(
1568 GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose GL_INVALID_VALUE");
1569 return;
1570 }
1571 helper_->UniformMatrix4fvImmediate(location, count, value);
1572 CheckGLError();
1573 }
1574
UseProgram(GLuint program)1575 void GLES2Implementation::UseProgram(GLuint program) {
1576 GPU_CLIENT_SINGLE_THREAD_CHECK();
1577 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUseProgram(" << program << ")");
1578 if (IsProgramReservedId(program)) {
1579 SetGLError(GL_INVALID_OPERATION, "UseProgram", "program reserved id");
1580 return;
1581 }
1582 if (UseProgramHelper(program)) {
1583 helper_->UseProgram(program);
1584 }
1585 CheckGLError();
1586 }
1587
ValidateProgram(GLuint program)1588 void GLES2Implementation::ValidateProgram(GLuint program) {
1589 GPU_CLIENT_SINGLE_THREAD_CHECK();
1590 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glValidateProgram(" << program
1591 << ")");
1592 helper_->ValidateProgram(program);
1593 CheckGLError();
1594 }
1595
VertexAttrib1f(GLuint indx,GLfloat x)1596 void GLES2Implementation::VertexAttrib1f(GLuint indx, GLfloat x) {
1597 GPU_CLIENT_SINGLE_THREAD_CHECK();
1598 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib1f(" << indx << ", "
1599 << x << ")");
1600 helper_->VertexAttrib1f(indx, x);
1601 CheckGLError();
1602 }
1603
VertexAttrib1fv(GLuint indx,const GLfloat * values)1604 void GLES2Implementation::VertexAttrib1fv(GLuint indx, const GLfloat* values) {
1605 GPU_CLIENT_SINGLE_THREAD_CHECK();
1606 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib1fv(" << indx << ", "
1607 << static_cast<const void*>(values) << ")");
1608 GPU_CLIENT_LOG("values: " << values[0]);
1609 helper_->VertexAttrib1fvImmediate(indx, values);
1610 CheckGLError();
1611 }
1612
VertexAttrib2f(GLuint indx,GLfloat x,GLfloat y)1613 void GLES2Implementation::VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
1614 GPU_CLIENT_SINGLE_THREAD_CHECK();
1615 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib2f(" << indx << ", "
1616 << x << ", " << y << ")");
1617 helper_->VertexAttrib2f(indx, x, y);
1618 CheckGLError();
1619 }
1620
VertexAttrib2fv(GLuint indx,const GLfloat * values)1621 void GLES2Implementation::VertexAttrib2fv(GLuint indx, const GLfloat* values) {
1622 GPU_CLIENT_SINGLE_THREAD_CHECK();
1623 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib2fv(" << indx << ", "
1624 << static_cast<const void*>(values) << ")");
1625 GPU_CLIENT_LOG("values: " << values[0] << ", " << values[1]);
1626 helper_->VertexAttrib2fvImmediate(indx, values);
1627 CheckGLError();
1628 }
1629
VertexAttrib3f(GLuint indx,GLfloat x,GLfloat y,GLfloat z)1630 void GLES2Implementation::VertexAttrib3f(GLuint indx,
1631 GLfloat x,
1632 GLfloat y,
1633 GLfloat z) {
1634 GPU_CLIENT_SINGLE_THREAD_CHECK();
1635 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib3f(" << indx << ", "
1636 << x << ", " << y << ", " << z << ")");
1637 helper_->VertexAttrib3f(indx, x, y, z);
1638 CheckGLError();
1639 }
1640
VertexAttrib3fv(GLuint indx,const GLfloat * values)1641 void GLES2Implementation::VertexAttrib3fv(GLuint indx, const GLfloat* values) {
1642 GPU_CLIENT_SINGLE_THREAD_CHECK();
1643 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib3fv(" << indx << ", "
1644 << static_cast<const void*>(values) << ")");
1645 GPU_CLIENT_LOG("values: " << values[0] << ", " << values[1] << ", "
1646 << values[2]);
1647 helper_->VertexAttrib3fvImmediate(indx, values);
1648 CheckGLError();
1649 }
1650
VertexAttrib4f(GLuint indx,GLfloat x,GLfloat y,GLfloat z,GLfloat w)1651 void GLES2Implementation::VertexAttrib4f(GLuint indx,
1652 GLfloat x,
1653 GLfloat y,
1654 GLfloat z,
1655 GLfloat w) {
1656 GPU_CLIENT_SINGLE_THREAD_CHECK();
1657 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib4f(" << indx << ", "
1658 << x << ", " << y << ", " << z << ", " << w << ")");
1659 helper_->VertexAttrib4f(indx, x, y, z, w);
1660 CheckGLError();
1661 }
1662
VertexAttrib4fv(GLuint indx,const GLfloat * values)1663 void GLES2Implementation::VertexAttrib4fv(GLuint indx, const GLfloat* values) {
1664 GPU_CLIENT_SINGLE_THREAD_CHECK();
1665 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib4fv(" << indx << ", "
1666 << static_cast<const void*>(values) << ")");
1667 GPU_CLIENT_LOG("values: " << values[0] << ", " << values[1] << ", "
1668 << values[2] << ", " << values[3]);
1669 helper_->VertexAttrib4fvImmediate(indx, values);
1670 CheckGLError();
1671 }
1672
Viewport(GLint x,GLint y,GLsizei width,GLsizei height)1673 void GLES2Implementation::Viewport(GLint x,
1674 GLint y,
1675 GLsizei width,
1676 GLsizei height) {
1677 GPU_CLIENT_SINGLE_THREAD_CHECK();
1678 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glViewport(" << x << ", " << y
1679 << ", " << width << ", " << height << ")");
1680 if (width < 0) {
1681 SetGLError(GL_INVALID_VALUE, "glViewport", "width < 0");
1682 return;
1683 }
1684 if (height < 0) {
1685 SetGLError(GL_INVALID_VALUE, "glViewport", "height < 0");
1686 return;
1687 }
1688 helper_->Viewport(x, y, width, height);
1689 CheckGLError();
1690 }
1691
BlitFramebufferCHROMIUM(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)1692 void GLES2Implementation::BlitFramebufferCHROMIUM(GLint srcX0,
1693 GLint srcY0,
1694 GLint srcX1,
1695 GLint srcY1,
1696 GLint dstX0,
1697 GLint dstY0,
1698 GLint dstX1,
1699 GLint dstY1,
1700 GLbitfield mask,
1701 GLenum filter) {
1702 GPU_CLIENT_SINGLE_THREAD_CHECK();
1703 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBlitFramebufferCHROMIUM("
1704 << srcX0 << ", " << srcY0 << ", " << srcX1 << ", " << srcY1
1705 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1 << ", "
1706 << dstY1 << ", " << mask << ", "
1707 << GLES2Util::GetStringBlitFilter(filter) << ")");
1708 helper_->BlitFramebufferCHROMIUM(
1709 srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
1710 CheckGLError();
1711 }
1712
RenderbufferStorageMultisampleCHROMIUM(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)1713 void GLES2Implementation::RenderbufferStorageMultisampleCHROMIUM(
1714 GLenum target,
1715 GLsizei samples,
1716 GLenum internalformat,
1717 GLsizei width,
1718 GLsizei height) {
1719 GPU_CLIENT_SINGLE_THREAD_CHECK();
1720 GPU_CLIENT_LOG(
1721 "[" << GetLogPrefix() << "] glRenderbufferStorageMultisampleCHROMIUM("
1722 << GLES2Util::GetStringRenderBufferTarget(target) << ", " << samples
1723 << ", " << GLES2Util::GetStringRenderBufferFormat(internalformat)
1724 << ", " << width << ", " << height << ")");
1725 if (samples < 0) {
1726 SetGLError(GL_INVALID_VALUE,
1727 "glRenderbufferStorageMultisampleCHROMIUM",
1728 "samples < 0");
1729 return;
1730 }
1731 if (width < 0) {
1732 SetGLError(GL_INVALID_VALUE,
1733 "glRenderbufferStorageMultisampleCHROMIUM",
1734 "width < 0");
1735 return;
1736 }
1737 if (height < 0) {
1738 SetGLError(GL_INVALID_VALUE,
1739 "glRenderbufferStorageMultisampleCHROMIUM",
1740 "height < 0");
1741 return;
1742 }
1743 helper_->RenderbufferStorageMultisampleCHROMIUM(
1744 target, samples, internalformat, width, height);
1745 CheckGLError();
1746 }
1747
RenderbufferStorageMultisampleEXT(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)1748 void GLES2Implementation::RenderbufferStorageMultisampleEXT(
1749 GLenum target,
1750 GLsizei samples,
1751 GLenum internalformat,
1752 GLsizei width,
1753 GLsizei height) {
1754 GPU_CLIENT_SINGLE_THREAD_CHECK();
1755 GPU_CLIENT_LOG(
1756 "[" << GetLogPrefix() << "] glRenderbufferStorageMultisampleEXT("
1757 << GLES2Util::GetStringRenderBufferTarget(target) << ", " << samples
1758 << ", " << GLES2Util::GetStringRenderBufferFormat(internalformat)
1759 << ", " << width << ", " << height << ")");
1760 if (samples < 0) {
1761 SetGLError(
1762 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "samples < 0");
1763 return;
1764 }
1765 if (width < 0) {
1766 SetGLError(
1767 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "width < 0");
1768 return;
1769 }
1770 if (height < 0) {
1771 SetGLError(
1772 GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "height < 0");
1773 return;
1774 }
1775 helper_->RenderbufferStorageMultisampleEXT(
1776 target, samples, internalformat, width, height);
1777 CheckGLError();
1778 }
1779
FramebufferTexture2DMultisampleEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLsizei samples)1780 void GLES2Implementation::FramebufferTexture2DMultisampleEXT(GLenum target,
1781 GLenum attachment,
1782 GLenum textarget,
1783 GLuint texture,
1784 GLint level,
1785 GLsizei samples) {
1786 GPU_CLIENT_SINGLE_THREAD_CHECK();
1787 GPU_CLIENT_LOG("[" << GetLogPrefix()
1788 << "] glFramebufferTexture2DMultisampleEXT("
1789 << GLES2Util::GetStringFrameBufferTarget(target) << ", "
1790 << GLES2Util::GetStringAttachment(attachment) << ", "
1791 << GLES2Util::GetStringTextureTarget(textarget) << ", "
1792 << texture << ", " << level << ", " << samples << ")");
1793 if (level != 0) {
1794 SetGLError(GL_INVALID_VALUE,
1795 "glFramebufferTexture2DMultisampleEXT",
1796 "level GL_INVALID_VALUE");
1797 return;
1798 }
1799 if (samples < 0) {
1800 SetGLError(GL_INVALID_VALUE,
1801 "glFramebufferTexture2DMultisampleEXT",
1802 "samples < 0");
1803 return;
1804 }
1805 helper_->FramebufferTexture2DMultisampleEXT(
1806 target, attachment, textarget, texture, samples);
1807 CheckGLError();
1808 }
1809
TexStorage2DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height)1810 void GLES2Implementation::TexStorage2DEXT(GLenum target,
1811 GLsizei levels,
1812 GLenum internalFormat,
1813 GLsizei width,
1814 GLsizei height) {
1815 GPU_CLIENT_SINGLE_THREAD_CHECK();
1816 GPU_CLIENT_LOG(
1817 "[" << GetLogPrefix() << "] glTexStorage2DEXT("
1818 << GLES2Util::GetStringTextureTarget(target) << ", " << levels << ", "
1819 << GLES2Util::GetStringTextureInternalFormatStorage(internalFormat)
1820 << ", " << width << ", " << height << ")");
1821 if (levels < 0) {
1822 SetGLError(GL_INVALID_VALUE, "glTexStorage2DEXT", "levels < 0");
1823 return;
1824 }
1825 if (width < 0) {
1826 SetGLError(GL_INVALID_VALUE, "glTexStorage2DEXT", "width < 0");
1827 return;
1828 }
1829 if (height < 0) {
1830 SetGLError(GL_INVALID_VALUE, "glTexStorage2DEXT", "height < 0");
1831 return;
1832 }
1833 helper_->TexStorage2DEXT(target, levels, internalFormat, width, height);
1834 CheckGLError();
1835 }
1836
GenQueriesEXT(GLsizei n,GLuint * queries)1837 void GLES2Implementation::GenQueriesEXT(GLsizei n, GLuint* queries) {
1838 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenQueriesEXT(" << n << ", "
1839 << static_cast<const void*>(queries) << ")");
1840 if (n < 0) {
1841 SetGLError(GL_INVALID_VALUE, "glGenQueriesEXT", "n < 0");
1842 return;
1843 }
1844 GPU_CLIENT_SINGLE_THREAD_CHECK();
1845 GetIdHandler(id_namespaces::kQueries)->MakeIds(this, 0, n, queries);
1846 GenQueriesEXTHelper(n, queries);
1847 helper_->GenQueriesEXTImmediate(n, queries);
1848 if (share_group_->bind_generates_resource())
1849 helper_->CommandBufferHelper::Flush();
1850 GPU_CLIENT_LOG_CODE_BLOCK({
1851 for (GLsizei i = 0; i < n; ++i) {
1852 GPU_CLIENT_LOG(" " << i << ": " << queries[i]);
1853 }
1854 });
1855 CheckGLError();
1856 }
1857
DeleteQueriesEXT(GLsizei n,const GLuint * queries)1858 void GLES2Implementation::DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
1859 GPU_CLIENT_SINGLE_THREAD_CHECK();
1860 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteQueriesEXT(" << n << ", "
1861 << static_cast<const void*>(queries) << ")");
1862 GPU_CLIENT_LOG_CODE_BLOCK({
1863 for (GLsizei i = 0; i < n; ++i) {
1864 GPU_CLIENT_LOG(" " << i << ": " << queries[i]);
1865 }
1866 });
1867 GPU_CLIENT_DCHECK_CODE_BLOCK({
1868 for (GLsizei i = 0; i < n; ++i) {
1869 DCHECK(queries[i] != 0);
1870 }
1871 });
1872 if (n < 0) {
1873 SetGLError(GL_INVALID_VALUE, "glDeleteQueriesEXT", "n < 0");
1874 return;
1875 }
1876 DeleteQueriesEXTHelper(n, queries);
1877 CheckGLError();
1878 }
1879
GenVertexArraysOES(GLsizei n,GLuint * arrays)1880 void GLES2Implementation::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1881 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenVertexArraysOES(" << n << ", "
1882 << static_cast<const void*>(arrays) << ")");
1883 if (n < 0) {
1884 SetGLError(GL_INVALID_VALUE, "glGenVertexArraysOES", "n < 0");
1885 return;
1886 }
1887 GPU_CLIENT_SINGLE_THREAD_CHECK();
1888 GetIdHandler(id_namespaces::kVertexArrays)->MakeIds(this, 0, n, arrays);
1889 GenVertexArraysOESHelper(n, arrays);
1890 helper_->GenVertexArraysOESImmediate(n, arrays);
1891 if (share_group_->bind_generates_resource())
1892 helper_->CommandBufferHelper::Flush();
1893 GPU_CLIENT_LOG_CODE_BLOCK({
1894 for (GLsizei i = 0; i < n; ++i) {
1895 GPU_CLIENT_LOG(" " << i << ": " << arrays[i]);
1896 }
1897 });
1898 CheckGLError();
1899 }
1900
DeleteVertexArraysOES(GLsizei n,const GLuint * arrays)1901 void GLES2Implementation::DeleteVertexArraysOES(GLsizei n,
1902 const GLuint* arrays) {
1903 GPU_CLIENT_SINGLE_THREAD_CHECK();
1904 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteVertexArraysOES(" << n
1905 << ", " << static_cast<const void*>(arrays) << ")");
1906 GPU_CLIENT_LOG_CODE_BLOCK({
1907 for (GLsizei i = 0; i < n; ++i) {
1908 GPU_CLIENT_LOG(" " << i << ": " << arrays[i]);
1909 }
1910 });
1911 GPU_CLIENT_DCHECK_CODE_BLOCK({
1912 for (GLsizei i = 0; i < n; ++i) {
1913 DCHECK(arrays[i] != 0);
1914 }
1915 });
1916 if (n < 0) {
1917 SetGLError(GL_INVALID_VALUE, "glDeleteVertexArraysOES", "n < 0");
1918 return;
1919 }
1920 DeleteVertexArraysOESHelper(n, arrays);
1921 CheckGLError();
1922 }
1923
IsVertexArrayOES(GLuint array)1924 GLboolean GLES2Implementation::IsVertexArrayOES(GLuint array) {
1925 GPU_CLIENT_SINGLE_THREAD_CHECK();
1926 TRACE_EVENT0("gpu", "GLES2Implementation::IsVertexArrayOES");
1927 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsVertexArrayOES(" << array
1928 << ")");
1929 typedef cmds::IsVertexArrayOES::Result Result;
1930 Result* result = GetResultAs<Result*>();
1931 if (!result) {
1932 return GL_FALSE;
1933 }
1934 *result = 0;
1935 helper_->IsVertexArrayOES(array, GetResultShmId(), GetResultShmOffset());
1936 WaitForCmd();
1937 GLboolean result_value = *result;
1938 GPU_CLIENT_LOG("returned " << result_value);
1939 CheckGLError();
1940 return result_value;
1941 }
1942
BindVertexArrayOES(GLuint array)1943 void GLES2Implementation::BindVertexArrayOES(GLuint array) {
1944 GPU_CLIENT_SINGLE_THREAD_CHECK();
1945 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindVertexArrayOES(" << array
1946 << ")");
1947 if (IsVertexArrayReservedId(array)) {
1948 SetGLError(GL_INVALID_OPERATION, "BindVertexArrayOES", "array reserved id");
1949 return;
1950 }
1951 if (BindVertexArrayOESHelper(array)) {
1952 helper_->BindVertexArrayOES(array);
1953 }
1954 CheckGLError();
1955 }
1956
GetTranslatedShaderSourceANGLE(GLuint shader,GLsizei bufsize,GLsizei * length,char * source)1957 void GLES2Implementation::GetTranslatedShaderSourceANGLE(GLuint shader,
1958 GLsizei bufsize,
1959 GLsizei* length,
1960 char* source) {
1961 GPU_CLIENT_SINGLE_THREAD_CHECK();
1962 GPU_CLIENT_VALIDATE_DESTINATION_OPTIONAL_INITALIZATION(GLsizei, length);
1963 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetTranslatedShaderSourceANGLE"
1964 << "(" << shader << ", " << bufsize << ", "
1965 << static_cast<void*>(length) << ", "
1966 << static_cast<void*>(source) << ")");
1967 helper_->SetBucketSize(kResultBucketId, 0);
1968 helper_->GetTranslatedShaderSourceANGLE(shader, kResultBucketId);
1969 std::string str;
1970 GLsizei max_size = 0;
1971 if (GetBucketAsString(kResultBucketId, &str)) {
1972 if (bufsize > 0) {
1973 max_size = std::min(static_cast<size_t>(bufsize) - 1, str.size());
1974 memcpy(source, str.c_str(), max_size);
1975 source[max_size] = '\0';
1976 GPU_CLIENT_LOG("------\n" << source << "\n------");
1977 }
1978 }
1979 if (length != NULL) {
1980 *length = max_size;
1981 }
1982 CheckGLError();
1983 }
TexImageIOSurface2DCHROMIUM(GLenum target,GLsizei width,GLsizei height,GLuint ioSurfaceId,GLuint plane)1984 void GLES2Implementation::TexImageIOSurface2DCHROMIUM(GLenum target,
1985 GLsizei width,
1986 GLsizei height,
1987 GLuint ioSurfaceId,
1988 GLuint plane) {
1989 GPU_CLIENT_SINGLE_THREAD_CHECK();
1990 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImageIOSurface2DCHROMIUM("
1991 << GLES2Util::GetStringTextureBindTarget(target) << ", "
1992 << width << ", " << height << ", " << ioSurfaceId << ", "
1993 << plane << ")");
1994 if (width < 0) {
1995 SetGLError(GL_INVALID_VALUE, "glTexImageIOSurface2DCHROMIUM", "width < 0");
1996 return;
1997 }
1998 if (height < 0) {
1999 SetGLError(GL_INVALID_VALUE, "glTexImageIOSurface2DCHROMIUM", "height < 0");
2000 return;
2001 }
2002 helper_->TexImageIOSurface2DCHROMIUM(
2003 target, width, height, ioSurfaceId, plane);
2004 CheckGLError();
2005 }
2006
CopyTextureCHROMIUM(GLenum target,GLenum source_id,GLenum dest_id,GLint level,GLint internalformat,GLenum dest_type)2007 void GLES2Implementation::CopyTextureCHROMIUM(GLenum target,
2008 GLenum source_id,
2009 GLenum dest_id,
2010 GLint level,
2011 GLint internalformat,
2012 GLenum dest_type) {
2013 GPU_CLIENT_SINGLE_THREAD_CHECK();
2014 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCopyTextureCHROMIUM("
2015 << GLES2Util::GetStringEnum(target) << ", "
2016 << GLES2Util::GetStringEnum(source_id) << ", "
2017 << GLES2Util::GetStringEnum(dest_id) << ", " << level
2018 << ", " << internalformat << ", "
2019 << GLES2Util::GetStringPixelType(dest_type) << ")");
2020 helper_->CopyTextureCHROMIUM(
2021 target, source_id, dest_id, level, internalformat, dest_type);
2022 CheckGLError();
2023 }
2024
BindTexImage2DCHROMIUM(GLenum target,GLint imageId)2025 void GLES2Implementation::BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
2026 GPU_CLIENT_SINGLE_THREAD_CHECK();
2027 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindTexImage2DCHROMIUM("
2028 << GLES2Util::GetStringTextureBindTarget(target) << ", "
2029 << imageId << ")");
2030 helper_->BindTexImage2DCHROMIUM(target, imageId);
2031 CheckGLError();
2032 }
2033
ReleaseTexImage2DCHROMIUM(GLenum target,GLint imageId)2034 void GLES2Implementation::ReleaseTexImage2DCHROMIUM(GLenum target,
2035 GLint imageId) {
2036 GPU_CLIENT_SINGLE_THREAD_CHECK();
2037 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glReleaseTexImage2DCHROMIUM("
2038 << GLES2Util::GetStringTextureBindTarget(target) << ", "
2039 << imageId << ")");
2040 helper_->ReleaseTexImage2DCHROMIUM(target, imageId);
2041 CheckGLError();
2042 }
2043
DiscardFramebufferEXT(GLenum target,GLsizei count,const GLenum * attachments)2044 void GLES2Implementation::DiscardFramebufferEXT(GLenum target,
2045 GLsizei count,
2046 const GLenum* attachments) {
2047 GPU_CLIENT_SINGLE_THREAD_CHECK();
2048 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDiscardFramebufferEXT("
2049 << GLES2Util::GetStringEnum(target) << ", " << count
2050 << ", " << static_cast<const void*>(attachments) << ")");
2051 GPU_CLIENT_LOG_CODE_BLOCK({
2052 for (GLsizei i = 0; i < count; ++i) {
2053 GPU_CLIENT_LOG(" " << i << ": " << attachments[0 + i * 1]);
2054 }
2055 });
2056 if (count < 0) {
2057 SetGLError(GL_INVALID_VALUE, "glDiscardFramebufferEXT", "count < 0");
2058 return;
2059 }
2060 helper_->DiscardFramebufferEXTImmediate(target, count, attachments);
2061 CheckGLError();
2062 }
2063
LoseContextCHROMIUM(GLenum current,GLenum other)2064 void GLES2Implementation::LoseContextCHROMIUM(GLenum current, GLenum other) {
2065 GPU_CLIENT_SINGLE_THREAD_CHECK();
2066 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glLoseContextCHROMIUM("
2067 << GLES2Util::GetStringResetStatus(current) << ", "
2068 << GLES2Util::GetStringResetStatus(other) << ")");
2069 helper_->LoseContextCHROMIUM(current, other);
2070 CheckGLError();
2071 }
2072
WaitSyncPointCHROMIUM(GLuint sync_point)2073 void GLES2Implementation::WaitSyncPointCHROMIUM(GLuint sync_point) {
2074 GPU_CLIENT_SINGLE_THREAD_CHECK();
2075 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glWaitSyncPointCHROMIUM("
2076 << sync_point << ")");
2077 helper_->WaitSyncPointCHROMIUM(sync_point);
2078 CheckGLError();
2079 }
2080
DrawBuffersEXT(GLsizei count,const GLenum * bufs)2081 void GLES2Implementation::DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
2082 GPU_CLIENT_SINGLE_THREAD_CHECK();
2083 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDrawBuffersEXT(" << count << ", "
2084 << static_cast<const void*>(bufs) << ")");
2085 GPU_CLIENT_LOG_CODE_BLOCK({
2086 for (GLsizei i = 0; i < count; ++i) {
2087 GPU_CLIENT_LOG(" " << i << ": " << bufs[0 + i * 1]);
2088 }
2089 });
2090 if (count < 0) {
2091 SetGLError(GL_INVALID_VALUE, "glDrawBuffersEXT", "count < 0");
2092 return;
2093 }
2094 helper_->DrawBuffersEXTImmediate(count, bufs);
2095 CheckGLError();
2096 }
2097
DiscardBackbufferCHROMIUM()2098 void GLES2Implementation::DiscardBackbufferCHROMIUM() {
2099 GPU_CLIENT_SINGLE_THREAD_CHECK();
2100 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDiscardBackbufferCHROMIUM("
2101 << ")");
2102 helper_->DiscardBackbufferCHROMIUM();
2103 CheckGLError();
2104 }
2105
ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,GLenum plane_transform,GLuint overlay_texture_id,GLint bounds_x,GLint bounds_y,GLint bounds_width,GLint bounds_height,GLfloat uv_x,GLfloat uv_y,GLfloat uv_width,GLfloat uv_height)2106 void GLES2Implementation::ScheduleOverlayPlaneCHROMIUM(
2107 GLint plane_z_order,
2108 GLenum plane_transform,
2109 GLuint overlay_texture_id,
2110 GLint bounds_x,
2111 GLint bounds_y,
2112 GLint bounds_width,
2113 GLint bounds_height,
2114 GLfloat uv_x,
2115 GLfloat uv_y,
2116 GLfloat uv_width,
2117 GLfloat uv_height) {
2118 GPU_CLIENT_SINGLE_THREAD_CHECK();
2119 GPU_CLIENT_LOG(
2120 "[" << GetLogPrefix() << "] glScheduleOverlayPlaneCHROMIUM("
2121 << plane_z_order << ", " << GLES2Util::GetStringEnum(plane_transform)
2122 << ", " << overlay_texture_id << ", " << bounds_x << ", " << bounds_y
2123 << ", " << bounds_width << ", " << bounds_height << ", " << uv_x
2124 << ", " << uv_y << ", " << uv_width << ", " << uv_height << ")");
2125 helper_->ScheduleOverlayPlaneCHROMIUM(plane_z_order,
2126 plane_transform,
2127 overlay_texture_id,
2128 bounds_x,
2129 bounds_y,
2130 bounds_width,
2131 bounds_height,
2132 uv_x,
2133 uv_y,
2134 uv_width,
2135 uv_height);
2136 CheckGLError();
2137 }
2138
2139 #endif // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_IMPL_AUTOGEN_H_
2140