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 "gpu/command_buffer/client/gles2_implementation.h" | 7 #include "gpu/command_buffer/client/gles2_implementation.h" |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 #include <map> | 10 #include <map> |
(...skipping 4079 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4090 GPU_CLIENT_SINGLE_THREAD_CHECK(); | 4090 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
4091 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params); | 4091 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params); |
4092 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glImageParameterivCHROMIUM(" | 4092 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glImageParameterivCHROMIUM(" |
4093 << image_id << ", " | 4093 << image_id << ", " |
4094 << GLES2Util::GetStringBufferParameter(pname) << ", " | 4094 << GLES2Util::GetStringBufferParameter(pname) << ", " |
4095 << static_cast<const void*>(params) << ")"); | 4095 << static_cast<const void*>(params) << ")"); |
4096 GetImageParameterivCHROMIUMHelper(image_id, pname, params); | 4096 GetImageParameterivCHROMIUMHelper(image_id, pname, params); |
4097 CheckGLError(); | 4097 CheckGLError(); |
4098 } | 4098 } |
4099 | 4099 |
| 4100 GLuint GLES2Implementation::GenPathsCHROMIUM(GLsizei range) { |
| 4101 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenPathsCHROMIUM(" << range |
| 4102 << ")"); |
| 4103 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
| 4104 if (range <= 0) { |
| 4105 SetGLError(GL_INVALID_VALUE, "glGenPathsCHROMIUM", "invalid range"); |
| 4106 return -1; |
| 4107 } |
| 4108 |
| 4109 uint32 sizeClientIds = sizeof(GLuint) * range; |
| 4110 // Check if we can send it all at once. |
| 4111 ScopedTransferBufferPtr buffer(sizeClientIds, helper_, transfer_buffer_); |
| 4112 if (!buffer.valid()) { |
| 4113 SetGLError( |
| 4114 GL_INVALID_VALUE, "glGenPathsCHROMIUM", "no room in transfer buffer"); |
| 4115 return -1; |
| 4116 } |
| 4117 |
| 4118 if (buffer.size() < sizeClientIds) { |
| 4119 SetGLError( |
| 4120 GL_INVALID_VALUE, "glGenPathsCHROMIUM", "no room in transfer buffer"); |
| 4121 return -1; |
| 4122 } |
| 4123 |
| 4124 GLuint* client_ids = static_cast<GLuint*>(buffer.address()); |
| 4125 GetIdHandler(id_namespaces::kPaths)->MakeIds(this, 0, range, client_ids); |
| 4126 helper_->GenPathsCHROMIUM(range, buffer.shm_id(), buffer.offset()); |
| 4127 helper_->CommandBufferHelper::Flush(); |
| 4128 |
| 4129 GPU_CLIENT_LOG_CODE_BLOCK({ |
| 4130 for (GLsizei i = 0; i < range; ++i) { |
| 4131 GPU_CLIENT_LOG(" " << i << ": " << client_ids[i]); |
| 4132 } |
| 4133 }); |
| 4134 CheckGLError(); |
| 4135 return client_ids[0]; |
| 4136 } |
| 4137 |
| 4138 void GLES2Implementation::PathCommandsCHROMIUM(GLuint path, |
| 4139 GLsizei numCommands, |
| 4140 const GLubyte* commands, |
| 4141 GLsizei numCoords, |
| 4142 GLenum coordType, |
| 4143 const GLvoid* coords) { |
| 4144 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
| 4145 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPathCommandsCHROMIUM(" << path |
| 4146 << ", " << numCommands << ", " |
| 4147 << static_cast<const GLubyte*>(commands) << ", " |
| 4148 << numCoords << ", " |
| 4149 << GLES2Util::GetStringVertexAttribType(coordType) << ", " |
| 4150 << static_cast<const GLubyte*>(coords) << ")"); |
| 4151 if (!path) { |
| 4152 SetGLError( |
| 4153 GL_INVALID_VALUE, "glPathCommandsCHROMIUM", "invalid path object"); |
| 4154 return; |
| 4155 } |
| 4156 if (numCommands < 0 || numCoords < 0) { |
| 4157 SetGLError(GL_INVALID_VALUE, |
| 4158 "glPathCommandsCHROMIUM", |
| 4159 "number of commands or coords < 0"); |
| 4160 return; |
| 4161 } |
| 4162 uint32_t num_commands = numCommands; |
| 4163 uint32_t num_coords = numCoords; |
| 4164 uint32 coords_size = |
| 4165 GLES2Util::GetGLTypeSizeForTexturesAndBuffers(coordType) * num_coords; |
| 4166 |
| 4167 ScopedTransferBufferPtr buffer( |
| 4168 coords_size + num_commands, helper_, transfer_buffer_); |
| 4169 if (!buffer.valid() || buffer.size() < coords_size + num_commands) { |
| 4170 SetGLError(GL_INVALID_VALUE, |
| 4171 "glPathCommandsCHROMIUM", |
| 4172 "no room in transfer buffer for coords and commands"); |
| 4173 return; |
| 4174 } |
| 4175 |
| 4176 // Copy coords first because they need stricter alignment. |
| 4177 unsigned char* coords_addr = static_cast<unsigned char*>(buffer.address()); |
| 4178 memcpy(coords_addr, coords, coords_size); |
| 4179 |
| 4180 unsigned char* commands_addr = |
| 4181 static_cast<unsigned char*>(buffer.address()) + coords_size; |
| 4182 memcpy(commands_addr, commands, num_commands); |
| 4183 |
| 4184 helper_->PathCommandsCHROMIUM(path, |
| 4185 num_commands, |
| 4186 buffer.shm_id(), |
| 4187 buffer.offset() + coords_size, |
| 4188 num_coords, |
| 4189 coordType, |
| 4190 buffer.shm_id(), |
| 4191 buffer.offset()); |
| 4192 CheckGLError(); |
| 4193 } |
| 4194 |
| 4195 void GLES2Implementation::PathTexGenCHROMIUM(GLenum texCoordSet, |
| 4196 GLenum genMode, |
| 4197 GLint components, |
| 4198 const GLfloat* coeffs) { |
| 4199 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
| 4200 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] PathTexGenCHROMIUM(" << texCoordSet |
| 4201 << ", " << genMode << ", " << components << ", " << coeffs |
| 4202 << ")"); |
| 4203 |
| 4204 uint32 coeffs_size = sizeof(GLfloat) * components * |
| 4205 (genMode == GL_EYE_LINEAR_CHROMIUM ? 4 : 3); |
| 4206 |
| 4207 ScopedTransferBufferPtr buffer(coeffs_size, helper_, transfer_buffer_); |
| 4208 if (!buffer.valid()) { |
| 4209 SetGLError( |
| 4210 GL_INVALID_VALUE, "glPathTexGenCHROMIUM", "no room in transfer buffer"); |
| 4211 return; |
| 4212 } |
| 4213 |
| 4214 if (buffer.size() < coeffs_size) { |
| 4215 SetGLError( |
| 4216 GL_INVALID_VALUE, "glPathTexGenCHROMIUM", "no room in transfer buffer"); |
| 4217 return; |
| 4218 } |
| 4219 |
| 4220 unsigned char* addr = static_cast<unsigned char*>(buffer.address()); |
| 4221 memcpy(addr, coeffs, coeffs_size); |
| 4222 helper_->PathTexGenCHROMIUM( |
| 4223 texCoordSet, genMode, components, buffer.shm_id(), buffer.offset()); |
| 4224 CheckGLError(); |
| 4225 } |
| 4226 |
| 4227 void GLES2Implementation::StencilFillPathInstancedCHROMIUM( |
| 4228 GLsizei numPaths, |
| 4229 GLenum pathNameType, |
| 4230 const void* paths, |
| 4231 GLuint pathBase, |
| 4232 GLenum fillMode, |
| 4233 GLuint mask, |
| 4234 GLenum transformType, |
| 4235 const GLfloat* transformValues) { |
| 4236 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
| 4237 GPU_CLIENT_LOG("[" << GetLogPrefix() |
| 4238 << "] glStencilFillPathInstancedCHROMIUM(" << numPaths |
| 4239 << ", " << pathNameType << ", " |
| 4240 << static_cast<const GLubyte*>(paths) << ", " << pathBase |
| 4241 << ", " << fillMode << ", " << mask << ", " |
| 4242 << transformType << ", " << transformValues << ")"); |
| 4243 if (numPaths < 0) { |
| 4244 SetGLError(GL_INVALID_VALUE, |
| 4245 "glStencilFillPathInstancedCHROMIUM", |
| 4246 "number of paths < 0"); |
| 4247 return; |
| 4248 } |
| 4249 if (numPaths == 0) { |
| 4250 return; |
| 4251 } |
| 4252 |
| 4253 uint32_t num_paths = static_cast<uint32_t>(numPaths); |
| 4254 |
| 4255 DCHECK(pathNameType == GL_UNSIGNED_INT); |
| 4256 |
| 4257 uint32_t paths_size = sizeof(GL_UNSIGNED_INT) * num_paths; |
| 4258 uint32_t transforms_size = |
| 4259 sizeof(GLfloat) * |
| 4260 GLES2Util::GetComponentCountForGLTransformType(transformType) * num_paths; |
| 4261 |
| 4262 ScopedTransferBufferPtr buffer( |
| 4263 transforms_size + paths_size, helper_, transfer_buffer_); |
| 4264 |
| 4265 if (!buffer.valid() || buffer.size() < transforms_size + paths_size) { |
| 4266 SetGLError(GL_OUT_OF_MEMORY, |
| 4267 "glStencilFillPathInstancedCHROMIUM", |
| 4268 "no room in paths and transforms in transfer buffer"); |
| 4269 return; |
| 4270 } |
| 4271 |
| 4272 // Copy transforms first, they may have stricter alignment. |
| 4273 unsigned char* transforms_addr = |
| 4274 static_cast<unsigned char*>(buffer.address()); |
| 4275 memcpy(transforms_addr, transformValues, transforms_size); |
| 4276 DCHECK((reinterpret_cast<uintptr_t>(transforms_addr) & 0x3) == 0); |
| 4277 |
| 4278 unsigned char* paths_addr = |
| 4279 static_cast<unsigned char*>(buffer.address()) + transforms_size; |
| 4280 memcpy(paths_addr, paths, paths_size); |
| 4281 DCHECK((reinterpret_cast<uintptr_t>(paths_addr) & 0x3) == 0); |
| 4282 |
| 4283 helper_->StencilFillPathInstancedCHROMIUM(numPaths, |
| 4284 pathNameType, |
| 4285 buffer.shm_id(), |
| 4286 buffer.offset() + transforms_size, |
| 4287 pathBase, |
| 4288 fillMode, |
| 4289 mask, |
| 4290 transformType, |
| 4291 buffer.shm_id(), |
| 4292 buffer.offset()); |
| 4293 |
| 4294 CheckGLError(); |
| 4295 } |
| 4296 |
| 4297 void GLES2Implementation::StencilStrokePathInstancedCHROMIUM( |
| 4298 GLsizei numPaths, |
| 4299 GLenum pathNameType, |
| 4300 const void* paths, |
| 4301 GLuint pathBase, |
| 4302 GLint ref, |
| 4303 GLuint mask, |
| 4304 GLenum transformType, |
| 4305 const GLfloat* transformValues) { |
| 4306 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
| 4307 GPU_CLIENT_LOG("[" << GetLogPrefix() |
| 4308 << "] glStencilStrokePathInstancedCHROMIUM(" << numPaths |
| 4309 << ", " << pathNameType << ", " |
| 4310 << static_cast<const GLubyte*>(paths) << ", " << pathBase |
| 4311 << ", " << ref << ", " << mask << ", " << transformType |
| 4312 << ", " << transformValues << ")"); |
| 4313 |
| 4314 if (numPaths < 0) { |
| 4315 SetGLError(GL_INVALID_VALUE, |
| 4316 "glStencilStrokePathInstancedCHROMIUM", |
| 4317 "number of paths < 0"); |
| 4318 return; |
| 4319 } |
| 4320 if (numPaths == 0) { |
| 4321 return; |
| 4322 } |
| 4323 |
| 4324 uint32_t num_paths = static_cast<uint32_t>(numPaths); |
| 4325 |
| 4326 DCHECK(pathNameType == GL_UNSIGNED_INT); |
| 4327 |
| 4328 uint32_t paths_size = sizeof(GL_UNSIGNED_INT) * num_paths; |
| 4329 uint32_t transforms_size = |
| 4330 sizeof(GLfloat) * |
| 4331 GLES2Util::GetComponentCountForGLTransformType(transformType) * num_paths; |
| 4332 |
| 4333 ScopedTransferBufferPtr buffer( |
| 4334 transforms_size + paths_size, helper_, transfer_buffer_); |
| 4335 |
| 4336 if (!buffer.valid() || buffer.size() < transforms_size + paths_size) { |
| 4337 SetGLError(GL_OUT_OF_MEMORY, |
| 4338 "glStencilStrokePathInstancedCHROMIUM", |
| 4339 "no room in paths and transforms in transfer buffer"); |
| 4340 return; |
| 4341 } |
| 4342 |
| 4343 // Copy transforms first, they may have stricter alignment. |
| 4344 unsigned char* transforms_addr = |
| 4345 static_cast<unsigned char*>(buffer.address()); |
| 4346 memcpy(transforms_addr, transformValues, transforms_size); |
| 4347 DCHECK((reinterpret_cast<uintptr_t>(transforms_addr) & 0x3) == 0); |
| 4348 |
| 4349 unsigned char* paths_addr = |
| 4350 static_cast<unsigned char*>(buffer.address()) + transforms_size; |
| 4351 memcpy(paths_addr, paths, paths_size); |
| 4352 DCHECK((reinterpret_cast<uintptr_t>(paths_addr) & 0x3) == 0); |
| 4353 |
| 4354 helper_->StencilStrokePathInstancedCHROMIUM(numPaths, |
| 4355 pathNameType, |
| 4356 buffer.shm_id(), |
| 4357 buffer.offset() + transforms_size, |
| 4358 pathBase, |
| 4359 ref, |
| 4360 mask, |
| 4361 transformType, |
| 4362 buffer.shm_id(), |
| 4363 buffer.offset()); |
| 4364 |
| 4365 CheckGLError(); |
| 4366 } |
| 4367 |
| 4368 void GLES2Implementation::CoverFillPathInstancedCHROMIUM( |
| 4369 GLsizei numPaths, |
| 4370 GLenum pathNameType, |
| 4371 const void* paths, |
| 4372 GLuint pathBase, |
| 4373 GLenum coverMode, |
| 4374 GLenum transformType, |
| 4375 const GLfloat* transformValues) { |
| 4376 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
| 4377 GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCoverFillPathInstancedCHROMIUM(" |
| 4378 << numPaths << ", " << pathNameType << ", " |
| 4379 << static_cast<const GLubyte*>(paths) << ", " << pathBase |
| 4380 << ", " << coverMode << ", " << transformType << ", " |
| 4381 << transformValues << ")"); |
| 4382 |
| 4383 if (numPaths < 0) { |
| 4384 SetGLError(GL_INVALID_VALUE, |
| 4385 "glCoverFillPathInstancedCHROMIUM", |
| 4386 "number of paths < 0"); |
| 4387 return; |
| 4388 } |
| 4389 if (numPaths == 0) { |
| 4390 return; |
| 4391 } |
| 4392 |
| 4393 uint32_t num_paths = static_cast<uint32_t>(numPaths); |
| 4394 |
| 4395 DCHECK(pathNameType == GL_UNSIGNED_INT); |
| 4396 |
| 4397 uint32_t paths_size = sizeof(GL_UNSIGNED_INT) * num_paths; |
| 4398 uint32_t transforms_size = |
| 4399 sizeof(GLfloat) * |
| 4400 GLES2Util::GetComponentCountForGLTransformType(transformType) * num_paths; |
| 4401 |
| 4402 ScopedTransferBufferPtr buffer( |
| 4403 transforms_size + paths_size, helper_, transfer_buffer_); |
| 4404 |
| 4405 if (!buffer.valid() || buffer.size() < transforms_size + paths_size) { |
| 4406 SetGLError(GL_OUT_OF_MEMORY, |
| 4407 "glCoverFillPathInstancedCHROMIUM", |
| 4408 "no room in paths and transforms in transfer buffer"); |
| 4409 return; |
| 4410 } |
| 4411 |
| 4412 // Copy transforms first, they may have stricter alignment. |
| 4413 unsigned char* transforms_addr = |
| 4414 static_cast<unsigned char*>(buffer.address()); |
| 4415 memcpy(transforms_addr, transformValues, transforms_size); |
| 4416 DCHECK((reinterpret_cast<uintptr_t>(transforms_addr) & 0x3) == 0); |
| 4417 |
| 4418 unsigned char* paths_addr = |
| 4419 static_cast<unsigned char*>(buffer.address()) + transforms_size; |
| 4420 memcpy(paths_addr, paths, paths_size); |
| 4421 DCHECK((reinterpret_cast<uintptr_t>(paths_addr) & 0x3) == 0); |
| 4422 |
| 4423 helper_->CoverFillPathInstancedCHROMIUM(numPaths, |
| 4424 pathNameType, |
| 4425 buffer.shm_id(), |
| 4426 buffer.offset() + transforms_size, |
| 4427 pathBase, |
| 4428 coverMode, |
| 4429 transformType, |
| 4430 buffer.shm_id(), |
| 4431 buffer.offset()); |
| 4432 } |
| 4433 |
| 4434 void GLES2Implementation::CoverStrokePathInstancedCHROMIUM( |
| 4435 GLsizei numPaths, |
| 4436 GLenum pathNameType, |
| 4437 const void* paths, |
| 4438 GLuint pathBase, |
| 4439 GLenum coverMode, |
| 4440 GLenum transformType, |
| 4441 const GLfloat* transformValues) { |
| 4442 GPU_CLIENT_SINGLE_THREAD_CHECK(); |
| 4443 GPU_CLIENT_LOG("[" << GetLogPrefix() |
| 4444 << "] glCoverStrokePathInstancedCHROMIUM(" << numPaths |
| 4445 << ", " << pathNameType << ", " |
| 4446 << static_cast<const GLubyte*>(paths) << ", " << pathBase |
| 4447 << ", " << coverMode << ", " << transformType << ", " |
| 4448 << transformValues << ")"); |
| 4449 |
| 4450 if (numPaths < 0) { |
| 4451 SetGLError(GL_INVALID_VALUE, |
| 4452 "glCoverStrokePathInstancedCHROMIUM", |
| 4453 "number of paths < 0"); |
| 4454 return; |
| 4455 } |
| 4456 if (numPaths == 0) { |
| 4457 return; |
| 4458 } |
| 4459 |
| 4460 uint32_t num_paths = static_cast<uint32_t>(numPaths); |
| 4461 |
| 4462 DCHECK(pathNameType == GL_UNSIGNED_INT); |
| 4463 |
| 4464 uint32_t paths_size = sizeof(GL_UNSIGNED_INT) * num_paths; |
| 4465 uint32_t transforms_size = |
| 4466 sizeof(GLfloat) * |
| 4467 GLES2Util::GetComponentCountForGLTransformType(transformType) * num_paths; |
| 4468 |
| 4469 ScopedTransferBufferPtr buffer( |
| 4470 transforms_size + paths_size, helper_, transfer_buffer_); |
| 4471 |
| 4472 if (!buffer.valid() || buffer.size() < transforms_size + paths_size) { |
| 4473 SetGLError(GL_OUT_OF_MEMORY, |
| 4474 "glCoverStrokePathInstancedCHROMIUM", |
| 4475 "no room in paths and transforms in transfer buffer"); |
| 4476 return; |
| 4477 } |
| 4478 |
| 4479 // Copy transforms first, they may have stricter alignment. |
| 4480 unsigned char* transforms_addr = |
| 4481 static_cast<unsigned char*>(buffer.address()); |
| 4482 memcpy(transforms_addr, transformValues, transforms_size); |
| 4483 DCHECK((reinterpret_cast<uintptr_t>(transforms_addr) & 0x3) == 0); |
| 4484 |
| 4485 unsigned char* paths_addr = |
| 4486 static_cast<unsigned char*>(buffer.address()) + transforms_size; |
| 4487 memcpy(paths_addr, paths, paths_size); |
| 4488 DCHECK((reinterpret_cast<uintptr_t>(paths_addr) & 0x3) == 0); |
| 4489 |
| 4490 helper_->CoverStrokePathInstancedCHROMIUM(numPaths, |
| 4491 pathNameType, |
| 4492 buffer.shm_id(), |
| 4493 buffer.offset() + transforms_size, |
| 4494 pathBase, |
| 4495 coverMode, |
| 4496 transformType, |
| 4497 buffer.shm_id(), |
| 4498 buffer.offset()); |
| 4499 } |
| 4500 |
4100 // Include the auto-generated part of this file. We split this because it means | 4501 // Include the auto-generated part of this file. We split this because it means |
4101 // we can easily edit the non-auto generated parts right here in this file | 4502 // we can easily edit the non-auto generated parts right here in this file |
4102 // instead of having to edit some template or the code generator. | 4503 // instead of having to edit some template or the code generator. |
4103 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h" | 4504 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h" |
4104 | 4505 |
4105 } // namespace gles2 | 4506 } // namespace gles2 |
4106 } // namespace gpu | 4507 } // namespace gpu |
OLD | NEW |