command_buffer: Implement path rendering functions for CHROMIUM_path_rendering

gpu/command_buffer/client/gles2_implementation.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 4079 matching lines @@
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glImageParameterivCHROMIUM("
       << image_id << ", "
       << GLES2Util::GetStringBufferParameter(pname) << ", "
       << static_cast<const void*>(params) << ")");
   GetImageParameterivCHROMIUMHelper(image_id, pname, params);
   CheckGLError();
 }
 
+GLuint GLES2Implementation::GenPathsCHROMIUM(GLsizei range) {
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenPathsCHROMIUM(" << range
+                     << ")");
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  if (range <= 0) {
+    SetGLError(GL_INVALID_VALUE, "glGenPathsCHROMIUM", "invalid range");
+    return -1;
+  }
+
+  uint32 sizeClientIds = sizeof(GLuint) * range;
+  // Check if we can send it all at once.
+  ScopedTransferBufferPtr buffer(sizeClientIds, helper_, transfer_buffer_);
+  if (!buffer.valid()) {
+    SetGLError(
+        GL_INVALID_VALUE, "glGenPathsCHROMIUM", "no room in transfer buffer");
+    return -1;
+  }
+
+  if (buffer.size() < sizeClientIds) {
+    SetGLError(
+        GL_INVALID_VALUE, "glGenPathsCHROMIUM", "no room in transfer buffer");
+    return -1;
+  }
+
+  GLuint* client_ids = static_cast<GLuint*>(buffer.address());
+  GetIdHandler(id_namespaces::kPaths)->MakeIds(this, 0, range, client_ids);
+  helper_->GenPathsCHROMIUM(range, buffer.shm_id(), buffer.offset());
+  helper_->CommandBufferHelper::Flush();
+
+  GPU_CLIENT_LOG_CODE_BLOCK({
+    for (GLsizei i = 0; i < range; ++i) {
+      GPU_CLIENT_LOG("  " << i << ": " << client_ids[i]);
+    }
+  });
+  CheckGLError();
+  return client_ids[0];
+}
+
+void GLES2Implementation::PathCommandsCHROMIUM(GLuint path,
+                                               GLsizei numCommands,
+                                               const GLubyte* commands,
+                                               GLsizei numCoords,
+                                               GLenum coordType,
+                                               const GLvoid* coords) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPathCommandsCHROMIUM(" << path
+                     << ", " << numCommands << ", "
+                     << static_cast<const GLubyte*>(commands) << ", "
+                     << numCoords << ", "
+                     << GLES2Util::GetStringVertexAttribType(coordType) << ", "
+                     << static_cast<const GLubyte*>(coords) << ")");
+  if (!path) {
+    SetGLError(
+        GL_INVALID_VALUE, "glPathCommandsCHROMIUM", "invalid path object");
+    return;
+  }
+  if (numCommands < 0) {
+    SetGLError(GL_INVALID_VALUE, "glPathCommandsCHROMIUM",
+               "numCommands < 0");
+    return;
+  }
+  if (numCoords < 0) {
+    SetGLError(GL_INVALID_VALUE, "glPathCommandsCHROMIUM",
+               "numCoords < 0");
+    return;
+  }
+
+  if (coordType != GL_FLOAT) {
+    SetGLError(GL_INVALID_ENUM, "glPathCommandsCHROMIUM",
+               "coordType != GL_FLOAT");
+    return;
+  }
+
+  uint32_t num_commands = numCommands;
+  uint32_t num_coords = numCoords;
+  uint32 coords_size =
+      GLES2Util::GetGLTypeSizeForTexturesAndBuffers(coordType) * num_coords;
+
+  ScopedTransferBufferPtr buffer(
+      coords_size + num_commands, helper_, transfer_buffer_);
+  if (!buffer.valid() || buffer.size() < coords_size + num_commands) {
+    SetGLError(GL_INVALID_VALUE,
+               "glPathCommandsCHROMIUM",
+               "no room in transfer buffer for coords and commands");
+    return;
+  }
+
+  // Copy coords first because they need stricter alignment.
+  unsigned char* coords_addr = static_cast<unsigned char*>(buffer.address());
+  memcpy(coords_addr, coords, coords_size);
+
+  unsigned char* commands_addr =
+      static_cast<unsigned char*>(buffer.address()) + coords_size;
+  memcpy(commands_addr, commands, num_commands);
+
+  helper_->PathCommandsCHROMIUM(path,
+                                num_commands,
+                                buffer.shm_id(),
+                                buffer.offset() + coords_size,
+                                num_coords,
+                                coordType,
+                                buffer.shm_id(),
+                                buffer.offset());
+  CheckGLError();
+}
+
+void GLES2Implementation::PathTexGenCHROMIUM(GLenum texCoordSet,
+                                             GLenum genMode,
+                                             GLint components,
+                                             const GLfloat* coeffs) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] PathTexGenCHROMIUM(" << texCoordSet
+                     << ", " << genMode << ", " << components << ", " << coeffs
+                     << ")");
+
+  uint32 coeffs_size = sizeof(GLfloat) * components *
+                       (genMode == GL_EYE_LINEAR_CHROMIUM ? 4 : 3);
+
+  ScopedTransferBufferPtr buffer(coeffs_size, helper_, transfer_buffer_);
+  if (!buffer.valid()) {
+    SetGLError(
+        GL_INVALID_VALUE, "glPathTexGenCHROMIUM", "no room in transfer buffer");
+    return;
+  }
+
+  if (buffer.size() < coeffs_size) {
+    SetGLError(
+        GL_INVALID_VALUE, "glPathTexGenCHROMIUM", "no room in transfer buffer");
+    return;
+  }
+
+  unsigned char* addr = static_cast<unsigned char*>(buffer.address());
+  memcpy(addr, coeffs, coeffs_size);
+  helper_->PathTexGenCHROMIUM(
+      texCoordSet, genMode, components, buffer.shm_id(), buffer.offset());
+  CheckGLError();
+}
+
+void GLES2Implementation::StencilFillPathInstancedCHROMIUM(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix()
+                     << "] glStencilFillPathInstancedCHROMIUM(" << numPaths
+                     << ", " << pathNameType << ", "
+                     << static_cast<const GLubyte*>(paths) << ", " << pathBase
+                     << ", " << fillMode << ", " << mask << ", "
+                     << transformType << ", " << transformValues << ")");
+  if (pathNameType != GL_UNSIGNED_INT) {
+    SetGLError(GL_INVALID_ENUM, "glStencilFillPathInstancedCHROMIUM",
+               "pathNameType != GL_UNSIGNED_INT");
+    return;
+  }
+
+  if (numPaths < 0) {
+    SetGLError(GL_INVALID_VALUE, "glStencilFillPathInstancedCHROMIUM",
+               "numPaths < 0");
+    return;
+  } else if (numPaths == 0) {
+    return;
+  }
+
+  uint32_t num_paths = static_cast<uint32_t>(numPaths);
+
+  DCHECK(pathNameType == GL_UNSIGNED_INT);
+
+  uint32_t paths_size = sizeof(GL_UNSIGNED_INT) * num_paths;
+  uint32_t transforms_size =
+      sizeof(GLfloat) *
+      GLES2Util::GetComponentCountForGLTransformType(transformType) * num_paths;
+
+  ScopedTransferBufferPtr buffer(
+      transforms_size + paths_size, helper_, transfer_buffer_);
+
+  if (!buffer.valid() || buffer.size() < transforms_size + paths_size) {
+    SetGLError(GL_OUT_OF_MEMORY,
+               "glStencilFillPathInstancedCHROMIUM",
+               "no room in paths and transforms in transfer buffer");
+    return;
+  }
+
+  // Copy transforms first, they may have stricter alignment.
+  unsigned char* transforms_addr =
+      static_cast<unsigned char*>(buffer.address());
+  memcpy(transforms_addr, transformValues, transforms_size);
+  DCHECK((reinterpret_cast<uintptr_t>(transforms_addr) & 0x3) == 0);
+
+  unsigned char* paths_addr =
+      static_cast<unsigned char*>(buffer.address()) + transforms_size;
+  memcpy(paths_addr, paths, paths_size);
+  DCHECK((reinterpret_cast<uintptr_t>(paths_addr) & 0x3) == 0);
+
+  helper_->StencilFillPathInstancedCHROMIUM(numPaths,
+                                            pathNameType,
+                                            buffer.shm_id(),
+                                            buffer.offset() + transforms_size,
+                                            pathBase,
+                                            fillMode,
+                                            mask,
+                                            transformType,
+                                            buffer.shm_id(),
+                                            buffer.offset());
+
+  CheckGLError();
+}
+
+void GLES2Implementation::StencilStrokePathInstancedCHROMIUM(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix()
+                     << "] glStencilStrokePathInstancedCHROMIUM(" << numPaths
+                     << ", " << pathNameType << ", "
+                     << static_cast<const GLubyte*>(paths) << ", " << pathBase
+                     << ", " << ref << ", " << mask << ", " << transformType
+                     << ", " << transformValues << ")");
+
+  if (pathNameType != GL_UNSIGNED_INT) {
+    SetGLError(GL_INVALID_ENUM, "glStencilStrokePathInstancedCHROMIUM",
+               "pathNameType != GL_UNSIGNED_INT");
+    return;
+  }
+
+  if (numPaths < 0) {
+    SetGLError(GL_INVALID_VALUE, "glStencilStrokePathInstancedCHROMIUM",
+               "numPaths < 0");
+    return;
+  } else if (numPaths == 0) {
+    return;
+  }
+
+  uint32_t num_paths = static_cast<uint32_t>(numPaths);
+
+  DCHECK(pathNameType == GL_UNSIGNED_INT);
+
+  uint32_t paths_size = sizeof(GL_UNSIGNED_INT) * num_paths;
+  uint32_t transforms_size =
+      sizeof(GLfloat) *
+      GLES2Util::GetComponentCountForGLTransformType(transformType) * num_paths;
+
+  ScopedTransferBufferPtr buffer(
+      transforms_size + paths_size, helper_, transfer_buffer_);
+
+  if (!buffer.valid() || buffer.size() < transforms_size + paths_size) {
+    SetGLError(GL_OUT_OF_MEMORY,
+               "glStencilStrokePathInstancedCHROMIUM",
+               "no room in paths and transforms in transfer buffer");
+    return;
+  }
+
+  // Copy transforms first, they may have stricter alignment.
+  unsigned char* transforms_addr =
+      static_cast<unsigned char*>(buffer.address());
+  memcpy(transforms_addr, transformValues, transforms_size);
+  DCHECK((reinterpret_cast<uintptr_t>(transforms_addr) & 0x3) == 0);
+
+  unsigned char* paths_addr =
+      static_cast<unsigned char*>(buffer.address()) + transforms_size;
+  memcpy(paths_addr, paths, paths_size);
+  DCHECK((reinterpret_cast<uintptr_t>(paths_addr) & 0x3) == 0);
+
+  helper_->StencilStrokePathInstancedCHROMIUM(numPaths,
+                                              pathNameType,
+                                              buffer.shm_id(),
+                                              buffer.offset() + transforms_size,
+                                              pathBase,
+                                              ref,
+                                              mask,
+                                              transformType,
+                                              buffer.shm_id(),
+                                              buffer.offset());
+
+  CheckGLError();
+}
+
+void GLES2Implementation::CoverFillPathInstancedCHROMIUM(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCoverFillPathInstancedCHROMIUM("
+                     << numPaths << ", " << pathNameType << ", "
+                     << static_cast<const GLubyte*>(paths) << ", " << pathBase
+                     << ", " << coverMode << ", " << transformType << ", "
+                     << transformValues << ")");
+
+  if (pathNameType != GL_UNSIGNED_INT) {
+    SetGLError(GL_INVALID_ENUM, "glCoverFillPathInstancedCHROMIUM",
+               "pathNameType != GL_UNSIGNED_INT");
+    return;
+  }
+
+  if (numPaths < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCoverFillPathInstancedCHROMIUM",
+               "numPaths < 0");
+    return;
+  } else if (numPaths == 0) {
+    return;
+  }
+
+  uint32_t num_paths = static_cast<uint32_t>(numPaths);
+
+  DCHECK(pathNameType == GL_UNSIGNED_INT);
+
+  uint32_t paths_size = sizeof(GL_UNSIGNED_INT) * num_paths;
+  uint32_t transforms_size =
+      sizeof(GLfloat) *
+      GLES2Util::GetComponentCountForGLTransformType(transformType) * num_paths;
+
+  ScopedTransferBufferPtr buffer(
+      transforms_size + paths_size, helper_, transfer_buffer_);
+
+  if (!buffer.valid() || buffer.size() < transforms_size + paths_size) {
+    SetGLError(GL_OUT_OF_MEMORY,
+               "glCoverFillPathInstancedCHROMIUM",
+               "no room in paths and transforms in transfer buffer");
+    return;
+  }
+
+  // Copy transforms first, they may have stricter alignment.
+  unsigned char* transforms_addr =
+      static_cast<unsigned char*>(buffer.address());
+  memcpy(transforms_addr, transformValues, transforms_size);
+  DCHECK((reinterpret_cast<uintptr_t>(transforms_addr) & 0x3) == 0);
+
+  unsigned char* paths_addr =
+      static_cast<unsigned char*>(buffer.address()) + transforms_size;
+  memcpy(paths_addr, paths, paths_size);
+  DCHECK((reinterpret_cast<uintptr_t>(paths_addr) & 0x3) == 0);
+
+  helper_->CoverFillPathInstancedCHROMIUM(numPaths,
+                                          pathNameType,
+                                          buffer.shm_id(),
+                                          buffer.offset() + transforms_size,
+                                          pathBase,
+                                          coverMode,
+                                          transformType,
+                                          buffer.shm_id(),
+                                          buffer.offset());
+}
+
+void GLES2Implementation::CoverStrokePathInstancedCHROMIUM(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix()
+                     << "] glCoverStrokePathInstancedCHROMIUM(" << numPaths
+                     << ", " << pathNameType << ", "
+                     << static_cast<const GLubyte*>(paths) << ", " << pathBase
+                     << ", " << coverMode << ", " << transformType << ", "
+                     << transformValues << ")");
+
+  if (pathNameType != GL_UNSIGNED_INT) {
+    SetGLError(GL_INVALID_ENUM, "glCoverStrokePathInstancedCHROMIUM",
+               "pathNameType != GL_UNSIGNED_INT");
+    return;
+  }
+
+  if (numPaths < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCoverStrokePathInstancedCHROMIUM",
+               "numPaths < 0");
+    return;
+  } else if (numPaths == 0) {
+    return;
+  }
+
+  uint32_t num_paths = static_cast<uint32_t>(numPaths);
+
+  DCHECK(pathNameType == GL_UNSIGNED_INT);
+
+  uint32_t paths_size = sizeof(GL_UNSIGNED_INT) * num_paths;
+  uint32_t transforms_size =
+      sizeof(GLfloat) *
+      GLES2Util::GetComponentCountForGLTransformType(transformType) * num_paths;
+
+  ScopedTransferBufferPtr buffer(
+      transforms_size + paths_size, helper_, transfer_buffer_);
+
+  if (!buffer.valid() || buffer.size() < transforms_size + paths_size) {
+    SetGLError(GL_OUT_OF_MEMORY,
+               "glCoverStrokePathInstancedCHROMIUM",
+               "no room in paths and transforms in transfer buffer");
+    return;
+  }
+
+  // Copy transforms first, they may have stricter alignment.
+  unsigned char* transforms_addr =
+      static_cast<unsigned char*>(buffer.address());
+  memcpy(transforms_addr, transformValues, transforms_size);
+  DCHECK((reinterpret_cast<uintptr_t>(transforms_addr) & 0x3) == 0);
+
+  unsigned char* paths_addr =
+      static_cast<unsigned char*>(buffer.address()) + transforms_size;
+  memcpy(paths_addr, paths, paths_size);
+  DCHECK((reinterpret_cast<uintptr_t>(paths_addr) & 0x3) == 0);
+
+  helper_->CoverStrokePathInstancedCHROMIUM(numPaths,
+                                            pathNameType,
+                                            buffer.shm_id(),
+                                            buffer.offset() + transforms_size,
+                                            pathBase,
+                                            coverMode,
+                                            transformType,
+                                            buffer.shm_id(),
+                                            buffer.offset());
+}
+
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu