OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // A class to emulate GLES2 over command buffers. | 5 // A class to emulate GLES2 over command buffers. |
6 | 6 |
7 #include "../client/gles2_implementation.h" | 7 #include "../client/gles2_implementation.h" |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 #include <map> | 10 #include <map> |
11 #include <queue> | 11 #include <queue> |
12 #include <set> | 12 #include <set> |
13 #include <limits> | 13 #include <limits> |
14 #include <stdio.h> | 14 #include <stdio.h> |
15 #include <string.h> | 15 #include <string.h> |
16 #include <GLES2/gl2ext.h> | 16 #include <GLES2/gl2ext.h> |
17 #include <GLES2/gl2extchromium.h> | 17 #include <GLES2/gl2extchromium.h> |
18 #include "../client/buffer_tracker.h" | 18 #include "../client/buffer_tracker.h" |
19 #include "../client/gpu_memory_buffer.h" | |
20 #include "../client/gpu_memory_buffer_factory.h" | |
21 #include "../client/gpu_memory_buffer_tracker.h" | |
19 #include "../client/mapped_memory.h" | 22 #include "../client/mapped_memory.h" |
20 #include "../client/program_info_manager.h" | 23 #include "../client/program_info_manager.h" |
21 #include "../client/query_tracker.h" | 24 #include "../client/query_tracker.h" |
22 #include "../client/transfer_buffer.h" | 25 #include "../client/transfer_buffer.h" |
23 #include "../client/vertex_array_object_manager.h" | 26 #include "../client/vertex_array_object_manager.h" |
24 #include "../common/gles2_cmd_utils.h" | 27 #include "../common/gles2_cmd_utils.h" |
25 #include "../common/trace_event.h" | 28 #include "../common/trace_event.h" |
26 | 29 |
27 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS) | 30 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS) |
28 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS | 31 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
91 unpack_skip_pixels_(0), | 94 unpack_skip_pixels_(0), |
92 pack_reverse_row_order_(false), | 95 pack_reverse_row_order_(false), |
93 active_texture_unit_(0), | 96 active_texture_unit_(0), |
94 bound_framebuffer_(0), | 97 bound_framebuffer_(0), |
95 bound_read_framebuffer_(0), | 98 bound_read_framebuffer_(0), |
96 bound_renderbuffer_(0), | 99 bound_renderbuffer_(0), |
97 current_program_(0), | 100 current_program_(0), |
98 bound_array_buffer_id_(0), | 101 bound_array_buffer_id_(0), |
99 bound_pixel_pack_transfer_buffer_id_(0), | 102 bound_pixel_pack_transfer_buffer_id_(0), |
100 bound_pixel_unpack_transfer_buffer_id_(0), | 103 bound_pixel_unpack_transfer_buffer_id_(0), |
104 bound_gpu_memory_buffer_id_(0), | |
101 error_bits_(0), | 105 error_bits_(0), |
102 debug_(false), | 106 debug_(false), |
103 use_count_(0), | 107 use_count_(0), |
104 current_query_(NULL), | 108 current_query_(NULL), |
105 error_message_callback_(NULL) { | 109 error_message_callback_(NULL) { |
106 GPU_DCHECK(helper); | 110 GPU_DCHECK(helper); |
107 GPU_DCHECK(transfer_buffer); | 111 GPU_DCHECK(transfer_buffer); |
108 | 112 |
109 char temp[128]; | 113 char temp[128]; |
110 sprintf(temp, "%p", static_cast<void*>(this)); | 114 sprintf(temp, "%p", static_cast<void*>(this)); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
166 static_state_.int_state.num_compressed_texture_formats); | 170 static_state_.int_state.num_compressed_texture_formats); |
167 util_.set_num_shader_binary_formats( | 171 util_.set_num_shader_binary_formats( |
168 static_state_.int_state.num_shader_binary_formats); | 172 static_state_.int_state.num_shader_binary_formats); |
169 | 173 |
170 texture_units_.reset( | 174 texture_units_.reset( |
171 new TextureUnit[ | 175 new TextureUnit[ |
172 static_state_.int_state.max_combined_texture_image_units]); | 176 static_state_.int_state.max_combined_texture_image_units]); |
173 | 177 |
174 query_tracker_.reset(new QueryTracker(mapped_memory_.get())); | 178 query_tracker_.reset(new QueryTracker(mapped_memory_.get())); |
175 buffer_tracker_.reset(new BufferTracker(mapped_memory_.get())); | 179 buffer_tracker_.reset(new BufferTracker(mapped_memory_.get())); |
180 gpu_memory_buffer_tracker_.reset(new GpuMemoryBufferTracker()); | |
176 | 181 |
177 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS) | 182 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS) |
178 GetIdHandler(id_namespaces::kBuffers)->MakeIds( | 183 GetIdHandler(id_namespaces::kBuffers)->MakeIds( |
179 this, kClientSideArrayId, arraysize(reserved_ids_), &reserved_ids_[0]); | 184 this, kClientSideArrayId, arraysize(reserved_ids_), &reserved_ids_[0]); |
180 #endif | 185 #endif |
181 | 186 |
182 vertex_array_object_manager_.reset(new VertexArrayObjectManager( | 187 vertex_array_object_manager_.reset(new VertexArrayObjectManager( |
183 static_state_.int_state.max_vertex_attribs, | 188 static_state_.int_state.max_vertex_attribs, |
184 reserved_ids_[0], | 189 reserved_ids_[0], |
185 reserved_ids_[1])); | 190 reserved_ids_[1])); |
(...skipping 437 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
623 *params = bound_read_framebuffer_; | 628 *params = bound_read_framebuffer_; |
624 return true; | 629 return true; |
625 } | 630 } |
626 return false; | 631 return false; |
627 case GL_RENDERBUFFER_BINDING: | 632 case GL_RENDERBUFFER_BINDING: |
628 if (share_group_->bind_generates_resource()) { | 633 if (share_group_->bind_generates_resource()) { |
629 *params = bound_renderbuffer_; | 634 *params = bound_renderbuffer_; |
630 return true; | 635 return true; |
631 } | 636 } |
632 return false; | 637 return false; |
638 case GL_IMAGE_BUFFER_BINDING_CHROMIUM: | |
639 *params = bound_gpu_memory_buffer_id_; | |
640 return true; | |
633 default: | 641 default: |
634 return false; | 642 return false; |
635 } | 643 } |
636 } | 644 } |
637 | 645 |
638 bool GLES2Implementation::GetBooleanvHelper(GLenum pname, GLboolean* params) { | 646 bool GLES2Implementation::GetBooleanvHelper(GLenum pname, GLboolean* params) { |
639 // TODO(gman): Make this handle pnames that return more than 1 value. | 647 // TODO(gman): Make this handle pnames that return more than 1 value. |
640 GLint value; | 648 GLint value; |
641 if (!GetHelper(pname, &value)) { | 649 if (!GetHelper(pname, &value)) { |
642 return false; | 650 return false; |
(...skipping 595 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1238 } | 1246 } |
1239 } | 1247 } |
1240 | 1248 |
1241 GPU_DCHECK_EQ(total_size, offset); | 1249 GPU_DCHECK_EQ(total_size, offset); |
1242 | 1250 |
1243 helper_->ShaderSourceBucket(shader, kResultBucketId); | 1251 helper_->ShaderSourceBucket(shader, kResultBucketId); |
1244 helper_->SetBucketSize(kResultBucketId, 0); | 1252 helper_->SetBucketSize(kResultBucketId, 0); |
1245 CheckGLError(); | 1253 CheckGLError(); |
1246 } | 1254 } |
1247 | 1255 |
1256 bool GLES2Implementation::GetBoundGpuMemoryBuffer( | |
1257 const char* function_name, GLuint* buffer_id) { | |
1258 *buffer_id = bound_gpu_memory_buffer_id_; | |
1259 | |
1260 if (*buffer_id == 0) { | |
1261 SetGLError(GL_INVALID_OPERATION, function_name, "no buffer bound"); | |
greggman
2013/04/29 19:58:33
This function returns only ever returns 'true'. Sh
kaanb
2013/04/30 03:40:10
Done.
| |
1262 } | |
1263 | |
1264 return true; | |
1265 } | |
1266 | |
1248 void GLES2Implementation::BufferDataHelper( | 1267 void GLES2Implementation::BufferDataHelper( |
1249 GLenum target, GLsizeiptr size, const void* data, GLenum usage) { | 1268 GLenum target, GLsizeiptr size, const void* data, GLenum usage) { |
1250 if (size < 0) { | 1269 if (size < 0) { |
1251 SetGLError(GL_INVALID_VALUE, "glBufferData", "size < 0"); | 1270 SetGLError(GL_INVALID_VALUE, "glBufferData", "size < 0"); |
1252 return; | 1271 return; |
1253 } | 1272 } |
1254 | 1273 |
1255 GLuint buffer_id; | 1274 GLuint buffer_id; |
1256 if (GetBoundPixelTransferBuffer(target, "glBufferData", &buffer_id)) { | 1275 if (GetBoundPixelTransferBuffer(target, "glBufferData", &buffer_id)) { |
1257 if (!buffer_id) { | 1276 if (!buffer_id) { |
(...skipping 764 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2022 std::string str; | 2041 std::string str; |
2023 if (GetBucketAsString(kResultBucketId, &str)) { | 2042 if (GetBucketAsString(kResultBucketId, &str)) { |
2024 // Adds extensions implemented on client side only. | 2043 // Adds extensions implemented on client side only. |
2025 switch (name) { | 2044 switch (name) { |
2026 case GL_EXTENSIONS: | 2045 case GL_EXTENSIONS: |
2027 str += std::string(str.empty() ? "" : " ") + | 2046 str += std::string(str.empty() ? "" : " ") + |
2028 "GL_CHROMIUM_flipy " | 2047 "GL_CHROMIUM_flipy " |
2029 "GL_CHROMIUM_map_sub " | 2048 "GL_CHROMIUM_map_sub " |
2030 "GL_CHROMIUM_shallow_flush " | 2049 "GL_CHROMIUM_shallow_flush " |
2031 "GL_EXT_unpack_subimage"; | 2050 "GL_EXT_unpack_subimage"; |
2051 if (!GetProcessDefaultGpuMemoryBufferFactory().is_null()) { | |
2052 str += " "; | |
greggman
2013/04/29 19:58:33
Sadly this probably has to be the same as above, o
kaanb
2013/04/30 03:40:10
Here str is guaranteed to be non-empty though. We
| |
2053 str += "GL_CHROMIUM_gpu_memory_buffer"; | |
2054 } | |
2032 break; | 2055 break; |
2033 default: | 2056 default: |
2034 break; | 2057 break; |
2035 } | 2058 } |
2036 | 2059 |
2037 // Because of WebGL the extensions can change. We have to cache each unique | 2060 // Because of WebGL the extensions can change. We have to cache each unique |
2038 // result since we don't know when the client will stop referring to a | 2061 // result since we don't know when the client will stop referring to a |
2039 // previous one it queries. | 2062 // previous one it queries. |
2040 GLStringMap::iterator it = gl_strings_.find(name); | 2063 GLStringMap::iterator it = gl_strings_.find(name); |
2041 if (it == gl_strings_.end()) { | 2064 if (it == gl_strings_.end()) { |
(...skipping 252 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2294 break; | 2317 break; |
2295 case GL_ELEMENT_ARRAY_BUFFER: | 2318 case GL_ELEMENT_ARRAY_BUFFER: |
2296 changed = vertex_array_object_manager_->BindElementArray(buffer); | 2319 changed = vertex_array_object_manager_->BindElementArray(buffer); |
2297 break; | 2320 break; |
2298 case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM: | 2321 case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM: |
2299 bound_pixel_pack_transfer_buffer_id_ = buffer; | 2322 bound_pixel_pack_transfer_buffer_id_ = buffer; |
2300 break; | 2323 break; |
2301 case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: | 2324 case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: |
2302 bound_pixel_unpack_transfer_buffer_id_ = buffer; | 2325 bound_pixel_unpack_transfer_buffer_id_ = buffer; |
2303 break; | 2326 break; |
2327 case GL_IMAGE_BUFFER_CHROMIUM: | |
2328 bound_gpu_memory_buffer_id_ = buffer; | |
2329 break; | |
2304 default: | 2330 default: |
2305 changed = true; | 2331 changed = true; |
2306 break; | 2332 break; |
2307 } | 2333 } |
2308 // TODO(gman): There's a bug here. If the target is invalid the ID will not be | 2334 // TODO(gman): There's a bug here. If the target is invalid the ID will not be |
2309 // used even though it's marked it as used here. | 2335 // used even though it's marked it as used here. |
2310 GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(buffer); | 2336 GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(buffer); |
2311 return changed; | 2337 return changed; |
2312 } | 2338 } |
2313 | 2339 |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2438 BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffers[ii]); | 2464 BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffers[ii]); |
2439 if (buffer) { | 2465 if (buffer) { |
2440 // Free buffer memory, pending the passage of a token. | 2466 // Free buffer memory, pending the passage of a token. |
2441 buffer_tracker_->FreePendingToken(buffer, helper_->InsertToken()); | 2467 buffer_tracker_->FreePendingToken(buffer, helper_->InsertToken()); |
2442 // Remove buffer. | 2468 // Remove buffer. |
2443 buffer_tracker_->RemoveBuffer(buffers[ii]); | 2469 buffer_tracker_->RemoveBuffer(buffers[ii]); |
2444 } | 2470 } |
2445 if (buffers[ii] == bound_pixel_unpack_transfer_buffer_id_) { | 2471 if (buffers[ii] == bound_pixel_unpack_transfer_buffer_id_) { |
2446 bound_pixel_unpack_transfer_buffer_id_ = 0; | 2472 bound_pixel_unpack_transfer_buffer_id_ = 0; |
2447 } | 2473 } |
2474 if (buffers[ii] == bound_gpu_memory_buffer_id_) { | |
2475 bound_gpu_memory_buffer_id_ = 0; | |
2476 } | |
2477 GpuMemoryBuffer* gpu_buffer = | |
2478 gpu_memory_buffer_tracker_->GetBuffer(buffers[ii]); | |
2479 if (gpu_buffer) { | |
2480 gpu_memory_buffer_tracker_->RemoveBuffer(buffers[ii]); | |
2481 } | |
2448 } | 2482 } |
2449 } | 2483 } |
2450 | 2484 |
2451 void GLES2Implementation::DeleteBuffersStub( | 2485 void GLES2Implementation::DeleteBuffersStub( |
2452 GLsizei n, const GLuint* buffers) { | 2486 GLsizei n, const GLuint* buffers) { |
2453 helper_->DeleteBuffersImmediate(n, buffers); | 2487 helper_->DeleteBuffersImmediate(n, buffers); |
2454 } | 2488 } |
2455 | 2489 |
2456 | 2490 |
2457 void GLES2Implementation::DeleteFramebuffersHelper( | 2491 void GLES2Implementation::DeleteFramebuffersHelper( |
(...skipping 925 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3383 SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode"); | 3417 SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode"); |
3384 return NULL; | 3418 return NULL; |
3385 } | 3419 } |
3386 break; | 3420 break; |
3387 case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: | 3421 case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: |
3388 if (access != GL_WRITE_ONLY) { | 3422 if (access != GL_WRITE_ONLY) { |
3389 SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode"); | 3423 SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode"); |
3390 return NULL; | 3424 return NULL; |
3391 } | 3425 } |
3392 break; | 3426 break; |
3427 case GL_IMAGE_BUFFER_CHROMIUM: | |
3428 break; | |
3393 default: | 3429 default: |
3430 // TODO(kaanb): Do we need matching CheckGLError() calls for these? | |
greggman
2013/04/29 19:58:33
no I don't think you do. CheckGLError is for debug
kaanb
2013/04/30 03:40:10
Done.
| |
3394 SetGLError( | 3431 SetGLError( |
3395 GL_INVALID_ENUM, "glMapBufferCHROMIUM", "invalid target"); | 3432 GL_INVALID_ENUM, "glMapBufferCHROMIUM", "invalid target"); |
3396 return NULL; | 3433 return NULL; |
3397 } | 3434 } |
3435 | |
3398 GLuint buffer_id; | 3436 GLuint buffer_id; |
3399 GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id); | 3437 switch(target) { |
3400 if (!buffer_id) { | 3438 case GL_IMAGE_BUFFER_CHROMIUM: { |
3401 return NULL; | 3439 GetBoundGpuMemoryBuffer("glMapBufferCHROMIUM", &buffer_id); |
3440 if (buffer_id == 0) { | |
3441 return NULL; | |
3442 } | |
3443 GpuMemoryBuffer* gpu_buffer = | |
3444 gpu_memory_buffer_tracker_->GetBuffer(buffer_id); | |
3445 if (!gpu_buffer) { | |
3446 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", | |
3447 "invalid GPU memory buffer"); | |
3448 return NULL; | |
3449 } | |
3450 GpuMemoryBuffer::AccessMode mode = GpuMemoryBuffer::READ_ONLY; | |
3451 switch(access) { | |
3452 case GL_WRITE_ONLY: | |
3453 mode = GpuMemoryBuffer::WRITE_ONLY; | |
3454 break; | |
3455 case GL_READ_ONLY: | |
3456 mode = GpuMemoryBuffer::READ_ONLY; | |
3457 break; | |
3458 // TODO(kaanb): should we add GL_READ_WRITE to gl2ext.h? | |
3459 default: | |
3460 SetGLError( | |
3461 GL_INVALID_ENUM, "glMapBufferCHROMIUM", | |
3462 "invalid GPU access mode"); | |
3463 return NULL; | |
3464 } | |
3465 | |
3466 if (gpu_buffer->IsMapped()) { | |
3467 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", | |
3468 "already mapped"); | |
3469 return NULL; | |
3470 } | |
3471 | |
3472 void* mapped_buffer = NULL; | |
3473 gpu_buffer->Map(mode, &mapped_buffer); | |
3474 CheckGLError(); | |
3475 return mapped_buffer; | |
3476 } | |
3477 case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM: | |
3478 case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: { | |
3479 GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id); | |
3480 if (!buffer_id) { | |
3481 return NULL; | |
3482 } | |
3483 BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id); | |
3484 if (!buffer) { | |
3485 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", | |
3486 "invalid buffer"); | |
3487 return NULL; | |
3488 } | |
3489 if (buffer->mapped()) { | |
3490 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", | |
3491 "already mapped"); | |
3492 return NULL; | |
3493 } | |
3494 // Here we wait for previous transfer operations to be finished. | |
3495 // TODO(hubbe): AsyncTex(Sub)Image2dCHROMIUM does not currently work | |
3496 // with this method of synchronization. Until this is fixed, | |
3497 // MapBufferCHROMIUM will not block even if the transfer is not ready | |
3498 // for these calls. | |
3499 if (buffer->transfer_ready_token()) { | |
3500 helper_->WaitForToken(buffer->transfer_ready_token()); | |
3501 buffer->set_transfer_ready_token(0); | |
3502 } | |
3503 buffer->set_mapped(true); | |
3504 | |
3505 GPU_DCHECK(buffer->address()); | |
3506 GPU_CLIENT_LOG(" returned " << buffer->address()); | |
3507 CheckGLError(); | |
3508 return buffer->address(); | |
3509 } | |
3510 default: | |
3511 return NULL; | |
3402 } | 3512 } |
3403 BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id); | 3513 return NULL; |
3404 if (!buffer) { | |
3405 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "invalid buffer"); | |
3406 return NULL; | |
3407 } | |
3408 if (buffer->mapped()) { | |
3409 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "already mapped"); | |
3410 return NULL; | |
3411 } | |
3412 // Here we wait for previous transfer operations to be finished. | |
3413 // TODO(hubbe): AsyncTex(Sub)Image2dCHROMIUM does not currently work | |
3414 // with this method of synchronization. Until this is fixed, | |
3415 // MapBufferCHROMIUM will not block even if the transfer is not ready | |
3416 // for these calls. | |
3417 if (buffer->transfer_ready_token()) { | |
3418 helper_->WaitForToken(buffer->transfer_ready_token()); | |
3419 buffer->set_transfer_ready_token(0); | |
3420 } | |
3421 buffer->set_mapped(true); | |
3422 | |
3423 GPU_DCHECK(buffer->address()); | |
3424 GPU_CLIENT_LOG(" returned " << buffer->address()); | |
3425 CheckGLError(); | |
3426 return buffer->address(); | |
3427 } | 3514 } |
3428 | 3515 |
3429 GLboolean GLES2Implementation::UnmapBufferCHROMIUM(GLuint target) { | 3516 GLboolean GLES2Implementation::UnmapBufferCHROMIUM(GLuint target) { |
3430 GPU_CLIENT_SINGLE_THREAD_CHECK(); | 3517 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
3431 GPU_CLIENT_LOG( | 3518 GPU_CLIENT_LOG( |
3432 "[" << GetLogPrefix() << "] glUnmapBufferCHROMIUM(" << target << ")"); | 3519 "[" << GetLogPrefix() << "] glUnmapBufferCHROMIUM(" << target << ")"); |
3433 GLuint buffer_id; | 3520 GLuint buffer_id; |
3434 if (!GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id)) { | 3521 switch(target) { |
3435 SetGLError(GL_INVALID_ENUM, "glUnmapBufferCHROMIUM", "invalid target"); | 3522 case GL_IMAGE_BUFFER_CHROMIUM: { |
3523 GetBoundGpuMemoryBuffer("glUnmapBufferCHROMIUM", &buffer_id); | |
3524 if (buffer_id == 0) { | |
3525 break; | |
3526 } | |
3527 GpuMemoryBuffer* gpu_buffer = | |
3528 gpu_memory_buffer_tracker_->GetBuffer(buffer_id); | |
3529 | |
3530 if (!gpu_buffer->IsMapped()) { | |
3531 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "not mapped"); | |
greggman
2013/04/29 19:58:33
Here and below s/glMap/glUnmap/
kaanb
2013/04/30 03:40:10
Done.
| |
3532 break; | |
3533 } | |
3534 gpu_buffer->Unmap(); | |
3535 return true; | |
3536 } | |
3537 case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM: | |
3538 case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: { | |
3539 if (!GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", | |
3540 &buffer_id)) { | |
3541 SetGLError(GL_INVALID_ENUM, "glUnmapBufferCHROMIUM", "invalid target"); | |
3542 break; | |
3543 } | |
3544 if (!buffer_id) { | |
3545 break; | |
3546 } | |
3547 BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id); | |
3548 if (!buffer) { | |
3549 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", | |
3550 "invalid buffer"); | |
3551 break; | |
3552 } | |
3553 if (!buffer->mapped()) { | |
3554 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "not mapped"); | |
3555 break; | |
3556 } | |
3557 buffer->set_mapped(false); | |
3558 return true; | |
3559 } | |
3560 default: | |
3561 SetGLError(GL_INVALID_ENUM, "glUnmapBufferCHROMIUM", "invalid target"); | |
3436 } | 3562 } |
3437 if (!buffer_id) { | |
3438 return false; | |
3439 } | |
3440 BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id); | |
3441 if (!buffer) { | |
3442 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "invalid buffer"); | |
3443 return false; | |
3444 } | |
3445 if (!buffer->mapped()) { | |
3446 SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "not mapped"); | |
3447 return false; | |
3448 } | |
3449 buffer->set_mapped(false); | |
3450 CheckGLError(); | 3563 CheckGLError(); |
3451 return true; | 3564 return false; |
3452 } | 3565 } |
3453 | 3566 |
3454 void GLES2Implementation::AsyncTexImage2DCHROMIUM( | 3567 void GLES2Implementation::AsyncTexImage2DCHROMIUM( |
3455 GLenum target, GLint level, GLint internalformat, GLsizei width, | 3568 GLenum target, GLint level, GLint internalformat, GLsizei width, |
3456 GLsizei height, GLint border, GLenum format, GLenum type, | 3569 GLsizei height, GLint border, GLenum format, GLenum type, |
3457 const void* pixels) { | 3570 const void* pixels) { |
3458 GPU_CLIENT_SINGLE_THREAD_CHECK(); | 3571 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
3459 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D(" | 3572 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D(" |
3460 << GLES2Util::GetStringTextureTarget(target) << ", " | 3573 << GLES2Util::GetStringTextureTarget(target) << ", " |
3461 << level << ", " | 3574 << level << ", " |
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3556 helper_->WaitAsyncTexImage2DCHROMIUM(target); | 3669 helper_->WaitAsyncTexImage2DCHROMIUM(target); |
3557 CheckGLError(); | 3670 CheckGLError(); |
3558 } | 3671 } |
3559 | 3672 |
3560 GLuint GLES2Implementation::InsertSyncPointCHROMIUM() { | 3673 GLuint GLES2Implementation::InsertSyncPointCHROMIUM() { |
3561 GPU_CLIENT_SINGLE_THREAD_CHECK(); | 3674 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
3562 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glInsertSyncPointCHROMIUM"); | 3675 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glInsertSyncPointCHROMIUM"); |
3563 return helper_->InsertSyncPointCHROMIUM(); | 3676 return helper_->InsertSyncPointCHROMIUM(); |
3564 } | 3677 } |
3565 | 3678 |
3679 void* GLES2Implementation::GetNativeHandleForBoundGpuMemoryBuffer() { | |
3680 if (bound_gpu_memory_buffer_id_ == 0) { | |
3681 return NULL; | |
3682 } | |
3683 | |
3684 GpuMemoryBuffer* buffer = | |
3685 gpu_memory_buffer_tracker_->GetBuffer(bound_gpu_memory_buffer_id_); | |
3686 | |
3687 return (buffer != NULL) ? buffer->GetNativeBuffer() : NULL; | |
3688 } | |
3689 | |
3690 void GLES2Implementation::ImageBufferDataCHROMIUMHelper( | |
3691 GLenum target, GLsizei width, GLsizei height) { | |
3692 if (width < 0) { | |
3693 SetGLError(GL_INVALID_VALUE, "glImageBufferDataCHROMIUM", "width < 0"); | |
3694 return; | |
3695 } | |
3696 | |
3697 if (height < 0) { | |
3698 SetGLError(GL_INVALID_VALUE, "glImageBufferDataCHROMIUM", "height < 0"); | |
3699 return; | |
3700 } | |
3701 | |
3702 if (target != GL_IMAGE_BUFFER_CHROMIUM) { | |
3703 SetGLErrorInvalidEnum("glImageBufferDataCHROMIUM", target, "target"); | |
3704 return; | |
3705 } | |
3706 | |
3707 GLuint buffer_id; | |
3708 bool found_buffer = GetBoundGpuMemoryBuffer( | |
3709 "glImageBufferDataCHROMIUM", &buffer_id); | |
3710 | |
3711 if (!found_buffer || buffer_id == 0) { | |
3712 return; | |
3713 } | |
3714 | |
3715 GpuMemoryBuffer* buffer = | |
3716 gpu_memory_buffer_tracker_->GetBuffer(buffer_id); | |
3717 if (buffer) { | |
3718 // Remove old buffer, deletes the buffer pointer. | |
3719 gpu_memory_buffer_tracker_->RemoveBuffer(buffer_id); | |
3720 } | |
3721 | |
3722 if (width != 0 && height != 0) { | |
3723 // Create new buffer. | |
3724 buffer = gpu_memory_buffer_tracker_->CreateBuffer(buffer_id, width, height); | |
3725 GPU_DCHECK(buffer); | |
3726 } | |
3727 | |
3728 return; | |
3729 } | |
3730 | |
3731 void GLES2Implementation::ImageBufferDataCHROMIUM( | |
3732 GLenum target, GLsizei width, GLsizei height) { | |
3733 GPU_CLIENT_SINGLE_THREAD_CHECK(); | |
3734 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glImageBufferDataCHROMIUM(" | |
3735 << GLES2Util::GetStringBufferTarget(target) << ", " | |
3736 << width << ", " | |
3737 << height << ")"); | |
3738 ImageBufferDataCHROMIUMHelper(target, width, height); | |
3739 CheckGLError(); | |
3740 } | |
3741 | |
3566 // Include the auto-generated part of this file. We split this because it means | 3742 // Include the auto-generated part of this file. We split this because it means |
3567 // we can easily edit the non-auto generated parts right here in this file | 3743 // we can easily edit the non-auto generated parts right here in this file |
3568 // instead of having to edit some template or the code generator. | 3744 // instead of having to edit some template or the code generator. |
3569 #include "../client/gles2_implementation_impl_autogen.h" | 3745 #include "../client/gles2_implementation_impl_autogen.h" |
3570 | 3746 |
3571 } // namespace gles2 | 3747 } // namespace gles2 |
3572 } // namespace gpu | 3748 } // namespace gpu |
OLD | NEW |