Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(44)

Side by Side Diff: gpu/command_buffer/client/gles2_implementation.cc

Issue 169403005: command_buffer: Implement path rendering functions for CHROMIUM_path_rendering (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@nv-pr-02-texgen
Patch Set: rebase Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698